// Example shader for a scriptable render loop that calculates multiple lights // in a single forward-rendered shading pass. Uses same PBR shading model as the // Standard shader. // // The parameters and inspector of the shader are the same as Standard shader, // for easier experimentation. Shader "RenderLoop/Basic/Standard" { // Properties is just a copy of Standard.shader. Our example shader does not use all of them, // but the inspector UI expects all these to exist. Properties { _Color("Color", Color) = (1,1,1,1) _MainTex("Albedo", 2D) = "white" {} _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5 _Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5 _GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0 [Enum(Metallic Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel ("Smoothness texture channel", Float) = 0 [Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0 _MetallicGlossMap("Metallic", 2D) = "white" {} [ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0 [ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0 _BumpScale("Scale", Float) = 1.0 _BumpMap("Normal Map", 2D) = "bump" {} _Parallax ("Height Scale", Range (0.005, 0.08)) = 0.02 _ParallaxMap ("Height Map", 2D) = "black" {} _OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0 _OcclusionMap("Occlusion", 2D) = "white" {} _EmissionColor("Color", Color) = (0,0,0) _EmissionMap("Emission", 2D) = "white" {} _DetailMask("Detail Mask", 2D) = "white" {} _DetailAlbedoMap("Detail Albedo x2", 2D) = "grey" {} _DetailNormalMapScale("Scale", Float) = 1.0 _DetailNormalMap("Normal Map", 2D) = "bump" {} [Enum(UV0,0,UV1,1)] _UVSec("UV Set for secondary textures", Float) = 0 [HideInInspector] _Mode("__mode", Float) = 0.0 [HideInInspector] _SrcBlend("__src", Float) = 1.0 [HideInInspector] _DstBlend("__dst", Float) = 0.0 [HideInInspector] _ZWrite("__zw", Float) = 1.0 } SubShader { Tags { "RenderType" = "Opaque" "PerformanceChecks" = "False" } LOD 300 // Include forward (base + additive) pass from regular Standard shader. // They are not used by the scriptable render loop; only here so that // if we turn off our example loop, then regular forward rendering kicks in // and objects look just like with a Standard shader. UsePass "Standard/FORWARD" UsePass "Standard/FORWARD_DELTA" // Multiple lights at once pass, for our example Basic render loop. Pass { Tags { "LightMode" = "BasicPass" } // Use same blending / depth states as Standard shader Blend[_SrcBlend][_DstBlend] ZWrite[_ZWrite] CGPROGRAM #pragma target 3.0 #pragma vertex vert #pragma fragment frag #pragma shader_feature _METALLICGLOSSMAP #include "UnityCG.cginc" #include "UnityStandardBRDF.cginc" #include "UnityStandardUtils.cginc" // Global lighting data (setup from C# code once per frame). CBUFFER_START(GlobalLightData) // The variables are very similar to built-in unity_LightColor, unity_LightPosition, // unity_LightAtten, unity_SpotDirection as used by the VertexLit shaders, except here // we use world space positions instead of view space. half4 globalLightColor[8]; float4 globalLightPos[8]; float4 globalLightSpotDir[8]; float4 globalLightAtten[8]; int4 globalLightCount; // Global ambient/SH probe, similar to unity_SH* built-in variables. float4 globalSH[7]; CBUFFER_END // Surface inputs for evaluating Standard BRDF struct SurfaceInputData { half3 diffColor, specColor; half oneMinusReflectivity, smoothness; }; // Compute attenuation & illumination from one light half3 EvaluateOneLight(int idx, float3 positionWS, half3 normalWS, half3 eyeVec, SurfaceInputData s) { // direction to light float3 dirToLight = globalLightPos[idx].xyz; dirToLight -= positionWS * globalLightPos[idx].w; // distance attenuation float att = 1.0; float distSqr = dot(dirToLight, dirToLight); att /= (1.0 + globalLightAtten[idx].z * distSqr); if (globalLightPos[idx].w != 0 && distSqr > globalLightAtten[idx].w) att = 0.0; // set to 0 if outside of range distSqr = max(distSqr, 0.000001); // don't produce NaNs if some vertex position overlaps with the light dirToLight *= rsqrt(distSqr); // spotlight angular attenuation float rho = max(dot(dirToLight, globalLightSpotDir[idx].xyz), 0.0); float spotAtt = (rho - globalLightAtten[idx].x) * globalLightAtten[idx].y; att *= saturate(spotAtt); // Super simple diffuse lighting instead of PBR would be this: //half ndotl = max(dot(normalWS, dirToLight), 0.0); //half3 color = ndotl * s.diffColor * globalLightColor[idx].rgb; //return color * att; // Fill in light & indirect structures, and evaluate Standard BRDF UnityLight light; light.color = globalLightColor[idx].rgb * att; light.dir = dirToLight; UnityIndirect indirect; indirect.diffuse = 0; indirect.specular = 0; half4 c = BRDF1_Unity_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, normalWS, -eyeVec, light, indirect); return c.rgb; } // Evaluate 2nd order spherical harmonics, given normalized world space direction. // Similar to ShadeSH9 in UnityCG.cginc half3 EvaluateSH(half3 n) { half3 res; half4 normal = half4(n, 1); // Linear (L1) + constant (L0) polynomial terms res.r = dot(globalSH[0], normal); res.g = dot(globalSH[1], normal); res.b = dot(globalSH[2], normal); // 4 of the quadratic (L2) polynomials half4 vB = normal.xyzz * normal.yzzx; res.r += dot(globalSH[3], vB); res.g += dot(globalSH[4], vB); res.b += dot(globalSH[5], vB); // Final (5th) quadratic (L2) polynomial half vC = normal.x*normal.x - normal.y*normal.y; res += globalSH[6].rgb * vC; return res; } // Vertex shader struct v2f { float2 uv : TEXCOORD0; float3 positionWS : TEXCOORD1; float3 normalWS : TEXCOORD2; float4 hpos : SV_POSITION; }; float4 _MainTex_ST; v2f vert(appdata_base v) { v2f o; o.uv = TRANSFORM_TEX(v.texcoord,_MainTex); o.hpos = UnityObjectToClipPos(v.vertex); o.positionWS = mul(unity_ObjectToWorld, v.vertex).xyz; o.normalWS = UnityObjectToWorldNormal(v.normal); return o; } sampler2D _MainTex; sampler2D _MetallicGlossMap; float _Metallic; float _Glossiness; // Fragment shader half4 frag(v2f i) : SV_Target { i.normalWS = normalize(i.normalWS); half3 eyeVec = normalize(i.positionWS - _WorldSpaceCameraPos); // Sample textures half4 diffuseAlbedo = tex2D(_MainTex, i.uv); half2 metalSmooth; #ifdef _METALLICGLOSSMAP metalSmooth = tex2D(_MetallicGlossMap, i.uv).ra; #else metalSmooth.r = _Metallic; metalSmooth.g = _Glossiness; #endif // Fill in surface input structure SurfaceInputData s; s.diffColor = DiffuseAndSpecularFromMetallic(diffuseAlbedo.rgb, metalSmooth.x, s.specColor, s.oneMinusReflectivity); s.smoothness = metalSmooth.y; // Ambient lighting half4 color = half4(0,0,0, diffuseAlbedo.a); UnityLight light; light.color = 0; light.dir = 0; UnityIndirect indirect; indirect.diffuse = EvaluateSH(i.normalWS); indirect.specular = 0; color.rgb += BRDF1_Unity_PBS(s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, i.normalWS, -eyeVec, light, indirect); // Add illumination from all lights for (int il = 0; il < globalLightCount.x; ++il) { color.rgb += EvaluateOneLight(il, i.positionWS, i.normalWS, eyeVec, s); } return color; } ENDCG } } CustomEditor "StandardShaderGUI" }