spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

Quellcode

color= color * (1 - sampleValue)  + sampleColor * sampleValue

HLSL-Quelltext

Shader "Custom/VolumeRenderer"
{
    Properties
    {
        _VolumeTex ("Volume Texture", 3D) = "white" {}
        _MaxSteps ("Max Steps", Int) = 64
        _Density ("Density", Float) = 1.0
        _TransferTex ("Transfer Texture", 2D) = "white" {}

    }
    SubShader
    {
        Tags { "Queue"="Transparent" 
                "RenderType"="Transparent"
                "ForceNoShadowCasting"="True" }

        Pass
        {
            Blend One One
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            
            #include "UnityCG.cginc"

            struct appdata
            {
                float4 vertex : POSITION;
            };

            struct v2f
            {
                float4 vertex : SV_POSITION;
                float4 localPos : TEXCOORD0;
            };

            sampler3D _VolumeTex;
            sampler2D _TransferTex;
            int _MaxSteps;
            float _Density;
            
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.localPos = v.vertex;
                return o;
            }

            float2 lineBoxIntersection(float3 invRayDir, float3 localCamPos)
            {
                float3 isect0 = (0 - localCamPos) * invRayDir;
                float3 isect1 = (1 - localCamPos) * invRayDir;
                float3 closest = min(isect0, isect1);
                float3 furthest = max(isect0, isect1);

                float t0 = max(closest.x, max(closest.y, closest.z));
                float t1 = min(furthest.x, min(furthest.y, furthest.z));

                return float2(t0, t1);
            }

            fixed4 frag (v2f i) : SV_Target
            {
                // Preparation stage
                float3 localCamPos = mul(unity_WorldToObject, float4(_WorldSpaceCameraPos, 1.00000000)).xyz;
                
                float3 viewDir = normalize(i.localPos - localCamPos);

                // transforms camera pos, so that in the box you have coordinate from [0;1] instead of [-0.5;0.5]
                // Assumes uniformly scaled box with pivot in the center and corresponding [-0.5;0.5] vertex coords
                localCamPos = (localCamPos) + 0.5;

                // Precomputes reciprocal ray direction for line-box intersection
                float3 invRayDir = 1.0f / viewDir;

                // Calculate intersections
                float2 t = lineBoxIntersection(invRayDir, localCamPos);

                // Aligning first sample point to view planes to remove moire-aliasing
                //float planeOffset = 1 - frac((t.x - length(localCamPos - 0.5)) * _MaxSteps);
                //t.x += (planeOffset / _MaxSteps);
                //t.x = max(0, t.x);
                float3 entryPos = localCamPos + (max(0, t.x) * viewDir);

                // Calculate thickness of the box, i.e. 1.0 iff the ray goes parallel to one side and can go 
                // up to sqrt(2) for a ray from one corner diagonal to the opposite
                // We need this, so that we know how many steps we have to take
                float boxThickness = max(0, t.y - t.x);
                
                // We keep the original step size
                float stepSize = 1.0 / _MaxSteps;
                float actualStepCount = floor(boxThickness * _MaxSteps);
                actualStepCount = clamp(actualStepCount, 0, 512);

                // Actual ray marching
                // Perform back-to-front ray-marching
                float3 endPos = entryPos + viewDir * actualStepCount * stepSize;

                float3 color = float3(0,0,0);
                
                for(int i = 0; i < actualStepCount; i++)
                {
                    float sampleValue = tex3Dlod(_VolumeTex, float4(endPos,0.f)).a;
                    float4 transferColor = tex2Dlod(_TransferTex, float4(sampleValue, 0.0f, 0.0f, 0.0f));
                    sampleValue *= transferColor.a;
                    color = color * (1.0f - sampleValue) + transferColor.rgb * sampleValue * stepSize * 64;
                    endPos -= viewDir * stepSize;
                }

                // exponential density function
                //float finalColor =  1 - exp(-accumdist * _Density);
                return fixed4(color, 1);
            }
            ENDCG
        }
    }
}

HLSL-Quelltext

float3 color = float3(0,0,0);

float3 localCamVec = normalize(mul(Parameters.CameraVector, Primitive.WorldToLocal));

float3 endPos = CurPos + -localCamVec * MaxSteps * StepSize;

for(int i = 0; i < MaxSteps; i++)
{
    float3 satPos = saturate(endPos);

    float curSample = Tex.SampleLevel(TexSampler, satPos, 0).r;

    float4 transferColor = Transfer.SampleLevel(TransferSampler,
    float2(curSample, 0.0f),0); 
    curSample *= transferColor.a;
    color = color * (1.0f - curSample) + curSample * transferColor.rgb * StepSize * 64;
    endPos += localCamVec * StepSize;
}

return color;