# Thibault Ober

Member

4

1 Neutral

• Rank
Newbie

• Interests
Programming
1. ## 3D Screen-Space Projected Lines

Hi, I have found this paper dealing with how to compute the perfect bias when dealing with shadow map. The idea is to: get the texel used when sampling the shadowMap project the texel location back to eyeSpace (ray tracing) get the difference between your frament.z and the intersection with the fragment's face and your ray. This way you have calculated the error which serve as the appropriate bias for z-fighting. Now I am trying to implement it, but I experiment some troubles: I am using a OrthoProjectionMatrix, so i think I don't need to divide by w back and forth. I am good until I am computing the ray intersection with the face. I have a lot of faces failing the test, and my bias is way to important. This is my fragment shader code: float getBias(float depthFromTexture) { vec3 n = lightFragNormal.xyz; //no need to divide by w, we got an ortho projection //we are in NDC [-1,1] we go to [0,1] //vec4 smTexCoord = 0.5 * shadowCoord + vec4(0.5, 0.5, 0.5, 0.0); vec4 smTexCoord = lightProjectionMatrix * lightFragmentCoord; smTexCoord = 0.5 * smTexCoord + vec4(0.5, 0.5, 0.5, 0.5); //we are in [0,1] we go to texture_space [0,1]->[0,shadowMap.dimension]:[0,1024] //get the nearest index in the shadow map, the texel corresponding to our fragment //we use floor (125.6,237.9) -> (125,237) vec2 delta = vec2(xPixelOffset, yPixelOffset); vec2 textureDim = vec2(1/xPixelOffset, 1/yPixelOffset); vec2 index = floor(smTexCoord.xy * textureDim); //we get the center of the current texel, we had 0.5 to put us in the middle (125,237) -> (125.5,237.5) //we go back to [0,1024] -> [0,1], (125.5,237.5) -> (0.125, 0.235) vec2 nlsGridCenter = delta*(index + vec2(0.5f, 0.5f)); // go back to NDC [0,1] -> [-1,1] vec2 lsGridCenter = 2.0 * nlsGridCenter - vec2(1.0); //compute lightSpace grid direction, multiply by the inverse projection matrice or vec4 lsGridCenter4 = inverse(lightProjectionMatrix) * vec4(lsGridCenter, -frustrumNear, 0); vec3 lsGridLineDir = vec3(normalize(lsGridCenter4)); /** Plane ray intersection **/ // Locate the potential occluder for the shading fragment //compute the distance t we need to continue in the gridDir direction, the point is "t" far float ls_t_hit = dot(n, lightFragmentCoord.xyz) / dot(n, lsGridLineDir); if(ls_t_hit<=0){ return 0; // i got a lot of negativ values it shouldn t be the case } //compute the point p with the face vec3 ls_hit_p = ls_t_hit * lsGridLineDir; float intersectionDepth = lightProjectionMatrix * vec4(ls_hit_p, 1.0f).z / 2 + 0.5; float fragmentDepth = lightProjectionMatrix * lightFragmentCoord.z / 2 + 0.5; float result = abs(intersectionDepth - fragmentDepth); return result; } My intersectionDepth don't match my fragmentDepth, they should be really close I am struggling with this line of code and the ray plane intersection: vec4 lsGridCenter4 = inverse(lightProjectionMatrix) * vec4(lsGridCenter, -1.0, 0); I need to go from NDC space to Eye space, i don't know what should be my z and w component. I am starting with a point in the shadowMap I think my z component should match the near plane so in NDC space it should be -1 but i am not sure. Same for w it's a ray so maybe 0 is a better a choice than one. I don't know if my plane/ray intersection is wrong but from wikipedia: $$d = { dot(Po - O) \cdot n \over dir \cdot n}$$ where: dir = my vector normalized direction Po = a point belonging to the the plane O = point belonging to the ray, the origin should match. in eye space the origin should be my light position -> (0,0,0) ? n = normal of the plane, the normal of my fragment in eyespace