I've tried implementing a shader that will take a height map and compute a normal map from it. The performance results look promising, as I can generate a new normal map every frame on the GPU with about the same framerate when I was generating 4 maps per second on the CPU.
But the normal maps from the shader give some serious artifacts, as shown in the picture below. The resulting map looks too sharp and it has some 'jumpy pixels', artifacts similar to rigid JPEG encoding that shift every frame, which gives a very interesting, yet unwanted results.
And some sample heightmap & corresponding normal maps (the CPU normal map is what I hope to achieve, even though it looks a bit dull):
I'm supplying the cloud density map as a height map to the shader and tell it the width of the map to compute dU and dV for obtaining the sample points, as described in the last picture in the topic start. I use the shader in a RenderToSurface pass to render a pre-transformed quad (with the same size as the heightmap, for pixel-perfect sampling) onto the normal map texture. You can find the code for the shader below:
[source lang=hlsl]float HeightMapSize; texture HeightMap;sampler HeightMapSampler = sampler_state{ Texture = <HeightMap>; MinFilter = Linear; MagFilter = Linear; AddressU = Clamp; AddressV = Clamp;}; //application to vertex structurestruct a2v{ float4 position : POSITION0; float2 tex0 : TEXCOORD0;}; //vertex to pixel shader structurestruct v2p{ float4 position : POSITION0; float2 tex0 : TEXCOORD0;}; //pixel shader to screenstruct p2f{ float4 color : COLOR0;}; void ps( in v2p IN, out p2f OUT){ float dU = 1 / HeightMapSize; float s0 = tex2D(HeightMapSampler, IN.tex0).r; float s1 = tex2D(HeightMapSampler, float2(IN.tex0.x - dU, IN.tex0.y)).r; float s2 = tex2D(HeightMapSampler, float2(IN.tex0.x, IN.tex0.y - dU)).r; float s3 = tex2D(HeightMapSampler, float2(IN.tex0.x + dU, IN.tex0.y)).r; float s4 = tex2D(HeightMapSampler, float2(IN.tex0.x, IN.tex0.y + dU)).r; float3 v1 = float3( -dU, 0, s1 - s0); float3 v2 = float3( 0, -dU, s2 - s0); float3 v3 = float3( dU, 0, s3 - s0); float3 v4 = float3( 0, dU, s4 - s0); float3 n1 = normalize(cross( v1, v2 )); float3 n2 = normalize(cross( v2, v3 )); float3 n3 = normalize(cross( v3, v4 )); float3 n4 = normalize(cross( v4, v1 )); float3 n = normalize(n1 + n2 + n3 + n4); OUT.color = float4( (n.x + 1) / 2, (n.y + 1) / 2, (n.z + 1) / 2, 1); }; void vs( in a2v IN, out v2p OUT ){ OUT.position = IN.position; OUT.tex0 = IN.tex0; } //--------------------------------------------------------------------------------------// Techniques//--------------------------------------------------------------------------------------technique NormalMapComputation{ pass P0 { VertexShader = compile vs_1_1 vs(); PixelShader = compile ps_2_0 ps(); }}
At first I though the problem was coming from the normal encoding, so I used various texture formats for the normal map (up to ARGB32f) but that didn't help at all. So I guess there's something wrong with the normal computing shader, as the normal maps generated on the CPU do give the correct results. If someone has any idea on how to fix this, please let me know because I've been tinkering with the code for a few hours now without any result.
Does anyone see what I'm missing in the shader? Or could the artifacts perhaps be caused by the quad rendering pass? Doesn't anyone have some sample code to generate a normal map from a heightmap (in any language!), so I can check if my code is missing something?
Well, thanks again... *crosses fingers* :)
From some articles here at GameDev I read that the clouds are typically shaded using some basic form of raytracing. I get the general idea, but I'm not quite sure on how to implement this at all, let alone efficiently. So I decided to go for bump mapping on the clouds to get that shaded look, which gives the added bonus that the sun's position is taken into account. This turned out like this (sun position set to around 3pm):
I generate the normal map on the CPU using the cloud density map as a height field, with TextureLoader.ComputeNormalMap. It works, but it's quite slow. If I generate the normal map every frame, my framerate drops to 30, so for now I settled for recalculating the normal 4 times per second, which still has quite an impact on the framerate (about -400 fps, when you disregard the rendering overhead) and it occasionally produces some (minor) lighting artifacts.
Now, there's three things I had in mind to solve this. I could simply forget about the shading, since I'm not 100% convinced it's worth the performance penalty. What do YOU think?
The second approach would be to generate the normal map asynchronously on another thread, leveraging today's common hyperthreading/dual core to keep the framerate up. This approach would be the easiest real solution, but I don't know if it'll give any significant speed gains. Does anyone have any experience with this or something similar?
And finally I was wondering, wouldn't it be possible to dynamically calculate the normal map on the GPU once I got the octaves composed? I'm not entirely sure about how to code it, but the approach would be to use a shader and RenderToSurface again to sample the 'height values' on the cloud density map, like this:
That way I could calculate the surface normals of the adjacent triangles and use the to calculate the normal for S0. But still, it would be a bit difficult to code in order to get it just right in HLSL, especially with the sampling. Does anyone know how the DirectX method TextureLoader.ComputeNormalMap works internally? A code snippet on this would really help out. A complete shader that already does this is also very welcome, of course :)
Well, thanks for bearing with me this long. If you have suggestions for alternatives or any other comments, please let's hear em.
[Edited by - remigius on December 2, 2005 11:04:00 AM]
