Blog

This is my implementation of Alan Zucconi’s tutorial on Volumetric Rendering.

This is a vertex and fragment shader.

An important observation I made is the order of declaring functions is important. A function must be declared before it can be called by another function.

I expanded on the tutorial by declaring Properties, making the center of the sphere and its size available from Unity’s inspector. This way I could play with values without updating the shader each time.

Properties
{
	_Center ("Center", Vector) = (0, 0, 0, 0)
	_Radius ("Radius", Float) = 0.5
}

In the vertex function I get the world position of the vertex for use in the fragment function.

v2f vert (appdata_base input)
{
	v2f output;
	output.vertex = UnityObjectToClipPos(input.vertex);
	output.wPos = mul(unity_ObjectToWorld, input.vertex).xyz; 

	return output;
}

The fragment function is where most of the work in this shader happens.

fixed4 frag (v2f input) : SV_Target
{
	float3 worldPos = input.wPos;
	float3 viewDir = normalize(input.wPos - _WorldSpaceCameraPos);

	fixed4 color;

	if (raymarchHit(worldPos, viewDir))
	{
		color = fixed4(1,0,0,1);
	}
	else
	{
		color = fixed4(1,1,1,1);
	}

	return color;
}

Full listing:

Shader "Custom/VolumetricSphere"
{
	Properties
	{
		_Center ("Center", Vector) = (0, 0, 0, 0)
		_Radius ("Radius", Float) = 0.5
	}
	SubShader
	{
		Tags { "RenderType"="Opaque" }

		Pass
		{
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			
			#include "UnityCG.cginc"
			
			float3 _Center;
			float _Radius;
		
			#define STEPS 64
			#define STEP_SIZE 0.01

			struct v2f
			{
				float4 vertex : SV_POSITION;
				float3 wPos : TEXCOORD1;
			};

			bool sphereHit(float3 pos)
			{
				return distance(pos, _Center) < _Radius;
			}

			bool raymarchHit(float3 worldPos, float3 viewDir)
			{
				for (int i = 0; i < STEPS; i++)
				{
					if (sphereHit(worldPos))
					{
						return true;
					}

					worldPos += viewDir * STEP_SIZE;
				}

				return false;
			}

			v2f vert (appdata_base input)
			{
				v2f output;
				output.vertex = UnityObjectToClipPos(input.vertex);
				output.wPos = mul(unity_ObjectToWorld, input.vertex).xyz; 

				return output;
			}

			fixed4 frag (v2f input) : SV_Target
			{
				float3 worldPos = input.wPos;
				float3 viewDir = normalize(input.wPos - _WorldSpaceCameraPos);

				fixed4 color;

				if (raymarchHit(worldPos, viewDir))
				{
					color = fixed4(1,0,0,1);
				}
				else
				{
					color = fixed4(1,1,1,1);
				}

				return color;
			}

			ENDCG
		}
	}
}

Let me explain my Wavy Ocean Shader available from my Shader Gallery on GitHub.

This is a vertex and fragment shader.

The vertex function shifts the UV map along the x-axis in proportion to the sine of the y-axis plus time.

vertOutput vert (appdata_base input)
{
  vertOutput output;

  output.vertex = UnityObjectToClipPos(input.vertex);

  float2 dtexcoord = input.texcoord;
  dtexcoord.x = dtexcoord.x + sin(dtexcoord.y * 2 * mpi + _Time[0] * 2) * 0.1;

  output.uv = TRANSFORM_TEX(dtexcoord, _MainTex);

  return output;
}

The fragment function just gets the color from the texture based on the new UV map coordinate.

fixed4 frag (vertOutput input) : SV_Target
{
  fixed4 col = tex2D(_MainTex, input.uv);
  return col;
}

Full listing:

// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'

Shader "Custom/WavyOcean"
{
  Properties
  {
    _MainTex ("Texture", 2D) = "white" {}
  }
  SubShader
  {
    Tags { "RenderType" = "Opaque" }
    LOD 100

    Pass
    {
      CGPROGRAM
      #pragma vertex vert
      #pragma fragment frag

      #include "UnityCG.cginc"

      static const float mpi = 3.141592654;

      sampler2D _MainTex;
      float4 _MainTex_ST;

      struct vertOutput
      {
        float2 uv : TEXCOORD0;
        float4 vertex : SV_POSITION;
      };

      vertOutput vert (appdata_base input)
      {
        vertOutput output;

        output.vertex = UnityObjectToClipPos(input.vertex);

        float2 dtexcoord = input.texcoord;
        dtexcoord.x = dtexcoord.x + sin(dtexcoord.y * 2 * mpi + _Time[0] * 2) * 0.1;

        output.uv = TRANSFORM_TEX(dtexcoord, _MainTex);

        return output;
      }

      fixed4 frag (vertOutput input) : SV_Target
      {
        fixed4 col = tex2D(_MainTex, input.uv);
        return col;
      }
      ENDCG
    }
  }
}