[SOLVED] Recalculate Normals (Displacement)

Unity Engine
,
1

I’m using a greyscale image to displace a plane and want to recalculate the correct normals inside of my shader. There’s a technique, which seem to work quite good, like for example in this video here, shifting additional points around:

or GLITCHERS - Games for Good

For some reason, of all the examples i tried to implement, not even one worked- Can maybe someone see, where my error lies? In most examples, they did some crazy wooble or stuff like that, but I literally just want to displace on the y-axis- What I’m missing to make it work?

5019281--491576--Displacement_Normals_1.jpg
5019281--491576--Displacement_Normals_1.jpg2271×497 167 KB

Here’s my shader:

Shader "BellsArietta/Terrain" {
    Properties {
        _Color ("Color", Color) = (1,1,1,1)
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
        _HeightMap ("Height Map", 2D) = "gray" {}
        _Glossiness ("Smoothness", Range(0,1)) = 0.5
        _Metallic ("Metallic", Range(0,1)) = 0.0
        [Header(Tessellation)]
        _TessDetail ("Tessellation", Range(1,15)) = 4
        _TessMin ("Min", float) = 5
        _TessMax ("Max", float) = 15

    }
    SubShader {
        Tags { "RenderType"="Opaque" }
        LOD 300

        CGPROGRAM
        #pragma surface surf Standard fullforwardshadows addshadow vertex:vert tessellate:tessDistance
        #pragma target 4.6
        #include "Tessellation.cginc"

        sampler2D _MainTex, _HeightMap;
        fixed4 _Color;
        half _Glossiness, _Metallic;
        fixed _TessDetail, _TessMin, _TessMax;
     

        float4 tessDistance (appdata_full v0, appdata_full v1, appdata_full v2) {
            return UnityDistanceBasedTess(v0.vertex, v1.vertex, v2.vertex, _TessMin, _TessMax, _TessDetail);
        }


        void vert (inout appdata_full v)
        {
            float d = tex2Dlod(_HeightMap, float4(v.texcoord.xy,0,0)).r;
         
            float3 v0 = v.vertex.xyz;
            float3 bitangent = cross(v.normal, v.tangent.xyz);
            float3 v1 = v0 + (v.tangent.xyz * 0.01);
            float3 v2 = v0 + (bitangent * 0.01);

            float ns0 = v0.y + d;
            float ns1 = v1.y + d;
            float ns2 = v2.y + d;

            v0.xyz += ns0 * v.normal;
            v1.xyz += ns1 * v.normal;
            v2.xyz += ns2 * v.normal;

            float3 modifiedNormal = cross(v2-v0, v1-v0);

            v.normal = normalize(-modifiedNormal);
            v.vertex.xyz = v0;
        }



        struct Input {
            float2 uv_MainTex;
        };
     
        void surf (Input IN, inout SurfaceOutputStandard o) {

            fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
            o.Albedo = c.rgb;
            o.Metallic = _Metallic;
            o.Smoothness = _Glossiness;
            o.Alpha = c.a;
        }
        ENDCG
    }
    FallBack "Diffuse"
}
2

To extra a normal from a height map you need to calculate the slope. To calculate the slope you need to sample the height at multiple offset positions and calculate the difference. The height difference relative to the distance between samples determines the slope. Two slopes gives you two vectors that the cross product of gives you the new normal.

You need to know the depth at each of the offset positions, and you’re just using the depth at the current position. The idea would be to sample the heightmap texture multiple times with fixed offsets and remap that to the surface normal. You’d have to manually scale things to match the height offset and scale of the UVs relative to the mesh’s size to get the correct normal, but that should be easy enough with a simple plane.

1 Like
3

Thanks for the advice! Also found this code snippet in another thread Calculate Vertex Normals in shader from heightmap. , which does exactly that. I modified it a bit for it to work properly though.

        float3 normalsFromHeight(sampler2D heigthTex, float4 uv, float texelSize)
        {
            float4 h;
            h[0] = tex2Dlod(heigthTex, uv + float4(texelSize * float2( 0,-1 / _texSize),0,0)).r * _Height;
            h[1] = tex2Dlod(heigthTex, uv + float4(texelSize * float2(-1 / _texSize, 0),0,0)).r * _Height;
            h[2] = tex2Dlod(heigthTex, uv + float4(texelSize * float2( 1 / _texSize, 0),0,0)).r * _Height;
            h[3] = tex2Dlod(heigthTex, uv + float4(texelSize * float2( 0, 1 / _texSize),0,0)).r * _Height;
            float3 n;
            n.z = h[3] - h[0];
            n.x = h[2] - h[1];
            n.y = 2;
            return normalize(n);
        }