J'essaie de faire un ombrage de tuile différé dans OpenGL en utilisant le shader de calcul, mais j'ai réussi à créer un tronc pour chaque tuile. J'utilise la démo Forward + d'AMD (écrite en D3D) comme guide, mais les lumières semblent être supprimées alors qu'elles ne devraient pas.
MISE À JOUR
Lisez ci-dessous pour les mises à jour.
Voici mon shader de calcul (complet):
#version 430 core
#define MAX_LIGHTS 1024
#define MAX_LIGHTS_PER_TILE 40
#define WORK_GROUP_SIZE 16
struct PointLight
{
vec3 position;
float radius;
vec3 color;
float intensity;
};
layout (binding = 0, rgba32f) uniform writeonly image2D outTexture;
layout (binding = 1, rgba32f) uniform readonly image2D normalDepth;
layout (binding = 2, rgba32f) uniform readonly image2D diffuse;
layout (binding = 3, rgba32f) uniform readonly image2D specular;
layout (binding = 4, rgba32f) uniform readonly image2D glowMatID;
layout (std430, binding = 5) buffer BufferObject
{
PointLight pointLights[];
};
uniform mat4 view;
uniform mat4 proj;
uniform mat4 viewProj;
uniform mat4 invViewProj;
uniform mat4 invProj;
uniform vec2 framebufferDim;
layout (local_size_x = WORK_GROUP_SIZE, local_size_y = WORK_GROUP_SIZE) in;
shared uint minDepth = 0xFFFFFFFF;
shared uint maxDepth = 0;
shared uint pointLightIndex[MAX_LIGHTS];
shared uint pointLightCount = 0;
vec3 ReconstructWP(float z, vec2 uv_f)
{
vec4 sPos = vec4(uv_f * 2.0 - 1.0, z, 1.0);
sPos = invViewProj * sPos;
return (sPos.xyz / sPos.w);
}
vec4 ConvertProjToView( vec4 p )
{
p = invProj * p;
p /= p.w;
return p;
}
// calculate the number of tiles in the horizontal direction
uint GetNumTilesX()
{
return uint(( ( 1280 + WORK_GROUP_SIZE - 1 ) / float(WORK_GROUP_SIZE) ));
}
// calculate the number of tiles in the vertical direction
uint GetNumTilesY()
{
return uint(( ( 720 + WORK_GROUP_SIZE - 1 ) / float(WORK_GROUP_SIZE) ));
}
vec4 CreatePlaneEquation( vec4 b, vec4 c )
{
vec4 n;
// normalize(cross( b.xyz-a.xyz, c.xyz-a.xyz )), except we know "a" is the origin
n.xyz = normalize(cross( b.xyz, c.xyz ));
// -(n dot a), except we know "a" is the origin
n.w = 0;
return n;
}
float GetSignedDistanceFromPlane( vec4 p, vec4 eqn )
{
// dot( eqn.xyz, p.xyz ) + eqn.w, , except we know eqn.w is zero
// (see CreatePlaneEquation above)
return dot( eqn.xyz, p.xyz );
}
vec4 CalculateLighting( PointLight p, vec3 wPos, vec3 wNormal, vec4 wSpec, vec4 wGlow)
{
vec3 direction = p.position - wPos;
if(length(direction) > p.radius)
return vec4(0.0f, 0.0f, 0.0f, 0.0f);
float attenuation = 1.0f - length(direction) / (p.radius);
direction = normalize(direction);
float diffuseFactor = max(0.0f, dot(direction, wNormal)) * attenuation;
return vec4(p.color.xyz, 0.0f) * diffuseFactor * p.intensity;
}
void main()
{
ivec2 pixelPos = ivec2(gl_GlobalInvocationID.xy);
vec2 tilePos = vec2(gl_WorkGroupID.xy * gl_WorkGroupSize.xy) / vec2(1280, 720);
vec4 normalColor = imageLoad(normalDepth, pixelPos);
float d = normalColor.w;
uint depth = uint(d * 0xFFFFFFFF);
atomicMin(minDepth, depth);
atomicMax(maxDepth, depth);
barrier();
float minDepthZ = float(minDepth / float(0xFFFFFFFF));
float maxDepthZ = float(maxDepth / float(0xFFFFFFFF));
vec4 frustumEqn[4];
uint pxm = WORK_GROUP_SIZE * gl_WorkGroupID.x;
uint pym = WORK_GROUP_SIZE * gl_WorkGroupID.y;
uint pxp = WORK_GROUP_SIZE * (gl_WorkGroupID.x + 1);
uint pyp = WORK_GROUP_SIZE * (gl_WorkGroupID.y + 1);
uint uWindowWidthEvenlyDivisibleByTileRes = WORK_GROUP_SIZE * GetNumTilesX();
uint uWindowHeightEvenlyDivisibleByTileRes = WORK_GROUP_SIZE * GetNumTilesY();
vec4 frustum[4];
frustum[0] = ConvertProjToView( vec4( pxm / float(uWindowWidthEvenlyDivisibleByTileRes) * 2.0f - 1.0f, (uWindowHeightEvenlyDivisibleByTileRes - pym) / float(uWindowHeightEvenlyDivisibleByTileRes) * 2.0f - 1.0f, 1.0f, 1.0f) );
frustum[1] = ConvertProjToView( vec4( pxp / float(uWindowWidthEvenlyDivisibleByTileRes) * 2.0f - 1.0f, (uWindowHeightEvenlyDivisibleByTileRes - pym) / float(uWindowHeightEvenlyDivisibleByTileRes) * 2.0f - 1.0f, 1.0f, 1.0f) );
frustum[2] = ConvertProjToView( vec4( pxp / float(uWindowWidthEvenlyDivisibleByTileRes) * 2.0f - 1.0f, (uWindowHeightEvenlyDivisibleByTileRes - pyp) / float(uWindowHeightEvenlyDivisibleByTileRes) * 2.0f - 1.0f, 1.0f ,1.0f) );
frustum[3] = ConvertProjToView( vec4( pxm / float(uWindowWidthEvenlyDivisibleByTileRes) * 2.0f - 1.0f, (uWindowHeightEvenlyDivisibleByTileRes - pyp) / float(uWindowHeightEvenlyDivisibleByTileRes) * 2.0f - 1.0f, 1.0f, 1.0f) );
for (int i = 0; i < 4; i++)
frustumEqn[i] = CreatePlaneEquation(frustum[i], frustum[(i+1) & 3]);
barrier();
int threadsPerTile = WORK_GROUP_SIZE * WORK_GROUP_SIZE;
for (uint i = 0; i < MAX_LIGHTS; i+= threadsPerTile)
{
uint il = gl_LocalInvocationIndex + i;
if (il < MAX_LIGHTS)
{
PointLight p = pointLights[il];
vec4 viewPos = view * vec4(p.position, 1.0f);
float r = p.radius;
if (viewPos.z + minDepthZ < r && viewPos.z - maxDepthZ < r)
{
if( ( GetSignedDistanceFromPlane( viewPos, frustumEqn[0] ) < r ) &&
( GetSignedDistanceFromPlane( viewPos, frustumEqn[1] ) < r ) &&
( GetSignedDistanceFromPlane( viewPos, frustumEqn[2] ) < r ) &&
( GetSignedDistanceFromPlane( viewPos, frustumEqn[3] ) < r) )
{
uint id = atomicAdd(pointLightCount, 1);
pointLightIndex[id] = il;
}
}
}
}
barrier();
vec4 diffuseColor = imageLoad(diffuse, pixelPos);
vec4 specularColor = imageLoad(specular, pixelPos);
vec4 glowColor = imageLoad(glowMatID, pixelPos);
vec2 uv = vec2(pixelPos.x / 1280.0f, pixelPos.y / 720.0f);
vec3 wp = ReconstructWP(d, uv);
vec4 color = vec4(0.0f, 0.0f, 0.0f, 1.0f);
for (int i = 0; i < pointLightCount; i++)
{
color += CalculateLighting( pointLights[pointLightIndex[i]], wp, normalColor.xyz, specularColor, glowColor);
}
barrier();
if (gl_LocalInvocationID.x == 0 || gl_LocalInvocationID.y == 0 || gl_LocalInvocationID.x == 16 || gl_LocalInvocationID.y == 16)
imageStore(outTexture, pixelPos, vec4(.2f, .2f, .2f, 1.0f));
else
{
imageStore(outTexture, pixelPos, color);
//imageStore(outTexture, pixelPos, vec4(maxDepthZ));
//imageStore(outTexture, pixelPos, vec4(pointLightCount / 128.0f));
//imageStore(outTexture, pixelPos, vec4(vec2(tilePos.xy), 0.0f, 1.0f));
}
}
C'est la partie que je pense être le problème, la partie d'abattage:
barrier();
float minDepthZ = float(minDepth / float(0xFFFFFFFF));
float maxDepthZ = float(maxDepth / float(0xFFFFFFFF));
vec4 frustumEqn[4];
uint pxm = WORK_GROUP_SIZE * gl_WorkGroupID.x;
uint pym = WORK_GROUP_SIZE * gl_WorkGroupID.y;
uint pxp = WORK_GROUP_SIZE * (gl_WorkGroupID.x + 1);
uint pyp = WORK_GROUP_SIZE * (gl_WorkGroupID.y + 1);
uint uWindowWidthEvenlyDivisibleByTileRes = WORK_GROUP_SIZE * GetNumTilesX();
uint uWindowHeightEvenlyDivisibleByTileRes = WORK_GROUP_SIZE * GetNumTilesY();
vec4 frustum[4];
frustum[0] = ConvertProjToView( vec4( pxm / float(uWindowWidthEvenlyDivisibleByTileRes) * 2.0f - 1.0f, (uWindowHeightEvenlyDivisibleByTileRes - pym) / float(uWindowHeightEvenlyDivisibleByTileRes) * 2.0f - 1.0f, 1.0f, 1.0f) );
frustum[1] = ConvertProjToView( vec4( pxp / float(uWindowWidthEvenlyDivisibleByTileRes) * 2.0f - 1.0f, (uWindowHeightEvenlyDivisibleByTileRes - pym) / float(uWindowHeightEvenlyDivisibleByTileRes) * 2.0f - 1.0f, 1.0f, 1.0f) );
frustum[2] = ConvertProjToView( vec4( pxp / float(uWindowWidthEvenlyDivisibleByTileRes) * 2.0f - 1.0f, (uWindowHeightEvenlyDivisibleByTileRes - pyp) / float(uWindowHeightEvenlyDivisibleByTileRes) * 2.0f - 1.0f, 1.0f ,1.0f) );
frustum[3] = ConvertProjToView( vec4( pxm / float(uWindowWidthEvenlyDivisibleByTileRes) * 2.0f - 1.0f, (uWindowHeightEvenlyDivisibleByTileRes - pyp) / float(uWindowHeightEvenlyDivisibleByTileRes) * 2.0f - 1.0f, 1.0f, 1.0f) );
for (int i = 0; i < 4; i++)
frustumEqn[i] = CreatePlaneEquation(frustum[i], frustum[(i+1) & 3]);
barrier();
int threadsPerTile = WORK_GROUP_SIZE * WORK_GROUP_SIZE;
for (uint i = 0; i < MAX_LIGHTS; i+= threadsPerTile)
{
uint il = gl_LocalInvocationIndex + i;
if (il < MAX_LIGHTS)
{
PointLight p = pointLights[il];
vec4 viewPos = view * vec4(p.position, 1.0f);
float r = p.radius;
if (viewPos.z + minDepthZ < r && viewPos.z - maxDepthZ < r)
{
if( ( GetSignedDistanceFromPlane( viewPos, frustumEqn[0] ) < r ) &&
( GetSignedDistanceFromPlane( viewPos, frustumEqn[1] ) < r ) &&
( GetSignedDistanceFromPlane( viewPos, frustumEqn[2] ) < r ) &&
( GetSignedDistanceFromPlane( viewPos, frustumEqn[3] ) < r) )
{
uint id = atomicAdd(pointLightCount, 1);
pointLightIndex[id] = il;
}
}
}
}
barrier();Ce qui est bizarre, c'est que lorsque je visualise le nombre de lumière par tuile, cela montre toutes les tuiles ayant une certaine forme de lumière (première image).
La deuxième image montre la sortie finale, une fine ligne de lumière au milieu de l'écran et rien au-dessus ou en dessous. La suppression de l'abattage (GetSignedDistanceFromPlane ()) donne le résultat souhaité, bien que mon taux de rafraîchissement tombe comme un rocher.
Je suppose que le tronc est mal construit, mais je ne suis pas sûr des calculs et je pourrais utiliser de l'aide pour le moment.
Modifier: Ajout d'une autre image qui montre la sortie attendue.
MISE À JOUR 1
Nous avons changé la façon dont l'abattage est fait, le code ressemble maintenant à ceci:
barrier();
float minDepthZ = float(minDepth / float(0xFFFFFFFF));
float maxDepthZ = float(maxDepth / float(0xFFFFFFFF));
//total tiles = tileScale * 2
vec2 tileScale = vec2(1280, 720) * (1.0f / float(2*WORK_GROUP_SIZE));
vec2 tileBias = tileScale - vec2(gl_WorkGroupID.xy);
vec4 c1 = vec4(-proj[0][0] * tileScale.x, 0.0f, tileBias.x, 0.0f);
vec4 c2 = vec4(0.0f, -proj[1][1] * tileScale.y, tileBias.y, 0.0f);
vec4 c4 = vec4(0.0f, 0.0f, 1.0f, 0.0f);
// Derive frustum planes
vec4 frustumPlanes[6];
// Sides
//right
frustumPlanes[0] = c4 - c1;
//left
frustumPlanes[1] = c4 + c1;
//bottom
frustumPlanes[2] = c4 - c2;
//top
frustumPlanes[3] = c4 + c2;
// Near/far
frustumPlanes[4] = vec4(0.0f, 0.0f, 1.0f, -minDepthZ);
frustumPlanes[5] = vec4(0.0f, 0.0f, -1.0f, maxDepthZ);
for(int i = 0; i < 4; i++)
{
frustumPlanes[i] *= 1.0f / length(frustumPlanes[i].xyz);
}
//DO CULLING HERE
for (uint lightIndex = gl_LocalInvocationIndex; lightIndex < numActiveLights; lightIndex += WORK_GROUP_SIZE)
{
PointLight p = pointLights[lightIndex];
if (lightIndex < numActiveLights)
{
bool inFrustum = true;
for (uint i = 0; i < 4; i++)
{
float dd = dot(frustumPlanes[i], view * vec4(p.position, 1.0f));
inFrustum = inFrustum && (dd >= -p.radius_length);
}
if (inFrustum)
{
uint id = atomicAdd(pointLightCount, 1);
pointLightIndex[id] = lightIndex;
}
}
}
barrier();Cela fonctionne mieux, nos lumières sont maintenant éliminées correctement (sauf la profondeur min / max car elle n'est pas encore implémentée correctement) contre nos tuiles. Jusqu'ici, tout va bien, MAIS! Nous avons un problème avec les bords des lumières, les carreaux ne couvrent pas tout le rayon de lumière et les performances sont illimitées. 1024 lumières donne au mieux 40fps avec des tonnes de bégaiement.
Cette vidéo montre ce qui se passe sur les bords, les tuiles grises sont les tuiles affectées par la lumière (lumière ponctuelle unique) et les parties rouges sont la géométrie ombrée.
http://www.youtube.com/watch?v=PiwGcFb9rWk&feature=youtu.be
La mise à l'échelle du rayon pour qu'il soit plus grand lors de l'abattage "fonctionne" mais rend les performances encore plus difficiles.