Hey es,

Very interesting. Just to clarify could you
please elaborate on what you mean by 11%?
Also could you show your pixel shader? And also are you using same texture format in both cases?

Has anyone else here tried some different configurations?

Cheers,

Morten.

Hi, Morten!

I used the same BC5 textures in both cases. Here are my shaders:

Vertex Shader(derivative maps)
[source lang="cpp"]
layout(location=0) in vec3 Position;
layout(location=1) in vec2 UV;
layout(location=2) in vec3 Normal;

out block {
vec2 vUV;
vec3 vPos;
vec3 vNormal;
vec2 vScaleDuDv;
flat mat3 mNormalsWV;
} Out;

void main() {
Out.vScaleDuDv=mWorldView[gl_InstanceID][3].xy;
Out.mNormalsWV=mat3(cross(mWorldView[gl_InstanceID][1].xyz,mWorldView[gl_InstanceID][2].xyz),
cross(mWorldView[gl_InstanceID][2].xyz,mWorldView[gl_InstanceID][0].xyz),
cross(mWorldView[gl_InstanceID][0].xyz,mWorldView[gl_InstanceID][1].xyz));
Out.vUV=UV;
Out.vNormal=Normal;
Out.vPos=Position;
gl_Position=vec4((vec4(Position,1.0)*mWorldView[gl_InstanceID]).xyz,1.0)*mProjection;
}
[/source]

Fragment Shader(derivative maps)
[source lang="cpp"]
uniform sampler2D texDiffuse;
uniform sampler2D texBump;

in block {
vec2 vUV;
vec3 vPos;
vec3 vNormal;
vec2 vScaleDuDv;
flat mat3 mNormalsWV;
} In;

layout(location=0) out vec4 FragColor;

//------------------------------------------------------------------------------
// mmikkelsen3d.blogspot.com/2011/07/derivative-maps.html
//------------------------------------------------------------------------------
vec3 GetUnNormalizedBumpNormal(in vec2 dBdUV,in vec2 vUV,in vec3 vPos,in vec3 vNormal) {
// chain rule
vec2 vDxUV=dFdx(vUV);
vec2 vDyUV=dFdy(vUV);
float dBs=dot(dBdUV,vDxUV);
float dBt=dot(dBdUV,vDyUV);
vec3 vSigmaS=dFdx(vPos);
vec3 vSigmaT=dFdy(vPos);
vec3 vR1=cross(vSigmaT,vNormal);
vec3 vR2=cross(vNormal,vSigmaS);
float fDet=dot(vSigmaS,vR1);
vec3 vSurfGrad=sign(fDet)*(dBs*vR1+dBt*vR2);
return (abs(fDet)*vNormal-vSurfGrad);
}

void main() {
vec2 vDuDv=In.vScaleDuDv*(texture(texBump,In.vUV).xy*2.0-1.0);
vec3 vBumpNormal=normalize(GetUnNormalizedBumpNormal(vDuDv,In.vUV,In.vPos,normalize(In.vNormal))*In.mNormalsWV)*(gl_FrontFacing ? 1.0:-1.0);
vec4 vDiffuse=texture(texDiffuse,In.vUV);
FragColor=vec4(ToneMapFilmicU2(vSunColor*(max(dot(vSunDirection,vBumpNormal),0.0)+0.01)*vDiffuse.rgb),vDiffuse.a);
}
[/source]

Vertex Shader(tangent space)
[source lang="cpp"]
layout(location=0) in vec3 vPosition;
layout(location=1) in vec2 vUV;
layout(location=2) in vec3 vNormal;
layout(location=3) in vec4 vTangent;

out block {
vec3 vTangent;
vec3 vBiTangent;
vec3 vNormal;
vec2 vUV;
} Out;

void main() {
mat3 mNormalsWV=mat3(cross(mWorldView[gl_InstanceID][1].xyz,mWorldView[gl_InstanceID][2].xyz),
cross(mWorldView[gl_InstanceID][2].xyz,mWorldView[gl_InstanceID][0].xyz),
cross(mWorldView[gl_InstanceID][0].xyz,mWorldView[gl_InstanceID][1].xyz));
Out.vUV=vUV;
Out.vNormal=normalize(vNormal*mNormalsWV);
Out.vTangent=normalize(vTangent.xyz*mNormalsWV);
Out.vBiTangent=normalize(vTangent.w*cross(Out.vNormal,Out.vTangent));
gl_Position=vec4((vec4(vPosition,1.0)*mWorldView[gl_InstanceID]).xyz,1.0)*mProjection;
}
[/source]

Fragment Shader(tangent space)
[source lang="cpp"]
uniform sampler2D texDiffuse;
uniform sampler2D texBump;

in block {
vec3 vTangent;
vec3 vBiTangent;
vec3 vNormal;
vec2 vUV;
} In;

layout(location=0) out vec4 FragColor;

void main() {
vec3 vBump;
vBump.xy=2.0*texture(texBump,In.vUV).xy-1.0;
vBump.z=sqrt(1.0-dot(vBump.xy,vBump.xy));
vec4 vDiffuse=texture(texDiffuse,In.vUV);
vec3 vBumpNormal=normalize(normalize(In.vTangent)*vBump.x+normalize(In.vBiTangent)*vBump.y+normalize(In.vNormal)*vBump.z)*(gl_FrontFacing ? 1.0:-1.0);
FragColor=vec4(ToneMapFilmicU2(vSunColor*(max(dot(vSunDirection,vBumpNormal),0.0)+0.01)*vDiffuse.rgb),vDiffuse.a);
}
[/source]

And here are screenshots with test scene:

Sponza (derivative maps approach, 373 fps)
http://imageshack.us...7/testdudv.jpg/

Sponza (tangent space approach, 419 fps)
http://imageshack.us.../6/testtbn.jpg/

Well, 373.0 fps / 419.0 fps ~ 0.89 -> derivative maps approach is slower than tangent space approach at 11% (in my tests)

Dima.

In other words take out vScaleDuDv and mNormalsWV entirely. You're needlessly burning up
interpolators. Using fewer interpolators is supposed to be one of the advantages.

Morten, thanks for the tips!
I would like to say few words about my variables (but my english is not so good and perhaps i didn't understand your words properly). The vScaleDuDv is a user-scale for dBs and dBt and the mNormalsWV is a matrix which apply world-view transformations to normals. The world matrix can has scale factor and there are 2 options for computation of bumped-normal:
1. I can get bumped-normal in object space and then transform it in camera space(there is matrix multiplication in pixel shader).
2. I can get bumped-normal directly in camera space(and all matrix multiplications are made in vertex shader)

These 2 approaches give different results and i had doubts about right way of computation. In the end i chose the first approach.

Naughty Dog rules!
Uncharted rules!

Dima.

It looks like you are writing the .xy of the translation part of your world view to it?

no, my matrices have row-major order(like in DirectX), fourth column of world-view matrix is just float4(0,0,0,1) by default and is not important in computations. So i can use this space for my needs.

As for the shader I am still having a tough time wrapping my brain around your vScaleDuDv. The bump scale I had in mind is a single value (1 float) specified either per material, per object or both.

Well, these lines of code are from your blog:

int2 dim; dbmap.GetDimensions(dim.x, dim.y);
const float2 dBdUV = dim*(2*dbmap.Sample(sampler, In.texST).xy-1);

The vScaleDuDv has the following meaning :
const float2 vScaleDuDv=fUserScale*dim;

And In my case the vScaleDuDv is specified per object (i.e. mWorldView[gl_InstanceID1][3].xy == mWorldView[gl_InstanceID2][3].xy).

Dima.

Why don't you simply use getTextureSize() which is what I think GetDimensions() is called in glsl?

I was afraid that it could have been expensive

Did you check if there is a performance difference when perturbing in view space?

Yeah, I've installed new experimental Nvidia's drivers with OpenGL 4.2 support and here are my results:

derivative maps approach(camera space) - 415 fps
derivative maps approach(object space) - 385 fps
tangent space approach - 425 fps

But, Morten, is this correct to compute perturbing normal in view space when you have any scale factor in world matrix?
Is there any rule or maybe hint how to control user-scale for dBs and dBt or designers specify it "by sight" ?

Thanks for support,
Dima.