Hello everyone,

I am struggling with calculating the lightmap for my game. A level just consists of surfaces for walls/floors/ceilings (like in Wolfenstein3D).

Currently the pipeline looks as the following:

1. render the scene into the depth buffer from the light source's point of view
2. iterate over all surfaces (each surfaces consists of an 8x8 grid of lumels)
3. for each lumel check the distance D to the light source
4. find the point Q in the near plane of the light source
5. transform Q into screen space and look inside the depth buffer at that position
6. if depth value is less then D then lumel is in shadow

I guess that I am doing something wrong transforming Q into screen space.

// ...
float u = ((float)x + 0.5f) / lmWidth;
float v = ((float)y + 0.5f) / lmHeight;

glm::vec3 lumel = surface.vertices[0].position + u * uAxis + v * vAxis;
glm::vec3 lightLumelDir = glm::normalize(lumel - lightPosition);

// ==== EDIT: It isn't the near plane to get the actual point on the plane
// glm::vec3 planePositionWorld = lightPosition + near * lightLumelDir;

float dist = 0.0f;
glm::intersectRayPlane(lightPosition, lightLumelDir, lightPosition + near * lightNormal, nearPlane.normal, dist);
glm::vec3 planePositionWorld = lightPosition + dist * lightLumelDir;
// EDIT ====

glm::vec4 position = projection * view * glm::vec4(planePositionWorld, 1.0f);
glm::vec4 positionNDC = position / position.w;

float nx = positionNDC.x;
float ny = positionNDC.y;

if (nx < -1.0f || nx > 1.0f || ny < -1.0f || ny > 1.0f) continue;

// Screen space coordinates
float sx = ((nx + 1.0f) / 2.0f) * frameBufferWidth;
float sy = ((ny + 1.0f) / 2.0f) * frameBufferHeight;

float depth = 0.0f;
glReadPixels((int)sx, (int)sy, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &depth);

// Check distance between lumel and depth value
float lumelDistance = glm::distance(lumel, lightPosition);

if (depth < lumelDistance) continue;

// light intensity calculation
// ...

Of course, without the check in point 4 I get a nicely shaded lightmap ? - without shadows :(

Thanks,
danqua

I was thinking from the wrong “perspective”.

Got it working by projecting the lumel into the light sources view.

glm::vec4 position = projection * view * glm::vec4(lumel, 1.0f);
glm::vec4 ndc = position / position.w;

if (glm::abs(ndc.x) > 1.0f || glm::abs(ndc.y) > 1.0f || glm::abs(ndc.z) > 1.0f) continue;

int sx = (int)(((ndc.x + 1.0f) / 2.0f) * 1024.0f);
int sy = (int)(((ndc.y + 1.0f) / 2.0f) * 1024.0f);

float depth = LinearizeDepth(depthBuffer[sx + sy * 1024], near, far);

// Check distance between lumel and depth value
if (depth < position.z) continue;
float lumelDistance = glm::distance(lumel, lightPosition);

Calculating proper lightmaps requires path tracing or some other similar solution for physically-based indirect lighting. What you have is just calculating the direct light, which won't produce satisfactory results, especially with shadows. In the simplest sense, path tracing would just involve emitting random rays from light sources and bouncing them around the scene, adding up how much light intensity is incident on all surfaces in the light map.

Aressera said:

Calculating proper lightmaps requires path tracing or some other similar solution for physically-based indirect lighting. What you have is just calculating the direct light, which won't produce satisfactory results, especially with shadows. In the simplest sense, path tracing would just involve emitting random rays from light sources and bouncing them around the scene, adding up how much light intensity is incident on all surfaces in the light map.

You're absolutely right. I wanted to get there eventually (to some extent), but for now I tried to achieve good looking results and get things going like uv extension for texture filtering etc.

I read somewhere on this forum that someone uses this technique for pre-calculating lighting in a scene on level loading and I thought I give it a go. Unfortunately I am still facing some issues because of depth resolution and perspective inaccuracies I assume.

I actually did ray tracing (not path) in the beginning, but I had problems determine lumels that lie in shadow because of the extended uv space, which in my case had wall surfaces exceed the floor and ceiling surfaces resulting in ray intersections I didn't want.

But in the end I just want a simple lighting solution with shadows that doesn't require a lot of textures.

@Vilem Otte Thanks for your suggestions. I use the same approach like calculating a shadow map. I use the depth buffer to check if certain lumels are visible from the light sources and if they are, I color them accordingly. For the depth buffer - I use the default depth buffer. If I'm not mistaken it has a bit-depth of 24, so this should be plenty I guess. And I also use a bias you have mentioned.

What really got me to a point where I am quite happy with the result is tweaking the near and far plane when rendering the depth. There are still some small light glitches here and there, but when combined with the actual textures it isn't that bad anymore. I made a small fly-through so you can see my results. For now I guess I move on and got my hands dirty on a small room/sector system and an editor.