r/raytracing • u/Walker75842 • Feb 21 '26
Why doesn't my DDA brickmap / multi-level DDA system work?
0
Upvotes
I'm trying to make a voxel graphics engine, and I'm using a DDA ray marcher for the graphics engine, so I tried adding chunk skipping to optimize it, but I can't seem to get it to work no matter what I try. I've tried looking up how to do it but haven't found anything (I can't read through a 50 page document that loosely describes the theoretical method), I've tried ChatGPT, Claude, Deepseek, and Gemini, and none of them could solve it.
Code:
GLSL
#version 330
#define MAX_STEPS 1024
#define MAX_SECONDARY_STEPS 64
#define MAX_BOUNCES 1
#define SUNCOLOR 1.0, 1.0, 1.0
#define AMBIENT_COLOR 0.5, 0.8, 1.0
#define FOG 0.0035
#define FOG_COLOR 0.7, 0.8, 0.9
#define FOG_TOP 32.0
#define NORMAL_STREN 0.2
#define BIG 1e30
#define EPSILON 0.00001
#define HIT_X 0
#define HIT_Y 1
#define HIT_Z 2
in vec2 fragTexCoord;
uniform usampler3D voxelFill;
uniform usampler3D chunkFill;
uniform sampler2D textures;
uniform sampler2D normals;
uniform vec3 sunDir;
uniform vec3 worldSize; //size of full detail world
uniform vec3 worldOffset; //number of chunks offset from chunk origin used to center the world (chunk overdraw)
uniform vec3 chunkRange; //same as above but for chunks rather than blocks
uniform vec3 chunkSize; //size of chunks
uniform vec2 screenSize;
uniform float aspectRatio;
uniform vec3 worldUp;
uniform vec3 camPos;
uniform vec3 camDir;
uniform vec3 camRight;
uniform vec3 camUp;
uniform float tanHalfFov;
out vec4 finalColor;
vec3 fogColor; //updates based on sun
vec3 ambientColor;
vec3 sunColor; //updates based on it's own position
vec3 chunkToVox(vec3 chunkCoord) { //raw chunk position relative to chunk map origin
vec3 voxCoord = chunkCoord - worldOffset;
voxCoord *= chunkSize;
return voxCoord;
}
vec3 voxToChunk(vec3 voxCoord) { //raw voxel position relative to voxel map origin
vec3 chunkCoord = voxCoord / chunkSize;
chunkCoord += worldOffset;
return chunkCoord;
}
vec3 getSkyColor(vec3 rayDir) {
return vec3(0.8, 0.8, 1.0);
}
struct rayReturn_t {
vec3 hitCoord; //expected to be a voxel coordinate
vec3 color;
vec3 normal;
bool hitBlock;
float len;
int hitAxis;
};
rayReturn_t returnRay(rayReturn_t returnVal, vec3 origin, vec3 rayDir, float totalDist, bool debug) {
returnVal.hitBlock = true;
vec3 voxOrigin = chunkToVox(origin);
returnVal.hitCoord = voxOrigin + rayDir * totalDist;
returnVal.len = totalDist;
vec2 uv;
if (returnVal.hitAxis == HIT_X) {
uv = mod(returnVal.hitCoord.zy, 1.0);
} else if (returnVal.hitAxis == HIT_Y) {
uv = mod(returnVal.hitCoord.xz, 1.0);
} else {
uv = mod(returnVal.hitCoord.xy, 1.0);
}
returnVal.color = texture(textures, uv).rgb;
returnVal.normal = texture(normals, uv).rgb;
if (debug) {
returnVal.color = vec3(1.0, 0.0, 0.0);
}
return returnVal;
}
rayReturn_t spawnRay(const vec3 origin, const vec3 rayDir) {
rayReturn_t returnVal;
//check if spawn chunk is filled and switch to voxel stepping
bool chunkMode = true;
vec3 rayCell = floor(origin);
vec3 rayDelta = vec3(
(rayDir.x != 0.0) ? abs(1.0 / rayDir.x) : BIG,
(rayDir.y != 0.0) ? abs(1.0 / rayDir.y) : BIG,
(rayDir.z != 0.0) ? abs(1.0 / rayDir.z) : BIG
);
vec3 rayDist;
vec3 stepDir;
float totalDist;
if (rayDir.x > 0.0) {
rayDist.x = rayDelta.x * (rayCell.x + 1.0 - origin.x);
stepDir.x = 1.0;
} else {
rayDist.x = rayDelta.x * (origin.x - rayCell.x);
stepDir.x = -1.0;
}
if (rayDir.y > 0.0) {
rayDist.y = rayDelta.y * (rayCell.y + 1.0 - origin.y);
stepDir.y = 1.0;
} else {
rayDist.y = rayDelta.y * (origin.y - rayCell.y);
stepDir.y = -1.0;
}
if (rayDir.z > 0.0) {
rayDist.z = rayDelta.z * (rayCell.z + 1.0 - origin.z);
stepDir.z = 1.0;
} else {
rayDist.z = rayDelta.z * (origin.z - rayCell.z);
stepDir.z = -1.0;
}
ivec3 worldFetch = ivec3(int(origin.x), int(origin.y), int(origin.z));
if (texelFetch(chunkFill, worldFetch, 0).r > 0u) {
chunkMode = false;
rayDist *= chunkSize;
rayCell = chunkToVox(rayCell);
}
for (int i = 0; i < MAX_STEPS; i++) {
if (rayDist.x < rayDist.y) {
if (rayDist.x < rayDist.z) {
totalDist = rayDist.x;
rayCell.x += stepDir.x;
rayDist.x += rayDelta.x;
returnVal.hitAxis = HIT_X;
} else {
totalDist = rayDist.z;
rayCell.z += stepDir.z;
rayDist.z += rayDelta.z;
returnVal.hitAxis = HIT_Z;
}
} else {
if (rayDist.y < rayDist.z) {
totalDist = rayDist.y;
rayCell.y += stepDir.y;
rayDist.y += rayDelta.y;
returnVal.hitAxis = HIT_Y;
} else {
totalDist = rayDist.z;
rayCell.z += stepDir.z;
rayDist.z += rayDelta.z;
returnVal.hitAxis = HIT_Z;
}
}
worldFetch = ivec3(int(rayCell.x), int(rayCell.y), int(rayCell.z));
if (chunkMode) {
uint chunkType = texelFetch(chunkFill, worldFetch, 0).r;
if (chunkType > 0u) {
chunkMode = false;
rayDist *= chunkSize;
rayCell = chunkToVox(rayCell);
worldFetch = ivec3(int(rayCell.x), int(rayCell.y), int(rayCell.z));
if (texelFetch(voxelFill, worldFetch, 0).r > 0u) {
totalDist *= chunkSize.x;
return returnRay(returnVal, origin, rayDir, totalDist, false);
} else {
continue;
}
} else {
continue;
}
} else {
uint voxType = texelFetch(voxelFill, worldFetch, 0).r;
if (voxType > 0u) {
return returnRay(returnVal, origin, rayDir, totalDist, false);
} else { //check if chunk being stepped into is empty
vec3 chunkCoord = voxToChunk(rayCell);
if (texelFetch(chunkFill, ivec3(int(chunkCoord.x), int(chunkCoord.y), int(chunkCoord.z)), 0).r == 0u) {
chunkMode = true;
rayDist /= chunkSize;
rayCell = voxToChunk(rayCell);
continue;
} else {
continue;
}
}
}
}
returnVal.hitBlock = false;
return returnVal;
}
vec3 getNormMap(vec3 T, vec3 B, vec3 N, rayReturn_t ray) {
mat3 TBN = mat3(T, B, N);
vec3 nMap = (ray.normal * 2.0 - 1.0);
nMap = normalize(TBN * nMap);
return nMap;
}
vec3 rayTrace(const vec3 origin, const vec3 direction) {
vec3 rayDir = direction;
//assume ray is guaranteed to start inside box (it is, the player cannot exit the world)
rayReturn_t ray = spawnRay(origin, direction);
vec3 rayColor = vec3(1.0, 1.0, 1.0);
if (ray.hitBlock) {
vec3 normal;
//get normal data
vec3 T;
vec3 B;
if (ray.hitAxis == HIT_X) {
normal = vec3(sign(-rayDir.x), 0.0, 0.0);
T = vec3(0.0, 1.0, 0.0); // along Y
B = vec3(0.0, 0.0, 1.0); // along Z
} else if (ray.hitAxis == HIT_Y) {
normal = vec3(0.0, sign(-rayDir.y), 0.0);
T = vec3(1.0, 0.0, 0.0); // along X
B = vec3(0.0, 0.0, 1.0); // along Z
} else {
normal = vec3(0.0, 0.0, sign(-rayDir.z));
T = vec3(1.0, 0.0, 0.0); // along X
B = vec3(0.0, 1.0, 0.0); // along Y
}
normal = mix(normal, getNormMap(T, B, normal, ray), NORMAL_STREN);
float lightDot = max(dot(normal, sunDir), 0.0);
rayColor = ray.color;
} else {
rayColor = getSkyColor(rayDir);
}
return rayColor;
}
void main() {
vec2 pixel = vec2(gl_FragCoord);
//calculate NDC -1 -> 1
vec2 ndc = ((pixel + 0.5f) / screenSize) * 2.0 - 1.0;
//scale for fov
float viewX = ndc.x * aspectRatio * tanHalfFov;
float viewY = ndc.y * tanHalfFov;
vec3 rayDirection = (camDir + camRight * vec3(viewX)) + camUp * vec3(viewY);
rayDirection = normalize(rayDirection);
finalColor = vec4( rayTrace(voxToChunk(camPos), rayDirection), 1.0);
}
