Shader "Fabric Master" { Properties { _uvBaseMask("Base UV Mask", Vector) = (1,0,0,0) _uvBaseST("Base UV Scale Transform", Vector) = (1,1,0,0) [NoScaleOffset] _BaseColorMap("Base Color Map", 2D) = "white" {} _BaseColor("Base Color", Color) = (0.7294118,0.7294118,0.7294118,0) [NoScaleOffset] _MaskMap("Mask Map T(R) AO(G) SSS(B)", 2D) = "white" {} _SmoothnessMin("Smoothness Min", Range(0, 1)) = 0 _SmoothnessMax("Smoothness Max", Range(0, 1)) = 1 [NoScaleOffset] _SpecColorMap("Specular Color Map S(A)", 2D) = "white" {} _SpecularColor("Specular Color Multiplier", Color) = (0.2,0.2,0.2,0) [NoScaleOffset] _NormalMap("Normal Map", 2D) = "bump" {} _NormalMapStrength("Normal Map Strength", Range(0, 8)) = 1 [Toggle] _useThreadMap("use Thread Map", Float) = 1 [NoScaleOffset] _ThreadMap("Thread Map", 2D) = "grey" {} _uvThreadMask("Thread UV Mask", Vector) = (1,0,0,0) _uvThreadST("Thread UV Scale Transform", Vector) = (1,1,0,0) _ThreadAOStrength01("Thread AO Strength", Range(0, 1)) = 0,5 _ThreadNormalStrength("Thread Normal Strength", Range(0, 2)) = 0,5 _ThreadSmoothnessScale("Thread Smoothness Scale", Range(0, 1)) = 0,5 [NoScaleOffset] _FuzzMap("Fuzz Map", 2D) = "black" {} _FuzzMapUVScale("Fuzz Map UV scale", Float) = 0,1 _FuzzStrength("Fuzz Strength", Range(0, 2)) = 1 [HideInInspector] _EmissionColor("Color", Color) = (1,1,1,1) } SubShader { Tags { "RenderPipeline"="HDRenderPipeline" "RenderType"="Opaque" "Queue"="Geometry+0" } Pass { // based on FabricPass.template Name "META" Tags { "LightMode" = "Meta" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Blend One Zero Cull Off ZTest LEqual ZWrite On ZClip [_ZClip] // Default Stencil //------------------------------------------------------------------------------------- // End Render Modes //------------------------------------------------------------------------------------- HLSLPROGRAM #pragma target 4.5 #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch //#pragma enable_d3d11_debug_symbols #pragma multi_compile_instancing #pragma instancing_options renderinglayer #pragma multi_compile _ LOD_FADE_CROSSFADE //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- #define _MATERIAL_FEATURE_COTTON_WOOL 1 #define _EMISSION 1 #define _SPECULAR_OCCLUSION_FROM_AO 1 #define _ENERGY_CONSERVING_SPECULAR 1 #define _DISABLE_SSR 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag #define UNITY_MATERIAL_FABRIC // Need to be define before including Material.hlsl // This will be enabled in an upcoming change. // #define SURFACE_GRADIENT // If we use subsurface scattering, enable output split lighting (for forward pass) #if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT) #define OUTPUT_SPLIT_LIGHTING #endif #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Wind.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl" // define FragInputs structure #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl" //------------------------------------------------------------------------------------- // Defines //------------------------------------------------------------------------------------- #define SHADERPASS SHADERPASS_LIGHT_TRANSPORT // this translates the new dependency tracker into the old preprocessor definitions for the existing HDRP shader code #define ATTRIBUTES_NEED_NORMAL #define ATTRIBUTES_NEED_TANGENT #define ATTRIBUTES_NEED_TEXCOORD0 #define ATTRIBUTES_NEED_TEXCOORD1 #define ATTRIBUTES_NEED_TEXCOORD2 #define ATTRIBUTES_NEED_TEXCOORD3 #define ATTRIBUTES_NEED_COLOR #define VARYINGS_NEED_TEXCOORD0 #define VARYINGS_NEED_TEXCOORD1 #define VARYINGS_NEED_TEXCOORD2 #define VARYINGS_NEED_TEXCOORD3 //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #if (SHADERPASS == SHADERPASS_FORWARD) // used for shaders that want to do lighting (and materials) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #else // used for shaders that don't need lighting #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl" //Used by SceneSelectionPass int _ObjectId; int _PassValue; // this function assumes the bitangent flip is encoded in tangentWS.w // TODO: move this function to HDRP shared file, once we merge with HDRP repo float3x3 BuildWorldToTangent(float4 tangentWS, float3 normalWS) { // tangentWS must not be normalized (mikkts requirement) // Normalize normalWS vector but keep the renormFactor to apply it to bitangent and tangent float3 unnormalizedNormalWS = normalWS; float renormFactor = 1.0 / length(unnormalizedNormalWS); // bitangent on the fly option in xnormal to reduce vertex shader outputs. // this is the mikktspace transformation (must use unnormalized attributes) float3x3 worldToTangent = CreateWorldToTangent(unnormalizedNormalWS, tangentWS.xyz, tangentWS.w > 0.0 ? 1.0 : -1.0); // surface gradient based formulation requires a unit length initial normal. We can maintain compliance with mikkts // by uniformly scaling all 3 vectors since normalization of the perturbed normal will cancel it. worldToTangent[0] = worldToTangent[0] * renormFactor; worldToTangent[1] = worldToTangent[1] * renormFactor; worldToTangent[2] = worldToTangent[2] * renormFactor; // normalizes the interpolated vertex normal return worldToTangent; } //------------------------------------------------------------------------------------- // Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- // Generated Type: AttributesMesh struct AttributesMesh { float3 positionOS : POSITION; float3 normalOS : NORMAL; // optional float4 tangentOS : TANGENT; // optional float4 uv0 : TEXCOORD0; // optional float4 uv1 : TEXCOORD1; // optional float4 uv2 : TEXCOORD2; // optional float4 uv3 : TEXCOORD3; // optional float4 color : COLOR; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; // Generated Type: VaryingsMeshToPS struct VaryingsMeshToPS { float4 positionCS : SV_Position; float4 texCoord0; // optional float4 texCoord1; // optional float4 texCoord2; // optional float4 texCoord3; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToPS { float4 interp00 : TEXCOORD0; // auto-packed float4 interp01 : TEXCOORD1; // auto-packed float4 interp02 : TEXCOORD2; // auto-packed float4 interp03 : TEXCOORD3; // auto-packed float4 positionCS : SV_Position; // unpacked #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToPS PackVaryingsMeshToPS(VaryingsMeshToPS input) { PackedVaryingsMeshToPS output; output.positionCS = input.positionCS; output.interp00.xyzw = input.texCoord0; output.interp01.xyzw = input.texCoord1; output.interp02.xyzw = input.texCoord2; output.interp03.xyzw = input.texCoord3; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToPS UnpackVaryingsMeshToPS(PackedVaryingsMeshToPS input) { VaryingsMeshToPS output; output.positionCS = input.positionCS; output.texCoord0 = input.interp00.xyzw; output.texCoord1 = input.interp01.xyzw; output.texCoord2 = input.interp02.xyzw; output.texCoord3 = input.interp03.xyzw; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToDS { float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _uvBaseMask; float4 _uvBaseST; float4 _BaseColor; float _SmoothnessMin; float _SmoothnessMax; float4 _SpecularColor; float _NormalMapStrength; float _useThreadMap; float4 _uvThreadMask; float4 _uvThreadST; float _ThreadAOStrength01; float _ThreadNormalStrength; float _ThreadSmoothnessScale; float _FuzzMapUVScale; float _FuzzStrength; float4 _EmissionColor; CBUFFER_END TEXTURE2D(_BaseColorMap); SAMPLER(sampler_BaseColorMap); float4 _BaseColorMap_TexelSize; TEXTURE2D(_MaskMap); SAMPLER(sampler_MaskMap); float4 _MaskMap_TexelSize; TEXTURE2D(_SpecColorMap); SAMPLER(sampler_SpecColorMap); float4 _SpecColorMap_TexelSize; TEXTURE2D(_NormalMap); SAMPLER(sampler_NormalMap); float4 _NormalMap_TexelSize; TEXTURE2D(_ThreadMap); SAMPLER(sampler_ThreadMap); float4 _ThreadMap_TexelSize; TEXTURE2D(_FuzzMap); SAMPLER(sampler_FuzzMap); float4 _FuzzMap_TexelSize; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float4 uv0; // optional float4 uv1; // optional float4 uv2; // optional float4 uv3; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float3 Albedo; float3 Normal; float Smoothness; float Occlusion; float3 Specular; float DiffusionProfile; float SubsurfaceMask; float Thickness; float3 Emission; float Alpha; }; // Shared Graph Node Functions void Unity_Combine_float(float R, float G, float B, float A, out float4 RGBA, out float3 RGB, out float2 RG) { RGBA = float4(R, G, B, A); RGB = float3(R, G, B); RG = float2(R, G); } void Unity_Multiply_float (float2 A, float2 B, out float2 Out) { Out = A * B; } void Unity_Add_float2(float2 A, float2 B, out float2 Out) { Out = A + B; } // Subgraph function void sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(float4 _uvST, float4 _uvMask, SurfaceDescriptionInputs IN, out float4 Output1) { float4 _UV_23AF8552_Out = IN.uv0; float _Split_7957D60_R = _UV_23AF8552_Out[0]; float _Split_7957D60_G = _UV_23AF8552_Out[1]; float _Split_7957D60_B = _UV_23AF8552_Out[2]; float _Split_7957D60_A = _UV_23AF8552_Out[3]; float4 _Combine_5396A6C7_RGBA; float3 _Combine_5396A6C7_RGB; float2 _Combine_5396A6C7_RG; Unity_Combine_float(_Split_7957D60_R, _Split_7957D60_G, 0, 0, _Combine_5396A6C7_RGBA, _Combine_5396A6C7_RGB, _Combine_5396A6C7_RG); float4 _Property_CB55E443_Out = _uvMask; float _Split_6086B0A5_R = _Property_CB55E443_Out[0]; float _Split_6086B0A5_G = _Property_CB55E443_Out[1]; float _Split_6086B0A5_B = _Property_CB55E443_Out[2]; float _Split_6086B0A5_A = _Property_CB55E443_Out[3]; float2 _Multiply_FC550A07_Out; Unity_Multiply_float(_Combine_5396A6C7_RG, (_Split_6086B0A5_R.xx), _Multiply_FC550A07_Out); float4 _UV_3B1D042C_Out = IN.uv1; float _Split_107320B6_R = _UV_3B1D042C_Out[0]; float _Split_107320B6_G = _UV_3B1D042C_Out[1]; float _Split_107320B6_B = _UV_3B1D042C_Out[2]; float _Split_107320B6_A = _UV_3B1D042C_Out[3]; float4 _Combine_2E8D3795_RGBA; float3 _Combine_2E8D3795_RGB; float2 _Combine_2E8D3795_RG; Unity_Combine_float(_Split_107320B6_R, _Split_107320B6_G, 0, 0, _Combine_2E8D3795_RGBA, _Combine_2E8D3795_RGB, _Combine_2E8D3795_RG); float2 _Multiply_FDA7BA1E_Out; Unity_Multiply_float(_Combine_2E8D3795_RG, (_Split_6086B0A5_G.xx), _Multiply_FDA7BA1E_Out); float2 _Add_92015245_Out; Unity_Add_float2(_Multiply_FC550A07_Out, _Multiply_FDA7BA1E_Out, _Add_92015245_Out); float4 _UV_49BE4158_Out = IN.uv2; float _Split_A24186AD_R = _UV_49BE4158_Out[0]; float _Split_A24186AD_G = _UV_49BE4158_Out[1]; float _Split_A24186AD_B = _UV_49BE4158_Out[2]; float _Split_A24186AD_A = _UV_49BE4158_Out[3]; float4 _Combine_6951B6BC_RGBA; float3 _Combine_6951B6BC_RGB; float2 _Combine_6951B6BC_RG; Unity_Combine_float(_Split_A24186AD_R, _Split_A24186AD_G, 0, 0, _Combine_6951B6BC_RGBA, _Combine_6951B6BC_RGB, _Combine_6951B6BC_RG); float2 _Multiply_1480B81_Out; Unity_Multiply_float(_Combine_6951B6BC_RG, (_Split_6086B0A5_B.xx), _Multiply_1480B81_Out); float4 _UV_9CA65C2_Out = IN.uv3; float _Split_9EC6EA10_R = _UV_9CA65C2_Out[0]; float _Split_9EC6EA10_G = _UV_9CA65C2_Out[1]; float _Split_9EC6EA10_B = _UV_9CA65C2_Out[2]; float _Split_9EC6EA10_A = _UV_9CA65C2_Out[3]; float4 _Combine_633F7D3D_RGBA; float3 _Combine_633F7D3D_RGB; float2 _Combine_633F7D3D_RG; Unity_Combine_float(_Split_9EC6EA10_R, _Split_9EC6EA10_G, 0, 0, _Combine_633F7D3D_RGBA, _Combine_633F7D3D_RGB, _Combine_633F7D3D_RG); float2 _Multiply_2A2B5227_Out; Unity_Multiply_float(_Combine_633F7D3D_RG, (_Split_6086B0A5_A.xx), _Multiply_2A2B5227_Out); float2 _Add_B5E7679D_Out; Unity_Add_float2(_Multiply_1480B81_Out, _Multiply_2A2B5227_Out, _Add_B5E7679D_Out); float2 _Add_892742E3_Out; Unity_Add_float2(_Add_92015245_Out, _Add_B5E7679D_Out, _Add_892742E3_Out); float4 _Property_8DA1B077_Out = _uvST; float _Split_1AB0DA31_R = _Property_8DA1B077_Out[0]; float _Split_1AB0DA31_G = _Property_8DA1B077_Out[1]; float _Split_1AB0DA31_B = _Property_8DA1B077_Out[2]; float _Split_1AB0DA31_A = _Property_8DA1B077_Out[3]; float4 _Combine_44459F1_RGBA; float3 _Combine_44459F1_RGB; float2 _Combine_44459F1_RG; Unity_Combine_float(_Split_1AB0DA31_R, _Split_1AB0DA31_G, 0, 0, _Combine_44459F1_RGBA, _Combine_44459F1_RGB, _Combine_44459F1_RG); float2 _Multiply_38815E23_Out; Unity_Multiply_float(_Add_892742E3_Out, _Combine_44459F1_RG, _Multiply_38815E23_Out); float _Split_35A1DC4_R = _Property_8DA1B077_Out[0]; float _Split_35A1DC4_G = _Property_8DA1B077_Out[1]; float _Split_35A1DC4_B = _Property_8DA1B077_Out[2]; float _Split_35A1DC4_A = _Property_8DA1B077_Out[3]; float4 _Combine_91984BDF_RGBA; float3 _Combine_91984BDF_RGB; float2 _Combine_91984BDF_RG; Unity_Combine_float(_Split_35A1DC4_B, _Split_35A1DC4_A, 0, 0, _Combine_91984BDF_RGBA, _Combine_91984BDF_RGB, _Combine_91984BDF_RG); float2 _Add_63012CEE_Out; Unity_Add_float2(_Multiply_38815E23_Out, _Combine_91984BDF_RG, _Add_63012CEE_Out); Output1 = (float4(_Add_63012CEE_Out, 0.0, 1.0)); } void Unity_Multiply_float (float4 A, float4 B, out float4 Out) { Out = A * B; } void Unity_Lerp_float(float A, float B, float T, out float Out) { Out = lerp(A, B, T); } void Unity_Add_float4(float4 A, float4 B, out float4 Out) { Out = A + B; } void Unity_Saturate_float4(float4 In, out float4 Out) { Out = saturate(In); } void Unity_NormalStrength_float(float3 In, float Strength, out float3 Out) { Out = float3(In.rg * Strength, lerp(1, In.b, saturate(Strength))); } void Unity_Normalize_float3(float3 In, out float3 Out) { Out = normalize(In); } void Unity_Remap_float(float In, float2 InMinMax, float2 OutMinMax, out float Out) { Out = OutMinMax.x + (In - InMinMax.x) * (OutMinMax.y - OutMinMax.x) / (InMinMax.y - InMinMax.x); } void Unity_NormalUnpack_float(float4 In, out float3 Out) { Out = UnpackNormalmapRGorAG(In); } void Unity_NormalBlend_float(float3 A, float3 B, out float3 Out) { Out = normalize(float3(A.rg + B.rg, A.b * B.b)); } void Unity_Branch_float3(float Predicate, float3 True, float3 False, out float3 Out) { Out = lerp(False, True, Predicate); } void Unity_Add_float(float A, float B, out float Out) { Out = A + B; } void Unity_Saturate_float(float In, out float Out) { Out = saturate(In); } void Unity_Branch_float(float Predicate, float True, float False, out float Out) { Out = lerp(False, True, Predicate); } void Unity_Multiply_float (float A, float B, out float Out) { Out = A * B; } // Subgraph function void sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52(float2 _UV, TEXTURE2D_ARGS(_ThreadMap, sampler_ThreadMap), float _ThreadSmoothnessStrength, float _AmbientOcclusion, float _UseThreadMap, float _ThreadAOStrength, float _ThreadNormalStrength, float _Smoothness, float3 _Normals, float _Alpha, SurfaceDescriptionInputs IN, out float4 Output1, out float4 Output2, out float4 Output3, out float4 Output4) { float _Property_7B789410_Out = _UseThreadMap; float3 _Property_D380C535_Out = _Normals; float2 _Property_247E83DC_Out = _UV; float4 _SampleTexture2D_B39DD828_RGBA = SAMPLE_TEXTURE2D(_ThreadMap, sampler_ThreadMap, _Property_247E83DC_Out); float _SampleTexture2D_B39DD828_R = _SampleTexture2D_B39DD828_RGBA.r; float _SampleTexture2D_B39DD828_G = _SampleTexture2D_B39DD828_RGBA.g; float _SampleTexture2D_B39DD828_B = _SampleTexture2D_B39DD828_RGBA.b; float _SampleTexture2D_B39DD828_A = _SampleTexture2D_B39DD828_RGBA.a; float4 _Combine_3989CE7_RGBA; float3 _Combine_3989CE7_RGB; float2 _Combine_3989CE7_RG; Unity_Combine_float(_SampleTexture2D_B39DD828_A, _SampleTexture2D_B39DD828_G, 1, 1, _Combine_3989CE7_RGBA, _Combine_3989CE7_RGB, _Combine_3989CE7_RG); float3 _NormalUnpack_6B39F6EC_Out; Unity_NormalUnpack_float((float4(_Combine_3989CE7_RGB, 1.0)), _NormalUnpack_6B39F6EC_Out); float3 _Normalize_1F52E5EC_Out; Unity_Normalize_float3(_NormalUnpack_6B39F6EC_Out, _Normalize_1F52E5EC_Out); float _Property_2E175598_Out = _ThreadNormalStrength; float3 _NormalStrength_A15875A3_Out; Unity_NormalStrength_float(_Normalize_1F52E5EC_Out, _Property_2E175598_Out, _NormalStrength_A15875A3_Out); float3 _NormalBlend_191D51BE_Out; Unity_NormalBlend_float(_Property_D380C535_Out, _NormalStrength_A15875A3_Out, _NormalBlend_191D51BE_Out); float3 _Normalize_4D9B04E_Out; Unity_Normalize_float3(_NormalBlend_191D51BE_Out, _Normalize_4D9B04E_Out); float3 _Branch_54FF636E_Out; Unity_Branch_float3(_Property_7B789410_Out, _Normalize_4D9B04E_Out, _Property_D380C535_Out, _Branch_54FF636E_Out); float _Property_B5560A97_Out = _UseThreadMap; float _Property_6FAEC412_Out = _Smoothness; float _Remap_C272A01C_Out; Unity_Remap_float(_SampleTexture2D_B39DD828_B, float2 (0,1), float2 (-1,1), _Remap_C272A01C_Out); float _Property_CF380DCA_Out = _ThreadSmoothnessStrength; float _Lerp_1EB6EBC0_Out; Unity_Lerp_float(0, _Remap_C272A01C_Out, _Property_CF380DCA_Out, _Lerp_1EB6EBC0_Out); float _Add_2975BB_Out; Unity_Add_float(_Property_6FAEC412_Out, _Lerp_1EB6EBC0_Out, _Add_2975BB_Out); float _Saturate_1F46047D_Out; Unity_Saturate_float(_Add_2975BB_Out, _Saturate_1F46047D_Out); float _Branch_1C4EA1E2_Out; Unity_Branch_float(_Property_B5560A97_Out, _Saturate_1F46047D_Out, _Property_6FAEC412_Out, _Branch_1C4EA1E2_Out); float _Property_57F076E2_Out = _UseThreadMap; float _Property_829FEB4F_Out = _ThreadAOStrength; float _Lerp_1DC743E3_Out; Unity_Lerp_float(1, _SampleTexture2D_B39DD828_R, _Property_829FEB4F_Out, _Lerp_1DC743E3_Out); float _Property_416E73AE_Out = _AmbientOcclusion; float _Multiply_FBD87ACD_Out; Unity_Multiply_float(_Lerp_1DC743E3_Out, _Property_416E73AE_Out, _Multiply_FBD87ACD_Out); float _Branch_A5F3B7F9_Out; Unity_Branch_float(_Property_57F076E2_Out, _Multiply_FBD87ACD_Out, _Property_416E73AE_Out, _Branch_A5F3B7F9_Out); float _Property_5FDD4914_Out = _Alpha; float _Multiply_716B151B_Out; Unity_Multiply_float(_SampleTexture2D_B39DD828_R, _Property_5FDD4914_Out, _Multiply_716B151B_Out); Output1 = (float4(_Branch_54FF636E_Out, 1.0)); Output2 = (_Branch_1C4EA1E2_Out.xxxx); Output3 = (_Branch_A5F3B7F9_Out.xxxx); Output4 = (_Multiply_716B151B_Out.xxxx); } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float4 _Property_90FAF786_Out = _BaseColor; float4 _Property_1E040901_Out = _uvBaseMask; float4 _Property_97A7EF85_Out = _uvBaseST; float4 _Subgraph_8DDCEE61_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_97A7EF85_Out, _Property_1E040901_Out, IN, _Subgraph_8DDCEE61_Output1); float4 _SampleTexture2D_11CFD011_RGBA = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_11CFD011_R = _SampleTexture2D_11CFD011_RGBA.r; float _SampleTexture2D_11CFD011_G = _SampleTexture2D_11CFD011_RGBA.g; float _SampleTexture2D_11CFD011_B = _SampleTexture2D_11CFD011_RGBA.b; float _SampleTexture2D_11CFD011_A = _SampleTexture2D_11CFD011_RGBA.a; float4 _Multiply_98A7A079_Out; Unity_Multiply_float(_Property_90FAF786_Out, _SampleTexture2D_11CFD011_RGBA, _Multiply_98A7A079_Out); float _Property_7C6435CB_Out = _FuzzMapUVScale; float4 _Multiply_18C3A780_Out; Unity_Multiply_float(_Subgraph_8DDCEE61_Output1, (_Property_7C6435CB_Out.xxxx), _Multiply_18C3A780_Out); float4 _SampleTexture2D_4D82F05E_RGBA = SAMPLE_TEXTURE2D(_FuzzMap, sampler_FuzzMap, (_Multiply_18C3A780_Out.xy)); float _SampleTexture2D_4D82F05E_R = _SampleTexture2D_4D82F05E_RGBA.r; float _SampleTexture2D_4D82F05E_G = _SampleTexture2D_4D82F05E_RGBA.g; float _SampleTexture2D_4D82F05E_B = _SampleTexture2D_4D82F05E_RGBA.b; float _SampleTexture2D_4D82F05E_A = _SampleTexture2D_4D82F05E_RGBA.a; float _Property_6CCE2816_Out = _FuzzStrength; float _Lerp_2C953D15_Out; Unity_Lerp_float(0, _SampleTexture2D_4D82F05E_R, _Property_6CCE2816_Out, _Lerp_2C953D15_Out); float4 _Add_A30FF2E2_Out; Unity_Add_float4(_Multiply_98A7A079_Out, (_Lerp_2C953D15_Out.xxxx), _Add_A30FF2E2_Out); float4 _Saturate_69BD2FF3_Out; Unity_Saturate_float4(_Add_A30FF2E2_Out, _Saturate_69BD2FF3_Out); float _Property_1E54B66A_Out = _useThreadMap; float4 _Property_8AE14795_Out = _uvThreadMask; float4 _Property_958B7FC9_Out = _uvThreadST; float4 _Subgraph_B567E108_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_958B7FC9_Out, _Property_8AE14795_Out, IN, _Subgraph_B567E108_Output1); float4 _Property_FEDB20A0_Out = _uvBaseMask; float4 _Property_F42AAF3B_Out = _uvBaseST; float4 _Subgraph_9D4E0F1_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_F42AAF3B_Out, _Property_FEDB20A0_Out, IN, _Subgraph_9D4E0F1_Output1); float4 _SampleTexture2D_105B35B3_RGBA = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, (_Subgraph_9D4E0F1_Output1.xy)); _SampleTexture2D_105B35B3_RGBA.rgb = UnpackNormalmapRGorAG(_SampleTexture2D_105B35B3_RGBA); float _SampleTexture2D_105B35B3_R = _SampleTexture2D_105B35B3_RGBA.r; float _SampleTexture2D_105B35B3_G = _SampleTexture2D_105B35B3_RGBA.g; float _SampleTexture2D_105B35B3_B = _SampleTexture2D_105B35B3_RGBA.b; float _SampleTexture2D_105B35B3_A = _SampleTexture2D_105B35B3_RGBA.a; float _Property_82D183C3_Out = _NormalMapStrength; float3 _NormalStrength_BFF5C35E_Out; Unity_NormalStrength_float((_SampleTexture2D_105B35B3_RGBA.xyz), _Property_82D183C3_Out, _NormalStrength_BFF5C35E_Out); float3 _Normalize_ACA4E10E_Out; Unity_Normalize_float3(_NormalStrength_BFF5C35E_Out, _Normalize_ACA4E10E_Out); float4 _SampleTexture2D_8C3CF01A_RGBA = SAMPLE_TEXTURE2D(_SpecColorMap, sampler_SpecColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_8C3CF01A_R = _SampleTexture2D_8C3CF01A_RGBA.r; float _SampleTexture2D_8C3CF01A_G = _SampleTexture2D_8C3CF01A_RGBA.g; float _SampleTexture2D_8C3CF01A_B = _SampleTexture2D_8C3CF01A_RGBA.b; float _SampleTexture2D_8C3CF01A_A = _SampleTexture2D_8C3CF01A_RGBA.a; float _Property_B948927_Out = _SmoothnessMin; float _Property_2962A49E_Out = _SmoothnessMax; float2 _Vector2_9C783D17_Out = float2(_Property_B948927_Out,_Property_2962A49E_Out); float _Remap_10DEF6A_Out; Unity_Remap_float(_SampleTexture2D_8C3CF01A_A, float2 (0,1), _Vector2_9C783D17_Out, _Remap_10DEF6A_Out); float _Split_EB0B739F_R = _Saturate_69BD2FF3_Out[0]; float _Split_EB0B739F_G = _Saturate_69BD2FF3_Out[1]; float _Split_EB0B739F_B = _Saturate_69BD2FF3_Out[2]; float _Split_EB0B739F_A = _Saturate_69BD2FF3_Out[3]; float4 _SampleTexture2D_EECA7933_RGBA = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_EECA7933_R = _SampleTexture2D_EECA7933_RGBA.r; float _SampleTexture2D_EECA7933_G = _SampleTexture2D_EECA7933_RGBA.g; float _SampleTexture2D_EECA7933_B = _SampleTexture2D_EECA7933_RGBA.b; float _SampleTexture2D_EECA7933_A = _SampleTexture2D_EECA7933_RGBA.a; float _Property_88B45C0E_Out = _ThreadAOStrength01; float _Property_FC0CC4C0_Out = _ThreadNormalStrength; float _Property_AC495D22_Out = _ThreadSmoothnessScale; float4 _Subgraph_E494B5B1_Output1; float4 _Subgraph_E494B5B1_Output2; float4 _Subgraph_E494B5B1_Output3; float4 _Subgraph_E494B5B1_Output4; sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52((_Subgraph_B567E108_Output1.xy), TEXTURE2D_PARAM(_ThreadMap, sampler_ThreadMap), _Property_AC495D22_Out, _SampleTexture2D_EECA7933_G, _Property_1E54B66A_Out, _Property_88B45C0E_Out, _Property_FC0CC4C0_Out, _Remap_10DEF6A_Out, _Normalize_ACA4E10E_Out, _Split_EB0B739F_A, IN, _Subgraph_E494B5B1_Output1, _Subgraph_E494B5B1_Output2, _Subgraph_E494B5B1_Output3, _Subgraph_E494B5B1_Output4); float4 _Property_BFE334DC_Out = _SpecularColor; surface.Albedo = (_Saturate_69BD2FF3_Out.xyz); surface.Normal = (_Subgraph_E494B5B1_Output1.xyz); surface.Smoothness = (_Subgraph_E494B5B1_Output2).x; surface.Occlusion = (_Subgraph_E494B5B1_Output3).x; surface.Specular = (_Property_BFE334DC_Out.xyz); surface.DiffusionProfile = 4; surface.SubsurfaceMask = _SampleTexture2D_EECA7933_B; surface.Thickness = _SampleTexture2D_EECA7933_R; surface.Emission = float3(0, 0, 0); surface.Alpha = (_Subgraph_E494B5B1_Output4).x; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- FragInputs BuildFragInputs(VaryingsMeshToPS input) { FragInputs output; ZERO_INITIALIZE(FragInputs, output); // Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used). // TODO: this is a really poor workaround, but the variable is used in a bunch of places // to compute normals which are then passed on elsewhere to compute other values... output.worldToTangent = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.texCoord0 = input.texCoord0; output.texCoord1 = input.texCoord1; output.texCoord2 = input.texCoord2; output.texCoord3 = input.texCoord3; #if SHADER_STAGE_FRAGMENT #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; output.uv2 = input.texCoord2; output.uv3 = input.texCoord3; return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void ApplyDecalToSurfaceData(DecalSurfaceData decalSurfaceData, inout SurfaceData surfaceData) { // using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_DIFFUSE) { surfaceData.baseColor.xyz = surfaceData.baseColor.xyz * decalSurfaceData.baseColor.w + decalSurfaceData.baseColor.xyz; } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_NORMAL) { surfaceData.normalWS.xyz = normalize(surfaceData.normalWS.xyz * decalSurfaceData.normalWS.w + decalSurfaceData.normalWS.xyz); } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_MASK) { #ifdef DECALS_4RT // only smoothness in 3RT mode // Don't apply any metallic modification surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.MAOSBlend.y + decalSurfaceData.mask.y; #endif surfaceData.perceptualSmoothness = surfaceData.perceptualSmoothness * decalSurfaceData.mask.w + decalSurfaceData.mask.z; } } void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, out SurfaceData surfaceData) { // setup defaults -- these are used if the graph doesn't output a value ZERO_INITIALIZE(SurfaceData, surfaceData); // copy across graph values, if defined surfaceData.baseColor = surfaceDescription.Albedo; surfaceData.perceptualSmoothness = surfaceDescription.Smoothness; surfaceData.ambientOcclusion = surfaceDescription.Occlusion; surfaceData.specularColor = surfaceDescription.Specular; surfaceData.diffusionProfile = surfaceDescription.DiffusionProfile; surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask; surfaceData.thickness = surfaceDescription.Thickness; surfaceData.diffusionProfile = surfaceDescription.DiffusionProfile; // These static material feature allow compile time optimization surfaceData.materialFeatures = 0; // Transform the preprocess macro into a material feature (note that silk flag is deduced from the abscence of this one) #ifdef _MATERIAL_FEATURE_COTTON_WOOL surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL; #endif #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION; #endif #if defined (_ENERGY_CONSERVING_SPECULAR) // Require to have setup baseColor // Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b)); #endif // tangent-space normal float3 normalTS = float3(0.0f, 0.0f, 1.0f); normalTS = surfaceDescription.Normal; // compute world space normal GetNormalWS(fragInputs, normalTS, surfaceData.normalWS); surfaceData.geomNormalWS = fragInputs.worldToTangent[2]; surfaceData.tangentWS = normalize(fragInputs.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS); // By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion. // If user provide bent normal then we process a better term surfaceData.specularOcclusion = 1.0; #if defined(_SPECULAR_OCCLUSION_CUSTOM) // Just use the value passed through via the slot (not active otherwise) #elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL) // If we have bent normal and ambient occlusion, process a specular occlusion surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness)); #elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO) surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness)); #else surfaceData.specularOcclusion = 1.0; surfaceData.specularOcclusion = 1.0; #endif #ifdef DEBUG_DISPLAY // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.worldToTangent, surfaceData); #endif } void GetSurfaceAndBuiltinData(FragInputs fragInputs, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData) { #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group uint3 fadeMaskSeed = asuint((int3)(V * _ScreenSize.xyx)); // Quantize V to _ScreenSize values LODDitheringTransition(fadeMaskSeed, unity_LODFade.x); #endif // this applies the double sided tangent space correction -- see 'ApplyDoubleSidedFlipOrMirror()' SurfaceDescriptionInputs surfaceDescriptionInputs = FragInputsToSurfaceDescriptionInputs(fragInputs, V); SurfaceDescription surfaceDescription = SurfaceDescriptionFunction(surfaceDescriptionInputs); // Perform alpha test very early to save performance (a killed pixel will not sample textures) // TODO: split graph evaluation to grab just alpha dependencies first? tricky.. BuildSurfaceData(fragInputs, surfaceDescription, V, surfaceData); #if HAVE_DECALS && _DECALS DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); #endif // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(surfaceDescription.Alpha, surfaceData.normalWS, -fragInputs.worldToTangent[2], fragInputs.positionRWS, fragInputs.texCoord1, fragInputs.texCoord2, builtinData); builtinData.emissiveColor = surfaceDescription.Emission; builtinData.depthOffset = 0.0; // ApplyPerPixelDisplacement(input, V, layerTexCoord, blendMasks); #ifdef _DEPTHOFFSET_ON : ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput); PostInitBuiltinData(V, posInput, surfaceData, builtinData); } //------------------------------------------------------------------------------------- // Pass Includes //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPassLightTransport.hlsl" //------------------------------------------------------------------------------------- // End Pass Includes //------------------------------------------------------------------------------------- ENDHLSL } Pass { // based on FabricPass.template Name "SceneSelectionPass" Tags { "LightMode" = "SceneSelectionPass" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Blend One Zero Cull Back ZTest LEqual ZWrite On ZClip [_ZClip] // Default Stencil ColorMask 0 //------------------------------------------------------------------------------------- // End Render Modes //------------------------------------------------------------------------------------- HLSLPROGRAM #pragma target 4.5 #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch //#pragma enable_d3d11_debug_symbols #pragma multi_compile_instancing #pragma instancing_options renderinglayer #pragma multi_compile _ LOD_FADE_CROSSFADE //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- #define _MATERIAL_FEATURE_COTTON_WOOL 1 #define _SPECULAR_OCCLUSION_FROM_AO 1 #define _ENERGY_CONSERVING_SPECULAR 1 #define _DISABLE_SSR 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag #define UNITY_MATERIAL_FABRIC // Need to be define before including Material.hlsl // This will be enabled in an upcoming change. // #define SURFACE_GRADIENT // If we use subsurface scattering, enable output split lighting (for forward pass) #if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT) #define OUTPUT_SPLIT_LIGHTING #endif #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Wind.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl" // define FragInputs structure #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl" //------------------------------------------------------------------------------------- // Defines //------------------------------------------------------------------------------------- #define SHADERPASS SHADERPASS_DEPTH_ONLY #define SCENESELECTIONPASS // this translates the new dependency tracker into the old preprocessor definitions for the existing HDRP shader code #define ATTRIBUTES_NEED_TEXCOORD0 #define ATTRIBUTES_NEED_TEXCOORD1 #define ATTRIBUTES_NEED_TEXCOORD2 #define ATTRIBUTES_NEED_TEXCOORD3 #define VARYINGS_NEED_TEXCOORD0 #define VARYINGS_NEED_TEXCOORD1 #define VARYINGS_NEED_TEXCOORD2 #define VARYINGS_NEED_TEXCOORD3 //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #if (SHADERPASS == SHADERPASS_FORWARD) // used for shaders that want to do lighting (and materials) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #else // used for shaders that don't need lighting #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl" //Used by SceneSelectionPass int _ObjectId; int _PassValue; // this function assumes the bitangent flip is encoded in tangentWS.w // TODO: move this function to HDRP shared file, once we merge with HDRP repo float3x3 BuildWorldToTangent(float4 tangentWS, float3 normalWS) { // tangentWS must not be normalized (mikkts requirement) // Normalize normalWS vector but keep the renormFactor to apply it to bitangent and tangent float3 unnormalizedNormalWS = normalWS; float renormFactor = 1.0 / length(unnormalizedNormalWS); // bitangent on the fly option in xnormal to reduce vertex shader outputs. // this is the mikktspace transformation (must use unnormalized attributes) float3x3 worldToTangent = CreateWorldToTangent(unnormalizedNormalWS, tangentWS.xyz, tangentWS.w > 0.0 ? 1.0 : -1.0); // surface gradient based formulation requires a unit length initial normal. We can maintain compliance with mikkts // by uniformly scaling all 3 vectors since normalization of the perturbed normal will cancel it. worldToTangent[0] = worldToTangent[0] * renormFactor; worldToTangent[1] = worldToTangent[1] * renormFactor; worldToTangent[2] = worldToTangent[2] * renormFactor; // normalizes the interpolated vertex normal return worldToTangent; } //------------------------------------------------------------------------------------- // Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- // Generated Type: AttributesMesh struct AttributesMesh { float3 positionOS : POSITION; float4 uv0 : TEXCOORD0; // optional float4 uv1 : TEXCOORD1; // optional float4 uv2 : TEXCOORD2; // optional float4 uv3 : TEXCOORD3; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; // Generated Type: VaryingsMeshToPS struct VaryingsMeshToPS { float4 positionCS : SV_Position; float4 texCoord0; // optional float4 texCoord1; // optional float4 texCoord2; // optional float4 texCoord3; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToPS { float4 interp00 : TEXCOORD0; // auto-packed float4 interp01 : TEXCOORD1; // auto-packed float4 interp02 : TEXCOORD2; // auto-packed float4 interp03 : TEXCOORD3; // auto-packed float4 positionCS : SV_Position; // unpacked #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToPS PackVaryingsMeshToPS(VaryingsMeshToPS input) { PackedVaryingsMeshToPS output; output.positionCS = input.positionCS; output.interp00.xyzw = input.texCoord0; output.interp01.xyzw = input.texCoord1; output.interp02.xyzw = input.texCoord2; output.interp03.xyzw = input.texCoord3; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToPS UnpackVaryingsMeshToPS(PackedVaryingsMeshToPS input) { VaryingsMeshToPS output; output.positionCS = input.positionCS; output.texCoord0 = input.interp00.xyzw; output.texCoord1 = input.interp01.xyzw; output.texCoord2 = input.interp02.xyzw; output.texCoord3 = input.interp03.xyzw; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToDS { float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _uvBaseMask; float4 _uvBaseST; float4 _BaseColor; float _SmoothnessMin; float _SmoothnessMax; float4 _SpecularColor; float _NormalMapStrength; float _useThreadMap; float4 _uvThreadMask; float4 _uvThreadST; float _ThreadAOStrength01; float _ThreadNormalStrength; float _ThreadSmoothnessScale; float _FuzzMapUVScale; float _FuzzStrength; float4 _EmissionColor; CBUFFER_END TEXTURE2D(_BaseColorMap); SAMPLER(sampler_BaseColorMap); float4 _BaseColorMap_TexelSize; TEXTURE2D(_MaskMap); SAMPLER(sampler_MaskMap); float4 _MaskMap_TexelSize; TEXTURE2D(_SpecColorMap); SAMPLER(sampler_SpecColorMap); float4 _SpecColorMap_TexelSize; TEXTURE2D(_NormalMap); SAMPLER(sampler_NormalMap); float4 _NormalMap_TexelSize; TEXTURE2D(_ThreadMap); SAMPLER(sampler_ThreadMap); float4 _ThreadMap_TexelSize; TEXTURE2D(_FuzzMap); SAMPLER(sampler_FuzzMap); float4 _FuzzMap_TexelSize; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float4 uv0; // optional float4 uv1; // optional float4 uv2; // optional float4 uv3; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float Alpha; }; // Shared Graph Node Functions void Unity_Combine_float(float R, float G, float B, float A, out float4 RGBA, out float3 RGB, out float2 RG) { RGBA = float4(R, G, B, A); RGB = float3(R, G, B); RG = float2(R, G); } void Unity_Multiply_float (float2 A, float2 B, out float2 Out) { Out = A * B; } void Unity_Add_float2(float2 A, float2 B, out float2 Out) { Out = A + B; } // Subgraph function void sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(float4 _uvST, float4 _uvMask, SurfaceDescriptionInputs IN, out float4 Output1) { float4 _UV_23AF8552_Out = IN.uv0; float _Split_7957D60_R = _UV_23AF8552_Out[0]; float _Split_7957D60_G = _UV_23AF8552_Out[1]; float _Split_7957D60_B = _UV_23AF8552_Out[2]; float _Split_7957D60_A = _UV_23AF8552_Out[3]; float4 _Combine_5396A6C7_RGBA; float3 _Combine_5396A6C7_RGB; float2 _Combine_5396A6C7_RG; Unity_Combine_float(_Split_7957D60_R, _Split_7957D60_G, 0, 0, _Combine_5396A6C7_RGBA, _Combine_5396A6C7_RGB, _Combine_5396A6C7_RG); float4 _Property_CB55E443_Out = _uvMask; float _Split_6086B0A5_R = _Property_CB55E443_Out[0]; float _Split_6086B0A5_G = _Property_CB55E443_Out[1]; float _Split_6086B0A5_B = _Property_CB55E443_Out[2]; float _Split_6086B0A5_A = _Property_CB55E443_Out[3]; float2 _Multiply_FC550A07_Out; Unity_Multiply_float(_Combine_5396A6C7_RG, (_Split_6086B0A5_R.xx), _Multiply_FC550A07_Out); float4 _UV_3B1D042C_Out = IN.uv1; float _Split_107320B6_R = _UV_3B1D042C_Out[0]; float _Split_107320B6_G = _UV_3B1D042C_Out[1]; float _Split_107320B6_B = _UV_3B1D042C_Out[2]; float _Split_107320B6_A = _UV_3B1D042C_Out[3]; float4 _Combine_2E8D3795_RGBA; float3 _Combine_2E8D3795_RGB; float2 _Combine_2E8D3795_RG; Unity_Combine_float(_Split_107320B6_R, _Split_107320B6_G, 0, 0, _Combine_2E8D3795_RGBA, _Combine_2E8D3795_RGB, _Combine_2E8D3795_RG); float2 _Multiply_FDA7BA1E_Out; Unity_Multiply_float(_Combine_2E8D3795_RG, (_Split_6086B0A5_G.xx), _Multiply_FDA7BA1E_Out); float2 _Add_92015245_Out; Unity_Add_float2(_Multiply_FC550A07_Out, _Multiply_FDA7BA1E_Out, _Add_92015245_Out); float4 _UV_49BE4158_Out = IN.uv2; float _Split_A24186AD_R = _UV_49BE4158_Out[0]; float _Split_A24186AD_G = _UV_49BE4158_Out[1]; float _Split_A24186AD_B = _UV_49BE4158_Out[2]; float _Split_A24186AD_A = _UV_49BE4158_Out[3]; float4 _Combine_6951B6BC_RGBA; float3 _Combine_6951B6BC_RGB; float2 _Combine_6951B6BC_RG; Unity_Combine_float(_Split_A24186AD_R, _Split_A24186AD_G, 0, 0, _Combine_6951B6BC_RGBA, _Combine_6951B6BC_RGB, _Combine_6951B6BC_RG); float2 _Multiply_1480B81_Out; Unity_Multiply_float(_Combine_6951B6BC_RG, (_Split_6086B0A5_B.xx), _Multiply_1480B81_Out); float4 _UV_9CA65C2_Out = IN.uv3; float _Split_9EC6EA10_R = _UV_9CA65C2_Out[0]; float _Split_9EC6EA10_G = _UV_9CA65C2_Out[1]; float _Split_9EC6EA10_B = _UV_9CA65C2_Out[2]; float _Split_9EC6EA10_A = _UV_9CA65C2_Out[3]; float4 _Combine_633F7D3D_RGBA; float3 _Combine_633F7D3D_RGB; float2 _Combine_633F7D3D_RG; Unity_Combine_float(_Split_9EC6EA10_R, _Split_9EC6EA10_G, 0, 0, _Combine_633F7D3D_RGBA, _Combine_633F7D3D_RGB, _Combine_633F7D3D_RG); float2 _Multiply_2A2B5227_Out; Unity_Multiply_float(_Combine_633F7D3D_RG, (_Split_6086B0A5_A.xx), _Multiply_2A2B5227_Out); float2 _Add_B5E7679D_Out; Unity_Add_float2(_Multiply_1480B81_Out, _Multiply_2A2B5227_Out, _Add_B5E7679D_Out); float2 _Add_892742E3_Out; Unity_Add_float2(_Add_92015245_Out, _Add_B5E7679D_Out, _Add_892742E3_Out); float4 _Property_8DA1B077_Out = _uvST; float _Split_1AB0DA31_R = _Property_8DA1B077_Out[0]; float _Split_1AB0DA31_G = _Property_8DA1B077_Out[1]; float _Split_1AB0DA31_B = _Property_8DA1B077_Out[2]; float _Split_1AB0DA31_A = _Property_8DA1B077_Out[3]; float4 _Combine_44459F1_RGBA; float3 _Combine_44459F1_RGB; float2 _Combine_44459F1_RG; Unity_Combine_float(_Split_1AB0DA31_R, _Split_1AB0DA31_G, 0, 0, _Combine_44459F1_RGBA, _Combine_44459F1_RGB, _Combine_44459F1_RG); float2 _Multiply_38815E23_Out; Unity_Multiply_float(_Add_892742E3_Out, _Combine_44459F1_RG, _Multiply_38815E23_Out); float _Split_35A1DC4_R = _Property_8DA1B077_Out[0]; float _Split_35A1DC4_G = _Property_8DA1B077_Out[1]; float _Split_35A1DC4_B = _Property_8DA1B077_Out[2]; float _Split_35A1DC4_A = _Property_8DA1B077_Out[3]; float4 _Combine_91984BDF_RGBA; float3 _Combine_91984BDF_RGB; float2 _Combine_91984BDF_RG; Unity_Combine_float(_Split_35A1DC4_B, _Split_35A1DC4_A, 0, 0, _Combine_91984BDF_RGBA, _Combine_91984BDF_RGB, _Combine_91984BDF_RG); float2 _Add_63012CEE_Out; Unity_Add_float2(_Multiply_38815E23_Out, _Combine_91984BDF_RG, _Add_63012CEE_Out); Output1 = (float4(_Add_63012CEE_Out, 0.0, 1.0)); } void Unity_NormalStrength_float(float3 In, float Strength, out float3 Out) { Out = float3(In.rg * Strength, lerp(1, In.b, saturate(Strength))); } void Unity_Normalize_float3(float3 In, out float3 Out) { Out = normalize(In); } void Unity_Remap_float(float In, float2 InMinMax, float2 OutMinMax, out float Out) { Out = OutMinMax.x + (In - InMinMax.x) * (OutMinMax.y - OutMinMax.x) / (InMinMax.y - InMinMax.x); } void Unity_Multiply_float (float4 A, float4 B, out float4 Out) { Out = A * B; } void Unity_Lerp_float(float A, float B, float T, out float Out) { Out = lerp(A, B, T); } void Unity_Add_float4(float4 A, float4 B, out float4 Out) { Out = A + B; } void Unity_Saturate_float4(float4 In, out float4 Out) { Out = saturate(In); } void Unity_NormalUnpack_float(float4 In, out float3 Out) { Out = UnpackNormalmapRGorAG(In); } void Unity_NormalBlend_float(float3 A, float3 B, out float3 Out) { Out = normalize(float3(A.rg + B.rg, A.b * B.b)); } void Unity_Branch_float3(float Predicate, float3 True, float3 False, out float3 Out) { Out = lerp(False, True, Predicate); } void Unity_Add_float(float A, float B, out float Out) { Out = A + B; } void Unity_Saturate_float(float In, out float Out) { Out = saturate(In); } void Unity_Branch_float(float Predicate, float True, float False, out float Out) { Out = lerp(False, True, Predicate); } void Unity_Multiply_float (float A, float B, out float Out) { Out = A * B; } // Subgraph function void sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52(float2 _UV, TEXTURE2D_ARGS(_ThreadMap, sampler_ThreadMap), float _ThreadSmoothnessStrength, float _AmbientOcclusion, float _UseThreadMap, float _ThreadAOStrength, float _ThreadNormalStrength, float _Smoothness, float3 _Normals, float _Alpha, SurfaceDescriptionInputs IN, out float4 Output1, out float4 Output2, out float4 Output3, out float4 Output4) { float _Property_7B789410_Out = _UseThreadMap; float3 _Property_D380C535_Out = _Normals; float2 _Property_247E83DC_Out = _UV; float4 _SampleTexture2D_B39DD828_RGBA = SAMPLE_TEXTURE2D(_ThreadMap, sampler_ThreadMap, _Property_247E83DC_Out); float _SampleTexture2D_B39DD828_R = _SampleTexture2D_B39DD828_RGBA.r; float _SampleTexture2D_B39DD828_G = _SampleTexture2D_B39DD828_RGBA.g; float _SampleTexture2D_B39DD828_B = _SampleTexture2D_B39DD828_RGBA.b; float _SampleTexture2D_B39DD828_A = _SampleTexture2D_B39DD828_RGBA.a; float4 _Combine_3989CE7_RGBA; float3 _Combine_3989CE7_RGB; float2 _Combine_3989CE7_RG; Unity_Combine_float(_SampleTexture2D_B39DD828_A, _SampleTexture2D_B39DD828_G, 1, 1, _Combine_3989CE7_RGBA, _Combine_3989CE7_RGB, _Combine_3989CE7_RG); float3 _NormalUnpack_6B39F6EC_Out; Unity_NormalUnpack_float((float4(_Combine_3989CE7_RGB, 1.0)), _NormalUnpack_6B39F6EC_Out); float3 _Normalize_1F52E5EC_Out; Unity_Normalize_float3(_NormalUnpack_6B39F6EC_Out, _Normalize_1F52E5EC_Out); float _Property_2E175598_Out = _ThreadNormalStrength; float3 _NormalStrength_A15875A3_Out; Unity_NormalStrength_float(_Normalize_1F52E5EC_Out, _Property_2E175598_Out, _NormalStrength_A15875A3_Out); float3 _NormalBlend_191D51BE_Out; Unity_NormalBlend_float(_Property_D380C535_Out, _NormalStrength_A15875A3_Out, _NormalBlend_191D51BE_Out); float3 _Normalize_4D9B04E_Out; Unity_Normalize_float3(_NormalBlend_191D51BE_Out, _Normalize_4D9B04E_Out); float3 _Branch_54FF636E_Out; Unity_Branch_float3(_Property_7B789410_Out, _Normalize_4D9B04E_Out, _Property_D380C535_Out, _Branch_54FF636E_Out); float _Property_B5560A97_Out = _UseThreadMap; float _Property_6FAEC412_Out = _Smoothness; float _Remap_C272A01C_Out; Unity_Remap_float(_SampleTexture2D_B39DD828_B, float2 (0,1), float2 (-1,1), _Remap_C272A01C_Out); float _Property_CF380DCA_Out = _ThreadSmoothnessStrength; float _Lerp_1EB6EBC0_Out; Unity_Lerp_float(0, _Remap_C272A01C_Out, _Property_CF380DCA_Out, _Lerp_1EB6EBC0_Out); float _Add_2975BB_Out; Unity_Add_float(_Property_6FAEC412_Out, _Lerp_1EB6EBC0_Out, _Add_2975BB_Out); float _Saturate_1F46047D_Out; Unity_Saturate_float(_Add_2975BB_Out, _Saturate_1F46047D_Out); float _Branch_1C4EA1E2_Out; Unity_Branch_float(_Property_B5560A97_Out, _Saturate_1F46047D_Out, _Property_6FAEC412_Out, _Branch_1C4EA1E2_Out); float _Property_57F076E2_Out = _UseThreadMap; float _Property_829FEB4F_Out = _ThreadAOStrength; float _Lerp_1DC743E3_Out; Unity_Lerp_float(1, _SampleTexture2D_B39DD828_R, _Property_829FEB4F_Out, _Lerp_1DC743E3_Out); float _Property_416E73AE_Out = _AmbientOcclusion; float _Multiply_FBD87ACD_Out; Unity_Multiply_float(_Lerp_1DC743E3_Out, _Property_416E73AE_Out, _Multiply_FBD87ACD_Out); float _Branch_A5F3B7F9_Out; Unity_Branch_float(_Property_57F076E2_Out, _Multiply_FBD87ACD_Out, _Property_416E73AE_Out, _Branch_A5F3B7F9_Out); float _Property_5FDD4914_Out = _Alpha; float _Multiply_716B151B_Out; Unity_Multiply_float(_SampleTexture2D_B39DD828_R, _Property_5FDD4914_Out, _Multiply_716B151B_Out); Output1 = (float4(_Branch_54FF636E_Out, 1.0)); Output2 = (_Branch_1C4EA1E2_Out.xxxx); Output3 = (_Branch_A5F3B7F9_Out.xxxx); Output4 = (_Multiply_716B151B_Out.xxxx); } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float _Property_1E54B66A_Out = _useThreadMap; float4 _Property_8AE14795_Out = _uvThreadMask; float4 _Property_958B7FC9_Out = _uvThreadST; float4 _Subgraph_B567E108_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_958B7FC9_Out, _Property_8AE14795_Out, IN, _Subgraph_B567E108_Output1); float4 _Property_FEDB20A0_Out = _uvBaseMask; float4 _Property_F42AAF3B_Out = _uvBaseST; float4 _Subgraph_9D4E0F1_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_F42AAF3B_Out, _Property_FEDB20A0_Out, IN, _Subgraph_9D4E0F1_Output1); float4 _SampleTexture2D_105B35B3_RGBA = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, (_Subgraph_9D4E0F1_Output1.xy)); _SampleTexture2D_105B35B3_RGBA.rgb = UnpackNormalmapRGorAG(_SampleTexture2D_105B35B3_RGBA); float _SampleTexture2D_105B35B3_R = _SampleTexture2D_105B35B3_RGBA.r; float _SampleTexture2D_105B35B3_G = _SampleTexture2D_105B35B3_RGBA.g; float _SampleTexture2D_105B35B3_B = _SampleTexture2D_105B35B3_RGBA.b; float _SampleTexture2D_105B35B3_A = _SampleTexture2D_105B35B3_RGBA.a; float _Property_82D183C3_Out = _NormalMapStrength; float3 _NormalStrength_BFF5C35E_Out; Unity_NormalStrength_float((_SampleTexture2D_105B35B3_RGBA.xyz), _Property_82D183C3_Out, _NormalStrength_BFF5C35E_Out); float3 _Normalize_ACA4E10E_Out; Unity_Normalize_float3(_NormalStrength_BFF5C35E_Out, _Normalize_ACA4E10E_Out); float4 _Property_1E040901_Out = _uvBaseMask; float4 _Property_97A7EF85_Out = _uvBaseST; float4 _Subgraph_8DDCEE61_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_97A7EF85_Out, _Property_1E040901_Out, IN, _Subgraph_8DDCEE61_Output1); float4 _SampleTexture2D_8C3CF01A_RGBA = SAMPLE_TEXTURE2D(_SpecColorMap, sampler_SpecColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_8C3CF01A_R = _SampleTexture2D_8C3CF01A_RGBA.r; float _SampleTexture2D_8C3CF01A_G = _SampleTexture2D_8C3CF01A_RGBA.g; float _SampleTexture2D_8C3CF01A_B = _SampleTexture2D_8C3CF01A_RGBA.b; float _SampleTexture2D_8C3CF01A_A = _SampleTexture2D_8C3CF01A_RGBA.a; float _Property_B948927_Out = _SmoothnessMin; float _Property_2962A49E_Out = _SmoothnessMax; float2 _Vector2_9C783D17_Out = float2(_Property_B948927_Out,_Property_2962A49E_Out); float _Remap_10DEF6A_Out; Unity_Remap_float(_SampleTexture2D_8C3CF01A_A, float2 (0,1), _Vector2_9C783D17_Out, _Remap_10DEF6A_Out); float4 _Property_90FAF786_Out = _BaseColor; float4 _SampleTexture2D_11CFD011_RGBA = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_11CFD011_R = _SampleTexture2D_11CFD011_RGBA.r; float _SampleTexture2D_11CFD011_G = _SampleTexture2D_11CFD011_RGBA.g; float _SampleTexture2D_11CFD011_B = _SampleTexture2D_11CFD011_RGBA.b; float _SampleTexture2D_11CFD011_A = _SampleTexture2D_11CFD011_RGBA.a; float4 _Multiply_98A7A079_Out; Unity_Multiply_float(_Property_90FAF786_Out, _SampleTexture2D_11CFD011_RGBA, _Multiply_98A7A079_Out); float _Property_7C6435CB_Out = _FuzzMapUVScale; float4 _Multiply_18C3A780_Out; Unity_Multiply_float(_Subgraph_8DDCEE61_Output1, (_Property_7C6435CB_Out.xxxx), _Multiply_18C3A780_Out); float4 _SampleTexture2D_4D82F05E_RGBA = SAMPLE_TEXTURE2D(_FuzzMap, sampler_FuzzMap, (_Multiply_18C3A780_Out.xy)); float _SampleTexture2D_4D82F05E_R = _SampleTexture2D_4D82F05E_RGBA.r; float _SampleTexture2D_4D82F05E_G = _SampleTexture2D_4D82F05E_RGBA.g; float _SampleTexture2D_4D82F05E_B = _SampleTexture2D_4D82F05E_RGBA.b; float _SampleTexture2D_4D82F05E_A = _SampleTexture2D_4D82F05E_RGBA.a; float _Property_6CCE2816_Out = _FuzzStrength; float _Lerp_2C953D15_Out; Unity_Lerp_float(0, _SampleTexture2D_4D82F05E_R, _Property_6CCE2816_Out, _Lerp_2C953D15_Out); float4 _Add_A30FF2E2_Out; Unity_Add_float4(_Multiply_98A7A079_Out, (_Lerp_2C953D15_Out.xxxx), _Add_A30FF2E2_Out); float4 _Saturate_69BD2FF3_Out; Unity_Saturate_float4(_Add_A30FF2E2_Out, _Saturate_69BD2FF3_Out); float _Split_EB0B739F_R = _Saturate_69BD2FF3_Out[0]; float _Split_EB0B739F_G = _Saturate_69BD2FF3_Out[1]; float _Split_EB0B739F_B = _Saturate_69BD2FF3_Out[2]; float _Split_EB0B739F_A = _Saturate_69BD2FF3_Out[3]; float4 _SampleTexture2D_EECA7933_RGBA = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_EECA7933_R = _SampleTexture2D_EECA7933_RGBA.r; float _SampleTexture2D_EECA7933_G = _SampleTexture2D_EECA7933_RGBA.g; float _SampleTexture2D_EECA7933_B = _SampleTexture2D_EECA7933_RGBA.b; float _SampleTexture2D_EECA7933_A = _SampleTexture2D_EECA7933_RGBA.a; float _Property_88B45C0E_Out = _ThreadAOStrength01; float _Property_FC0CC4C0_Out = _ThreadNormalStrength; float _Property_AC495D22_Out = _ThreadSmoothnessScale; float4 _Subgraph_E494B5B1_Output1; float4 _Subgraph_E494B5B1_Output2; float4 _Subgraph_E494B5B1_Output3; float4 _Subgraph_E494B5B1_Output4; sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52((_Subgraph_B567E108_Output1.xy), TEXTURE2D_PARAM(_ThreadMap, sampler_ThreadMap), _Property_AC495D22_Out, _SampleTexture2D_EECA7933_G, _Property_1E54B66A_Out, _Property_88B45C0E_Out, _Property_FC0CC4C0_Out, _Remap_10DEF6A_Out, _Normalize_ACA4E10E_Out, _Split_EB0B739F_A, IN, _Subgraph_E494B5B1_Output1, _Subgraph_E494B5B1_Output2, _Subgraph_E494B5B1_Output3, _Subgraph_E494B5B1_Output4); surface.Alpha = (_Subgraph_E494B5B1_Output4).x; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- FragInputs BuildFragInputs(VaryingsMeshToPS input) { FragInputs output; ZERO_INITIALIZE(FragInputs, output); // Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used). // TODO: this is a really poor workaround, but the variable is used in a bunch of places // to compute normals which are then passed on elsewhere to compute other values... output.worldToTangent = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.texCoord0 = input.texCoord0; output.texCoord1 = input.texCoord1; output.texCoord2 = input.texCoord2; output.texCoord3 = input.texCoord3; #if SHADER_STAGE_FRAGMENT #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; output.uv2 = input.texCoord2; output.uv3 = input.texCoord3; return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void ApplyDecalToSurfaceData(DecalSurfaceData decalSurfaceData, inout SurfaceData surfaceData) { // using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_DIFFUSE) { surfaceData.baseColor.xyz = surfaceData.baseColor.xyz * decalSurfaceData.baseColor.w + decalSurfaceData.baseColor.xyz; } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_NORMAL) { surfaceData.normalWS.xyz = normalize(surfaceData.normalWS.xyz * decalSurfaceData.normalWS.w + decalSurfaceData.normalWS.xyz); } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_MASK) { #ifdef DECALS_4RT // only smoothness in 3RT mode // Don't apply any metallic modification surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.MAOSBlend.y + decalSurfaceData.mask.y; #endif surfaceData.perceptualSmoothness = surfaceData.perceptualSmoothness * decalSurfaceData.mask.w + decalSurfaceData.mask.z; } } void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, out SurfaceData surfaceData) { // setup defaults -- these are used if the graph doesn't output a value ZERO_INITIALIZE(SurfaceData, surfaceData); // copy across graph values, if defined // These static material feature allow compile time optimization surfaceData.materialFeatures = 0; // Transform the preprocess macro into a material feature (note that silk flag is deduced from the abscence of this one) #ifdef _MATERIAL_FEATURE_COTTON_WOOL surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL; #endif #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION; #endif #if defined (_ENERGY_CONSERVING_SPECULAR) // Require to have setup baseColor // Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b)); #endif // tangent-space normal float3 normalTS = float3(0.0f, 0.0f, 1.0f); // compute world space normal GetNormalWS(fragInputs, normalTS, surfaceData.normalWS); surfaceData.geomNormalWS = fragInputs.worldToTangent[2]; surfaceData.tangentWS = normalize(fragInputs.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS); // By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion. // If user provide bent normal then we process a better term surfaceData.specularOcclusion = 1.0; #if defined(_SPECULAR_OCCLUSION_CUSTOM) // Just use the value passed through via the slot (not active otherwise) #elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL) // If we have bent normal and ambient occlusion, process a specular occlusion surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness)); #elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO) surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness)); #else surfaceData.specularOcclusion = 1.0; surfaceData.specularOcclusion = 1.0; #endif #ifdef DEBUG_DISPLAY // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.worldToTangent, surfaceData); #endif } void GetSurfaceAndBuiltinData(FragInputs fragInputs, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData) { #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group uint3 fadeMaskSeed = asuint((int3)(V * _ScreenSize.xyx)); // Quantize V to _ScreenSize values LODDitheringTransition(fadeMaskSeed, unity_LODFade.x); #endif // this applies the double sided tangent space correction -- see 'ApplyDoubleSidedFlipOrMirror()' SurfaceDescriptionInputs surfaceDescriptionInputs = FragInputsToSurfaceDescriptionInputs(fragInputs, V); SurfaceDescription surfaceDescription = SurfaceDescriptionFunction(surfaceDescriptionInputs); // Perform alpha test very early to save performance (a killed pixel will not sample textures) // TODO: split graph evaluation to grab just alpha dependencies first? tricky.. BuildSurfaceData(fragInputs, surfaceDescription, V, surfaceData); #if HAVE_DECALS && _DECALS DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); #endif // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(surfaceDescription.Alpha, surfaceData.normalWS, -fragInputs.worldToTangent[2], fragInputs.positionRWS, fragInputs.texCoord1, fragInputs.texCoord2, builtinData); builtinData.depthOffset = 0.0; // ApplyPerPixelDisplacement(input, V, layerTexCoord, blendMasks); #ifdef _DEPTHOFFSET_ON : ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput); PostInitBuiltinData(V, posInput, surfaceData, builtinData); } //------------------------------------------------------------------------------------- // Pass Includes //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPassDepthOnly.hlsl" //------------------------------------------------------------------------------------- // End Pass Includes //------------------------------------------------------------------------------------- ENDHLSL } Pass { // based on FabricPass.template Name "ShadowCaster" Tags { "LightMode" = "ShadowCaster" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Blend One Zero Cull Back ZTest LEqual ZWrite On ZClip [_ZClip] // Default Stencil ColorMask 0 //------------------------------------------------------------------------------------- // End Render Modes //------------------------------------------------------------------------------------- HLSLPROGRAM #pragma target 4.5 #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch //#pragma enable_d3d11_debug_symbols #pragma multi_compile_instancing #pragma instancing_options renderinglayer #pragma multi_compile _ LOD_FADE_CROSSFADE //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- #define _MATERIAL_FEATURE_COTTON_WOOL 1 #define _SPECULAR_OCCLUSION_FROM_AO 1 #define _ENERGY_CONSERVING_SPECULAR 1 #define _DISABLE_SSR 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag #define UNITY_MATERIAL_FABRIC // Need to be define before including Material.hlsl // This will be enabled in an upcoming change. // #define SURFACE_GRADIENT // If we use subsurface scattering, enable output split lighting (for forward pass) #if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT) #define OUTPUT_SPLIT_LIGHTING #endif #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Wind.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl" // define FragInputs structure #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl" //------------------------------------------------------------------------------------- // Defines //------------------------------------------------------------------------------------- #define SHADERPASS SHADERPASS_SHADOWS #define USE_LEGACY_UNITY_MATRIX_VARIABLES // this translates the new dependency tracker into the old preprocessor definitions for the existing HDRP shader code #define ATTRIBUTES_NEED_TEXCOORD0 #define ATTRIBUTES_NEED_TEXCOORD1 #define ATTRIBUTES_NEED_TEXCOORD2 #define ATTRIBUTES_NEED_TEXCOORD3 #define VARYINGS_NEED_TEXCOORD0 #define VARYINGS_NEED_TEXCOORD1 #define VARYINGS_NEED_TEXCOORD2 #define VARYINGS_NEED_TEXCOORD3 //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #if (SHADERPASS == SHADERPASS_FORWARD) // used for shaders that want to do lighting (and materials) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #else // used for shaders that don't need lighting #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl" //Used by SceneSelectionPass int _ObjectId; int _PassValue; // this function assumes the bitangent flip is encoded in tangentWS.w // TODO: move this function to HDRP shared file, once we merge with HDRP repo float3x3 BuildWorldToTangent(float4 tangentWS, float3 normalWS) { // tangentWS must not be normalized (mikkts requirement) // Normalize normalWS vector but keep the renormFactor to apply it to bitangent and tangent float3 unnormalizedNormalWS = normalWS; float renormFactor = 1.0 / length(unnormalizedNormalWS); // bitangent on the fly option in xnormal to reduce vertex shader outputs. // this is the mikktspace transformation (must use unnormalized attributes) float3x3 worldToTangent = CreateWorldToTangent(unnormalizedNormalWS, tangentWS.xyz, tangentWS.w > 0.0 ? 1.0 : -1.0); // surface gradient based formulation requires a unit length initial normal. We can maintain compliance with mikkts // by uniformly scaling all 3 vectors since normalization of the perturbed normal will cancel it. worldToTangent[0] = worldToTangent[0] * renormFactor; worldToTangent[1] = worldToTangent[1] * renormFactor; worldToTangent[2] = worldToTangent[2] * renormFactor; // normalizes the interpolated vertex normal return worldToTangent; } //------------------------------------------------------------------------------------- // Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- // Generated Type: AttributesMesh struct AttributesMesh { float3 positionOS : POSITION; float4 uv0 : TEXCOORD0; // optional float4 uv1 : TEXCOORD1; // optional float4 uv2 : TEXCOORD2; // optional float4 uv3 : TEXCOORD3; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; // Generated Type: VaryingsMeshToPS struct VaryingsMeshToPS { float4 positionCS : SV_Position; float4 texCoord0; // optional float4 texCoord1; // optional float4 texCoord2; // optional float4 texCoord3; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToPS { float4 interp00 : TEXCOORD0; // auto-packed float4 interp01 : TEXCOORD1; // auto-packed float4 interp02 : TEXCOORD2; // auto-packed float4 interp03 : TEXCOORD3; // auto-packed float4 positionCS : SV_Position; // unpacked #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToPS PackVaryingsMeshToPS(VaryingsMeshToPS input) { PackedVaryingsMeshToPS output; output.positionCS = input.positionCS; output.interp00.xyzw = input.texCoord0; output.interp01.xyzw = input.texCoord1; output.interp02.xyzw = input.texCoord2; output.interp03.xyzw = input.texCoord3; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToPS UnpackVaryingsMeshToPS(PackedVaryingsMeshToPS input) { VaryingsMeshToPS output; output.positionCS = input.positionCS; output.texCoord0 = input.interp00.xyzw; output.texCoord1 = input.interp01.xyzw; output.texCoord2 = input.interp02.xyzw; output.texCoord3 = input.interp03.xyzw; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToDS { float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _uvBaseMask; float4 _uvBaseST; float4 _BaseColor; float _SmoothnessMin; float _SmoothnessMax; float4 _SpecularColor; float _NormalMapStrength; float _useThreadMap; float4 _uvThreadMask; float4 _uvThreadST; float _ThreadAOStrength01; float _ThreadNormalStrength; float _ThreadSmoothnessScale; float _FuzzMapUVScale; float _FuzzStrength; float4 _EmissionColor; CBUFFER_END TEXTURE2D(_BaseColorMap); SAMPLER(sampler_BaseColorMap); float4 _BaseColorMap_TexelSize; TEXTURE2D(_MaskMap); SAMPLER(sampler_MaskMap); float4 _MaskMap_TexelSize; TEXTURE2D(_SpecColorMap); SAMPLER(sampler_SpecColorMap); float4 _SpecColorMap_TexelSize; TEXTURE2D(_NormalMap); SAMPLER(sampler_NormalMap); float4 _NormalMap_TexelSize; TEXTURE2D(_ThreadMap); SAMPLER(sampler_ThreadMap); float4 _ThreadMap_TexelSize; TEXTURE2D(_FuzzMap); SAMPLER(sampler_FuzzMap); float4 _FuzzMap_TexelSize; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float4 uv0; // optional float4 uv1; // optional float4 uv2; // optional float4 uv3; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float Alpha; }; // Shared Graph Node Functions void Unity_Combine_float(float R, float G, float B, float A, out float4 RGBA, out float3 RGB, out float2 RG) { RGBA = float4(R, G, B, A); RGB = float3(R, G, B); RG = float2(R, G); } void Unity_Multiply_float (float2 A, float2 B, out float2 Out) { Out = A * B; } void Unity_Add_float2(float2 A, float2 B, out float2 Out) { Out = A + B; } // Subgraph function void sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(float4 _uvST, float4 _uvMask, SurfaceDescriptionInputs IN, out float4 Output1) { float4 _UV_23AF8552_Out = IN.uv0; float _Split_7957D60_R = _UV_23AF8552_Out[0]; float _Split_7957D60_G = _UV_23AF8552_Out[1]; float _Split_7957D60_B = _UV_23AF8552_Out[2]; float _Split_7957D60_A = _UV_23AF8552_Out[3]; float4 _Combine_5396A6C7_RGBA; float3 _Combine_5396A6C7_RGB; float2 _Combine_5396A6C7_RG; Unity_Combine_float(_Split_7957D60_R, _Split_7957D60_G, 0, 0, _Combine_5396A6C7_RGBA, _Combine_5396A6C7_RGB, _Combine_5396A6C7_RG); float4 _Property_CB55E443_Out = _uvMask; float _Split_6086B0A5_R = _Property_CB55E443_Out[0]; float _Split_6086B0A5_G = _Property_CB55E443_Out[1]; float _Split_6086B0A5_B = _Property_CB55E443_Out[2]; float _Split_6086B0A5_A = _Property_CB55E443_Out[3]; float2 _Multiply_FC550A07_Out; Unity_Multiply_float(_Combine_5396A6C7_RG, (_Split_6086B0A5_R.xx), _Multiply_FC550A07_Out); float4 _UV_3B1D042C_Out = IN.uv1; float _Split_107320B6_R = _UV_3B1D042C_Out[0]; float _Split_107320B6_G = _UV_3B1D042C_Out[1]; float _Split_107320B6_B = _UV_3B1D042C_Out[2]; float _Split_107320B6_A = _UV_3B1D042C_Out[3]; float4 _Combine_2E8D3795_RGBA; float3 _Combine_2E8D3795_RGB; float2 _Combine_2E8D3795_RG; Unity_Combine_float(_Split_107320B6_R, _Split_107320B6_G, 0, 0, _Combine_2E8D3795_RGBA, _Combine_2E8D3795_RGB, _Combine_2E8D3795_RG); float2 _Multiply_FDA7BA1E_Out; Unity_Multiply_float(_Combine_2E8D3795_RG, (_Split_6086B0A5_G.xx), _Multiply_FDA7BA1E_Out); float2 _Add_92015245_Out; Unity_Add_float2(_Multiply_FC550A07_Out, _Multiply_FDA7BA1E_Out, _Add_92015245_Out); float4 _UV_49BE4158_Out = IN.uv2; float _Split_A24186AD_R = _UV_49BE4158_Out[0]; float _Split_A24186AD_G = _UV_49BE4158_Out[1]; float _Split_A24186AD_B = _UV_49BE4158_Out[2]; float _Split_A24186AD_A = _UV_49BE4158_Out[3]; float4 _Combine_6951B6BC_RGBA; float3 _Combine_6951B6BC_RGB; float2 _Combine_6951B6BC_RG; Unity_Combine_float(_Split_A24186AD_R, _Split_A24186AD_G, 0, 0, _Combine_6951B6BC_RGBA, _Combine_6951B6BC_RGB, _Combine_6951B6BC_RG); float2 _Multiply_1480B81_Out; Unity_Multiply_float(_Combine_6951B6BC_RG, (_Split_6086B0A5_B.xx), _Multiply_1480B81_Out); float4 _UV_9CA65C2_Out = IN.uv3; float _Split_9EC6EA10_R = _UV_9CA65C2_Out[0]; float _Split_9EC6EA10_G = _UV_9CA65C2_Out[1]; float _Split_9EC6EA10_B = _UV_9CA65C2_Out[2]; float _Split_9EC6EA10_A = _UV_9CA65C2_Out[3]; float4 _Combine_633F7D3D_RGBA; float3 _Combine_633F7D3D_RGB; float2 _Combine_633F7D3D_RG; Unity_Combine_float(_Split_9EC6EA10_R, _Split_9EC6EA10_G, 0, 0, _Combine_633F7D3D_RGBA, _Combine_633F7D3D_RGB, _Combine_633F7D3D_RG); float2 _Multiply_2A2B5227_Out; Unity_Multiply_float(_Combine_633F7D3D_RG, (_Split_6086B0A5_A.xx), _Multiply_2A2B5227_Out); float2 _Add_B5E7679D_Out; Unity_Add_float2(_Multiply_1480B81_Out, _Multiply_2A2B5227_Out, _Add_B5E7679D_Out); float2 _Add_892742E3_Out; Unity_Add_float2(_Add_92015245_Out, _Add_B5E7679D_Out, _Add_892742E3_Out); float4 _Property_8DA1B077_Out = _uvST; float _Split_1AB0DA31_R = _Property_8DA1B077_Out[0]; float _Split_1AB0DA31_G = _Property_8DA1B077_Out[1]; float _Split_1AB0DA31_B = _Property_8DA1B077_Out[2]; float _Split_1AB0DA31_A = _Property_8DA1B077_Out[3]; float4 _Combine_44459F1_RGBA; float3 _Combine_44459F1_RGB; float2 _Combine_44459F1_RG; Unity_Combine_float(_Split_1AB0DA31_R, _Split_1AB0DA31_G, 0, 0, _Combine_44459F1_RGBA, _Combine_44459F1_RGB, _Combine_44459F1_RG); float2 _Multiply_38815E23_Out; Unity_Multiply_float(_Add_892742E3_Out, _Combine_44459F1_RG, _Multiply_38815E23_Out); float _Split_35A1DC4_R = _Property_8DA1B077_Out[0]; float _Split_35A1DC4_G = _Property_8DA1B077_Out[1]; float _Split_35A1DC4_B = _Property_8DA1B077_Out[2]; float _Split_35A1DC4_A = _Property_8DA1B077_Out[3]; float4 _Combine_91984BDF_RGBA; float3 _Combine_91984BDF_RGB; float2 _Combine_91984BDF_RG; Unity_Combine_float(_Split_35A1DC4_B, _Split_35A1DC4_A, 0, 0, _Combine_91984BDF_RGBA, _Combine_91984BDF_RGB, _Combine_91984BDF_RG); float2 _Add_63012CEE_Out; Unity_Add_float2(_Multiply_38815E23_Out, _Combine_91984BDF_RG, _Add_63012CEE_Out); Output1 = (float4(_Add_63012CEE_Out, 0.0, 1.0)); } void Unity_NormalStrength_float(float3 In, float Strength, out float3 Out) { Out = float3(In.rg * Strength, lerp(1, In.b, saturate(Strength))); } void Unity_Normalize_float3(float3 In, out float3 Out) { Out = normalize(In); } void Unity_Remap_float(float In, float2 InMinMax, float2 OutMinMax, out float Out) { Out = OutMinMax.x + (In - InMinMax.x) * (OutMinMax.y - OutMinMax.x) / (InMinMax.y - InMinMax.x); } void Unity_Multiply_float (float4 A, float4 B, out float4 Out) { Out = A * B; } void Unity_Lerp_float(float A, float B, float T, out float Out) { Out = lerp(A, B, T); } void Unity_Add_float4(float4 A, float4 B, out float4 Out) { Out = A + B; } void Unity_Saturate_float4(float4 In, out float4 Out) { Out = saturate(In); } void Unity_NormalUnpack_float(float4 In, out float3 Out) { Out = UnpackNormalmapRGorAG(In); } void Unity_NormalBlend_float(float3 A, float3 B, out float3 Out) { Out = normalize(float3(A.rg + B.rg, A.b * B.b)); } void Unity_Branch_float3(float Predicate, float3 True, float3 False, out float3 Out) { Out = lerp(False, True, Predicate); } void Unity_Add_float(float A, float B, out float Out) { Out = A + B; } void Unity_Saturate_float(float In, out float Out) { Out = saturate(In); } void Unity_Branch_float(float Predicate, float True, float False, out float Out) { Out = lerp(False, True, Predicate); } void Unity_Multiply_float (float A, float B, out float Out) { Out = A * B; } // Subgraph function void sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52(float2 _UV, TEXTURE2D_ARGS(_ThreadMap, sampler_ThreadMap), float _ThreadSmoothnessStrength, float _AmbientOcclusion, float _UseThreadMap, float _ThreadAOStrength, float _ThreadNormalStrength, float _Smoothness, float3 _Normals, float _Alpha, SurfaceDescriptionInputs IN, out float4 Output1, out float4 Output2, out float4 Output3, out float4 Output4) { float _Property_7B789410_Out = _UseThreadMap; float3 _Property_D380C535_Out = _Normals; float2 _Property_247E83DC_Out = _UV; float4 _SampleTexture2D_B39DD828_RGBA = SAMPLE_TEXTURE2D(_ThreadMap, sampler_ThreadMap, _Property_247E83DC_Out); float _SampleTexture2D_B39DD828_R = _SampleTexture2D_B39DD828_RGBA.r; float _SampleTexture2D_B39DD828_G = _SampleTexture2D_B39DD828_RGBA.g; float _SampleTexture2D_B39DD828_B = _SampleTexture2D_B39DD828_RGBA.b; float _SampleTexture2D_B39DD828_A = _SampleTexture2D_B39DD828_RGBA.a; float4 _Combine_3989CE7_RGBA; float3 _Combine_3989CE7_RGB; float2 _Combine_3989CE7_RG; Unity_Combine_float(_SampleTexture2D_B39DD828_A, _SampleTexture2D_B39DD828_G, 1, 1, _Combine_3989CE7_RGBA, _Combine_3989CE7_RGB, _Combine_3989CE7_RG); float3 _NormalUnpack_6B39F6EC_Out; Unity_NormalUnpack_float((float4(_Combine_3989CE7_RGB, 1.0)), _NormalUnpack_6B39F6EC_Out); float3 _Normalize_1F52E5EC_Out; Unity_Normalize_float3(_NormalUnpack_6B39F6EC_Out, _Normalize_1F52E5EC_Out); float _Property_2E175598_Out = _ThreadNormalStrength; float3 _NormalStrength_A15875A3_Out; Unity_NormalStrength_float(_Normalize_1F52E5EC_Out, _Property_2E175598_Out, _NormalStrength_A15875A3_Out); float3 _NormalBlend_191D51BE_Out; Unity_NormalBlend_float(_Property_D380C535_Out, _NormalStrength_A15875A3_Out, _NormalBlend_191D51BE_Out); float3 _Normalize_4D9B04E_Out; Unity_Normalize_float3(_NormalBlend_191D51BE_Out, _Normalize_4D9B04E_Out); float3 _Branch_54FF636E_Out; Unity_Branch_float3(_Property_7B789410_Out, _Normalize_4D9B04E_Out, _Property_D380C535_Out, _Branch_54FF636E_Out); float _Property_B5560A97_Out = _UseThreadMap; float _Property_6FAEC412_Out = _Smoothness; float _Remap_C272A01C_Out; Unity_Remap_float(_SampleTexture2D_B39DD828_B, float2 (0,1), float2 (-1,1), _Remap_C272A01C_Out); float _Property_CF380DCA_Out = _ThreadSmoothnessStrength; float _Lerp_1EB6EBC0_Out; Unity_Lerp_float(0, _Remap_C272A01C_Out, _Property_CF380DCA_Out, _Lerp_1EB6EBC0_Out); float _Add_2975BB_Out; Unity_Add_float(_Property_6FAEC412_Out, _Lerp_1EB6EBC0_Out, _Add_2975BB_Out); float _Saturate_1F46047D_Out; Unity_Saturate_float(_Add_2975BB_Out, _Saturate_1F46047D_Out); float _Branch_1C4EA1E2_Out; Unity_Branch_float(_Property_B5560A97_Out, _Saturate_1F46047D_Out, _Property_6FAEC412_Out, _Branch_1C4EA1E2_Out); float _Property_57F076E2_Out = _UseThreadMap; float _Property_829FEB4F_Out = _ThreadAOStrength; float _Lerp_1DC743E3_Out; Unity_Lerp_float(1, _SampleTexture2D_B39DD828_R, _Property_829FEB4F_Out, _Lerp_1DC743E3_Out); float _Property_416E73AE_Out = _AmbientOcclusion; float _Multiply_FBD87ACD_Out; Unity_Multiply_float(_Lerp_1DC743E3_Out, _Property_416E73AE_Out, _Multiply_FBD87ACD_Out); float _Branch_A5F3B7F9_Out; Unity_Branch_float(_Property_57F076E2_Out, _Multiply_FBD87ACD_Out, _Property_416E73AE_Out, _Branch_A5F3B7F9_Out); float _Property_5FDD4914_Out = _Alpha; float _Multiply_716B151B_Out; Unity_Multiply_float(_SampleTexture2D_B39DD828_R, _Property_5FDD4914_Out, _Multiply_716B151B_Out); Output1 = (float4(_Branch_54FF636E_Out, 1.0)); Output2 = (_Branch_1C4EA1E2_Out.xxxx); Output3 = (_Branch_A5F3B7F9_Out.xxxx); Output4 = (_Multiply_716B151B_Out.xxxx); } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float _Property_1E54B66A_Out = _useThreadMap; float4 _Property_8AE14795_Out = _uvThreadMask; float4 _Property_958B7FC9_Out = _uvThreadST; float4 _Subgraph_B567E108_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_958B7FC9_Out, _Property_8AE14795_Out, IN, _Subgraph_B567E108_Output1); float4 _Property_FEDB20A0_Out = _uvBaseMask; float4 _Property_F42AAF3B_Out = _uvBaseST; float4 _Subgraph_9D4E0F1_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_F42AAF3B_Out, _Property_FEDB20A0_Out, IN, _Subgraph_9D4E0F1_Output1); float4 _SampleTexture2D_105B35B3_RGBA = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, (_Subgraph_9D4E0F1_Output1.xy)); _SampleTexture2D_105B35B3_RGBA.rgb = UnpackNormalmapRGorAG(_SampleTexture2D_105B35B3_RGBA); float _SampleTexture2D_105B35B3_R = _SampleTexture2D_105B35B3_RGBA.r; float _SampleTexture2D_105B35B3_G = _SampleTexture2D_105B35B3_RGBA.g; float _SampleTexture2D_105B35B3_B = _SampleTexture2D_105B35B3_RGBA.b; float _SampleTexture2D_105B35B3_A = _SampleTexture2D_105B35B3_RGBA.a; float _Property_82D183C3_Out = _NormalMapStrength; float3 _NormalStrength_BFF5C35E_Out; Unity_NormalStrength_float((_SampleTexture2D_105B35B3_RGBA.xyz), _Property_82D183C3_Out, _NormalStrength_BFF5C35E_Out); float3 _Normalize_ACA4E10E_Out; Unity_Normalize_float3(_NormalStrength_BFF5C35E_Out, _Normalize_ACA4E10E_Out); float4 _Property_1E040901_Out = _uvBaseMask; float4 _Property_97A7EF85_Out = _uvBaseST; float4 _Subgraph_8DDCEE61_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_97A7EF85_Out, _Property_1E040901_Out, IN, _Subgraph_8DDCEE61_Output1); float4 _SampleTexture2D_8C3CF01A_RGBA = SAMPLE_TEXTURE2D(_SpecColorMap, sampler_SpecColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_8C3CF01A_R = _SampleTexture2D_8C3CF01A_RGBA.r; float _SampleTexture2D_8C3CF01A_G = _SampleTexture2D_8C3CF01A_RGBA.g; float _SampleTexture2D_8C3CF01A_B = _SampleTexture2D_8C3CF01A_RGBA.b; float _SampleTexture2D_8C3CF01A_A = _SampleTexture2D_8C3CF01A_RGBA.a; float _Property_B948927_Out = _SmoothnessMin; float _Property_2962A49E_Out = _SmoothnessMax; float2 _Vector2_9C783D17_Out = float2(_Property_B948927_Out,_Property_2962A49E_Out); float _Remap_10DEF6A_Out; Unity_Remap_float(_SampleTexture2D_8C3CF01A_A, float2 (0,1), _Vector2_9C783D17_Out, _Remap_10DEF6A_Out); float4 _Property_90FAF786_Out = _BaseColor; float4 _SampleTexture2D_11CFD011_RGBA = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_11CFD011_R = _SampleTexture2D_11CFD011_RGBA.r; float _SampleTexture2D_11CFD011_G = _SampleTexture2D_11CFD011_RGBA.g; float _SampleTexture2D_11CFD011_B = _SampleTexture2D_11CFD011_RGBA.b; float _SampleTexture2D_11CFD011_A = _SampleTexture2D_11CFD011_RGBA.a; float4 _Multiply_98A7A079_Out; Unity_Multiply_float(_Property_90FAF786_Out, _SampleTexture2D_11CFD011_RGBA, _Multiply_98A7A079_Out); float _Property_7C6435CB_Out = _FuzzMapUVScale; float4 _Multiply_18C3A780_Out; Unity_Multiply_float(_Subgraph_8DDCEE61_Output1, (_Property_7C6435CB_Out.xxxx), _Multiply_18C3A780_Out); float4 _SampleTexture2D_4D82F05E_RGBA = SAMPLE_TEXTURE2D(_FuzzMap, sampler_FuzzMap, (_Multiply_18C3A780_Out.xy)); float _SampleTexture2D_4D82F05E_R = _SampleTexture2D_4D82F05E_RGBA.r; float _SampleTexture2D_4D82F05E_G = _SampleTexture2D_4D82F05E_RGBA.g; float _SampleTexture2D_4D82F05E_B = _SampleTexture2D_4D82F05E_RGBA.b; float _SampleTexture2D_4D82F05E_A = _SampleTexture2D_4D82F05E_RGBA.a; float _Property_6CCE2816_Out = _FuzzStrength; float _Lerp_2C953D15_Out; Unity_Lerp_float(0, _SampleTexture2D_4D82F05E_R, _Property_6CCE2816_Out, _Lerp_2C953D15_Out); float4 _Add_A30FF2E2_Out; Unity_Add_float4(_Multiply_98A7A079_Out, (_Lerp_2C953D15_Out.xxxx), _Add_A30FF2E2_Out); float4 _Saturate_69BD2FF3_Out; Unity_Saturate_float4(_Add_A30FF2E2_Out, _Saturate_69BD2FF3_Out); float _Split_EB0B739F_R = _Saturate_69BD2FF3_Out[0]; float _Split_EB0B739F_G = _Saturate_69BD2FF3_Out[1]; float _Split_EB0B739F_B = _Saturate_69BD2FF3_Out[2]; float _Split_EB0B739F_A = _Saturate_69BD2FF3_Out[3]; float4 _SampleTexture2D_EECA7933_RGBA = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_EECA7933_R = _SampleTexture2D_EECA7933_RGBA.r; float _SampleTexture2D_EECA7933_G = _SampleTexture2D_EECA7933_RGBA.g; float _SampleTexture2D_EECA7933_B = _SampleTexture2D_EECA7933_RGBA.b; float _SampleTexture2D_EECA7933_A = _SampleTexture2D_EECA7933_RGBA.a; float _Property_88B45C0E_Out = _ThreadAOStrength01; float _Property_FC0CC4C0_Out = _ThreadNormalStrength; float _Property_AC495D22_Out = _ThreadSmoothnessScale; float4 _Subgraph_E494B5B1_Output1; float4 _Subgraph_E494B5B1_Output2; float4 _Subgraph_E494B5B1_Output3; float4 _Subgraph_E494B5B1_Output4; sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52((_Subgraph_B567E108_Output1.xy), TEXTURE2D_PARAM(_ThreadMap, sampler_ThreadMap), _Property_AC495D22_Out, _SampleTexture2D_EECA7933_G, _Property_1E54B66A_Out, _Property_88B45C0E_Out, _Property_FC0CC4C0_Out, _Remap_10DEF6A_Out, _Normalize_ACA4E10E_Out, _Split_EB0B739F_A, IN, _Subgraph_E494B5B1_Output1, _Subgraph_E494B5B1_Output2, _Subgraph_E494B5B1_Output3, _Subgraph_E494B5B1_Output4); surface.Alpha = (_Subgraph_E494B5B1_Output4).x; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- FragInputs BuildFragInputs(VaryingsMeshToPS input) { FragInputs output; ZERO_INITIALIZE(FragInputs, output); // Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used). // TODO: this is a really poor workaround, but the variable is used in a bunch of places // to compute normals which are then passed on elsewhere to compute other values... output.worldToTangent = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.texCoord0 = input.texCoord0; output.texCoord1 = input.texCoord1; output.texCoord2 = input.texCoord2; output.texCoord3 = input.texCoord3; #if SHADER_STAGE_FRAGMENT #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; output.uv2 = input.texCoord2; output.uv3 = input.texCoord3; return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void ApplyDecalToSurfaceData(DecalSurfaceData decalSurfaceData, inout SurfaceData surfaceData) { // using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_DIFFUSE) { surfaceData.baseColor.xyz = surfaceData.baseColor.xyz * decalSurfaceData.baseColor.w + decalSurfaceData.baseColor.xyz; } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_NORMAL) { surfaceData.normalWS.xyz = normalize(surfaceData.normalWS.xyz * decalSurfaceData.normalWS.w + decalSurfaceData.normalWS.xyz); } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_MASK) { #ifdef DECALS_4RT // only smoothness in 3RT mode // Don't apply any metallic modification surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.MAOSBlend.y + decalSurfaceData.mask.y; #endif surfaceData.perceptualSmoothness = surfaceData.perceptualSmoothness * decalSurfaceData.mask.w + decalSurfaceData.mask.z; } } void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, out SurfaceData surfaceData) { // setup defaults -- these are used if the graph doesn't output a value ZERO_INITIALIZE(SurfaceData, surfaceData); // copy across graph values, if defined // These static material feature allow compile time optimization surfaceData.materialFeatures = 0; // Transform the preprocess macro into a material feature (note that silk flag is deduced from the abscence of this one) #ifdef _MATERIAL_FEATURE_COTTON_WOOL surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL; #endif #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION; #endif #if defined (_ENERGY_CONSERVING_SPECULAR) // Require to have setup baseColor // Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b)); #endif // tangent-space normal float3 normalTS = float3(0.0f, 0.0f, 1.0f); // compute world space normal GetNormalWS(fragInputs, normalTS, surfaceData.normalWS); surfaceData.geomNormalWS = fragInputs.worldToTangent[2]; surfaceData.tangentWS = normalize(fragInputs.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS); // By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion. // If user provide bent normal then we process a better term surfaceData.specularOcclusion = 1.0; #if defined(_SPECULAR_OCCLUSION_CUSTOM) // Just use the value passed through via the slot (not active otherwise) #elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL) // If we have bent normal and ambient occlusion, process a specular occlusion surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness)); #elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO) surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness)); #else surfaceData.specularOcclusion = 1.0; surfaceData.specularOcclusion = 1.0; #endif #ifdef DEBUG_DISPLAY // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.worldToTangent, surfaceData); #endif } void GetSurfaceAndBuiltinData(FragInputs fragInputs, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData) { #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group uint3 fadeMaskSeed = asuint((int3)(V * _ScreenSize.xyx)); // Quantize V to _ScreenSize values LODDitheringTransition(fadeMaskSeed, unity_LODFade.x); #endif // this applies the double sided tangent space correction -- see 'ApplyDoubleSidedFlipOrMirror()' SurfaceDescriptionInputs surfaceDescriptionInputs = FragInputsToSurfaceDescriptionInputs(fragInputs, V); SurfaceDescription surfaceDescription = SurfaceDescriptionFunction(surfaceDescriptionInputs); // Perform alpha test very early to save performance (a killed pixel will not sample textures) // TODO: split graph evaluation to grab just alpha dependencies first? tricky.. BuildSurfaceData(fragInputs, surfaceDescription, V, surfaceData); #if HAVE_DECALS && _DECALS DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); #endif // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(surfaceDescription.Alpha, surfaceData.normalWS, -fragInputs.worldToTangent[2], fragInputs.positionRWS, fragInputs.texCoord1, fragInputs.texCoord2, builtinData); builtinData.depthOffset = 0.0; // ApplyPerPixelDisplacement(input, V, layerTexCoord, blendMasks); #ifdef _DEPTHOFFSET_ON : ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput); PostInitBuiltinData(V, posInput, surfaceData, builtinData); } //------------------------------------------------------------------------------------- // Pass Includes //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPassDepthOnly.hlsl" //------------------------------------------------------------------------------------- // End Pass Includes //------------------------------------------------------------------------------------- ENDHLSL } Pass { // based on FabricPass.template Name "Depth prepass" Tags { "LightMode" = "DepthForwardOnly" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Blend One Zero Cull Back ZTest LEqual ZWrite On ZClip [_ZClip] Stencil { WriteMask 16 Ref 16 Comp Always Pass Replace } //------------------------------------------------------------------------------------- // End Render Modes //------------------------------------------------------------------------------------- HLSLPROGRAM #pragma target 4.5 #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch //#pragma enable_d3d11_debug_symbols #pragma multi_compile_instancing #pragma instancing_options renderinglayer #pragma multi_compile _ LOD_FADE_CROSSFADE //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- #define _MATERIAL_FEATURE_COTTON_WOOL 1 #define _SPECULAR_OCCLUSION_FROM_AO 1 #define _ENERGY_CONSERVING_SPECULAR 1 #define _DISABLE_SSR 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag #define UNITY_MATERIAL_FABRIC // Need to be define before including Material.hlsl // This will be enabled in an upcoming change. // #define SURFACE_GRADIENT // If we use subsurface scattering, enable output split lighting (for forward pass) #if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT) #define OUTPUT_SPLIT_LIGHTING #endif #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Wind.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl" // define FragInputs structure #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl" //------------------------------------------------------------------------------------- // Defines //------------------------------------------------------------------------------------- #define SHADERPASS SHADERPASS_DEPTH_ONLY #define WRITE_NORMAL_BUFFER #pragma multi_compile _ WRITE_MSAA_DEPTH // this translates the new dependency tracker into the old preprocessor definitions for the existing HDRP shader code #define ATTRIBUTES_NEED_NORMAL #define ATTRIBUTES_NEED_TANGENT #define ATTRIBUTES_NEED_TEXCOORD0 #define ATTRIBUTES_NEED_TEXCOORD1 #define ATTRIBUTES_NEED_TEXCOORD2 #define ATTRIBUTES_NEED_TEXCOORD3 #define ATTRIBUTES_NEED_COLOR #define VARYINGS_NEED_POSITION_WS #define VARYINGS_NEED_TANGENT_TO_WORLD #define VARYINGS_NEED_TEXCOORD0 #define VARYINGS_NEED_TEXCOORD1 #define VARYINGS_NEED_TEXCOORD2 #define VARYINGS_NEED_TEXCOORD3 #define VARYINGS_NEED_COLOR //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #if (SHADERPASS == SHADERPASS_FORWARD) // used for shaders that want to do lighting (and materials) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #else // used for shaders that don't need lighting #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl" //Used by SceneSelectionPass int _ObjectId; int _PassValue; // this function assumes the bitangent flip is encoded in tangentWS.w // TODO: move this function to HDRP shared file, once we merge with HDRP repo float3x3 BuildWorldToTangent(float4 tangentWS, float3 normalWS) { // tangentWS must not be normalized (mikkts requirement) // Normalize normalWS vector but keep the renormFactor to apply it to bitangent and tangent float3 unnormalizedNormalWS = normalWS; float renormFactor = 1.0 / length(unnormalizedNormalWS); // bitangent on the fly option in xnormal to reduce vertex shader outputs. // this is the mikktspace transformation (must use unnormalized attributes) float3x3 worldToTangent = CreateWorldToTangent(unnormalizedNormalWS, tangentWS.xyz, tangentWS.w > 0.0 ? 1.0 : -1.0); // surface gradient based formulation requires a unit length initial normal. We can maintain compliance with mikkts // by uniformly scaling all 3 vectors since normalization of the perturbed normal will cancel it. worldToTangent[0] = worldToTangent[0] * renormFactor; worldToTangent[1] = worldToTangent[1] * renormFactor; worldToTangent[2] = worldToTangent[2] * renormFactor; // normalizes the interpolated vertex normal return worldToTangent; } //------------------------------------------------------------------------------------- // Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- // Generated Type: AttributesMesh struct AttributesMesh { float3 positionOS : POSITION; float3 normalOS : NORMAL; // optional float4 tangentOS : TANGENT; // optional float4 uv0 : TEXCOORD0; // optional float4 uv1 : TEXCOORD1; // optional float4 uv2 : TEXCOORD2; // optional float4 uv3 : TEXCOORD3; // optional float4 color : COLOR; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; // Generated Type: VaryingsMeshToPS struct VaryingsMeshToPS { float4 positionCS : SV_Position; float3 positionRWS; // optional float3 normalWS; // optional float4 tangentWS; // optional float4 texCoord0; // optional float4 texCoord1; // optional float4 texCoord2; // optional float4 texCoord3; // optional float4 color; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToPS { float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed float4 interp02 : TEXCOORD2; // auto-packed float4 interp03 : TEXCOORD3; // auto-packed float4 interp04 : TEXCOORD4; // auto-packed float4 interp05 : TEXCOORD5; // auto-packed float4 interp06 : TEXCOORD6; // auto-packed float4 interp07 : TEXCOORD7; // auto-packed float4 positionCS : SV_Position; // unpacked #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToPS PackVaryingsMeshToPS(VaryingsMeshToPS input) { PackedVaryingsMeshToPS output; output.positionCS = input.positionCS; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; output.interp02.xyzw = input.tangentWS; output.interp03.xyzw = input.texCoord0; output.interp04.xyzw = input.texCoord1; output.interp05.xyzw = input.texCoord2; output.interp06.xyzw = input.texCoord3; output.interp07.xyzw = input.color; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToPS UnpackVaryingsMeshToPS(PackedVaryingsMeshToPS input) { VaryingsMeshToPS output; output.positionCS = input.positionCS; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; output.tangentWS = input.interp02.xyzw; output.texCoord0 = input.interp03.xyzw; output.texCoord1 = input.interp04.xyzw; output.texCoord2 = input.interp05.xyzw; output.texCoord3 = input.interp06.xyzw; output.color = input.interp07.xyzw; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToDS { float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _uvBaseMask; float4 _uvBaseST; float4 _BaseColor; float _SmoothnessMin; float _SmoothnessMax; float4 _SpecularColor; float _NormalMapStrength; float _useThreadMap; float4 _uvThreadMask; float4 _uvThreadST; float _ThreadAOStrength01; float _ThreadNormalStrength; float _ThreadSmoothnessScale; float _FuzzMapUVScale; float _FuzzStrength; float4 _EmissionColor; CBUFFER_END TEXTURE2D(_BaseColorMap); SAMPLER(sampler_BaseColorMap); float4 _BaseColorMap_TexelSize; TEXTURE2D(_MaskMap); SAMPLER(sampler_MaskMap); float4 _MaskMap_TexelSize; TEXTURE2D(_SpecColorMap); SAMPLER(sampler_SpecColorMap); float4 _SpecColorMap_TexelSize; TEXTURE2D(_NormalMap); SAMPLER(sampler_NormalMap); float4 _NormalMap_TexelSize; TEXTURE2D(_ThreadMap); SAMPLER(sampler_ThreadMap); float4 _ThreadMap_TexelSize; TEXTURE2D(_FuzzMap); SAMPLER(sampler_FuzzMap); float4 _FuzzMap_TexelSize; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float4 uv0; // optional float4 uv1; // optional float4 uv2; // optional float4 uv3; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float Alpha; }; // Shared Graph Node Functions void Unity_Combine_float(float R, float G, float B, float A, out float4 RGBA, out float3 RGB, out float2 RG) { RGBA = float4(R, G, B, A); RGB = float3(R, G, B); RG = float2(R, G); } void Unity_Multiply_float (float2 A, float2 B, out float2 Out) { Out = A * B; } void Unity_Add_float2(float2 A, float2 B, out float2 Out) { Out = A + B; } // Subgraph function void sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(float4 _uvST, float4 _uvMask, SurfaceDescriptionInputs IN, out float4 Output1) { float4 _UV_23AF8552_Out = IN.uv0; float _Split_7957D60_R = _UV_23AF8552_Out[0]; float _Split_7957D60_G = _UV_23AF8552_Out[1]; float _Split_7957D60_B = _UV_23AF8552_Out[2]; float _Split_7957D60_A = _UV_23AF8552_Out[3]; float4 _Combine_5396A6C7_RGBA; float3 _Combine_5396A6C7_RGB; float2 _Combine_5396A6C7_RG; Unity_Combine_float(_Split_7957D60_R, _Split_7957D60_G, 0, 0, _Combine_5396A6C7_RGBA, _Combine_5396A6C7_RGB, _Combine_5396A6C7_RG); float4 _Property_CB55E443_Out = _uvMask; float _Split_6086B0A5_R = _Property_CB55E443_Out[0]; float _Split_6086B0A5_G = _Property_CB55E443_Out[1]; float _Split_6086B0A5_B = _Property_CB55E443_Out[2]; float _Split_6086B0A5_A = _Property_CB55E443_Out[3]; float2 _Multiply_FC550A07_Out; Unity_Multiply_float(_Combine_5396A6C7_RG, (_Split_6086B0A5_R.xx), _Multiply_FC550A07_Out); float4 _UV_3B1D042C_Out = IN.uv1; float _Split_107320B6_R = _UV_3B1D042C_Out[0]; float _Split_107320B6_G = _UV_3B1D042C_Out[1]; float _Split_107320B6_B = _UV_3B1D042C_Out[2]; float _Split_107320B6_A = _UV_3B1D042C_Out[3]; float4 _Combine_2E8D3795_RGBA; float3 _Combine_2E8D3795_RGB; float2 _Combine_2E8D3795_RG; Unity_Combine_float(_Split_107320B6_R, _Split_107320B6_G, 0, 0, _Combine_2E8D3795_RGBA, _Combine_2E8D3795_RGB, _Combine_2E8D3795_RG); float2 _Multiply_FDA7BA1E_Out; Unity_Multiply_float(_Combine_2E8D3795_RG, (_Split_6086B0A5_G.xx), _Multiply_FDA7BA1E_Out); float2 _Add_92015245_Out; Unity_Add_float2(_Multiply_FC550A07_Out, _Multiply_FDA7BA1E_Out, _Add_92015245_Out); float4 _UV_49BE4158_Out = IN.uv2; float _Split_A24186AD_R = _UV_49BE4158_Out[0]; float _Split_A24186AD_G = _UV_49BE4158_Out[1]; float _Split_A24186AD_B = _UV_49BE4158_Out[2]; float _Split_A24186AD_A = _UV_49BE4158_Out[3]; float4 _Combine_6951B6BC_RGBA; float3 _Combine_6951B6BC_RGB; float2 _Combine_6951B6BC_RG; Unity_Combine_float(_Split_A24186AD_R, _Split_A24186AD_G, 0, 0, _Combine_6951B6BC_RGBA, _Combine_6951B6BC_RGB, _Combine_6951B6BC_RG); float2 _Multiply_1480B81_Out; Unity_Multiply_float(_Combine_6951B6BC_RG, (_Split_6086B0A5_B.xx), _Multiply_1480B81_Out); float4 _UV_9CA65C2_Out = IN.uv3; float _Split_9EC6EA10_R = _UV_9CA65C2_Out[0]; float _Split_9EC6EA10_G = _UV_9CA65C2_Out[1]; float _Split_9EC6EA10_B = _UV_9CA65C2_Out[2]; float _Split_9EC6EA10_A = _UV_9CA65C2_Out[3]; float4 _Combine_633F7D3D_RGBA; float3 _Combine_633F7D3D_RGB; float2 _Combine_633F7D3D_RG; Unity_Combine_float(_Split_9EC6EA10_R, _Split_9EC6EA10_G, 0, 0, _Combine_633F7D3D_RGBA, _Combine_633F7D3D_RGB, _Combine_633F7D3D_RG); float2 _Multiply_2A2B5227_Out; Unity_Multiply_float(_Combine_633F7D3D_RG, (_Split_6086B0A5_A.xx), _Multiply_2A2B5227_Out); float2 _Add_B5E7679D_Out; Unity_Add_float2(_Multiply_1480B81_Out, _Multiply_2A2B5227_Out, _Add_B5E7679D_Out); float2 _Add_892742E3_Out; Unity_Add_float2(_Add_92015245_Out, _Add_B5E7679D_Out, _Add_892742E3_Out); float4 _Property_8DA1B077_Out = _uvST; float _Split_1AB0DA31_R = _Property_8DA1B077_Out[0]; float _Split_1AB0DA31_G = _Property_8DA1B077_Out[1]; float _Split_1AB0DA31_B = _Property_8DA1B077_Out[2]; float _Split_1AB0DA31_A = _Property_8DA1B077_Out[3]; float4 _Combine_44459F1_RGBA; float3 _Combine_44459F1_RGB; float2 _Combine_44459F1_RG; Unity_Combine_float(_Split_1AB0DA31_R, _Split_1AB0DA31_G, 0, 0, _Combine_44459F1_RGBA, _Combine_44459F1_RGB, _Combine_44459F1_RG); float2 _Multiply_38815E23_Out; Unity_Multiply_float(_Add_892742E3_Out, _Combine_44459F1_RG, _Multiply_38815E23_Out); float _Split_35A1DC4_R = _Property_8DA1B077_Out[0]; float _Split_35A1DC4_G = _Property_8DA1B077_Out[1]; float _Split_35A1DC4_B = _Property_8DA1B077_Out[2]; float _Split_35A1DC4_A = _Property_8DA1B077_Out[3]; float4 _Combine_91984BDF_RGBA; float3 _Combine_91984BDF_RGB; float2 _Combine_91984BDF_RG; Unity_Combine_float(_Split_35A1DC4_B, _Split_35A1DC4_A, 0, 0, _Combine_91984BDF_RGBA, _Combine_91984BDF_RGB, _Combine_91984BDF_RG); float2 _Add_63012CEE_Out; Unity_Add_float2(_Multiply_38815E23_Out, _Combine_91984BDF_RG, _Add_63012CEE_Out); Output1 = (float4(_Add_63012CEE_Out, 0.0, 1.0)); } void Unity_NormalStrength_float(float3 In, float Strength, out float3 Out) { Out = float3(In.rg * Strength, lerp(1, In.b, saturate(Strength))); } void Unity_Normalize_float3(float3 In, out float3 Out) { Out = normalize(In); } void Unity_Remap_float(float In, float2 InMinMax, float2 OutMinMax, out float Out) { Out = OutMinMax.x + (In - InMinMax.x) * (OutMinMax.y - OutMinMax.x) / (InMinMax.y - InMinMax.x); } void Unity_Multiply_float (float4 A, float4 B, out float4 Out) { Out = A * B; } void Unity_Lerp_float(float A, float B, float T, out float Out) { Out = lerp(A, B, T); } void Unity_Add_float4(float4 A, float4 B, out float4 Out) { Out = A + B; } void Unity_Saturate_float4(float4 In, out float4 Out) { Out = saturate(In); } void Unity_NormalUnpack_float(float4 In, out float3 Out) { Out = UnpackNormalmapRGorAG(In); } void Unity_NormalBlend_float(float3 A, float3 B, out float3 Out) { Out = normalize(float3(A.rg + B.rg, A.b * B.b)); } void Unity_Branch_float3(float Predicate, float3 True, float3 False, out float3 Out) { Out = lerp(False, True, Predicate); } void Unity_Add_float(float A, float B, out float Out) { Out = A + B; } void Unity_Saturate_float(float In, out float Out) { Out = saturate(In); } void Unity_Branch_float(float Predicate, float True, float False, out float Out) { Out = lerp(False, True, Predicate); } void Unity_Multiply_float (float A, float B, out float Out) { Out = A * B; } // Subgraph function void sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52(float2 _UV, TEXTURE2D_ARGS(_ThreadMap, sampler_ThreadMap), float _ThreadSmoothnessStrength, float _AmbientOcclusion, float _UseThreadMap, float _ThreadAOStrength, float _ThreadNormalStrength, float _Smoothness, float3 _Normals, float _Alpha, SurfaceDescriptionInputs IN, out float4 Output1, out float4 Output2, out float4 Output3, out float4 Output4) { float _Property_7B789410_Out = _UseThreadMap; float3 _Property_D380C535_Out = _Normals; float2 _Property_247E83DC_Out = _UV; float4 _SampleTexture2D_B39DD828_RGBA = SAMPLE_TEXTURE2D(_ThreadMap, sampler_ThreadMap, _Property_247E83DC_Out); float _SampleTexture2D_B39DD828_R = _SampleTexture2D_B39DD828_RGBA.r; float _SampleTexture2D_B39DD828_G = _SampleTexture2D_B39DD828_RGBA.g; float _SampleTexture2D_B39DD828_B = _SampleTexture2D_B39DD828_RGBA.b; float _SampleTexture2D_B39DD828_A = _SampleTexture2D_B39DD828_RGBA.a; float4 _Combine_3989CE7_RGBA; float3 _Combine_3989CE7_RGB; float2 _Combine_3989CE7_RG; Unity_Combine_float(_SampleTexture2D_B39DD828_A, _SampleTexture2D_B39DD828_G, 1, 1, _Combine_3989CE7_RGBA, _Combine_3989CE7_RGB, _Combine_3989CE7_RG); float3 _NormalUnpack_6B39F6EC_Out; Unity_NormalUnpack_float((float4(_Combine_3989CE7_RGB, 1.0)), _NormalUnpack_6B39F6EC_Out); float3 _Normalize_1F52E5EC_Out; Unity_Normalize_float3(_NormalUnpack_6B39F6EC_Out, _Normalize_1F52E5EC_Out); float _Property_2E175598_Out = _ThreadNormalStrength; float3 _NormalStrength_A15875A3_Out; Unity_NormalStrength_float(_Normalize_1F52E5EC_Out, _Property_2E175598_Out, _NormalStrength_A15875A3_Out); float3 _NormalBlend_191D51BE_Out; Unity_NormalBlend_float(_Property_D380C535_Out, _NormalStrength_A15875A3_Out, _NormalBlend_191D51BE_Out); float3 _Normalize_4D9B04E_Out; Unity_Normalize_float3(_NormalBlend_191D51BE_Out, _Normalize_4D9B04E_Out); float3 _Branch_54FF636E_Out; Unity_Branch_float3(_Property_7B789410_Out, _Normalize_4D9B04E_Out, _Property_D380C535_Out, _Branch_54FF636E_Out); float _Property_B5560A97_Out = _UseThreadMap; float _Property_6FAEC412_Out = _Smoothness; float _Remap_C272A01C_Out; Unity_Remap_float(_SampleTexture2D_B39DD828_B, float2 (0,1), float2 (-1,1), _Remap_C272A01C_Out); float _Property_CF380DCA_Out = _ThreadSmoothnessStrength; float _Lerp_1EB6EBC0_Out; Unity_Lerp_float(0, _Remap_C272A01C_Out, _Property_CF380DCA_Out, _Lerp_1EB6EBC0_Out); float _Add_2975BB_Out; Unity_Add_float(_Property_6FAEC412_Out, _Lerp_1EB6EBC0_Out, _Add_2975BB_Out); float _Saturate_1F46047D_Out; Unity_Saturate_float(_Add_2975BB_Out, _Saturate_1F46047D_Out); float _Branch_1C4EA1E2_Out; Unity_Branch_float(_Property_B5560A97_Out, _Saturate_1F46047D_Out, _Property_6FAEC412_Out, _Branch_1C4EA1E2_Out); float _Property_57F076E2_Out = _UseThreadMap; float _Property_829FEB4F_Out = _ThreadAOStrength; float _Lerp_1DC743E3_Out; Unity_Lerp_float(1, _SampleTexture2D_B39DD828_R, _Property_829FEB4F_Out, _Lerp_1DC743E3_Out); float _Property_416E73AE_Out = _AmbientOcclusion; float _Multiply_FBD87ACD_Out; Unity_Multiply_float(_Lerp_1DC743E3_Out, _Property_416E73AE_Out, _Multiply_FBD87ACD_Out); float _Branch_A5F3B7F9_Out; Unity_Branch_float(_Property_57F076E2_Out, _Multiply_FBD87ACD_Out, _Property_416E73AE_Out, _Branch_A5F3B7F9_Out); float _Property_5FDD4914_Out = _Alpha; float _Multiply_716B151B_Out; Unity_Multiply_float(_SampleTexture2D_B39DD828_R, _Property_5FDD4914_Out, _Multiply_716B151B_Out); Output1 = (float4(_Branch_54FF636E_Out, 1.0)); Output2 = (_Branch_1C4EA1E2_Out.xxxx); Output3 = (_Branch_A5F3B7F9_Out.xxxx); Output4 = (_Multiply_716B151B_Out.xxxx); } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float _Property_1E54B66A_Out = _useThreadMap; float4 _Property_8AE14795_Out = _uvThreadMask; float4 _Property_958B7FC9_Out = _uvThreadST; float4 _Subgraph_B567E108_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_958B7FC9_Out, _Property_8AE14795_Out, IN, _Subgraph_B567E108_Output1); float4 _Property_FEDB20A0_Out = _uvBaseMask; float4 _Property_F42AAF3B_Out = _uvBaseST; float4 _Subgraph_9D4E0F1_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_F42AAF3B_Out, _Property_FEDB20A0_Out, IN, _Subgraph_9D4E0F1_Output1); float4 _SampleTexture2D_105B35B3_RGBA = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, (_Subgraph_9D4E0F1_Output1.xy)); _SampleTexture2D_105B35B3_RGBA.rgb = UnpackNormalmapRGorAG(_SampleTexture2D_105B35B3_RGBA); float _SampleTexture2D_105B35B3_R = _SampleTexture2D_105B35B3_RGBA.r; float _SampleTexture2D_105B35B3_G = _SampleTexture2D_105B35B3_RGBA.g; float _SampleTexture2D_105B35B3_B = _SampleTexture2D_105B35B3_RGBA.b; float _SampleTexture2D_105B35B3_A = _SampleTexture2D_105B35B3_RGBA.a; float _Property_82D183C3_Out = _NormalMapStrength; float3 _NormalStrength_BFF5C35E_Out; Unity_NormalStrength_float((_SampleTexture2D_105B35B3_RGBA.xyz), _Property_82D183C3_Out, _NormalStrength_BFF5C35E_Out); float3 _Normalize_ACA4E10E_Out; Unity_Normalize_float3(_NormalStrength_BFF5C35E_Out, _Normalize_ACA4E10E_Out); float4 _Property_1E040901_Out = _uvBaseMask; float4 _Property_97A7EF85_Out = _uvBaseST; float4 _Subgraph_8DDCEE61_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_97A7EF85_Out, _Property_1E040901_Out, IN, _Subgraph_8DDCEE61_Output1); float4 _SampleTexture2D_8C3CF01A_RGBA = SAMPLE_TEXTURE2D(_SpecColorMap, sampler_SpecColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_8C3CF01A_R = _SampleTexture2D_8C3CF01A_RGBA.r; float _SampleTexture2D_8C3CF01A_G = _SampleTexture2D_8C3CF01A_RGBA.g; float _SampleTexture2D_8C3CF01A_B = _SampleTexture2D_8C3CF01A_RGBA.b; float _SampleTexture2D_8C3CF01A_A = _SampleTexture2D_8C3CF01A_RGBA.a; float _Property_B948927_Out = _SmoothnessMin; float _Property_2962A49E_Out = _SmoothnessMax; float2 _Vector2_9C783D17_Out = float2(_Property_B948927_Out,_Property_2962A49E_Out); float _Remap_10DEF6A_Out; Unity_Remap_float(_SampleTexture2D_8C3CF01A_A, float2 (0,1), _Vector2_9C783D17_Out, _Remap_10DEF6A_Out); float4 _Property_90FAF786_Out = _BaseColor; float4 _SampleTexture2D_11CFD011_RGBA = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_11CFD011_R = _SampleTexture2D_11CFD011_RGBA.r; float _SampleTexture2D_11CFD011_G = _SampleTexture2D_11CFD011_RGBA.g; float _SampleTexture2D_11CFD011_B = _SampleTexture2D_11CFD011_RGBA.b; float _SampleTexture2D_11CFD011_A = _SampleTexture2D_11CFD011_RGBA.a; float4 _Multiply_98A7A079_Out; Unity_Multiply_float(_Property_90FAF786_Out, _SampleTexture2D_11CFD011_RGBA, _Multiply_98A7A079_Out); float _Property_7C6435CB_Out = _FuzzMapUVScale; float4 _Multiply_18C3A780_Out; Unity_Multiply_float(_Subgraph_8DDCEE61_Output1, (_Property_7C6435CB_Out.xxxx), _Multiply_18C3A780_Out); float4 _SampleTexture2D_4D82F05E_RGBA = SAMPLE_TEXTURE2D(_FuzzMap, sampler_FuzzMap, (_Multiply_18C3A780_Out.xy)); float _SampleTexture2D_4D82F05E_R = _SampleTexture2D_4D82F05E_RGBA.r; float _SampleTexture2D_4D82F05E_G = _SampleTexture2D_4D82F05E_RGBA.g; float _SampleTexture2D_4D82F05E_B = _SampleTexture2D_4D82F05E_RGBA.b; float _SampleTexture2D_4D82F05E_A = _SampleTexture2D_4D82F05E_RGBA.a; float _Property_6CCE2816_Out = _FuzzStrength; float _Lerp_2C953D15_Out; Unity_Lerp_float(0, _SampleTexture2D_4D82F05E_R, _Property_6CCE2816_Out, _Lerp_2C953D15_Out); float4 _Add_A30FF2E2_Out; Unity_Add_float4(_Multiply_98A7A079_Out, (_Lerp_2C953D15_Out.xxxx), _Add_A30FF2E2_Out); float4 _Saturate_69BD2FF3_Out; Unity_Saturate_float4(_Add_A30FF2E2_Out, _Saturate_69BD2FF3_Out); float _Split_EB0B739F_R = _Saturate_69BD2FF3_Out[0]; float _Split_EB0B739F_G = _Saturate_69BD2FF3_Out[1]; float _Split_EB0B739F_B = _Saturate_69BD2FF3_Out[2]; float _Split_EB0B739F_A = _Saturate_69BD2FF3_Out[3]; float4 _SampleTexture2D_EECA7933_RGBA = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_EECA7933_R = _SampleTexture2D_EECA7933_RGBA.r; float _SampleTexture2D_EECA7933_G = _SampleTexture2D_EECA7933_RGBA.g; float _SampleTexture2D_EECA7933_B = _SampleTexture2D_EECA7933_RGBA.b; float _SampleTexture2D_EECA7933_A = _SampleTexture2D_EECA7933_RGBA.a; float _Property_88B45C0E_Out = _ThreadAOStrength01; float _Property_FC0CC4C0_Out = _ThreadNormalStrength; float _Property_AC495D22_Out = _ThreadSmoothnessScale; float4 _Subgraph_E494B5B1_Output1; float4 _Subgraph_E494B5B1_Output2; float4 _Subgraph_E494B5B1_Output3; float4 _Subgraph_E494B5B1_Output4; sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52((_Subgraph_B567E108_Output1.xy), TEXTURE2D_PARAM(_ThreadMap, sampler_ThreadMap), _Property_AC495D22_Out, _SampleTexture2D_EECA7933_G, _Property_1E54B66A_Out, _Property_88B45C0E_Out, _Property_FC0CC4C0_Out, _Remap_10DEF6A_Out, _Normalize_ACA4E10E_Out, _Split_EB0B739F_A, IN, _Subgraph_E494B5B1_Output1, _Subgraph_E494B5B1_Output2, _Subgraph_E494B5B1_Output3, _Subgraph_E494B5B1_Output4); surface.Alpha = (_Subgraph_E494B5B1_Output4).x; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- FragInputs BuildFragInputs(VaryingsMeshToPS input) { FragInputs output; ZERO_INITIALIZE(FragInputs, output); // Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used). // TODO: this is a really poor workaround, but the variable is used in a bunch of places // to compute normals which are then passed on elsewhere to compute other values... output.worldToTangent = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; output.worldToTangent = BuildWorldToTangent(input.tangentWS, input.normalWS); output.texCoord0 = input.texCoord0; output.texCoord1 = input.texCoord1; output.texCoord2 = input.texCoord2; output.texCoord3 = input.texCoord3; output.color = input.color; #if SHADER_STAGE_FRAGMENT #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; output.uv2 = input.texCoord2; output.uv3 = input.texCoord3; return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void ApplyDecalToSurfaceData(DecalSurfaceData decalSurfaceData, inout SurfaceData surfaceData) { // using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_DIFFUSE) { surfaceData.baseColor.xyz = surfaceData.baseColor.xyz * decalSurfaceData.baseColor.w + decalSurfaceData.baseColor.xyz; } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_NORMAL) { surfaceData.normalWS.xyz = normalize(surfaceData.normalWS.xyz * decalSurfaceData.normalWS.w + decalSurfaceData.normalWS.xyz); } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_MASK) { #ifdef DECALS_4RT // only smoothness in 3RT mode // Don't apply any metallic modification surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.MAOSBlend.y + decalSurfaceData.mask.y; #endif surfaceData.perceptualSmoothness = surfaceData.perceptualSmoothness * decalSurfaceData.mask.w + decalSurfaceData.mask.z; } } void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, out SurfaceData surfaceData) { // setup defaults -- these are used if the graph doesn't output a value ZERO_INITIALIZE(SurfaceData, surfaceData); // copy across graph values, if defined // These static material feature allow compile time optimization surfaceData.materialFeatures = 0; // Transform the preprocess macro into a material feature (note that silk flag is deduced from the abscence of this one) #ifdef _MATERIAL_FEATURE_COTTON_WOOL surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL; #endif #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION; #endif #if defined (_ENERGY_CONSERVING_SPECULAR) // Require to have setup baseColor // Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b)); #endif // tangent-space normal float3 normalTS = float3(0.0f, 0.0f, 1.0f); // compute world space normal GetNormalWS(fragInputs, normalTS, surfaceData.normalWS); surfaceData.geomNormalWS = fragInputs.worldToTangent[2]; surfaceData.tangentWS = normalize(fragInputs.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS); // By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion. // If user provide bent normal then we process a better term surfaceData.specularOcclusion = 1.0; #if defined(_SPECULAR_OCCLUSION_CUSTOM) // Just use the value passed through via the slot (not active otherwise) #elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL) // If we have bent normal and ambient occlusion, process a specular occlusion surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness)); #elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO) surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness)); #else surfaceData.specularOcclusion = 1.0; surfaceData.specularOcclusion = 1.0; #endif #ifdef DEBUG_DISPLAY // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.worldToTangent, surfaceData); #endif } void GetSurfaceAndBuiltinData(FragInputs fragInputs, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData) { #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group uint3 fadeMaskSeed = asuint((int3)(V * _ScreenSize.xyx)); // Quantize V to _ScreenSize values LODDitheringTransition(fadeMaskSeed, unity_LODFade.x); #endif // this applies the double sided tangent space correction -- see 'ApplyDoubleSidedFlipOrMirror()' SurfaceDescriptionInputs surfaceDescriptionInputs = FragInputsToSurfaceDescriptionInputs(fragInputs, V); SurfaceDescription surfaceDescription = SurfaceDescriptionFunction(surfaceDescriptionInputs); // Perform alpha test very early to save performance (a killed pixel will not sample textures) // TODO: split graph evaluation to grab just alpha dependencies first? tricky.. BuildSurfaceData(fragInputs, surfaceDescription, V, surfaceData); #if HAVE_DECALS && _DECALS DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); #endif // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(surfaceDescription.Alpha, surfaceData.normalWS, -fragInputs.worldToTangent[2], fragInputs.positionRWS, fragInputs.texCoord1, fragInputs.texCoord2, builtinData); builtinData.depthOffset = 0.0; // ApplyPerPixelDisplacement(input, V, layerTexCoord, blendMasks); #ifdef _DEPTHOFFSET_ON : ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput); PostInitBuiltinData(V, posInput, surfaceData, builtinData); } //------------------------------------------------------------------------------------- // Pass Includes //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPassDepthOnly.hlsl" //------------------------------------------------------------------------------------- // End Pass Includes //------------------------------------------------------------------------------------- ENDHLSL } Pass { // based on FabricPass.template Name "Motion Vectors" Tags { "LightMode" = "MotionVectors" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Blend One Zero Cull Back ZTest LEqual ZWrite On ZClip [_ZClip] // If velocity pass (motion vectors) is enabled we tag the stencil so it don't perform CameraMotionVelocity Stencil { WriteMask 128 Ref 128 Comp Always Pass Replace } //------------------------------------------------------------------------------------- // End Render Modes //------------------------------------------------------------------------------------- HLSLPROGRAM #pragma target 4.5 #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch //#pragma enable_d3d11_debug_symbols #pragma multi_compile_instancing #pragma instancing_options renderinglayer #pragma multi_compile _ LOD_FADE_CROSSFADE //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- #define _MATERIAL_FEATURE_COTTON_WOOL 1 #define _SPECULAR_OCCLUSION_FROM_AO 1 #define _ENERGY_CONSERVING_SPECULAR 1 #define _DISABLE_SSR 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag #define UNITY_MATERIAL_FABRIC // Need to be define before including Material.hlsl // This will be enabled in an upcoming change. // #define SURFACE_GRADIENT // If we use subsurface scattering, enable output split lighting (for forward pass) #if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT) #define OUTPUT_SPLIT_LIGHTING #endif #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Wind.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl" // define FragInputs structure #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl" //------------------------------------------------------------------------------------- // Defines //------------------------------------------------------------------------------------- #define SHADERPASS SHADERPASS_VELOCITY #define WRITE_NORMAL_BUFFER #pragma multi_compile _ WRITE_MSAA_DEPTH // this translates the new dependency tracker into the old preprocessor definitions for the existing HDRP shader code #define ATTRIBUTES_NEED_NORMAL #define ATTRIBUTES_NEED_TANGENT #define ATTRIBUTES_NEED_TEXCOORD0 #define ATTRIBUTES_NEED_TEXCOORD1 #define ATTRIBUTES_NEED_TEXCOORD2 #define ATTRIBUTES_NEED_TEXCOORD3 #define ATTRIBUTES_NEED_COLOR #define VARYINGS_NEED_POSITION_WS #define VARYINGS_NEED_TANGENT_TO_WORLD #define VARYINGS_NEED_TEXCOORD0 #define VARYINGS_NEED_TEXCOORD1 #define VARYINGS_NEED_TEXCOORD2 #define VARYINGS_NEED_TEXCOORD3 #define VARYINGS_NEED_COLOR //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #if (SHADERPASS == SHADERPASS_FORWARD) // used for shaders that want to do lighting (and materials) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #else // used for shaders that don't need lighting #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl" //Used by SceneSelectionPass int _ObjectId; int _PassValue; // this function assumes the bitangent flip is encoded in tangentWS.w // TODO: move this function to HDRP shared file, once we merge with HDRP repo float3x3 BuildWorldToTangent(float4 tangentWS, float3 normalWS) { // tangentWS must not be normalized (mikkts requirement) // Normalize normalWS vector but keep the renormFactor to apply it to bitangent and tangent float3 unnormalizedNormalWS = normalWS; float renormFactor = 1.0 / length(unnormalizedNormalWS); // bitangent on the fly option in xnormal to reduce vertex shader outputs. // this is the mikktspace transformation (must use unnormalized attributes) float3x3 worldToTangent = CreateWorldToTangent(unnormalizedNormalWS, tangentWS.xyz, tangentWS.w > 0.0 ? 1.0 : -1.0); // surface gradient based formulation requires a unit length initial normal. We can maintain compliance with mikkts // by uniformly scaling all 3 vectors since normalization of the perturbed normal will cancel it. worldToTangent[0] = worldToTangent[0] * renormFactor; worldToTangent[1] = worldToTangent[1] * renormFactor; worldToTangent[2] = worldToTangent[2] * renormFactor; // normalizes the interpolated vertex normal return worldToTangent; } //------------------------------------------------------------------------------------- // Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- // Generated Type: AttributesMesh struct AttributesMesh { float3 positionOS : POSITION; float3 normalOS : NORMAL; // optional float4 tangentOS : TANGENT; // optional float4 uv0 : TEXCOORD0; // optional float4 uv1 : TEXCOORD1; // optional float4 uv2 : TEXCOORD2; // optional float4 uv3 : TEXCOORD3; // optional float4 color : COLOR; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; // Generated Type: VaryingsMeshToPS struct VaryingsMeshToPS { float4 positionCS : SV_Position; float3 positionRWS; // optional float3 normalWS; // optional float4 tangentWS; // optional float4 texCoord0; // optional float4 texCoord1; // optional float4 texCoord2; // optional float4 texCoord3; // optional float4 color; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToPS { float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed float4 interp02 : TEXCOORD2; // auto-packed float4 interp03 : TEXCOORD3; // auto-packed float4 interp04 : TEXCOORD4; // auto-packed float4 interp05 : TEXCOORD5; // auto-packed float4 interp06 : TEXCOORD6; // auto-packed float4 interp07 : TEXCOORD7; // auto-packed float4 positionCS : SV_Position; // unpacked #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToPS PackVaryingsMeshToPS(VaryingsMeshToPS input) { PackedVaryingsMeshToPS output; output.positionCS = input.positionCS; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; output.interp02.xyzw = input.tangentWS; output.interp03.xyzw = input.texCoord0; output.interp04.xyzw = input.texCoord1; output.interp05.xyzw = input.texCoord2; output.interp06.xyzw = input.texCoord3; output.interp07.xyzw = input.color; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToPS UnpackVaryingsMeshToPS(PackedVaryingsMeshToPS input) { VaryingsMeshToPS output; output.positionCS = input.positionCS; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; output.tangentWS = input.interp02.xyzw; output.texCoord0 = input.interp03.xyzw; output.texCoord1 = input.interp04.xyzw; output.texCoord2 = input.interp05.xyzw; output.texCoord3 = input.interp06.xyzw; output.color = input.interp07.xyzw; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToDS { float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _uvBaseMask; float4 _uvBaseST; float4 _BaseColor; float _SmoothnessMin; float _SmoothnessMax; float4 _SpecularColor; float _NormalMapStrength; float _useThreadMap; float4 _uvThreadMask; float4 _uvThreadST; float _ThreadAOStrength01; float _ThreadNormalStrength; float _ThreadSmoothnessScale; float _FuzzMapUVScale; float _FuzzStrength; float4 _EmissionColor; CBUFFER_END TEXTURE2D(_BaseColorMap); SAMPLER(sampler_BaseColorMap); float4 _BaseColorMap_TexelSize; TEXTURE2D(_MaskMap); SAMPLER(sampler_MaskMap); float4 _MaskMap_TexelSize; TEXTURE2D(_SpecColorMap); SAMPLER(sampler_SpecColorMap); float4 _SpecColorMap_TexelSize; TEXTURE2D(_NormalMap); SAMPLER(sampler_NormalMap); float4 _NormalMap_TexelSize; TEXTURE2D(_ThreadMap); SAMPLER(sampler_ThreadMap); float4 _ThreadMap_TexelSize; TEXTURE2D(_FuzzMap); SAMPLER(sampler_FuzzMap); float4 _FuzzMap_TexelSize; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float4 uv0; // optional float4 uv1; // optional float4 uv2; // optional float4 uv3; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float Alpha; }; // Shared Graph Node Functions void Unity_Combine_float(float R, float G, float B, float A, out float4 RGBA, out float3 RGB, out float2 RG) { RGBA = float4(R, G, B, A); RGB = float3(R, G, B); RG = float2(R, G); } void Unity_Multiply_float (float2 A, float2 B, out float2 Out) { Out = A * B; } void Unity_Add_float2(float2 A, float2 B, out float2 Out) { Out = A + B; } // Subgraph function void sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(float4 _uvST, float4 _uvMask, SurfaceDescriptionInputs IN, out float4 Output1) { float4 _UV_23AF8552_Out = IN.uv0; float _Split_7957D60_R = _UV_23AF8552_Out[0]; float _Split_7957D60_G = _UV_23AF8552_Out[1]; float _Split_7957D60_B = _UV_23AF8552_Out[2]; float _Split_7957D60_A = _UV_23AF8552_Out[3]; float4 _Combine_5396A6C7_RGBA; float3 _Combine_5396A6C7_RGB; float2 _Combine_5396A6C7_RG; Unity_Combine_float(_Split_7957D60_R, _Split_7957D60_G, 0, 0, _Combine_5396A6C7_RGBA, _Combine_5396A6C7_RGB, _Combine_5396A6C7_RG); float4 _Property_CB55E443_Out = _uvMask; float _Split_6086B0A5_R = _Property_CB55E443_Out[0]; float _Split_6086B0A5_G = _Property_CB55E443_Out[1]; float _Split_6086B0A5_B = _Property_CB55E443_Out[2]; float _Split_6086B0A5_A = _Property_CB55E443_Out[3]; float2 _Multiply_FC550A07_Out; Unity_Multiply_float(_Combine_5396A6C7_RG, (_Split_6086B0A5_R.xx), _Multiply_FC550A07_Out); float4 _UV_3B1D042C_Out = IN.uv1; float _Split_107320B6_R = _UV_3B1D042C_Out[0]; float _Split_107320B6_G = _UV_3B1D042C_Out[1]; float _Split_107320B6_B = _UV_3B1D042C_Out[2]; float _Split_107320B6_A = _UV_3B1D042C_Out[3]; float4 _Combine_2E8D3795_RGBA; float3 _Combine_2E8D3795_RGB; float2 _Combine_2E8D3795_RG; Unity_Combine_float(_Split_107320B6_R, _Split_107320B6_G, 0, 0, _Combine_2E8D3795_RGBA, _Combine_2E8D3795_RGB, _Combine_2E8D3795_RG); float2 _Multiply_FDA7BA1E_Out; Unity_Multiply_float(_Combine_2E8D3795_RG, (_Split_6086B0A5_G.xx), _Multiply_FDA7BA1E_Out); float2 _Add_92015245_Out; Unity_Add_float2(_Multiply_FC550A07_Out, _Multiply_FDA7BA1E_Out, _Add_92015245_Out); float4 _UV_49BE4158_Out = IN.uv2; float _Split_A24186AD_R = _UV_49BE4158_Out[0]; float _Split_A24186AD_G = _UV_49BE4158_Out[1]; float _Split_A24186AD_B = _UV_49BE4158_Out[2]; float _Split_A24186AD_A = _UV_49BE4158_Out[3]; float4 _Combine_6951B6BC_RGBA; float3 _Combine_6951B6BC_RGB; float2 _Combine_6951B6BC_RG; Unity_Combine_float(_Split_A24186AD_R, _Split_A24186AD_G, 0, 0, _Combine_6951B6BC_RGBA, _Combine_6951B6BC_RGB, _Combine_6951B6BC_RG); float2 _Multiply_1480B81_Out; Unity_Multiply_float(_Combine_6951B6BC_RG, (_Split_6086B0A5_B.xx), _Multiply_1480B81_Out); float4 _UV_9CA65C2_Out = IN.uv3; float _Split_9EC6EA10_R = _UV_9CA65C2_Out[0]; float _Split_9EC6EA10_G = _UV_9CA65C2_Out[1]; float _Split_9EC6EA10_B = _UV_9CA65C2_Out[2]; float _Split_9EC6EA10_A = _UV_9CA65C2_Out[3]; float4 _Combine_633F7D3D_RGBA; float3 _Combine_633F7D3D_RGB; float2 _Combine_633F7D3D_RG; Unity_Combine_float(_Split_9EC6EA10_R, _Split_9EC6EA10_G, 0, 0, _Combine_633F7D3D_RGBA, _Combine_633F7D3D_RGB, _Combine_633F7D3D_RG); float2 _Multiply_2A2B5227_Out; Unity_Multiply_float(_Combine_633F7D3D_RG, (_Split_6086B0A5_A.xx), _Multiply_2A2B5227_Out); float2 _Add_B5E7679D_Out; Unity_Add_float2(_Multiply_1480B81_Out, _Multiply_2A2B5227_Out, _Add_B5E7679D_Out); float2 _Add_892742E3_Out; Unity_Add_float2(_Add_92015245_Out, _Add_B5E7679D_Out, _Add_892742E3_Out); float4 _Property_8DA1B077_Out = _uvST; float _Split_1AB0DA31_R = _Property_8DA1B077_Out[0]; float _Split_1AB0DA31_G = _Property_8DA1B077_Out[1]; float _Split_1AB0DA31_B = _Property_8DA1B077_Out[2]; float _Split_1AB0DA31_A = _Property_8DA1B077_Out[3]; float4 _Combine_44459F1_RGBA; float3 _Combine_44459F1_RGB; float2 _Combine_44459F1_RG; Unity_Combine_float(_Split_1AB0DA31_R, _Split_1AB0DA31_G, 0, 0, _Combine_44459F1_RGBA, _Combine_44459F1_RGB, _Combine_44459F1_RG); float2 _Multiply_38815E23_Out; Unity_Multiply_float(_Add_892742E3_Out, _Combine_44459F1_RG, _Multiply_38815E23_Out); float _Split_35A1DC4_R = _Property_8DA1B077_Out[0]; float _Split_35A1DC4_G = _Property_8DA1B077_Out[1]; float _Split_35A1DC4_B = _Property_8DA1B077_Out[2]; float _Split_35A1DC4_A = _Property_8DA1B077_Out[3]; float4 _Combine_91984BDF_RGBA; float3 _Combine_91984BDF_RGB; float2 _Combine_91984BDF_RG; Unity_Combine_float(_Split_35A1DC4_B, _Split_35A1DC4_A, 0, 0, _Combine_91984BDF_RGBA, _Combine_91984BDF_RGB, _Combine_91984BDF_RG); float2 _Add_63012CEE_Out; Unity_Add_float2(_Multiply_38815E23_Out, _Combine_91984BDF_RG, _Add_63012CEE_Out); Output1 = (float4(_Add_63012CEE_Out, 0.0, 1.0)); } void Unity_NormalStrength_float(float3 In, float Strength, out float3 Out) { Out = float3(In.rg * Strength, lerp(1, In.b, saturate(Strength))); } void Unity_Normalize_float3(float3 In, out float3 Out) { Out = normalize(In); } void Unity_Remap_float(float In, float2 InMinMax, float2 OutMinMax, out float Out) { Out = OutMinMax.x + (In - InMinMax.x) * (OutMinMax.y - OutMinMax.x) / (InMinMax.y - InMinMax.x); } void Unity_Multiply_float (float4 A, float4 B, out float4 Out) { Out = A * B; } void Unity_Lerp_float(float A, float B, float T, out float Out) { Out = lerp(A, B, T); } void Unity_Add_float4(float4 A, float4 B, out float4 Out) { Out = A + B; } void Unity_Saturate_float4(float4 In, out float4 Out) { Out = saturate(In); } void Unity_NormalUnpack_float(float4 In, out float3 Out) { Out = UnpackNormalmapRGorAG(In); } void Unity_NormalBlend_float(float3 A, float3 B, out float3 Out) { Out = normalize(float3(A.rg + B.rg, A.b * B.b)); } void Unity_Branch_float3(float Predicate, float3 True, float3 False, out float3 Out) { Out = lerp(False, True, Predicate); } void Unity_Add_float(float A, float B, out float Out) { Out = A + B; } void Unity_Saturate_float(float In, out float Out) { Out = saturate(In); } void Unity_Branch_float(float Predicate, float True, float False, out float Out) { Out = lerp(False, True, Predicate); } void Unity_Multiply_float (float A, float B, out float Out) { Out = A * B; } // Subgraph function void sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52(float2 _UV, TEXTURE2D_ARGS(_ThreadMap, sampler_ThreadMap), float _ThreadSmoothnessStrength, float _AmbientOcclusion, float _UseThreadMap, float _ThreadAOStrength, float _ThreadNormalStrength, float _Smoothness, float3 _Normals, float _Alpha, SurfaceDescriptionInputs IN, out float4 Output1, out float4 Output2, out float4 Output3, out float4 Output4) { float _Property_7B789410_Out = _UseThreadMap; float3 _Property_D380C535_Out = _Normals; float2 _Property_247E83DC_Out = _UV; float4 _SampleTexture2D_B39DD828_RGBA = SAMPLE_TEXTURE2D(_ThreadMap, sampler_ThreadMap, _Property_247E83DC_Out); float _SampleTexture2D_B39DD828_R = _SampleTexture2D_B39DD828_RGBA.r; float _SampleTexture2D_B39DD828_G = _SampleTexture2D_B39DD828_RGBA.g; float _SampleTexture2D_B39DD828_B = _SampleTexture2D_B39DD828_RGBA.b; float _SampleTexture2D_B39DD828_A = _SampleTexture2D_B39DD828_RGBA.a; float4 _Combine_3989CE7_RGBA; float3 _Combine_3989CE7_RGB; float2 _Combine_3989CE7_RG; Unity_Combine_float(_SampleTexture2D_B39DD828_A, _SampleTexture2D_B39DD828_G, 1, 1, _Combine_3989CE7_RGBA, _Combine_3989CE7_RGB, _Combine_3989CE7_RG); float3 _NormalUnpack_6B39F6EC_Out; Unity_NormalUnpack_float((float4(_Combine_3989CE7_RGB, 1.0)), _NormalUnpack_6B39F6EC_Out); float3 _Normalize_1F52E5EC_Out; Unity_Normalize_float3(_NormalUnpack_6B39F6EC_Out, _Normalize_1F52E5EC_Out); float _Property_2E175598_Out = _ThreadNormalStrength; float3 _NormalStrength_A15875A3_Out; Unity_NormalStrength_float(_Normalize_1F52E5EC_Out, _Property_2E175598_Out, _NormalStrength_A15875A3_Out); float3 _NormalBlend_191D51BE_Out; Unity_NormalBlend_float(_Property_D380C535_Out, _NormalStrength_A15875A3_Out, _NormalBlend_191D51BE_Out); float3 _Normalize_4D9B04E_Out; Unity_Normalize_float3(_NormalBlend_191D51BE_Out, _Normalize_4D9B04E_Out); float3 _Branch_54FF636E_Out; Unity_Branch_float3(_Property_7B789410_Out, _Normalize_4D9B04E_Out, _Property_D380C535_Out, _Branch_54FF636E_Out); float _Property_B5560A97_Out = _UseThreadMap; float _Property_6FAEC412_Out = _Smoothness; float _Remap_C272A01C_Out; Unity_Remap_float(_SampleTexture2D_B39DD828_B, float2 (0,1), float2 (-1,1), _Remap_C272A01C_Out); float _Property_CF380DCA_Out = _ThreadSmoothnessStrength; float _Lerp_1EB6EBC0_Out; Unity_Lerp_float(0, _Remap_C272A01C_Out, _Property_CF380DCA_Out, _Lerp_1EB6EBC0_Out); float _Add_2975BB_Out; Unity_Add_float(_Property_6FAEC412_Out, _Lerp_1EB6EBC0_Out, _Add_2975BB_Out); float _Saturate_1F46047D_Out; Unity_Saturate_float(_Add_2975BB_Out, _Saturate_1F46047D_Out); float _Branch_1C4EA1E2_Out; Unity_Branch_float(_Property_B5560A97_Out, _Saturate_1F46047D_Out, _Property_6FAEC412_Out, _Branch_1C4EA1E2_Out); float _Property_57F076E2_Out = _UseThreadMap; float _Property_829FEB4F_Out = _ThreadAOStrength; float _Lerp_1DC743E3_Out; Unity_Lerp_float(1, _SampleTexture2D_B39DD828_R, _Property_829FEB4F_Out, _Lerp_1DC743E3_Out); float _Property_416E73AE_Out = _AmbientOcclusion; float _Multiply_FBD87ACD_Out; Unity_Multiply_float(_Lerp_1DC743E3_Out, _Property_416E73AE_Out, _Multiply_FBD87ACD_Out); float _Branch_A5F3B7F9_Out; Unity_Branch_float(_Property_57F076E2_Out, _Multiply_FBD87ACD_Out, _Property_416E73AE_Out, _Branch_A5F3B7F9_Out); float _Property_5FDD4914_Out = _Alpha; float _Multiply_716B151B_Out; Unity_Multiply_float(_SampleTexture2D_B39DD828_R, _Property_5FDD4914_Out, _Multiply_716B151B_Out); Output1 = (float4(_Branch_54FF636E_Out, 1.0)); Output2 = (_Branch_1C4EA1E2_Out.xxxx); Output3 = (_Branch_A5F3B7F9_Out.xxxx); Output4 = (_Multiply_716B151B_Out.xxxx); } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float _Property_1E54B66A_Out = _useThreadMap; float4 _Property_8AE14795_Out = _uvThreadMask; float4 _Property_958B7FC9_Out = _uvThreadST; float4 _Subgraph_B567E108_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_958B7FC9_Out, _Property_8AE14795_Out, IN, _Subgraph_B567E108_Output1); float4 _Property_FEDB20A0_Out = _uvBaseMask; float4 _Property_F42AAF3B_Out = _uvBaseST; float4 _Subgraph_9D4E0F1_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_F42AAF3B_Out, _Property_FEDB20A0_Out, IN, _Subgraph_9D4E0F1_Output1); float4 _SampleTexture2D_105B35B3_RGBA = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, (_Subgraph_9D4E0F1_Output1.xy)); _SampleTexture2D_105B35B3_RGBA.rgb = UnpackNormalmapRGorAG(_SampleTexture2D_105B35B3_RGBA); float _SampleTexture2D_105B35B3_R = _SampleTexture2D_105B35B3_RGBA.r; float _SampleTexture2D_105B35B3_G = _SampleTexture2D_105B35B3_RGBA.g; float _SampleTexture2D_105B35B3_B = _SampleTexture2D_105B35B3_RGBA.b; float _SampleTexture2D_105B35B3_A = _SampleTexture2D_105B35B3_RGBA.a; float _Property_82D183C3_Out = _NormalMapStrength; float3 _NormalStrength_BFF5C35E_Out; Unity_NormalStrength_float((_SampleTexture2D_105B35B3_RGBA.xyz), _Property_82D183C3_Out, _NormalStrength_BFF5C35E_Out); float3 _Normalize_ACA4E10E_Out; Unity_Normalize_float3(_NormalStrength_BFF5C35E_Out, _Normalize_ACA4E10E_Out); float4 _Property_1E040901_Out = _uvBaseMask; float4 _Property_97A7EF85_Out = _uvBaseST; float4 _Subgraph_8DDCEE61_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_97A7EF85_Out, _Property_1E040901_Out, IN, _Subgraph_8DDCEE61_Output1); float4 _SampleTexture2D_8C3CF01A_RGBA = SAMPLE_TEXTURE2D(_SpecColorMap, sampler_SpecColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_8C3CF01A_R = _SampleTexture2D_8C3CF01A_RGBA.r; float _SampleTexture2D_8C3CF01A_G = _SampleTexture2D_8C3CF01A_RGBA.g; float _SampleTexture2D_8C3CF01A_B = _SampleTexture2D_8C3CF01A_RGBA.b; float _SampleTexture2D_8C3CF01A_A = _SampleTexture2D_8C3CF01A_RGBA.a; float _Property_B948927_Out = _SmoothnessMin; float _Property_2962A49E_Out = _SmoothnessMax; float2 _Vector2_9C783D17_Out = float2(_Property_B948927_Out,_Property_2962A49E_Out); float _Remap_10DEF6A_Out; Unity_Remap_float(_SampleTexture2D_8C3CF01A_A, float2 (0,1), _Vector2_9C783D17_Out, _Remap_10DEF6A_Out); float4 _Property_90FAF786_Out = _BaseColor; float4 _SampleTexture2D_11CFD011_RGBA = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_11CFD011_R = _SampleTexture2D_11CFD011_RGBA.r; float _SampleTexture2D_11CFD011_G = _SampleTexture2D_11CFD011_RGBA.g; float _SampleTexture2D_11CFD011_B = _SampleTexture2D_11CFD011_RGBA.b; float _SampleTexture2D_11CFD011_A = _SampleTexture2D_11CFD011_RGBA.a; float4 _Multiply_98A7A079_Out; Unity_Multiply_float(_Property_90FAF786_Out, _SampleTexture2D_11CFD011_RGBA, _Multiply_98A7A079_Out); float _Property_7C6435CB_Out = _FuzzMapUVScale; float4 _Multiply_18C3A780_Out; Unity_Multiply_float(_Subgraph_8DDCEE61_Output1, (_Property_7C6435CB_Out.xxxx), _Multiply_18C3A780_Out); float4 _SampleTexture2D_4D82F05E_RGBA = SAMPLE_TEXTURE2D(_FuzzMap, sampler_FuzzMap, (_Multiply_18C3A780_Out.xy)); float _SampleTexture2D_4D82F05E_R = _SampleTexture2D_4D82F05E_RGBA.r; float _SampleTexture2D_4D82F05E_G = _SampleTexture2D_4D82F05E_RGBA.g; float _SampleTexture2D_4D82F05E_B = _SampleTexture2D_4D82F05E_RGBA.b; float _SampleTexture2D_4D82F05E_A = _SampleTexture2D_4D82F05E_RGBA.a; float _Property_6CCE2816_Out = _FuzzStrength; float _Lerp_2C953D15_Out; Unity_Lerp_float(0, _SampleTexture2D_4D82F05E_R, _Property_6CCE2816_Out, _Lerp_2C953D15_Out); float4 _Add_A30FF2E2_Out; Unity_Add_float4(_Multiply_98A7A079_Out, (_Lerp_2C953D15_Out.xxxx), _Add_A30FF2E2_Out); float4 _Saturate_69BD2FF3_Out; Unity_Saturate_float4(_Add_A30FF2E2_Out, _Saturate_69BD2FF3_Out); float _Split_EB0B739F_R = _Saturate_69BD2FF3_Out[0]; float _Split_EB0B739F_G = _Saturate_69BD2FF3_Out[1]; float _Split_EB0B739F_B = _Saturate_69BD2FF3_Out[2]; float _Split_EB0B739F_A = _Saturate_69BD2FF3_Out[3]; float4 _SampleTexture2D_EECA7933_RGBA = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_EECA7933_R = _SampleTexture2D_EECA7933_RGBA.r; float _SampleTexture2D_EECA7933_G = _SampleTexture2D_EECA7933_RGBA.g; float _SampleTexture2D_EECA7933_B = _SampleTexture2D_EECA7933_RGBA.b; float _SampleTexture2D_EECA7933_A = _SampleTexture2D_EECA7933_RGBA.a; float _Property_88B45C0E_Out = _ThreadAOStrength01; float _Property_FC0CC4C0_Out = _ThreadNormalStrength; float _Property_AC495D22_Out = _ThreadSmoothnessScale; float4 _Subgraph_E494B5B1_Output1; float4 _Subgraph_E494B5B1_Output2; float4 _Subgraph_E494B5B1_Output3; float4 _Subgraph_E494B5B1_Output4; sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52((_Subgraph_B567E108_Output1.xy), TEXTURE2D_PARAM(_ThreadMap, sampler_ThreadMap), _Property_AC495D22_Out, _SampleTexture2D_EECA7933_G, _Property_1E54B66A_Out, _Property_88B45C0E_Out, _Property_FC0CC4C0_Out, _Remap_10DEF6A_Out, _Normalize_ACA4E10E_Out, _Split_EB0B739F_A, IN, _Subgraph_E494B5B1_Output1, _Subgraph_E494B5B1_Output2, _Subgraph_E494B5B1_Output3, _Subgraph_E494B5B1_Output4); surface.Alpha = (_Subgraph_E494B5B1_Output4).x; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- FragInputs BuildFragInputs(VaryingsMeshToPS input) { FragInputs output; ZERO_INITIALIZE(FragInputs, output); // Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used). // TODO: this is a really poor workaround, but the variable is used in a bunch of places // to compute normals which are then passed on elsewhere to compute other values... output.worldToTangent = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; output.worldToTangent = BuildWorldToTangent(input.tangentWS, input.normalWS); output.texCoord0 = input.texCoord0; output.texCoord1 = input.texCoord1; output.texCoord2 = input.texCoord2; output.texCoord3 = input.texCoord3; output.color = input.color; #if SHADER_STAGE_FRAGMENT #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; output.uv2 = input.texCoord2; output.uv3 = input.texCoord3; return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void ApplyDecalToSurfaceData(DecalSurfaceData decalSurfaceData, inout SurfaceData surfaceData) { // using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_DIFFUSE) { surfaceData.baseColor.xyz = surfaceData.baseColor.xyz * decalSurfaceData.baseColor.w + decalSurfaceData.baseColor.xyz; } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_NORMAL) { surfaceData.normalWS.xyz = normalize(surfaceData.normalWS.xyz * decalSurfaceData.normalWS.w + decalSurfaceData.normalWS.xyz); } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_MASK) { #ifdef DECALS_4RT // only smoothness in 3RT mode // Don't apply any metallic modification surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.MAOSBlend.y + decalSurfaceData.mask.y; #endif surfaceData.perceptualSmoothness = surfaceData.perceptualSmoothness * decalSurfaceData.mask.w + decalSurfaceData.mask.z; } } void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, out SurfaceData surfaceData) { // setup defaults -- these are used if the graph doesn't output a value ZERO_INITIALIZE(SurfaceData, surfaceData); // copy across graph values, if defined // These static material feature allow compile time optimization surfaceData.materialFeatures = 0; // Transform the preprocess macro into a material feature (note that silk flag is deduced from the abscence of this one) #ifdef _MATERIAL_FEATURE_COTTON_WOOL surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL; #endif #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION; #endif #if defined (_ENERGY_CONSERVING_SPECULAR) // Require to have setup baseColor // Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b)); #endif // tangent-space normal float3 normalTS = float3(0.0f, 0.0f, 1.0f); // compute world space normal GetNormalWS(fragInputs, normalTS, surfaceData.normalWS); surfaceData.geomNormalWS = fragInputs.worldToTangent[2]; surfaceData.tangentWS = normalize(fragInputs.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS); // By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion. // If user provide bent normal then we process a better term surfaceData.specularOcclusion = 1.0; #if defined(_SPECULAR_OCCLUSION_CUSTOM) // Just use the value passed through via the slot (not active otherwise) #elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL) // If we have bent normal and ambient occlusion, process a specular occlusion surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness)); #elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO) surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness)); #else surfaceData.specularOcclusion = 1.0; surfaceData.specularOcclusion = 1.0; #endif #ifdef DEBUG_DISPLAY // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.worldToTangent, surfaceData); #endif } void GetSurfaceAndBuiltinData(FragInputs fragInputs, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData) { #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group uint3 fadeMaskSeed = asuint((int3)(V * _ScreenSize.xyx)); // Quantize V to _ScreenSize values LODDitheringTransition(fadeMaskSeed, unity_LODFade.x); #endif // this applies the double sided tangent space correction -- see 'ApplyDoubleSidedFlipOrMirror()' SurfaceDescriptionInputs surfaceDescriptionInputs = FragInputsToSurfaceDescriptionInputs(fragInputs, V); SurfaceDescription surfaceDescription = SurfaceDescriptionFunction(surfaceDescriptionInputs); // Perform alpha test very early to save performance (a killed pixel will not sample textures) // TODO: split graph evaluation to grab just alpha dependencies first? tricky.. BuildSurfaceData(fragInputs, surfaceDescription, V, surfaceData); #if HAVE_DECALS && _DECALS DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); #endif // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(surfaceDescription.Alpha, surfaceData.normalWS, -fragInputs.worldToTangent[2], fragInputs.positionRWS, fragInputs.texCoord1, fragInputs.texCoord2, builtinData); builtinData.depthOffset = 0.0; // ApplyPerPixelDisplacement(input, V, layerTexCoord, blendMasks); #ifdef _DEPTHOFFSET_ON : ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput); PostInitBuiltinData(V, posInput, surfaceData, builtinData); } //------------------------------------------------------------------------------------- // Pass Includes //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPassVelocity.hlsl" //------------------------------------------------------------------------------------- // End Pass Includes //------------------------------------------------------------------------------------- ENDHLSL } Pass { // based on FabricPass.template Name "Forward" Tags { "LightMode" = "ForwardOnly" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Blend One Zero Cull Back ZTest LEqual ZWrite On ZClip [_ZClip] // Stencil setup Stencil { WriteMask 39 Ref 33 Comp Always Pass Replace } //------------------------------------------------------------------------------------- // End Render Modes //------------------------------------------------------------------------------------- HLSLPROGRAM #pragma target 4.5 #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch //#pragma enable_d3d11_debug_symbols #pragma multi_compile_instancing #pragma instancing_options renderinglayer #pragma multi_compile _ LOD_FADE_CROSSFADE //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- #define _MATERIAL_FEATURE_COTTON_WOOL 1 #define _EMISSION 1 #define _SPECULAR_OCCLUSION_FROM_AO 1 #define _ENERGY_CONSERVING_SPECULAR 1 #define _DISABLE_SSR 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag #define UNITY_MATERIAL_FABRIC // Need to be define before including Material.hlsl // This will be enabled in an upcoming change. // #define SURFACE_GRADIENT // If we use subsurface scattering, enable output split lighting (for forward pass) #if defined(_MATERIAL_FEATURE_SUBSURFACE_SCATTERING) && !defined(_SURFACE_TYPE_TRANSPARENT) #define OUTPUT_SPLIT_LIGHTING #endif #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Wind.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl" // define FragInputs structure #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/FragInputs.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPass.cs.hlsl" //------------------------------------------------------------------------------------- // Defines //------------------------------------------------------------------------------------- #define SHADERPASS SHADERPASS_FORWARD #pragma multi_compile _ DEBUG_DISPLAY #pragma multi_compile _ LIGHTMAP_ON #pragma multi_compile _ DIRLIGHTMAP_COMBINED #pragma multi_compile _ DYNAMICLIGHTMAP_ON #pragma multi_compile _ SHADOWS_SHADOWMASK #pragma multi_compile DECALS_OFF DECALS_3RT DECALS_4RT #define LIGHTLOOP_TILE_PASS #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST #pragma multi_compile PUNCTUAL_SHADOW_LOW PUNCTUAL_SHADOW_MEDIUM PUNCTUAL_SHADOW_HIGH #pragma multi_compile DIRECTIONAL_SHADOW_LOW DIRECTIONAL_SHADOW_MEDIUM DIRECTIONAL_SHADOW_HIGH // this translates the new dependency tracker into the old preprocessor definitions for the existing HDRP shader code #define ATTRIBUTES_NEED_NORMAL #define ATTRIBUTES_NEED_TANGENT #define ATTRIBUTES_NEED_TEXCOORD0 #define ATTRIBUTES_NEED_TEXCOORD1 #define ATTRIBUTES_NEED_TEXCOORD2 #define ATTRIBUTES_NEED_TEXCOORD3 #define ATTRIBUTES_NEED_COLOR #define VARYINGS_NEED_POSITION_WS #define VARYINGS_NEED_TANGENT_TO_WORLD #define VARYINGS_NEED_TEXCOORD0 #define VARYINGS_NEED_TEXCOORD1 #define VARYINGS_NEED_TEXCOORD2 #define VARYINGS_NEED_TEXCOORD3 #define VARYINGS_NEED_COLOR //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #if (SHADERPASS == SHADERPASS_FORWARD) // used for shaders that want to do lighting (and materials) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #else // used for shaders that don't need lighting #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/BuiltinUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/MaterialUtilities.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Decal/DecalUtilities.hlsl" //Used by SceneSelectionPass int _ObjectId; int _PassValue; // this function assumes the bitangent flip is encoded in tangentWS.w // TODO: move this function to HDRP shared file, once we merge with HDRP repo float3x3 BuildWorldToTangent(float4 tangentWS, float3 normalWS) { // tangentWS must not be normalized (mikkts requirement) // Normalize normalWS vector but keep the renormFactor to apply it to bitangent and tangent float3 unnormalizedNormalWS = normalWS; float renormFactor = 1.0 / length(unnormalizedNormalWS); // bitangent on the fly option in xnormal to reduce vertex shader outputs. // this is the mikktspace transformation (must use unnormalized attributes) float3x3 worldToTangent = CreateWorldToTangent(unnormalizedNormalWS, tangentWS.xyz, tangentWS.w > 0.0 ? 1.0 : -1.0); // surface gradient based formulation requires a unit length initial normal. We can maintain compliance with mikkts // by uniformly scaling all 3 vectors since normalization of the perturbed normal will cancel it. worldToTangent[0] = worldToTangent[0] * renormFactor; worldToTangent[1] = worldToTangent[1] * renormFactor; worldToTangent[2] = worldToTangent[2] * renormFactor; // normalizes the interpolated vertex normal return worldToTangent; } //------------------------------------------------------------------------------------- // Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- // Generated Type: AttributesMesh struct AttributesMesh { float3 positionOS : POSITION; float3 normalOS : NORMAL; // optional float4 tangentOS : TANGENT; // optional float4 uv0 : TEXCOORD0; // optional float4 uv1 : TEXCOORD1; // optional float4 uv2 : TEXCOORD2; // optional float4 uv3 : TEXCOORD3; // optional float4 color : COLOR; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; // Generated Type: VaryingsMeshToPS struct VaryingsMeshToPS { float4 positionCS : SV_Position; float3 positionRWS; // optional float3 normalWS; // optional float4 tangentWS; // optional float4 texCoord0; // optional float4 texCoord1; // optional float4 texCoord2; // optional float4 texCoord3; // optional float4 color; // optional #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToPS { float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed float4 interp02 : TEXCOORD2; // auto-packed float4 interp03 : TEXCOORD3; // auto-packed float4 interp04 : TEXCOORD4; // auto-packed float4 interp05 : TEXCOORD5; // auto-packed float4 interp06 : TEXCOORD6; // auto-packed float4 interp07 : TEXCOORD7; // auto-packed float4 positionCS : SV_Position; // unpacked #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToPS PackVaryingsMeshToPS(VaryingsMeshToPS input) { PackedVaryingsMeshToPS output; output.positionCS = input.positionCS; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; output.interp02.xyzw = input.tangentWS; output.interp03.xyzw = input.texCoord0; output.interp04.xyzw = input.texCoord1; output.interp05.xyzw = input.texCoord2; output.interp06.xyzw = input.texCoord3; output.interp07.xyzw = input.color; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToPS UnpackVaryingsMeshToPS(PackedVaryingsMeshToPS input) { VaryingsMeshToPS output; output.positionCS = input.positionCS; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; output.tangentWS = input.interp02.xyzw; output.texCoord0 = input.interp03.xyzw; output.texCoord1 = input.interp04.xyzw; output.texCoord2 = input.interp05.xyzw; output.texCoord3 = input.interp06.xyzw; output.color = input.interp07.xyzw; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; #endif // INSTANCING_ON }; struct PackedVaryingsMeshToDS { float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed #if INSTANCING_ON uint instanceID : INSTANCEID_SEMANTIC; // unpacked #endif // INSTANCING_ON }; PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if INSTANCING_ON output.instanceID = input.instanceID; #endif // INSTANCING_ON return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _uvBaseMask; float4 _uvBaseST; float4 _BaseColor; float _SmoothnessMin; float _SmoothnessMax; float4 _SpecularColor; float _NormalMapStrength; float _useThreadMap; float4 _uvThreadMask; float4 _uvThreadST; float _ThreadAOStrength01; float _ThreadNormalStrength; float _ThreadSmoothnessScale; float _FuzzMapUVScale; float _FuzzStrength; float4 _EmissionColor; CBUFFER_END TEXTURE2D(_BaseColorMap); SAMPLER(sampler_BaseColorMap); float4 _BaseColorMap_TexelSize; TEXTURE2D(_MaskMap); SAMPLER(sampler_MaskMap); float4 _MaskMap_TexelSize; TEXTURE2D(_SpecColorMap); SAMPLER(sampler_SpecColorMap); float4 _SpecColorMap_TexelSize; TEXTURE2D(_NormalMap); SAMPLER(sampler_NormalMap); float4 _NormalMap_TexelSize; TEXTURE2D(_ThreadMap); SAMPLER(sampler_ThreadMap); float4 _ThreadMap_TexelSize; TEXTURE2D(_FuzzMap); SAMPLER(sampler_FuzzMap); float4 _FuzzMap_TexelSize; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float4 uv0; // optional float4 uv1; // optional float4 uv2; // optional float4 uv3; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float3 Albedo; float3 Normal; float Smoothness; float Occlusion; float3 Specular; float DiffusionProfile; float SubsurfaceMask; float Thickness; float3 Emission; float Alpha; }; // Shared Graph Node Functions void Unity_Combine_float(float R, float G, float B, float A, out float4 RGBA, out float3 RGB, out float2 RG) { RGBA = float4(R, G, B, A); RGB = float3(R, G, B); RG = float2(R, G); } void Unity_Multiply_float (float2 A, float2 B, out float2 Out) { Out = A * B; } void Unity_Add_float2(float2 A, float2 B, out float2 Out) { Out = A + B; } // Subgraph function void sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(float4 _uvST, float4 _uvMask, SurfaceDescriptionInputs IN, out float4 Output1) { float4 _UV_23AF8552_Out = IN.uv0; float _Split_7957D60_R = _UV_23AF8552_Out[0]; float _Split_7957D60_G = _UV_23AF8552_Out[1]; float _Split_7957D60_B = _UV_23AF8552_Out[2]; float _Split_7957D60_A = _UV_23AF8552_Out[3]; float4 _Combine_5396A6C7_RGBA; float3 _Combine_5396A6C7_RGB; float2 _Combine_5396A6C7_RG; Unity_Combine_float(_Split_7957D60_R, _Split_7957D60_G, 0, 0, _Combine_5396A6C7_RGBA, _Combine_5396A6C7_RGB, _Combine_5396A6C7_RG); float4 _Property_CB55E443_Out = _uvMask; float _Split_6086B0A5_R = _Property_CB55E443_Out[0]; float _Split_6086B0A5_G = _Property_CB55E443_Out[1]; float _Split_6086B0A5_B = _Property_CB55E443_Out[2]; float _Split_6086B0A5_A = _Property_CB55E443_Out[3]; float2 _Multiply_FC550A07_Out; Unity_Multiply_float(_Combine_5396A6C7_RG, (_Split_6086B0A5_R.xx), _Multiply_FC550A07_Out); float4 _UV_3B1D042C_Out = IN.uv1; float _Split_107320B6_R = _UV_3B1D042C_Out[0]; float _Split_107320B6_G = _UV_3B1D042C_Out[1]; float _Split_107320B6_B = _UV_3B1D042C_Out[2]; float _Split_107320B6_A = _UV_3B1D042C_Out[3]; float4 _Combine_2E8D3795_RGBA; float3 _Combine_2E8D3795_RGB; float2 _Combine_2E8D3795_RG; Unity_Combine_float(_Split_107320B6_R, _Split_107320B6_G, 0, 0, _Combine_2E8D3795_RGBA, _Combine_2E8D3795_RGB, _Combine_2E8D3795_RG); float2 _Multiply_FDA7BA1E_Out; Unity_Multiply_float(_Combine_2E8D3795_RG, (_Split_6086B0A5_G.xx), _Multiply_FDA7BA1E_Out); float2 _Add_92015245_Out; Unity_Add_float2(_Multiply_FC550A07_Out, _Multiply_FDA7BA1E_Out, _Add_92015245_Out); float4 _UV_49BE4158_Out = IN.uv2; float _Split_A24186AD_R = _UV_49BE4158_Out[0]; float _Split_A24186AD_G = _UV_49BE4158_Out[1]; float _Split_A24186AD_B = _UV_49BE4158_Out[2]; float _Split_A24186AD_A = _UV_49BE4158_Out[3]; float4 _Combine_6951B6BC_RGBA; float3 _Combine_6951B6BC_RGB; float2 _Combine_6951B6BC_RG; Unity_Combine_float(_Split_A24186AD_R, _Split_A24186AD_G, 0, 0, _Combine_6951B6BC_RGBA, _Combine_6951B6BC_RGB, _Combine_6951B6BC_RG); float2 _Multiply_1480B81_Out; Unity_Multiply_float(_Combine_6951B6BC_RG, (_Split_6086B0A5_B.xx), _Multiply_1480B81_Out); float4 _UV_9CA65C2_Out = IN.uv3; float _Split_9EC6EA10_R = _UV_9CA65C2_Out[0]; float _Split_9EC6EA10_G = _UV_9CA65C2_Out[1]; float _Split_9EC6EA10_B = _UV_9CA65C2_Out[2]; float _Split_9EC6EA10_A = _UV_9CA65C2_Out[3]; float4 _Combine_633F7D3D_RGBA; float3 _Combine_633F7D3D_RGB; float2 _Combine_633F7D3D_RG; Unity_Combine_float(_Split_9EC6EA10_R, _Split_9EC6EA10_G, 0, 0, _Combine_633F7D3D_RGBA, _Combine_633F7D3D_RGB, _Combine_633F7D3D_RG); float2 _Multiply_2A2B5227_Out; Unity_Multiply_float(_Combine_633F7D3D_RG, (_Split_6086B0A5_A.xx), _Multiply_2A2B5227_Out); float2 _Add_B5E7679D_Out; Unity_Add_float2(_Multiply_1480B81_Out, _Multiply_2A2B5227_Out, _Add_B5E7679D_Out); float2 _Add_892742E3_Out; Unity_Add_float2(_Add_92015245_Out, _Add_B5E7679D_Out, _Add_892742E3_Out); float4 _Property_8DA1B077_Out = _uvST; float _Split_1AB0DA31_R = _Property_8DA1B077_Out[0]; float _Split_1AB0DA31_G = _Property_8DA1B077_Out[1]; float _Split_1AB0DA31_B = _Property_8DA1B077_Out[2]; float _Split_1AB0DA31_A = _Property_8DA1B077_Out[3]; float4 _Combine_44459F1_RGBA; float3 _Combine_44459F1_RGB; float2 _Combine_44459F1_RG; Unity_Combine_float(_Split_1AB0DA31_R, _Split_1AB0DA31_G, 0, 0, _Combine_44459F1_RGBA, _Combine_44459F1_RGB, _Combine_44459F1_RG); float2 _Multiply_38815E23_Out; Unity_Multiply_float(_Add_892742E3_Out, _Combine_44459F1_RG, _Multiply_38815E23_Out); float _Split_35A1DC4_R = _Property_8DA1B077_Out[0]; float _Split_35A1DC4_G = _Property_8DA1B077_Out[1]; float _Split_35A1DC4_B = _Property_8DA1B077_Out[2]; float _Split_35A1DC4_A = _Property_8DA1B077_Out[3]; float4 _Combine_91984BDF_RGBA; float3 _Combine_91984BDF_RGB; float2 _Combine_91984BDF_RG; Unity_Combine_float(_Split_35A1DC4_B, _Split_35A1DC4_A, 0, 0, _Combine_91984BDF_RGBA, _Combine_91984BDF_RGB, _Combine_91984BDF_RG); float2 _Add_63012CEE_Out; Unity_Add_float2(_Multiply_38815E23_Out, _Combine_91984BDF_RG, _Add_63012CEE_Out); Output1 = (float4(_Add_63012CEE_Out, 0.0, 1.0)); } void Unity_Multiply_float (float4 A, float4 B, out float4 Out) { Out = A * B; } void Unity_Lerp_float(float A, float B, float T, out float Out) { Out = lerp(A, B, T); } void Unity_Add_float4(float4 A, float4 B, out float4 Out) { Out = A + B; } void Unity_Saturate_float4(float4 In, out float4 Out) { Out = saturate(In); } void Unity_NormalStrength_float(float3 In, float Strength, out float3 Out) { Out = float3(In.rg * Strength, lerp(1, In.b, saturate(Strength))); } void Unity_Normalize_float3(float3 In, out float3 Out) { Out = normalize(In); } void Unity_Remap_float(float In, float2 InMinMax, float2 OutMinMax, out float Out) { Out = OutMinMax.x + (In - InMinMax.x) * (OutMinMax.y - OutMinMax.x) / (InMinMax.y - InMinMax.x); } void Unity_NormalUnpack_float(float4 In, out float3 Out) { Out = UnpackNormalmapRGorAG(In); } void Unity_NormalBlend_float(float3 A, float3 B, out float3 Out) { Out = normalize(float3(A.rg + B.rg, A.b * B.b)); } void Unity_Branch_float3(float Predicate, float3 True, float3 False, out float3 Out) { Out = lerp(False, True, Predicate); } void Unity_Add_float(float A, float B, out float Out) { Out = A + B; } void Unity_Saturate_float(float In, out float Out) { Out = saturate(In); } void Unity_Branch_float(float Predicate, float True, float False, out float Out) { Out = lerp(False, True, Predicate); } void Unity_Multiply_float (float A, float B, out float Out) { Out = A * B; } // Subgraph function void sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52(float2 _UV, TEXTURE2D_ARGS(_ThreadMap, sampler_ThreadMap), float _ThreadSmoothnessStrength, float _AmbientOcclusion, float _UseThreadMap, float _ThreadAOStrength, float _ThreadNormalStrength, float _Smoothness, float3 _Normals, float _Alpha, SurfaceDescriptionInputs IN, out float4 Output1, out float4 Output2, out float4 Output3, out float4 Output4) { float _Property_7B789410_Out = _UseThreadMap; float3 _Property_D380C535_Out = _Normals; float2 _Property_247E83DC_Out = _UV; float4 _SampleTexture2D_B39DD828_RGBA = SAMPLE_TEXTURE2D(_ThreadMap, sampler_ThreadMap, _Property_247E83DC_Out); float _SampleTexture2D_B39DD828_R = _SampleTexture2D_B39DD828_RGBA.r; float _SampleTexture2D_B39DD828_G = _SampleTexture2D_B39DD828_RGBA.g; float _SampleTexture2D_B39DD828_B = _SampleTexture2D_B39DD828_RGBA.b; float _SampleTexture2D_B39DD828_A = _SampleTexture2D_B39DD828_RGBA.a; float4 _Combine_3989CE7_RGBA; float3 _Combine_3989CE7_RGB; float2 _Combine_3989CE7_RG; Unity_Combine_float(_SampleTexture2D_B39DD828_A, _SampleTexture2D_B39DD828_G, 1, 1, _Combine_3989CE7_RGBA, _Combine_3989CE7_RGB, _Combine_3989CE7_RG); float3 _NormalUnpack_6B39F6EC_Out; Unity_NormalUnpack_float((float4(_Combine_3989CE7_RGB, 1.0)), _NormalUnpack_6B39F6EC_Out); float3 _Normalize_1F52E5EC_Out; Unity_Normalize_float3(_NormalUnpack_6B39F6EC_Out, _Normalize_1F52E5EC_Out); float _Property_2E175598_Out = _ThreadNormalStrength; float3 _NormalStrength_A15875A3_Out; Unity_NormalStrength_float(_Normalize_1F52E5EC_Out, _Property_2E175598_Out, _NormalStrength_A15875A3_Out); float3 _NormalBlend_191D51BE_Out; Unity_NormalBlend_float(_Property_D380C535_Out, _NormalStrength_A15875A3_Out, _NormalBlend_191D51BE_Out); float3 _Normalize_4D9B04E_Out; Unity_Normalize_float3(_NormalBlend_191D51BE_Out, _Normalize_4D9B04E_Out); float3 _Branch_54FF636E_Out; Unity_Branch_float3(_Property_7B789410_Out, _Normalize_4D9B04E_Out, _Property_D380C535_Out, _Branch_54FF636E_Out); float _Property_B5560A97_Out = _UseThreadMap; float _Property_6FAEC412_Out = _Smoothness; float _Remap_C272A01C_Out; Unity_Remap_float(_SampleTexture2D_B39DD828_B, float2 (0,1), float2 (-1,1), _Remap_C272A01C_Out); float _Property_CF380DCA_Out = _ThreadSmoothnessStrength; float _Lerp_1EB6EBC0_Out; Unity_Lerp_float(0, _Remap_C272A01C_Out, _Property_CF380DCA_Out, _Lerp_1EB6EBC0_Out); float _Add_2975BB_Out; Unity_Add_float(_Property_6FAEC412_Out, _Lerp_1EB6EBC0_Out, _Add_2975BB_Out); float _Saturate_1F46047D_Out; Unity_Saturate_float(_Add_2975BB_Out, _Saturate_1F46047D_Out); float _Branch_1C4EA1E2_Out; Unity_Branch_float(_Property_B5560A97_Out, _Saturate_1F46047D_Out, _Property_6FAEC412_Out, _Branch_1C4EA1E2_Out); float _Property_57F076E2_Out = _UseThreadMap; float _Property_829FEB4F_Out = _ThreadAOStrength; float _Lerp_1DC743E3_Out; Unity_Lerp_float(1, _SampleTexture2D_B39DD828_R, _Property_829FEB4F_Out, _Lerp_1DC743E3_Out); float _Property_416E73AE_Out = _AmbientOcclusion; float _Multiply_FBD87ACD_Out; Unity_Multiply_float(_Lerp_1DC743E3_Out, _Property_416E73AE_Out, _Multiply_FBD87ACD_Out); float _Branch_A5F3B7F9_Out; Unity_Branch_float(_Property_57F076E2_Out, _Multiply_FBD87ACD_Out, _Property_416E73AE_Out, _Branch_A5F3B7F9_Out); float _Property_5FDD4914_Out = _Alpha; float _Multiply_716B151B_Out; Unity_Multiply_float(_SampleTexture2D_B39DD828_R, _Property_5FDD4914_Out, _Multiply_716B151B_Out); Output1 = (float4(_Branch_54FF636E_Out, 1.0)); Output2 = (_Branch_1C4EA1E2_Out.xxxx); Output3 = (_Branch_A5F3B7F9_Out.xxxx); Output4 = (_Multiply_716B151B_Out.xxxx); } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float4 _Property_90FAF786_Out = _BaseColor; float4 _Property_1E040901_Out = _uvBaseMask; float4 _Property_97A7EF85_Out = _uvBaseST; float4 _Subgraph_8DDCEE61_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_97A7EF85_Out, _Property_1E040901_Out, IN, _Subgraph_8DDCEE61_Output1); float4 _SampleTexture2D_11CFD011_RGBA = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_11CFD011_R = _SampleTexture2D_11CFD011_RGBA.r; float _SampleTexture2D_11CFD011_G = _SampleTexture2D_11CFD011_RGBA.g; float _SampleTexture2D_11CFD011_B = _SampleTexture2D_11CFD011_RGBA.b; float _SampleTexture2D_11CFD011_A = _SampleTexture2D_11CFD011_RGBA.a; float4 _Multiply_98A7A079_Out; Unity_Multiply_float(_Property_90FAF786_Out, _SampleTexture2D_11CFD011_RGBA, _Multiply_98A7A079_Out); float _Property_7C6435CB_Out = _FuzzMapUVScale; float4 _Multiply_18C3A780_Out; Unity_Multiply_float(_Subgraph_8DDCEE61_Output1, (_Property_7C6435CB_Out.xxxx), _Multiply_18C3A780_Out); float4 _SampleTexture2D_4D82F05E_RGBA = SAMPLE_TEXTURE2D(_FuzzMap, sampler_FuzzMap, (_Multiply_18C3A780_Out.xy)); float _SampleTexture2D_4D82F05E_R = _SampleTexture2D_4D82F05E_RGBA.r; float _SampleTexture2D_4D82F05E_G = _SampleTexture2D_4D82F05E_RGBA.g; float _SampleTexture2D_4D82F05E_B = _SampleTexture2D_4D82F05E_RGBA.b; float _SampleTexture2D_4D82F05E_A = _SampleTexture2D_4D82F05E_RGBA.a; float _Property_6CCE2816_Out = _FuzzStrength; float _Lerp_2C953D15_Out; Unity_Lerp_float(0, _SampleTexture2D_4D82F05E_R, _Property_6CCE2816_Out, _Lerp_2C953D15_Out); float4 _Add_A30FF2E2_Out; Unity_Add_float4(_Multiply_98A7A079_Out, (_Lerp_2C953D15_Out.xxxx), _Add_A30FF2E2_Out); float4 _Saturate_69BD2FF3_Out; Unity_Saturate_float4(_Add_A30FF2E2_Out, _Saturate_69BD2FF3_Out); float _Property_1E54B66A_Out = _useThreadMap; float4 _Property_8AE14795_Out = _uvThreadMask; float4 _Property_958B7FC9_Out = _uvThreadST; float4 _Subgraph_B567E108_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_958B7FC9_Out, _Property_8AE14795_Out, IN, _Subgraph_B567E108_Output1); float4 _Property_FEDB20A0_Out = _uvBaseMask; float4 _Property_F42AAF3B_Out = _uvBaseST; float4 _Subgraph_9D4E0F1_Output1; sg_SGRuvCombine_SurfaceDescriptionInputs_EDB73AA(_Property_F42AAF3B_Out, _Property_FEDB20A0_Out, IN, _Subgraph_9D4E0F1_Output1); float4 _SampleTexture2D_105B35B3_RGBA = SAMPLE_TEXTURE2D(_NormalMap, sampler_NormalMap, (_Subgraph_9D4E0F1_Output1.xy)); _SampleTexture2D_105B35B3_RGBA.rgb = UnpackNormalmapRGorAG(_SampleTexture2D_105B35B3_RGBA); float _SampleTexture2D_105B35B3_R = _SampleTexture2D_105B35B3_RGBA.r; float _SampleTexture2D_105B35B3_G = _SampleTexture2D_105B35B3_RGBA.g; float _SampleTexture2D_105B35B3_B = _SampleTexture2D_105B35B3_RGBA.b; float _SampleTexture2D_105B35B3_A = _SampleTexture2D_105B35B3_RGBA.a; float _Property_82D183C3_Out = _NormalMapStrength; float3 _NormalStrength_BFF5C35E_Out; Unity_NormalStrength_float((_SampleTexture2D_105B35B3_RGBA.xyz), _Property_82D183C3_Out, _NormalStrength_BFF5C35E_Out); float3 _Normalize_ACA4E10E_Out; Unity_Normalize_float3(_NormalStrength_BFF5C35E_Out, _Normalize_ACA4E10E_Out); float4 _SampleTexture2D_8C3CF01A_RGBA = SAMPLE_TEXTURE2D(_SpecColorMap, sampler_SpecColorMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_8C3CF01A_R = _SampleTexture2D_8C3CF01A_RGBA.r; float _SampleTexture2D_8C3CF01A_G = _SampleTexture2D_8C3CF01A_RGBA.g; float _SampleTexture2D_8C3CF01A_B = _SampleTexture2D_8C3CF01A_RGBA.b; float _SampleTexture2D_8C3CF01A_A = _SampleTexture2D_8C3CF01A_RGBA.a; float _Property_B948927_Out = _SmoothnessMin; float _Property_2962A49E_Out = _SmoothnessMax; float2 _Vector2_9C783D17_Out = float2(_Property_B948927_Out,_Property_2962A49E_Out); float _Remap_10DEF6A_Out; Unity_Remap_float(_SampleTexture2D_8C3CF01A_A, float2 (0,1), _Vector2_9C783D17_Out, _Remap_10DEF6A_Out); float _Split_EB0B739F_R = _Saturate_69BD2FF3_Out[0]; float _Split_EB0B739F_G = _Saturate_69BD2FF3_Out[1]; float _Split_EB0B739F_B = _Saturate_69BD2FF3_Out[2]; float _Split_EB0B739F_A = _Saturate_69BD2FF3_Out[3]; float4 _SampleTexture2D_EECA7933_RGBA = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, (_Subgraph_8DDCEE61_Output1.xy)); float _SampleTexture2D_EECA7933_R = _SampleTexture2D_EECA7933_RGBA.r; float _SampleTexture2D_EECA7933_G = _SampleTexture2D_EECA7933_RGBA.g; float _SampleTexture2D_EECA7933_B = _SampleTexture2D_EECA7933_RGBA.b; float _SampleTexture2D_EECA7933_A = _SampleTexture2D_EECA7933_RGBA.a; float _Property_88B45C0E_Out = _ThreadAOStrength01; float _Property_FC0CC4C0_Out = _ThreadNormalStrength; float _Property_AC495D22_Out = _ThreadSmoothnessScale; float4 _Subgraph_E494B5B1_Output1; float4 _Subgraph_E494B5B1_Output2; float4 _Subgraph_E494B5B1_Output3; float4 _Subgraph_E494B5B1_Output4; sg_SGRThreadMapDetail_SurfaceDescriptionInputs_64D53B52((_Subgraph_B567E108_Output1.xy), TEXTURE2D_PARAM(_ThreadMap, sampler_ThreadMap), _Property_AC495D22_Out, _SampleTexture2D_EECA7933_G, _Property_1E54B66A_Out, _Property_88B45C0E_Out, _Property_FC0CC4C0_Out, _Remap_10DEF6A_Out, _Normalize_ACA4E10E_Out, _Split_EB0B739F_A, IN, _Subgraph_E494B5B1_Output1, _Subgraph_E494B5B1_Output2, _Subgraph_E494B5B1_Output3, _Subgraph_E494B5B1_Output4); float4 _Property_BFE334DC_Out = _SpecularColor; surface.Albedo = (_Saturate_69BD2FF3_Out.xyz); surface.Normal = (_Subgraph_E494B5B1_Output1.xyz); surface.Smoothness = (_Subgraph_E494B5B1_Output2).x; surface.Occlusion = (_Subgraph_E494B5B1_Output3).x; surface.Specular = (_Property_BFE334DC_Out.xyz); surface.DiffusionProfile = 4; surface.SubsurfaceMask = _SampleTexture2D_EECA7933_B; surface.Thickness = _SampleTexture2D_EECA7933_R; surface.Emission = float3(0, 0, 0); surface.Alpha = (_Subgraph_E494B5B1_Output4).x; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- FragInputs BuildFragInputs(VaryingsMeshToPS input) { FragInputs output; ZERO_INITIALIZE(FragInputs, output); // Init to some default value to make the computer quiet (else it output 'divide by zero' warning even if value is not used). // TODO: this is a really poor workaround, but the variable is used in a bunch of places // to compute normals which are then passed on elsewhere to compute other values... output.worldToTangent = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; output.worldToTangent = BuildWorldToTangent(input.tangentWS, input.normalWS); output.texCoord0 = input.texCoord0; output.texCoord1 = input.texCoord1; output.texCoord2 = input.texCoord2; output.texCoord3 = input.texCoord3; output.color = input.color; #if SHADER_STAGE_FRAGMENT #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; output.uv2 = input.texCoord2; output.uv3 = input.texCoord3; return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void ApplyDecalToSurfaceData(DecalSurfaceData decalSurfaceData, inout SurfaceData surfaceData) { // using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_DIFFUSE) { surfaceData.baseColor.xyz = surfaceData.baseColor.xyz * decalSurfaceData.baseColor.w + decalSurfaceData.baseColor.xyz; } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_NORMAL) { surfaceData.normalWS.xyz = normalize(surfaceData.normalWS.xyz * decalSurfaceData.normalWS.w + decalSurfaceData.normalWS.xyz); } if (decalSurfaceData.HTileMask & DBUFFERHTILEBIT_MASK) { #ifdef DECALS_4RT // only smoothness in 3RT mode // Don't apply any metallic modification surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.MAOSBlend.y + decalSurfaceData.mask.y; #endif surfaceData.perceptualSmoothness = surfaceData.perceptualSmoothness * decalSurfaceData.mask.w + decalSurfaceData.mask.z; } } void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, out SurfaceData surfaceData) { // setup defaults -- these are used if the graph doesn't output a value ZERO_INITIALIZE(SurfaceData, surfaceData); // copy across graph values, if defined surfaceData.baseColor = surfaceDescription.Albedo; surfaceData.perceptualSmoothness = surfaceDescription.Smoothness; surfaceData.ambientOcclusion = surfaceDescription.Occlusion; surfaceData.specularColor = surfaceDescription.Specular; surfaceData.diffusionProfile = surfaceDescription.DiffusionProfile; surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask; surfaceData.thickness = surfaceDescription.Thickness; surfaceData.diffusionProfile = surfaceDescription.DiffusionProfile; // These static material feature allow compile time optimization surfaceData.materialFeatures = 0; // Transform the preprocess macro into a material feature (note that silk flag is deduced from the abscence of this one) #ifdef _MATERIAL_FEATURE_COTTON_WOOL surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_COTTON_WOOL; #endif #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_FABRIC_TRANSMISSION; #endif #if defined (_ENERGY_CONSERVING_SPECULAR) // Require to have setup baseColor // Reproduce the energy conservation done in legacy Unity. Not ideal but better for compatibility and users can unchek it surfaceData.baseColor *= (1.0 - Max3(surfaceData.specularColor.r, surfaceData.specularColor.g, surfaceData.specularColor.b)); #endif // tangent-space normal float3 normalTS = float3(0.0f, 0.0f, 1.0f); normalTS = surfaceDescription.Normal; // compute world space normal GetNormalWS(fragInputs, normalTS, surfaceData.normalWS); surfaceData.geomNormalWS = fragInputs.worldToTangent[2]; surfaceData.tangentWS = normalize(fragInputs.worldToTangent[0].xyz); // The tangent is not normalize in worldToTangent for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS); // By default we use the ambient occlusion with Tri-ace trick (apply outside) for specular occlusion. // If user provide bent normal then we process a better term surfaceData.specularOcclusion = 1.0; #if defined(_SPECULAR_OCCLUSION_CUSTOM) // Just use the value passed through via the slot (not active otherwise) #elif defined(_SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL) // If we have bent normal and ambient occlusion, process a specular occlusion surfaceData.specularOcclusion = GetSpecularOcclusionFromBentAO(V, bentNormalWS, surfaceData.normalWS, surfaceData.ambientOcclusion, PerceptualSmoothnessToPerceptualRoughness(surfaceData.perceptualSmoothness)); #elif defined(_AMBIENT_OCCLUSION) && defined(_SPECULAR_OCCLUSION_FROM_AO) surfaceData.specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(dot(surfaceData.normalWS, V)), surfaceData.ambientOcclusion, PerceptualSmoothnessToRoughness(surfaceData.perceptualSmoothness)); #else surfaceData.specularOcclusion = 1.0; surfaceData.specularOcclusion = 1.0; #endif #ifdef DEBUG_DISPLAY // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.worldToTangent, surfaceData); #endif } void GetSurfaceAndBuiltinData(FragInputs fragInputs, float3 V, inout PositionInputs posInput, out SurfaceData surfaceData, out BuiltinData builtinData) { #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group uint3 fadeMaskSeed = asuint((int3)(V * _ScreenSize.xyx)); // Quantize V to _ScreenSize values LODDitheringTransition(fadeMaskSeed, unity_LODFade.x); #endif // this applies the double sided tangent space correction -- see 'ApplyDoubleSidedFlipOrMirror()' SurfaceDescriptionInputs surfaceDescriptionInputs = FragInputsToSurfaceDescriptionInputs(fragInputs, V); SurfaceDescription surfaceDescription = SurfaceDescriptionFunction(surfaceDescriptionInputs); // Perform alpha test very early to save performance (a killed pixel will not sample textures) // TODO: split graph evaluation to grab just alpha dependencies first? tricky.. BuildSurfaceData(fragInputs, surfaceDescription, V, surfaceData); #if HAVE_DECALS && _DECALS DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); #endif // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(surfaceDescription.Alpha, surfaceData.normalWS, -fragInputs.worldToTangent[2], fragInputs.positionRWS, fragInputs.texCoord1, fragInputs.texCoord2, builtinData); builtinData.emissiveColor = surfaceDescription.Emission; builtinData.depthOffset = 0.0; // ApplyPerPixelDisplacement(input, V, layerTexCoord, blendMasks); #ifdef _DEPTHOFFSET_ON : ApplyDepthOffsetPositionInput(V, depthOffset, GetWorldToHClipMatrix(), posInput); PostInitBuiltinData(V, posInput, surfaceData, builtinData); } //------------------------------------------------------------------------------------- // Pass Includes //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPassForward.hlsl" //------------------------------------------------------------------------------------- // End Pass Includes //------------------------------------------------------------------------------------- ENDHLSL } } FallBack "Hidden/InternalErrorShader" }