SDF Fog Raymarch Shader

2024-07-31 14:11 UTC gpt-4o Open in ChatGPT ↗

You

a unity shader that performs simple fog-style (cumulative) raymarcing on an sdf, represented as a texture3d

ChatGPT

Certainly! Below is an example of a Unity shader that performs simple fog-style cumulative raymarching on a signed distance field (SDF) represented as a Texture3D. This shader will sample the SDF and accumulate fog density as it marches through the volume.

Unity Shader Code

This shader code uses the built-in Unity ShaderLab syntax and HLSL for the raymarching logic.

Shader "Custom/SDFRaymarchFog"
{
    Properties
    {
        _MainTex ("Texture", 3D) = "white" {}
        _LightColor ("Light Color", Color) = (1, 1, 1, 1)
        _FogDensity ("Fog Density", Range(0.0, 1.0)) = 0.1
        _MaxDistance ("Max Distance", Range(0.0, 100.0)) = 50.0
        _StepSize ("Step Size", Range(0.001, 1.0)) = 0.1
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float3 worldPos : TEXCOORD0;
                float3 worldNormal : TEXCOORD1;
                float2 uv : TEXCOORD2;
            };

            sampler3D _MainTex;
            float4 _MainTex_ST;
            float4 _LightColor;
            float _FogDensity;
            float _MaxDistance;
            float _StepSize;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                o.worldNormal = mul((float3x3)unity_ObjectToWorld, v.normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            float sdf(vec3 p)
            {
                return tex3D(_MainTex, p).r;
            }

            float raymarch(vec3 ro, vec3 rd, out float3 color)
            {
                float t = 0.0;
                float density = 0.0;
                for (int i = 0; i < 256; i++)
                {
                    float3 pos = ro + t * rd;
                    float d = sdf(pos);
                    if (d < 0.001)
                    {
                        break;
                    }
                    density += _FogDensity * (1.0 - exp(-d * _FogDensity));
                    t += _StepSize;
                    if (t > _MaxDistance) break;
                }
                color = _LightColor.rgb * density;
                return density;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 ro = i.worldPos;
                float3 rd = normalize(i.worldNormal);

                float3 color;
                float density = raymarch(ro, rd, color);

                return fixed4(color, 1.0);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

Explanation

1. Properties: The shader properties include the 3D texture for the SDF, light color, fog density, maximum distance for the raymarch, and step size for the raymarch.

2. Vertex Shader (vert): Transforms vertex positions and normals to world space and passes them to the fragment shader.

3. Signed Distance Function (sdf): Samples the Texture3D at a given position.

4. Raymarch Function (raymarch):

   • Initializes the distance t and density accumulation.
   • Iterates over a maximum of 256 steps (this can be adjusted).
   • Samples the SDF and accumulates fog density.
   • Breaks out of the loop if the maximum distance is exceeded or the SDF value is below a threshold.

5. Fragment Shader (frag):

   • Calls the raymarch function.
   • Computes the color based on accumulated fog density and light color.
   • Returns the computed color.

Usage

1. Create a new material in Unity and assign this shader to it.
2. Assign a Texture3D to the material’s _MainTex property.
3. Adjust the properties such as fog density, maximum distance, and step size to achieve the desired effect.

This shader should provide a basic fog-style cumulative raymarching effect on an SDF represented as a Texture3D. Adjust the parameters and iteration limits as needed for performance and visual quality.

You

we need to account for the fact that we display the SDF inside a box with a certain size and location in world space

ChatGPT

Certainly! We can adjust the shader to account for the SDF being displayed inside a box of a specific size and location in world space. We’ll introduce additional properties to define the bounds and scale of the box and modify the raymarching logic to account for these bounds.

Here’s the updated shader code:

Shader "Custom/SDFRaymarchFog"
{
    Properties
    {
        _MainTex ("Texture", 3D) = "white" {}
        _LightColor ("Light Color", Color) = (1, 1, 1, 1)
        _FogDensity ("Fog Density", Range(0.0, 1.0)) = 0.1
        _MaxDistance ("Max Distance", Range(0.0, 100.0)) = 50.0
        _StepSize ("Step Size", Range(0.001, 1.0)) = 0.1
        _BoxMin ("Box Min", Vector) = (-1, -1, -1, 1)
        _BoxMax ("Box Max", Vector) = (1, 1, 1, 1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float3 worldPos : TEXCOORD0;
                float3 worldNormal : TEXCOORD1;
                float2 uv : TEXCOORD2;
            };

            sampler3D _MainTex;
            float4 _MainTex_ST;
            float4 _LightColor;
            float _FogDensity;
            float _MaxDistance;
            float _StepSize;
            float4 _BoxMin;
            float4 _BoxMax;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                o.worldNormal = mul((float3x3)unity_ObjectToWorld, v.normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            float sdf(vec3 p)
            {
                // Transform point to [0,1] range for texture sampling
                vec3 boxSize = _BoxMax.xyz - _BoxMin.xyz;
                vec3 localPos = (p - _BoxMin.xyz) / boxSize;
                return tex3D(_MainTex, localPos).r;
            }

            float3 getRayBoxIntersection(vec3 ro, vec3 rd, vec3 boxMin, vec3 boxMax)
            {
                vec3 invDir = 1.0 / rd;
                vec3 tMin = (boxMin - ro) * invDir;
                vec3 tMax = (boxMax - ro) * invDir;
                vec3 t1 = min(tMin, tMax);
                vec3 t2 = max(tMin, tMax);
                float tNear = max(max(t1.x, t1.y), t1.z);
                float tFar = min(min(t2.x, t2.y), t2.z);
                return float3(tNear, tFar, tFar >= tNear ? 1.0 : 0.0);
            }

            float raymarch(vec3 ro, vec3 rd, out float3 color)
            {
                // Get the intersection of the ray with the box
                float3 tHit = getRayBoxIntersection(ro, rd, _BoxMin.xyz, _BoxMax.xyz);
                if (tHit.z == 0.0)
                {
                    color = float3(0, 0, 0);
                    return 0.0;
                }

                float t = max(0.0, tHit.x);
                float density = 0.0;
                for (int i = 0; i < 256; i++)
                {
                    float3 pos = ro + t * rd;
                    float d = sdf(pos);
                    if (d < 0.001)
                    {
                        break;
                    }
                    density += _FogDensity * (1.0 - exp(-d * _FogDensity));
                    t += _StepSize;
                    if (t > min(tHit.y, _MaxDistance)) break;
                }
                color = _LightColor.rgb * density;
                return density;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 ro = i.worldPos;
                float3 rd = normalize(i.worldNormal);

                float3 color;
                float density = raymarch(ro, rd, color);

                return fixed4(color, 1.0);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

Explanation of Changes

1. Properties: Added _BoxMin and _BoxMax to define the bounds of the box in world space.

2. sdf Function: Transforms the world space point to the local space of the Texture3D by normalizing the coordinates based on _BoxMin and _BoxMax.

3. getRayBoxIntersection Function: Computes the intersection points of the ray with the box. It returns the near and far intersection distances and a flag indicating if there was an intersection.

4. raymarch Function:

   • Computes the intersection of the ray with the box using getRayBoxIntersection.
   • Starts the raymarch at the intersection point.
   • Accumulates fog density within the bounds of the box and stops if it reaches the far intersection distance or exceeds the maximum distance.

This updated shader should now correctly handle the raymarching within a defined box in world space. Adjust the _BoxMin and _BoxMax properties to position and scale the box as needed in your scene.

You

make sure that if a ray goes through an area and doesn’t accumulate much, it should get discarded (transparent).

ChatGPT

To ensure that rays which pass through areas without significant fog density are discarded and rendered as transparent, we can introduce a threshold for the accumulated density. If the density is below this threshold, the fragment shader will output a fully transparent color.

Here’s the updated shader code:

Shader "Custom/SDFRaymarchFog"
{
    Properties
    {
        _MainTex ("Texture", 3D) = "white" {}
        _LightColor ("Light Color", Color) = (1, 1, 1, 1)
        _FogDensity ("Fog Density", Range(0.0, 1.0)) = 0.1
        _MaxDistance ("Max Distance", Range(0.0, 100.0)) = 50.0
        _StepSize ("Step Size", Range(0.001, 1.0)) = 0.1
        _BoxMin ("Box Min", Vector) = (-1, -1, -1, 1)
        _BoxMax ("Box Max", Vector) = (1, 1, 1, 1)
        _DensityThreshold ("Density Threshold", Range(0.0, 1.0)) = 0.01
    }
    SubShader
    {
        Tags { "Queue" = "Transparent" "RenderType"="Transparent" }
        Blend SrcAlpha OneMinusSrcAlpha
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float3 worldPos : TEXCOORD0;
                float3 worldNormal : TEXCOORD1;
                float2 uv : TEXCOORD2;
            };

            sampler3D _MainTex;
            float4 _MainTex_ST;
            float4 _LightColor;
            float _FogDensity;
            float _MaxDistance;
            float _StepSize;
            float4 _BoxMin;
            float4 _BoxMax;
            float _DensityThreshold;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                o.worldNormal = mul((float3x3)unity_ObjectToWorld, v.normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            float sdf(vec3 p)
            {
                // Transform point to [0,1] range for texture sampling
                vec3 boxSize = _BoxMax.xyz - _BoxMin.xyz;
                vec3 localPos = (p - _BoxMin.xyz) / boxSize;
                return tex3D(_MainTex, localPos).r;
            }

            float3 getRayBoxIntersection(vec3 ro, vec3 rd, vec3 boxMin, vec3 boxMax)
            {
                vec3 invDir = 1.0 / rd;
                vec3 tMin = (boxMin - ro) * invDir;
                vec3 tMax = (boxMax - ro) * invDir;
                vec3 t1 = min(tMin, tMax);
                vec3 t2 = max(tMin, tMax);
                float tNear = max(max(t1.x, t1.y), t1.z);
                float tFar = min(min(t2.x, t2.y), t2.z);
                return float3(tNear, tFar, tFar >= tNear ? 1.0 : 0.0);
            }

            float raymarch(vec3 ro, vec3 rd, out float3 color)
            {
                // Get the intersection of the ray with the box
                float3 tHit = getRayBoxIntersection(ro, rd, _BoxMin.xyz, _BoxMax.xyz);
                if (tHit.z == 0.0)
                {
                    color = float3(0, 0, 0);
                    return 0.0;
                }

                float t = max(0.0, tHit.x);
                float density = 0.0;
                for (int i = 0; i < 256; i++)
                {
                    float3 pos = ro + t * rd;
                    float d = sdf(pos);
                    if (d < 0.001)
                    {
                        break;
                    }
                    density += _FogDensity * (1.0 - exp(-d * _FogDensity));
                    t += _StepSize;
                    if (t > min(tHit.y, _MaxDistance)) break;
                }
                color = _LightColor.rgb * density;
                return density;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 ro = i.worldPos;
                float3 rd = normalize(i.worldNormal);

                float3 color;
                float density = raymarch(ro, rd, color);

                if (density < _DensityThreshold)
                {
                    return fixed4(0, 0, 0, 0); // Transparent
                }

                return fixed4(color, density);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

Explanation of Changes

1. Properties: Added _DensityThreshold to define the minimum accumulated density required to render the fragment as opaque.

2. Blend: Set the blend mode to handle transparency using Blend SrcAlpha OneMinusSrcAlpha.

3. frag Function:

   • After computing the density using raymarching, it checks if the accumulated density is below the threshold (_DensityThreshold).
   • If the density is below the threshold, the fragment shader returns a fully transparent color.
   • Otherwise, it returns the computed color and density.

This shader now discards rays that do not accumulate enough fog density, rendering those areas as transparent. Adjust the _DensityThreshold property to control the sensitivity of this threshold.

You

what is the largest dustance in a cube of 50 x 50 x 50 ?

ChatGPT

The largest distance in a cube of dimensions $50 \times 50 \times 50$ is the length of the space diagonal of the cube. The space diagonal of a cube can be calculated using the formula:

$$ d = \sqrt{a^2 + a^2 + a^2} $$

where $ a $ is the side length of the cube.

For a cube of side length 50:

$$ d = \sqrt{50^2 + 50^2 + 50^2} $$ $$ d = \sqrt{3 \cdot 50^2} $$ $$ d = \sqrt{3} \cdot 50 $$ $$ d = 50\sqrt{3} $$ $$ d \approx 50 \times 1.732 $$ $$ d \approx 86.6 $$

Therefore, the largest distance in a cube of $50 \times 50 \times 50$ is approximately $86.6$ units.

You

why does the shader only “paint” the sides of the cube, and it doesn’t really look volumetric?

ChatGPT

The issue might be due to the ray direction or the initial point of ray intersection with the cube’s surface. Here’s a checklist and some modifications to ensure the shader properly performs volumetric rendering:

1. Correct Ray Direction: Ensure the ray direction is calculated correctly from the camera or view direction.
2. Proper Ray Entry Point: Ensure the ray enters the box correctly and accumulates density through its traversal within the box.
3. Correct Mapping to Local Space: Ensure the coordinates are properly transformed to the local space of the texture.

Here’s an updated version of the shader with these considerations:

Shader "Custom/SDFRaymarchFog"
{
    Properties
    {
        _MainTex ("Texture", 3D) = "white" {}
        _LightColor ("Light Color", Color) = (1, 1, 1, 1)
        _FogDensity ("Fog Density", Range(0.0, 1.0)) = 0.1
        _MaxDistance ("Max Distance", Range(0.0, 100.0)) = 50.0
        _StepSize ("Step Size", Range(0.001, 1.0)) = 0.1
        _BoxMin ("Box Min", Vector) = (-1, -1, -1, 1)
        _BoxMax ("Box Max", Vector) = (1, 1, 1, 1)
        _DensityThreshold ("Density Threshold", Range(0.0, 1.0)) = 0.01
    }
    SubShader
    {
        Tags { "Queue" = "Transparent" "RenderType"="Transparent" }
        Blend SrcAlpha OneMinusSrcAlpha
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
                float3 normal : NORMAL;
                float2 uv : TEXCOORD0;
            };

            struct v2f
            {
                float4 pos : SV_POSITION;
                float3 worldPos : TEXCOORD0;
                float3 worldNormal : TEXCOORD1;
                float2 uv : TEXCOORD2;
            };

            sampler3D _MainTex;
            float4 _MainTex_ST;
            float4 _LightColor;
            float _FogDensity;
            float _MaxDistance;
            float _StepSize;
            float4 _BoxMin;
            float4 _BoxMax;
            float _DensityThreshold;

            v2f vert (appdata v)
            {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);
                o.worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
                o.worldNormal = mul((float3x3)unity_ObjectToWorld, v.normal);
                o.uv = TRANSFORM_TEX(v.uv, _MainTex);
                return o;
            }

            float sdf(vec3 p)
            {
                // Transform point to [0,1] range for texture sampling
                vec3 boxSize = _BoxMax.xyz - _BoxMin.xyz;
                vec3 localPos = (p - _BoxMin.xyz) / boxSize;
                return tex3D(_MainTex, localPos).r;
            }

            float3 getRayBoxIntersection(vec3 ro, vec3 rd, vec3 boxMin, vec3 boxMax)
            {
                vec3 invDir = 1.0 / rd;
                vec3 tMin = (boxMin - ro) * invDir;
                vec3 tMax = (boxMax - ro) * invDir;
                vec3 t1 = min(tMin, tMax);
                vec3 t2 = max(tMin, tMax);
                float tNear = max(max(t1.x, t1.y), t1.z);
                float tFar = min(min(t2.x, t2.y), t2.z);
                return float3(tNear, tFar, tFar >= tNear ? 1.0 : 0.0);
            }

            float raymarch(vec3 ro, vec3 rd, out float3 color)
            {
                // Get the intersection of the ray with the box
                float3 tHit = getRayBoxIntersection(ro, rd, _BoxMin.xyz, _BoxMax.xyz);
                if (tHit.z == 0.0)
                {
                    color = float3(0, 0, 0);
                    return 0.0;
                }

                float t = max(0.0, tHit.x);
                float density = 0.0;
                for (int i = 0; i < 256; i++)
                {
                    float3 pos = ro + t * rd;
                    float d = sdf(pos);
                    if (d < 0.001)
                    {
                        break;
                    }
                    density += _FogDensity * (1.0 - exp(-d * _FogDensity));
                    t += _StepSize;
                    if (t > min(tHit.y, _MaxDistance)) break;
                }
                color = _LightColor.rgb * density;
                return density;
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float3 ro = _WorldSpaceCameraPos;  // Camera position
                float3 rd = normalize(i.worldPos - ro);  // Ray direction

                float3 color;
                float density = raymarch(ro, rd, color);

                if (density < _DensityThreshold)
                {
                    return fixed4(0, 0, 0, 0); // Transparent
                }

                return fixed4(color, density);
            }
            ENDCG
        }
    }
    FallBack "Diffuse"
}

Explanation of Changes

1. Correct Ray Direction: Instead of using the vertex normal for the ray direction, calculate it based on the world position of the fragment and the camera position.

   • float3 ro = _WorldSpaceCameraPos; sets the ray origin to the camera position.
   • float3 rd = normalize(i.worldPos - ro); computes the ray direction from the camera to the fragment.

2. Density Check and Transparency: After accumulating the density, the shader checks if it is below the _DensityThreshold. If it is, it discards the fragment by returning a fully transparent color.

These changes ensure that the ray correctly traverses through the volume, and fragments with low accumulated density are rendered transparent, creating a more volumetric effect.