Generating a normal map from a height map in compute shader?-CodePudding

The problem is that when I tried converting height map to normal map. The results are wrong. For some reason there is 3 light sources that is emitting from top (green), right (red), and left (blue) in the texture.

This is the GeoMath.hlsl code that I am using

static const float PI = 3.141592653589793238462643383279;

float2 longitudeLatitudeToUV(float2 longLat) {
    float longitude = longLat[0];
    float latitude = longLat[1];
    
    float u = longitude / (2 * PI)   0.5;
    float v = latitude / PI   0.5;
    return float2(u,v);
}

float3 longitudeLatitudeToPoint(float2 longLat) {
    float longitude = longLat[0];
    float latitude = longLat[1];

    float x;
    float y;
    float z;

    y = sin(latitude);
    float r = cos(latitude);
    x = sin(longitude) * r;
    z = -cos(longitude) * r;

    return float3(x, y, z);
}

float2 uvToLongitudeLatitude(float2 uv) {
    float longitude = (uv.x - 0.5) * (2 * PI);
    float latitude = (uv.y - 0.5) * PI;
    return float2(longitude, latitude);
}

float2 pointToLongitudeLatitude(float3 p) {
    float longitude = atan2(p.x, p.z);
    float latitude = asin(p.y);
    return float2(longitude, latitude);
}

float2 pointToUV(float3 p) {
    p = normalize(p);
    return longitudeLatitudeToUV(pointToLongitudeLatitude(p));
}

This is the compute shader I am using to convert height map into normal map.

#pragma kernel CSMain
#include "GeoMath.hlsl"

Texture2D<float> _HeightMap;
RWTexture2D<float4> _NormalMap;
int _TextureSize_Width;
int _TextureSize_Height;
float _WorldRadius;
float _HeightMultiplier;

float3 CalculateWorldPoint(uint2 texCoord)
{
    float2 uv = texCoord / float2(_TextureSize_Width - 1, _TextureSize_Height - 1);
    float2 longLat = uvToLongitudeLatitude(uv);
    float3 spherePoint = longitudeLatitudeToPoint(longLat);

    float height01 = _HeightMap[texCoord].r   1.0;
    float worldHeight = _WorldRadius   height01 * _HeightMultiplier;

    return spherePoint * worldHeight;
}

uint2 WrapIndex(uint2 texCoord)
{
    texCoord.x = (texCoord.x   _TextureSize_Width) % _TextureSize_Width;
    texCoord.y = max(min(_TextureSize_Height - 1, texCoord.y), 0);
    return texCoord;
}

[numthreads(8,8,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{
    float3 normalVector;

    float3 posNorth = CalculateWorldPoint(WrapIndex(id.xy   uint2(0, 1)));
    float3 posSouth = CalculateWorldPoint(WrapIndex(id.xy   uint2(0, -1)));
    float3 posEast = CalculateWorldPoint(WrapIndex(id.xy   uint2(1, 0)));
    float3 posWest = CalculateWorldPoint(WrapIndex(id.xy   uint2(-1, 0)));

    float3 dirNorth = normalize(posNorth - posSouth);
    float3 dirEast = normalize(posEast - posWest);
    normalVector = normalize(cross(dirNorth, dirEast));

    _NormalMap[id.xy] = float4(normalVector, 1.0);
}

And this is the result I am getting is down below height map (top), generated normal map from the code above (bottom)

CodePudding user response：

I believe that you are trying to get object space normals. But there is tiny detail is missing. Possible values for normalized vector3 are -1..1 for each axis. And possible values for pixel: 0..1.

You just need to adjust ranges.

This line roughly fixes problem:

_NormalMap[id.xy] = float4(normalVector / 2   float3(0.5, 0.5, 0.5), 1.0);

Result