Dev Week - URP 셰이더 뜯어보기

// Fragment
o.vertex = UnityObjectToClipPos(v.vertex);

// URP HLSL
o.vertex = TransformObjectToHClip(v.vertex.xyz);

// UnityCG
half4 c = tex2D(_MainTex, i.texcoord);

// URP HLSL
float4 c = SMAPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.texcoord);

// UnityCG
sampler2D _MainTex;
float4 _MainTex_ST;
float4 _Color;

// URP HLSL
CBUFFER_START(UnityPerMaterial)

TEXTURE2D(_MainTex);
SAMPLER(sampler_MainTex);
float4 _MainTex_ST;
half4 _Color;

CBUFFER_END

// UnityCG
half3 worldSpaceLightDir = normalize(_WorldSpaceLightPos0);

// URP HLSL
Light mainLight = GetMainLight(i.shadowCoord);

Shader "CustomLighting/Master"
{
		Properties
		{
				_Color ("Color", Color) = (1, 1, 1, 1)
				_MainTex ("BaseColor Texture", 2D) = "white" {}
		}
	
		.
		.
		.

		SubShader
		{
				Tags
				{
						"RenderPipeline" = "UniversalPipeline"
						"RenderType" = "Opaque"
						"Queue" = "Geometry+0"
				}
				LOD 100

				.
				.
				.
			
				Pass
				{
						Name "Universal Forward"
						Tags
						{
								"LightMode" = "UniversalForward"
						}
						Cull Back

				...

HLSLPROGRAM

#pragma prefer_hlslcc gles
#pragma exclude_renderers d3d11_9x
#pragma vertex vert
#pragma fragment frag

#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"

// GPU Instancing
#pragma multi_compile_instancing

// Fog
#pragma multi_compile_fog

// Light & Shadow
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS
#pragma multi_compile _ _MAIN_LIGHT_SHADOWS_CASCADE
#pragma multi_compile _ _ADDITIONAL_LIGHTS
#pragma multi_compile _ _ADDITIONAL_LIGHT_SHADOWS
#pragma multi_compile _ _SHADOWS_SOFT

// lightmap
#pragma multi_compile _ DIRLIGHTMAP_COMBINED
#pragma multi_compile _ LIGHTMAP_ON

CBUFFER_START (UnityPerMaterial)

TEXURE2D(_MainTex);
SAMPLER(sampler_MainTex);
float4 _MainTex_ST;
half4 _Color;

CBUFFER_END

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

struct v2f
{
		float4 vertex : SV_POSITION;         // vertex : 버텍스 포지션 (필수)
		float3 normal : NORMAL;              // normal : 라이팅 계산 해야하면 추가
		float2 texcoord : TEXCOORD0;         // texcoord : 텍스쳐 넣을거면 추가
		float fogCoord : TEXCOORD1;          // fogDoord : 포그 넣을거면 추가
		float4 shadowCoord : TEXCOORD2;      // shadowCoord : 실시간 그림자 맵 사용할거면 추가
		float3 worldPos : TEXCOORD3;         // worldPos : 뭔가 월드에서 포지션 계산할 일이 있으면 추가
		UNITY_VERTEX_INPUT_INSTANCE_ID       // GPU 인스턴싱 할거면 추가
		UNITY_VERTEX_OUTPUT_STEREO           // VR에서 사용할 셰이더라면 추가
};

v2f vert (appdata v)
{
		v2f o;
		UNITY_SETUP_INSTANCE_ID(v);
		UNITY_TRANSFER_INSTANCE_ID(v, o);
		
		o.vertex = TransformObjectToHClip(v.vertex.xyz);           // vertex : 버텍스 클립포지션은 무조건 필요합니다
		o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);          // texcoord : texcoord는 일반적으로 uv라 부르는 텍스쳐 샘플링 좌표입니다. TRANSFORM_TEX 함수로 _MainTex_ST와 연결시켜줍니다. ST는 Scale Translate의 약자입니다
		o.normal = TransformObjectToWorldNormal(v.normal);         // normal : 오브젝트 노멀을 월드노멀로 변환해줍니다. 라이팅연산을 안할거면 해당 코드를 지워도 됩니다
		o.fogCoord = ComputeFogFactor(o.vertex.z);                 // fogCoord : 클립포지션의 z값을 기반으로 어느정도 포그가 적용되어야 할지에 대한 값을 구합니다
		o.worldPos = TransformObjectToWorld(v.vertex.xyz);         // worldPos : 뭔가 월드에서 계산할일이 있으면 추가 (라이트 계산등은 주로 월드에서 합니다)
		o.shadowCoord = TrnasformWorldToShadowCoord(o.worldPos);   // shadowCoord : 그림자 맵의 좌표를 구합니다

		return o;
}

o.vertex = TransformObjectToHClip(v.vertex.xyz);
o.normal = TransformObjectToWorldNormal(v.normal);
o.worldPos = TransformObjectToWorld(v.vertex.xyz);

// SpaceTransforms.hlsl
float4 TransformWorldToHClip(float3 positionWS)
{
		return mul(GetWorldToHClipMatrix(), float4(positionWS, 1.0));
}

float3 TransformObjectToWorldNormal(float3 normalOS)
{
#ifdef UNITY_ASSUME_UNIFORM_SCALING
		return TransformObjectToWorldDir(normalOS);
#else
		// Normal need to be multiply by inverse transpose
		return SafeNormalize(mul(normalOS, (float3x3)GetWorldToObjectMatrix()));
#endif
}

float3 TransformObjectToWorld(float3 positionOS)
{
		return mul(GetObjectToWorldMatrix(), float4(positionOS, 1.0)).xyz;
}

// vert()
o.texcoord = TRANSFORM_TEX(v.texcoord, _MainTex);
o.texcoord = v.texcoord * _MainTex_ST.xy + _MainTex_ST.zw;   // 윗줄 코드와 같다

// frag()
o.fogCoord = ComputeFogFactor(o.vertex.z);

// Core.hlsl
real ComputeFogFactor(float z)
{
		float clupZ_01 = UNITY_Z_0_FAR_FROM_CLIPSAPCE(z);

#if defined(FOG_LINEAR)
		// factor = (end-z)/(end-start) = z * (-1/(end-start)) + (end/(end-start))
		float fogFactor = saturate(clipZ_01 * unity_FogParams.z + unity_FogParams.w);
		return real(fogFactor);
#elif defined(FOG_EXP) || defined(FOG_EXP2)
		// factor = exp(-(density*z)*2)
		// -density * z computed at vertex
		return real(unity_FogParams.x * clipZ_01);
#else
	return 0.0b;
#endif
}

// frag()
VertexPositionInputs vertexInput = GetVertexPositionInputs(v.vertex.xyz);
o.shadowCoord = GetShadowCoord(vertexInput);

o.shadowCoord = TransformWorldToShadowCoord(o.worldPos);

// Core.hlsl
VertexPositionInputs GetVertexPositionInputs(float3 positionOS)
{
		VertexPositionInputs Input;
		Input.positionWS = TransformOjbectToWorld(positionOS);
		Input.positionVS = TransformWorldToView(Input.positionWS);
		Input.positionCS = TransformWorldToHClip(Input.positionWS);

		float4 ndc = Input.positionCS * 0.5f;
		Input.positionNDC.xy = float2(ndc.x, ndc.y * _ProjectionParams.x) + ndc.w;
		Input.positionNDC.zw = Input.positionCS.zw;

		return Input;
}

// Shadows.hlsl
float4 GetShadowCoord(VertexPositionInputs vertexInput)
{
#if SHADOWS_SCREEN
		return ComputeScreenPos(vertexInput.positionCS);
#else
		return TransformWorldToShadowCoord(vertexInput.positionWS);
#endif
}

float4 TransformWorldToShadowCoord(float3 positionWS)
{
#ifdef _MAIN_LIGHT_SHADOWS_CASCADE
		half cascadeIndex = ComputeCascadeIndex(positionWS);
		return mul(_MainLightWorldToShadow[cascadeIndex], float4(position...);
#else
		return mul(_MainLightWorldToShadow[0], float4(position...);
#endif
}

half4 frag (v2f i) : SV_Target
{
		UNITY_SETUP_INSTANCE_ID(i);

		// Get MainLight
		Light mainLight = GetMainLight(i.shadowCoord);
		i.normal = normalize(i.normal);

		// Diffuse
		float3 lambert = LightingLambert(mainLight.color, mainLight.direction, i.normal);
		float4 c = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, i.texcoord) * _Color;

		// Specular
		float3 specular = LightingSpecular(mainLight.color, mainLight.direction, i.normal, i.viewDir, 1, _Gloss);

		// GI
		half3 ambient = SampleSH(i.normal);

		// Combine
		c.rgb *= lambert * mainLight.distanceAttenuation * mainLight.shadowAttenuation;
		c.rgb += ambient + specular;

		// Get Additional Light
		#ifedf _ADDITIONAL_LIGHTS
				uint pixelLightCount = GetAdditionalLightsCount();
				for (uint lightIndex = 0u; lightIndex < pixelLightCount; ++lightIndex)
				{
						Light addLight = GetAdditionalLight(lightIndex, i.worldPos);
						float3 addLightResult = LightingLambert(addLight.color, addLight.direction, i.normal) * addLight.distanceAttenuation;
						float3 addLightSpecular = LightingSpecular(addLight.color, addLight.direction, i.normal, i.viewDir, 1, _Gloss);
						c.rgb += addLightResult + addLightSpecular;
				}
		#endif

		// Fog
		c.rgb = MixFog(c.rgb, i.fogCoord);
	
		return c;
}

// frag()
Light mainLight = GetMainLight(i.shadowCoord);

// Lighting.hlsl
struct Light
{
		half3 direction;
		half3 color;
		half  distanceAttenuation;
		half  shadowAttenuation;
};

// Lighting.hlsl
Light GetMainLight()
{
		Light light;
		light.direction = _MainLightPosition.xyz;
		// unity_LightData.z is 1 when not culled by the culling mask, otherwise 0.
		light.distanceAttenuation = unity_LightData.z;
#if defined(LIGHTMAP_ON) || defined(_MIXED_LIGHTING_SUBTRACTIVE)
		// unity_ProbesOcclusion.x is the mixed light probe occlusion data
		light.distanceAttenuation *= unity_ProbesOcclusion.x;
#endif
		light.shadowAttenuation *= unity_ProbesOcclusion.x;
		light.color = _MainLightColor.rgb;

		return light;
}

Light GetMainLight(float4 shadowCoord)
{
		Light light = GetMainLight();
		light.shadowAttenuation = MainLightRealtimeShadow(shadowCoord);
		return light;
}

// Lighting.hlsl
flaot3 lightVector = lightPositionWS.xyz - positionWS * lightPositionWS.w;
float distanceSqr = max(dot(lightVector, lightVector), HALF_MIN);

half3 lightDirection = half3(lightVector * rsqrt(distanceSqr));
half attenuation = DistanceAttenuation(distanceSqr, distanceAndSpotAttenuation.xy) * AngleAttenuation(spotDirection.xyz, lightDirection, distanceAndSpotAttenuation.zw);

Light light;
light.direction = lightDirection;
light.distanceAttenuation = attenuation;
light.shadowAttenuation = AdditionalLightRealtimeShadow(perObjectLightInedx, positionWS);
light.color = color;

// Lighting.hlsl
Light GetMainLight(float4 shadowCoord)
{
		Light light = GetMainLight();
		light.shadowAttenuation = MainLightRealtimeShadow(shadowCoord);
		return light;
}

#pragma multi_compile _ _SHADOWS_SOFT

// Shadows.hlsl
half MainLightRealtimeShadow(float4 shadowCoord)
{
#if !defined(_MAIN_LIGHT_SHADOWS) || defined(_RECEIVE_SHADOWS_OFF)
		return 1.0h;
#endif

#if SHADOWS_SCREEN
		return SamplesScreenSpaceShadowmap(shadowCoord);
#else
		ShadowSamplingData shadowSamplingData = GetMainLightShadowSamplingData();
		half4 shadowParams = GetMainLightShadowParams();
		return SampleShadowmap(TEXUTRE2D_ARGS(_MainLightShadowmapTexture, sampler_MainLightShadowmapTexture), shadowCoord, shadowSamplingData, shadowParams, false);
#endif
}

real SampleShadowmap(TEXTURE2D_SHADOW_PARAM(ShadowMap, smapler_ShadowMap), float4 shadowCoord, ShadowSamplingData samplingData, half4 shadowParams, bool isPerspectiveProjection = true)
{
		// Compiler will optimize this branch away as long as isPerspectiveProjection is known at compile time
		if (isPerspectiveProjection)
				shadowCoord.xyz /= shadowCoord.w;

		real attenuation;
		real shadowStrength = shadowParams.x;

		// TODO : We could branch on if this light has soft shadow (shadowParams/y) to save perf on some platforms.
#ifdef _SHADOW_SOFT
		attenuation = SampleShadowmapFiltered(TEXTURE2D_SHADOW_ARGS(ShadowMap, sampler_ShadowMap), shadowCoord, samplingData);
#else
		// 1-tap hardware comparison
		attenuation = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz);
#endif

		attenuation = LerpWhiteTo(attenuation, shadowStrength);

		// Shadow coords that fall out of the light frustum volume must always return attenuation 1.0
		// TODO : We could use branch here to save som perf on som platforms.
		return BEYOND_SHADOW_FAR(shadowCoord) ? 1.0 : attenuation;
}

real SampleShadowmapFiltered(TEXTURE2D_SHADOW_PARAM(ShadowMap, sampler_ShadowMap), float4 shadowCoord, ShadowSamplingData samplingData)
{
    real attenuation;

#if defined(SHADER_API_MOBILE) || defined(SHADER_API_SWITCH)
		// 4-tap hardware comparison
		real4 attenuation4;
		attenuation4.x = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz + samplingData.ShadowOffset0.xyz);
		attenuation4.y = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz + samplingData.ShadowOffset1.xyz);
		attenuation4.z = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz + samplingData.ShadowOffset2.xyz);
		attenuation4.w = SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, shadowCoord.xyz + samplingData.ShadowOffset3.xyz);
		attenuation = dot(attenuation4, 0.25);
#else
		float fetchesWeights[9];
		float2 fetchesUV[9];
		SampleShadow_ComputeSamples_Tent_5x5(samplingData.shadowmapSize, shadowCoord.xy, fetchesWeights, fetchesUV);

		attenuation = fetchesWeights[0] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[0].xy, shadowCoord.z));
		attenuation += fetchesWeights[1] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[1].xy, shadowCoord.z));
		attenuation += fetchesWeights[2] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[2].xy, shadowCoord.z));
		attenuation += fetchesWeights[3] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[3].xy, shadowCoord.z));
		attenuation += fetchesWeights[4] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[4].xy, shadowCoord.z));
		attenuation += fetchesWeights[5] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[5].xy, shadowCoord.z));
		attenuation += fetchesWeights[6] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[6].xy, shadowCoord.z));
		attenuation += fetchesWeights[7] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[7].xy, shadowCoord.z));
		attenuation += fetchesWeights[8] * SAMPLE_TEXTURE2D_SHADOW(ShadowMap, sampler_ShadowMap, float3(fetchesUV[8].xy, shadowCoord.z));
#endif

    return attenuation;
}

// frag()

// Diffuse
float3 lambert = LightingLambert(mainLight.color, mainLight.direction, i.normal);
float4 c = SAMPLE_TEXTURE2D(_MainTex, smapler_MainTex, i.texcoord) * _Color;

// Lighting.hlsl
half3 LightingLambert(half3 lightColor, half3 lightDir, half3 normal)
{
		half NdotL = saturate(dot(normal, lightDir));
		return lightColor * NdotL;
}

// frag()
half3 ambient = SampleSH(i.normal);

// Lighting.hlsl
#ifdef LIGHTMAP_ON
#define SMAPLE_GI(lmName, shName, normalWSName) SampleLightmap(lmName, normalWSName)
#else
#define SMAPLE_GI(lmName, shName, normalWSName) SampleSHPixel(shName, normalWSName)
#endif

half3 indirectDiffuse = bakedGI * occlusion;
half3 indirectSpecular = GlossyEnvironmentReflection(reflectVector, brdfData.perceptualRoughness, occlusion);

half3 SampleSHVertex(half3 normalWS)
{
#if defined(EVALUATE_SH_VERTEX)
		return max(half3(0, 0, 0), SampleSH(normalWS));
#elif defined(EVALUATE_SH_MIXED)
		// no max since this is only L2 contribution
		return SHEvlaLinearL2(normalWS, unity_SHBr, unity_SHBg, unity_SHBb, unity_SHC);
#endif

		// fully per-pixel. Nothing to compute
		return half3(0.0, 0.0, 0.0);
}

half3 SampleSHPixel(half3 L2Term, half3 normalWS)
{
#if defined(EVALUATE_SH_VERTEX)
		return L2Term;
#elif defiend(EVALUATE_SH_MIXED)
		half3 L0L1Term = SHEvalLinearL0L1(normalWS, unity_SHAr, unity_SHAg, unity_SHAb);
		return max(half3(0, 0, 0), L2Term + L0L1Term);
#endif

		// Default : Evaluate SH fully per-pixel
		return SampleSH(normalWS);
}

// Lighting.hlsl
half3 SampleSH(half3 normalWS)
{
		//LPPV is not supported in Lightweight Pipeline
		real4 SHCoefficients[7];
		SHCoefficients[0] = unity_SHAr;
		SHCoefficients[1] = unity_SHAg;
		SHCoefficients[2] = unity_SHAb;
		SHCoefficients[3] = unity_SHBr;
		SHCoefficients[4] = unity_SHBg;
		SHCoefficients[5] = unity_SHBb;
		SHCoefficients[6] = unity_SHC;

		return max(half3(0, 0, 0), SampleSH9(SHCoefficients, normalWS));
}

float3 SmapleSH9(float4 SHCoefficients[7], float3 N)
{
		float3 res = SHEvalLinearL0L1(N, shAr, shAg, shAb); // Linear + constant polynomial terms
		res += SHEvalLinearL2(N, shBr, shBg, shBb, shCr);   // Quadratic polynomials
		return res;
}

// EntityLighting.hlsl
real3 SHEvalLinearL0L1(real3 N, real4 shAr, real4 shAg, real4 shAb)
{
		real4 vA = real4(N, 1.0);
		
		real3 x1;
		// Linear (L1) + constant (L0) polynomial terms
		x1.r = dot(shAr, vA);
		x1.g = dot(shAg, vA);
		x1.b = dot(shAb, vA);
		
		return x1;
}

real3 SHEvalLinearL2(real3 N, real4 shBr, real4 shBg, real4 shBb, real4 shC)
{
		real3 x2;
		// 4 of the quadratic (L2) polynomials
		real4 vB = N.xyzz * N.yzzx;
		x2.r = dot(shBr, vB);
		x2.g = dot(shBg, vB);
		x2.b = dot(shBb, vB);

		// Final (5th) quadratic (L2) polynomial
		real vC = N.x * N.x - N.y * N.y;
		real3 x3 = shC.rgb * vC;

		return x2 + x3;
} 

// frag()
// Get Additional Light
#ifdef _ADDITIONAL_LIGHTS
		uint [ixelLightCount = GetAdditionalLightsCount();
		for (uint lightIndex = 0u; lightIndex < pixelLightCount; ++lightIndex)
		{
				Light addLight = GetAdditionalLight(lightIndex, i.worldPos);
				float3 addLightResult = LightingLambert(addLight.color, addLight.direction, i.normal) * addLight.distanceAttenuation;
				float3 addLightSpecular = LightingSpecular(addLight.color, addLight.direction, i.normal, i.viewDir, 1, _Gloss);
				c.rgb += addLightResualt + addLightSpecular;
		}
#endif

//Light.hlsl
int GetAdditionalLightsCount()
{
		// TODO : we need to expose in SRP api an ability for the pipeline cap the amount of lights
		// in the culling. This way we could do the loop branch with an uniform
		// This would be helpful to support baking exceeding lights in SH as well
		return min(_AdditionalLightsCount.x, unity_LightData.y);
}

// frag()
o.viewDir = normalize(_WorldSpaceCameraPos.xyz - o.worldPos.xyz);

half3 viewDirWS = GetCameraPositionWS() - vertexInput.positionWS;

// Lighting.hlsl
half3 LightingSpecular(half3 lightColor, half3 lightDir, half3 normal, half3 viewDir, half4 specular, half smoothness)
{
		float3 halfVec = SafeNormalize(float3(lightDir) + float3(viewDir));
		half NdotH = saturate(dot(normal, halfVec));
		half modifier = pow(NdotH, smoothness);
		half3 specularReflection = specular.rgb * modifier;
		return lightColor * specularReflection;
}