/* NOTES - shadows do not dither out because leaves and bark do not dither in... - fixed writing to normal and tangent in shadows and meta, ... anything else? - disable batching added */ Shader "CTI HDRP 10/CTI HSLS Billboard HDRP 10" { Properties { _HueVariation("Color Variation (RGB) Strength (A)", Color) = (0.9, 0.5, 0, 0.1019608) [MainTexture][NoScaleOffset]_MainTex("Albedo (RGB) Alpha (A)", 2D) = "white" {} _Cutoff("Alpha Cutoff", Range(0, 1)) = 0.5 [NoScaleOffset]_BumpTex("Normal (AG) Translucency(R) Smoothness(B)", 2D) = "white" {} _NormalScale("Normal Scale", Float) = 1 _Smoothness ("Smoothness", Range(0, 1)) = 1 _WindStrength("Wind Strength", Float) = 1 _WindPower("Wind Power", Float) = 1.5 _ThicknessRemap("Thickness Remap", Float) = 1 [HideInInspector]_EmissionColor("Color", Color) = (1, 1, 1, 1) [HideInInspector]_RenderQueueType("Vector1", Float) = 1 [HideInInspector]_StencilRef("Vector1", Int) = 0 [HideInInspector]_StencilWriteMask("Vector1", Int) = 3 [HideInInspector]_StencilRefDepth("Vector1", Int) = 0 [HideInInspector]_StencilWriteMaskDepth("Vector1", Int) = 32 [HideInInspector]_StencilRefMV("Vector1", Int) = 128 [HideInInspector]_StencilWriteMaskMV("Vector1", Int) = 128 [HideInInspector]_StencilRefDistortionVec("Vector1", Int) = 64 [HideInInspector]_StencilWriteMaskDistortionVec("Vector1", Int) = 64 [HideInInspector]_StencilWriteMaskGBuffer("Vector1", Int) = 3 [HideInInspector]_StencilRefGBuffer("Vector1", Int) = 2 [HideInInspector]_ZTestGBuffer("Vector1", Int) = 4 [HideInInspector][ToggleUI]_RequireSplitLighting("Boolean", Float) = 0 [HideInInspector][ToggleUI]_ReceivesSSR("Boolean", Float) = 1 [HideInInspector]_SurfaceType("Vector1", Float) = 0 [HideInInspector]_BlendMode("Vector1", Float) = 0 [HideInInspector]_SrcBlend("Vector1", Float) = 1 [HideInInspector]_DstBlend(" Vector1", Float) = 0 [HideInInspector]_AlphaSrcBlend("Vector1", Float) = 1 [HideInInspector]_AlphaDstBlend("Vector1", Float) = 0 [HideInInspector][ToggleUI]_ZWrite("Boolean", Float) = 0 [HideInInspector]_CullMode("Vector1", Float) = 2 [HideInInspector]_TransparentSortPriority("Vector1", Int) = 0 [HideInInspector]_CullModeForward("Vector1", Float) = 2 [HideInInspector][Enum(Front, 1, Back, 2)]_TransparentCullMode("Vector1", Float) = 2 [HideInInspector]_ZTestDepthEqualForOpaque("Vector1", Int) = 4 [HideInInspector][Enum(UnityEngine.Rendering.CompareFunction)]_ZTestTransparent("Vector1", Float) = 4 [HideInInspector][ToggleUI]_TransparentBackfaceEnable("Boolean", Float) = 0 [HideInInspector][ToggleUI]_AlphaCutoffEnable("Boolean", Float) = 1 [HideInInspector][ToggleUI]_UseShadowThreshold("Boolean", Float) = 0 [HideInInspector][ToggleUI]_DoubleSidedEnable("Boolean", Float) = 1 [HideInInspector][Enum(Flip, 0, Mirror, 1, None, 2)]_DoubleSidedNormalMode("Vector1", Float) = 2 [HideInInspector]_DoubleSidedConstants("Vector4", Vector) = (1, 1, -1, 0) [HideInInspector]_DiffusionProfileHash("Vector1", Float) = 0 [HideInInspector]_DiffusionProfileAsset("Vector4", Vector) = (0, 0, 0, 0) } SubShader { Tags { "RenderPipeline"="HDRenderPipeline" "RenderType"="HDLitShader" "Queue" = "AlphaTest+0" "DisableBatching"="LODFading" } Pass { // based on HDLitPass.template Name "ShadowCaster" Tags { "LightMode" = "ShadowCaster" } // "DisableBatching"="True"} // Does not help //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Cull [_CullMode] ZWrite On ZClip [_ZClip] ColorMask 0 //------------------------------------------------------------------------------------- // End Render Modes //------------------------------------------------------------------------------------- HLSLPROGRAM #pragma target 4.5 #pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch #pragma multi_compile_instancing #pragma instancing_options renderinglayer #pragma multi_compile _ LOD_FADE_CROSSFADE // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT #pragma shader_feature_local _DOUBLESIDED_ON // #pragma shader_feature_local _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- // #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1 // #define _MATERIAL_FEATURE_TRANSMISSION 1 // #define _MATERIAL_FEATURE_ANISOTROPY 1 // #define _MATERIAL_FEATURE_IRIDESCENCE 1 // #define _MATERIAL_FEATURE_SPECULAR_COLOR 1 // #define _ENABLE_FOG_ON_TRANSPARENT 1 // #define _AMBIENT_OCCLUSION 1 // #define _SPECULAR_OCCLUSION_FROM_AO 1 // #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1 // #define _SPECULAR_OCCLUSION_CUSTOM 1 #define _ENERGY_CONSERVING_SPECULAR 1 // #define _ENABLE_GEOMETRIC_SPECULAR_AA 1 // #define _HAS_REFRACTION 1 // #define _REFRACTION_PLANE 1 // #define _REFRACTION_SPHERE 1 #define _DISABLE_DECALS 1 #define _DISABLE_SSR 1 // #define _ADD_PRECOMPUTED_VELOCITY // #define _WRITE_TRANSPARENT_MOTION_VECTOR 1 // #define _DEPTHOFFSET_ON 1 // #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #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" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl" // Need to be here for Gradient struct definition //------------------------------------------------------------------------------------- // Defines //------------------------------------------------------------------------------------- // Attribute // #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 #define VARYINGS_NEED_CULLFACE #define HAVE_MESH_MODIFICATION #define SHADERPASS SHADERPASS_SHADOWS #ifdef RAYTRACING_SHADER_GRAPH_DEFAULT #define RAYTRACING_SHADER_GRAPH_HIGH #endif #ifdef RAYTRACING_SHADER_GRAPH_RAYTRACED #define RAYTRACING_SHADER_GRAPH_LOW #endif // 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 // We need isFontFace when using double sided #if defined(_DOUBLESIDED_ON) && !defined(VARYINGS_NEED_CULLFACE) #define VARYINGS_NEED_CULLFACE #endif //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _HueVariation; float _Smoothness; float _Cutoff; float _NormalScale; float _WindStrength; float _WindPower; float _ThicknessRemap; float4 _EmissionColor; float _RenderQueueType; float _StencilRef; float _StencilWriteMask; float _StencilRefDepth; float _StencilWriteMaskDepth; float _StencilRefMV; float _StencilWriteMaskMV; float _StencilRefDistortionVec; float _StencilWriteMaskDistortionVec; float _StencilWriteMaskGBuffer; float _StencilRefGBuffer; float _ZTestGBuffer; float _RequireSplitLighting; float _ReceivesSSR; float _SurfaceType; float _BlendMode; float _SrcBlend; float _DstBlend; float _AlphaSrcBlend; float _AlphaDstBlend; float _ZWrite; float _CullMode; float _TransparentSortPriority; float _CullModeForward; float _TransparentCullMode; float _ZTestDepthEqualForOpaque; float _ZTestTransparent; float _TransparentBackfaceEnable; float _AlphaCutoffEnable; float _UseShadowThreshold; float _DoubleSidedEnable; float _DoubleSidedNormalMode; float4 _DoubleSidedConstants; float _DiffusionProfileHash; float4 _DiffusionProfileAsset; CBUFFER_END TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex); float4 _MainTex_TexelSize; TEXTURE2D(_BumpTex); SAMPLER(sampler_BumpTex); float4 _BumpTex_TexelSize; SAMPLER(_SampleTexture2D_1F3A9BAF_Sampler_3_Linear_Repeat); // -- Property used by ScenePickingPass #ifdef SCENEPICKINGPASS float4 _SelectionID; #endif // -- Properties used by SceneSelectionPass #ifdef SCENESELECTIONPASS int _ObjectId; int _PassValue; #endif // Includes #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl" #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" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" //------------------------------------------------------------------------------------- // Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- // Generated Type: AttributesMesh struct AttributesMesh { float3 positionOS : POSITION; float4 uv0 : TEXCOORD0; // optional float4 uv1 : TEXCOORD1; // optional #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : INSTANCEID_SEMANTIC; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: VaryingsMeshToPS struct VaryingsMeshToPS { float4 positionCS : SV_Position; float3 positionRWS; // optional float4 texCoord0; // optional float4 texCoord1; // optional #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; #endif // defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) }; // Generated Type: PackedVaryingsMeshToPS struct PackedVaryingsMeshToPS { float4 positionCS : SV_Position; // unpacked #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float4 interp01 : TEXCOORD1; // auto-packed float4 interp02 : TEXCOORD2; // auto-packed #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; // unpacked #endif // conditional }; // Packed Type: VaryingsMeshToPS PackedVaryingsMeshToPS PackVaryingsMeshToPS(VaryingsMeshToPS input) { PackedVaryingsMeshToPS output; output.positionCS = input.positionCS; output.interp00.xyz = input.positionRWS; output.interp01.xyzw = input.texCoord0; output.interp02.xyzw = input.texCoord1; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToPS VaryingsMeshToPS UnpackVaryingsMeshToPS(PackedVaryingsMeshToPS input) { VaryingsMeshToPS output; output.positionCS = input.positionCS; output.positionRWS = input.interp00.xyz; output.texCoord0 = input.interp01.xyzw; output.texCoord1 = input.interp02.xyzw; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: PackedVaryingsMeshToDS struct PackedVaryingsMeshToDS { #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed }; // Packed Type: VaryingsMeshToDS PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToDS VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Vertex Graph Inputs struct VertexDescriptionInputs { float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Vertex Graph Outputs struct VertexDescription { float3 VertexPosition; float3 VertexNormal; float3 VertexTangent; float4 VertexUV; }; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float3 TangentSpaceNormal; // optional float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float Alpha; float AlphaClipThreshold; }; // Shared Graph Node Functions #include "Includes/CTI_HDRP_10_BillboardVertex.hlsl" // Vertex Graph Evaluation VertexDescription VertexDescriptionFunction(VertexDescriptionInputs IN) { VertexDescription description = (VertexDescription)0; float3 positionOut; float3 normalOut; float3 tangentOut; float2 uvOut; float colorVariation; CTIBillboard_float(IN.ObjectSpacePosition, IN.uv0.xy, IN.uv1.xyz, _WindStrength, _WindPower, positionOut, normalOut, tangentOut, uvOut, colorVariation); description.VertexPosition = positionOut; description.VertexNormal = normalOut; description.VertexTangent = tangentOut; description.VertexUV.xy = uvOut; return description; } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; surface.Alpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv0.xy).a; surface.AlphaClipThreshold = _Cutoff; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- VertexDescriptionInputs AttributesMeshToVertexDescriptionInputs(AttributesMesh input) { VertexDescriptionInputs output; ZERO_INITIALIZE(VertexDescriptionInputs, output); // output.ObjectSpaceNormal = input.normalOS; // output.WorldSpaceNormal = TransformObjectToWorldNormal(input.normalOS); // output.ViewSpaceNormal = TransformWorldToViewDir(output.WorldSpaceNormal); // output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.ObjectSpaceTangent = input.tangentOS; // output.WorldSpaceTangent = TransformObjectToWorldDir(input.tangentOS.xyz); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.ObjectSpaceBiTangent = normalize(cross(input.normalOS, input.tangentOS) * (input.tangentOS.w > 0.0f ? 1.0f : -1.0f) * GetOddNegativeScale()); // output.WorldSpaceBiTangent = TransformObjectToWorldDir(output.ObjectSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); output.ObjectSpacePosition = input.positionOS; // output.WorldSpacePosition = TransformObjectToWorld(input.positionOS); // output.ViewSpacePosition = TransformWorldToView(output.WorldSpacePosition); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(TransformObjectToWorld(input.positionOS)); // output.WorldSpaceViewDirection = GetWorldSpaceNormalizeViewDir(output.WorldSpacePosition); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(output.WorldSpacePosition), _ProjectionParams.x); output.uv0 = input.uv0; output.uv1 = input.uv1; // output.uv2 = input.uv2; // output.uv3 = input.uv3; // output.VertexColor = input.color; return output; } AttributesMesh ApplyMeshModification(AttributesMesh input, float3 timeParameters) { // build graph inputs VertexDescriptionInputs vertexDescriptionInputs = AttributesMeshToVertexDescriptionInputs(input); // Override time paramters with used one (This is required to correctly handle motion vector for vertex animation based on time) // vertexDescriptionInputs.TimeParameters = timeParameters; // evaluate vertex graph VertexDescription vertexDescription = VertexDescriptionFunction(vertexDescriptionInputs); // copy graph output to the results input.positionOS = vertexDescription.VertexPosition.xyz; // input.normalOS = vertexDescription.VertexNormal; // input.tangentOS.xyz = vertexDescription.VertexTangent; input.uv0.xy = vertexDescription.VertexUV.xy; return input; } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // 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.tangentToWorld = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; // output.tangentToWorld = BuildTangentToWorld(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 _DOUBLESIDED_ON && SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #elif SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); // output.WorldSpaceNormal = normalize(input.tangentToWorld[2].xyz); // output.ObjectSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_M); // transposed multiplication by inverse matrix to handle normal scale // output.ViewSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V); // transposed multiplication by inverse matrix to handle normal scale output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.WorldSpaceTangent = input.tangentToWorld[0].xyz; // output.ObjectSpaceTangent = TransformWorldToObjectDir(output.WorldSpaceTangent); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.WorldSpaceBiTangent = input.tangentToWorld[1].xyz; // output.ObjectSpaceBiTangent = TransformWorldToObjectDir(output.WorldSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); // output.WorldSpaceViewDirection = normalize(viewWS); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.WorldSpacePosition = input.positionRWS; output.ObjectSpacePosition = TransformWorldToObject(input.positionRWS); // output.ViewSpacePosition = TransformWorldToView(input.positionRWS); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(input.positionRWS); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(input.positionRWS), _ProjectionParams.x); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; // output.uv2 = input.texCoord2; // output.uv3 = input.texCoord3; // output.VertexColor = input.color; // output.FaceSign = input.isFrontFace; // output.TimeParameters = _TimeParameters.xyz; // This is mainly for LW as HD overwrite this value return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { UNITY_SETUP_INSTANCE_ID(input); VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS) { // 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.specularOcclusion = surfaceDescription.SpecularOcclusion; // surfaceData.metallic = surfaceDescription.Metallic; // surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask; // surfaceData.thickness = surfaceDescription.Thickness; // surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash); // surfaceData.specularColor = surfaceDescription.Specular; // surfaceData.coatMask = surfaceDescription.CoatMask; // surfaceData.anisotropy = surfaceDescription.Anisotropy; // surfaceData.iridescenceMask = surfaceDescription.IridescenceMask; // surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness; #ifdef _HAS_REFRACTION if (_EnableSSRefraction) { // surfaceData.ior = surfaceDescription.RefractionIndex; // surfaceData.transmittanceColor = surfaceDescription.RefractionColor; // surfaceData.atDistance = surfaceDescription.RefractionDistance; surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha); surfaceDescription.Alpha = 1.0; } else { surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; surfaceDescription.Alpha = 1.0; } #else surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; #endif // These static material feature allow compile time optimization surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD; #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION; #endif #ifdef _MATERIAL_FEATURE_ANISOTROPY surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY; #endif // surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT; #ifdef _MATERIAL_FEATURE_IRIDESCENCE surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE; #endif #ifdef _MATERIAL_FEATURE_SPECULAR_COLOR surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR; #endif #if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && 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 #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #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, doubleSidedConstants); bentNormalWS = surfaceData.normalWS; // GetNormalWS(fragInputs, surfaceDescription.BentNormal, bentNormalWS, doubleSidedConstants); surfaceData.geomNormalWS = fragInputs.tangentToWorld[2]; surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT // surfaceData.tangentWS = TransformTangentToWorld(surfaceDescription.Tangent, fragInputs.tangentToWorld); 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 #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; #endif #if HAVE_DECALS if (_EnableDecals) { DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); } #endif #ifdef _ENABLE_GEOMETRIC_SPECULAR_AA surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold); #endif #ifdef DEBUG_DISPLAY if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE) { // TODO: need to update mip info surfaceData.metallic = 0; } // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.tangentToWorld, 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 LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x); #endif // Old custom LOD dithering used with HDRP < 10 #ifdef LOD_FADE_CROSSFADECUSTOM // LOD dithering transition helper // LOD0 must use this function with ditherFactor 1..0 // LOD1 must use this function with ditherFactor -1..0 // This is what is provided by unity_LODFade float4 clipPos = fragInputs.positionSS; float2 screenPos = floor( clipPos.xy / clipPos.z * _ScreenParams.xy); // Interleaved Gradient Noise from http://www.iryoku.com/next-generation-post-processing-in-call-of-duty-advanced-warfare (slide 122) const float3 magic = float3(0.06711056f, 0.00583715f, 52.9829189f); const float2 frameMagicScale = float2(2.083f, 4.867f); //pixCoord += frameCount * frameMagicScale; float gradient = frac(magic.z * frac(dot(screenPos.xy, magic.xy))); float start = (unity_LODFade.x < 0) ? 1 : 0; // billboard to mesh: start = 1 // clip( start + (unity_LODFade.x) - gradient); // Lets use the provided function but use positionSS uint3 fadeMaskSeed = asuint((int3)(fragInputs.positionSS.xyz * _ScreenSize.xyx)); // Quantize V to _ScreenSize values LODDitheringTransition(fadeMaskSeed, unity_LODFade.x ); #endif #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #endif ApplyDoubleSidedFlipOrMirror(fragInputs, doubleSidedConstants); 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.. DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThreshold); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPrepass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPostpass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdShadow); // ApplyDepthOffsetPositionInput(V, surfaceDescription.DepthOffset, GetViewForwardDir(), GetWorldToHClipMatrix(), posInput); float3 bentNormalWS; BuildSurfaceData(fragInputs, surfaceDescription, V, posInput, surfaceData, bentNormalWS); // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(posInput, surfaceDescription.Alpha, bentNormalWS, -fragInputs.tangentToWorld[2], fragInputs.texCoord1, fragInputs.texCoord2, builtinData); // override sampleBakedGI: // builtinData.bakeDiffuseLighting = surfaceDescription.BakedGI; // builtinData.backBakeDiffuseLighting = surfaceDescription.BakedBackGI; // builtinData.emissiveColor = surfaceDescription.Emission; // builtinData.depthOffset = surfaceDescription.DepthOffset; #if (SHADERPASS == SHADERPASS_DISTORTION) builtinData.distortion = surfaceDescription.Distortion; builtinData.distortionBlur = surfaceDescription.DistortionBlur; #else builtinData.distortion = float2(0.0, 0.0); builtinData.distortionBlur = 0.0; #endif 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 HDLitPass.template Name "META" Tags { "LightMode" = "META" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Cull Off //------------------------------------------------------------------------------------- // 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 // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT #pragma shader_feature_local _DOUBLESIDED_ON // #pragma shader_feature_local _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- // #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1 #define _MATERIAL_FEATURE_TRANSMISSION 1 // #define _MATERIAL_FEATURE_ANISOTROPY 1 // #define _MATERIAL_FEATURE_IRIDESCENCE 1 // #define _MATERIAL_FEATURE_SPECULAR_COLOR 1 // #define _ENABLE_FOG_ON_TRANSPARENT 1 // #define _AMBIENT_OCCLUSION 1 // #define _SPECULAR_OCCLUSION_FROM_AO 1 // #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1 // #define _SPECULAR_OCCLUSION_CUSTOM 1 #define _ENERGY_CONSERVING_SPECULAR 1 // #define _ENABLE_GEOMETRIC_SPECULAR_AA 1 // #define _HAS_REFRACTION 1 // #define _REFRACTION_PLANE 1 // #define _REFRACTION_SPHERE 1 #define _DISABLE_DECALS 1 #define _DISABLE_SSR 1 // #define _ADD_PRECOMPUTED_VELOCITY // #define _WRITE_TRANSPARENT_MOTION_VECTOR 1 // #define _DEPTHOFFSET_ON 1 // #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag // 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/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 #define RAYTRACING_SHADER_GRAPH_HIGH // ACTIVE FIELDS: // DoubleSided // FragInputs.isFrontFace // Material.Translucent // Material.Transmission // AlphaTest // Specular.EnergyConserving // SurfaceDescriptionInputs.TangentSpaceNormal // SurfaceDescriptionInputs.ObjectSpacePosition // SurfaceDescriptionInputs.uv0 // SurfaceDescriptionInputs.uv1 // SurfaceDescription.Albedo // SurfaceDescription.Normal // SurfaceDescription.BentNormal // SurfaceDescription.Thickness // SurfaceDescription.DiffusionProfileHash // SurfaceDescription.CoatMask // SurfaceDescription.Emission // SurfaceDescription.Smoothness // SurfaceDescription.Occlusion // SurfaceDescription.Alpha // SurfaceDescription.AlphaClipThreshold // features.modifyMesh // AttributesMesh.normalOS // AttributesMesh.tangentOS // AttributesMesh.uv0 // AttributesMesh.uv1 // AttributesMesh.color // AttributesMesh.uv2 // VaryingsMeshToPS.cullFace // FragInputs.positionRWS // FragInputs.texCoord0 // FragInputs.texCoord1 // VaryingsMeshToPS.positionRWS // VaryingsMeshToPS.texCoord0 // VaryingsMeshToPS.texCoord1 // AttributesMesh.positionOS // Shared Graph Keywords // 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 #define VARYINGS_NEED_CULLFACE #define HAVE_MESH_MODIFICATION // We need isFontFace when using double sided #if defined(_DOUBLESIDED_ON) && !defined(VARYINGS_NEED_CULLFACE) #define VARYINGS_NEED_CULLFACE #endif //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #if (SHADERPASS == SHADERPASS_FORWARD) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #define HAS_LIGHTLOOP #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoopDef.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.hlsl" #else #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.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" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" // Used by SceneSelectionPass int _ObjectId; int _PassValue; //------------------------------------------------------------------------------------- // 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 color : COLOR; // optional #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : INSTANCEID_SEMANTIC; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: VaryingsMeshToPS struct VaryingsMeshToPS { float4 positionCS : SV_Position; float3 positionRWS; // optional float4 texCoord0; // optional float4 texCoord1; // optional #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; #endif // defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) }; // Generated Type: PackedVaryingsMeshToPS struct PackedVaryingsMeshToPS { float4 positionCS : SV_Position; // unpacked #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float4 interp01 : TEXCOORD1; // auto-packed float4 interp02 : TEXCOORD2; // auto-packed #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; // unpacked #endif // conditional }; // Packed Type: VaryingsMeshToPS PackedVaryingsMeshToPS PackVaryingsMeshToPS(VaryingsMeshToPS input) { PackedVaryingsMeshToPS output; output.positionCS = input.positionCS; output.interp00.xyz = input.positionRWS; output.interp01.xyzw = input.texCoord0; output.interp02.xyzw = input.texCoord1; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToPS VaryingsMeshToPS UnpackVaryingsMeshToPS(PackedVaryingsMeshToPS input) { VaryingsMeshToPS output; output.positionCS = input.positionCS; output.positionRWS = input.interp00.xyz; output.texCoord0 = input.interp01.xyzw; output.texCoord1 = input.interp02.xyzw; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: PackedVaryingsMeshToDS struct PackedVaryingsMeshToDS { #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed }; // Packed Type: VaryingsMeshToDS PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToDS VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _HueVariation; float _Smoothness; float _Cutoff; float _NormalScale; float _WindStrength; float _WindPower; float _ThicknessRemap; float4 _EmissionColor; float _RenderQueueType; float _StencilRef; float _StencilWriteMask; float _StencilRefDepth; float _StencilWriteMaskDepth; float _StencilRefMV; float _StencilWriteMaskMV; float _StencilRefDistortionVec; float _StencilWriteMaskDistortionVec; float _StencilWriteMaskGBuffer; float _StencilRefGBuffer; float _ZTestGBuffer; float _RequireSplitLighting; float _ReceivesSSR; float _SurfaceType; float _BlendMode; float _SrcBlend; float _DstBlend; float _AlphaSrcBlend; float _AlphaDstBlend; float _ZWrite; float _CullMode; float _TransparentSortPriority; float _CullModeForward; float _TransparentCullMode; float _ZTestDepthEqualForOpaque; float _ZTestTransparent; float _TransparentBackfaceEnable; float _AlphaCutoffEnable; float _UseShadowThreshold; float _DoubleSidedEnable; float _DoubleSidedNormalMode; float4 _DoubleSidedConstants; float _DiffusionProfileHash; float4 _DiffusionProfileAsset; CBUFFER_END TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex); float4 _MainTex_TexelSize; TEXTURE2D(_BumpTex); SAMPLER(sampler_BumpTex); float4 _BumpTex_TexelSize; SAMPLER(_SampleTexture2D_1F3A9BAF_Sampler_3_Linear_Repeat); SAMPLER(_SampleTexture2D_8F5727BE_Sampler_3_Linear_Repeat); // Vertex Graph Inputs struct VertexDescriptionInputs { }; // Vertex Graph Outputs struct VertexDescription { }; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float3 TangentSpaceNormal; // optional float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float3 Albedo; float3 Normal; float3 BentNormal; float Thickness; float DiffusionProfileHash; float CoatMask; float3 Emission; float Smoothness; float Occlusion; float Alpha; float AlphaClipThreshold; }; // Shared Graph Node Functions // 0bd5fad30b6e3175bb269301281cdc86 #include "Includes/CTI_HDRP_10_BillboardVertex.hlsl" void UnpackNormal_float(float4 packedNormal, float scale, out float3 Normal) { Normal.xy = packedNormal.ag * 2 -1; Normal.xy *= scale; //Normal.xy *= -1; // Why this?! Normal.z = sqrt( 1.0f - saturate( dot(Normal.xy, Normal.xy) ) ); } void Unity_OneMinus_float(float In, out float Out) { Out = 1 - In; } // Vertex Graph Evaluation VertexDescription VertexDescriptionFunction(VertexDescriptionInputs IN) { VertexDescription description = (VertexDescription)0; return description; } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float4 _UV_C5101A3_Out_0 = IN.uv0; float4 _UV_F5B876C_Out_0 = IN.uv1; float _Property_B7EA4ECB_Out_0 = _WindStrength; float _Property_AE2D9193_Out_0 = _WindPower; float3 positionOut; float3 normalOut; float3 tangentOut; float2 uvOut; float colorVariation; CTIBillboard_float(IN.ObjectSpacePosition, IN.uv0.xy, IN.uv1.xyz, _WindStrength, _WindPower, positionOut, normalOut, tangentOut, uvOut, colorVariation); float4 _SampleTexture2D_1F3A9BAF_RGBA_0 = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv0.xy); float _SampleTexture2D_1F3A9BAF_R_4 = _SampleTexture2D_1F3A9BAF_RGBA_0.r; float _SampleTexture2D_1F3A9BAF_G_5 = _SampleTexture2D_1F3A9BAF_RGBA_0.g; float _SampleTexture2D_1F3A9BAF_B_6 = _SampleTexture2D_1F3A9BAF_RGBA_0.b; float _SampleTexture2D_1F3A9BAF_A_7 = _SampleTexture2D_1F3A9BAF_RGBA_0.a; float4 _SampleTexture2D_8F5727BE_RGBA_0 = SAMPLE_TEXTURE2D(_BumpTex, sampler_BumpTex, uvOut); float _SampleTexture2D_8F5727BE_R_4 = _SampleTexture2D_8F5727BE_RGBA_0.r; float _SampleTexture2D_8F5727BE_G_5 = _SampleTexture2D_8F5727BE_RGBA_0.g; float _SampleTexture2D_8F5727BE_B_6 = _SampleTexture2D_8F5727BE_RGBA_0.b; float _SampleTexture2D_8F5727BE_A_7 = _SampleTexture2D_8F5727BE_RGBA_0.a; float _Property_F17FAA9B_Out_0 = _NormalScale; float3 _CustomFunction_67BD137E_Normal_1; UnpackNormal_float(_SampleTexture2D_8F5727BE_RGBA_0, _Property_F17FAA9B_Out_0, _CustomFunction_67BD137E_Normal_1); float _OneMinus_13657006_Out_1; Unity_OneMinus_float(_SampleTexture2D_8F5727BE_R_4, _OneMinus_13657006_Out_1); float _Property_C43CA9EC_Out_0 = _Cutoff; surface.Albedo = (_SampleTexture2D_1F3A9BAF_RGBA_0.xyz); surface.Normal = _CustomFunction_67BD137E_Normal_1; surface.BentNormal = IN.TangentSpaceNormal; surface.Thickness = _OneMinus_13657006_Out_1; surface.DiffusionProfileHash = ((asuint(_DiffusionProfileHash) != 0) ? _DiffusionProfileHash : asfloat(uint(1080305144))); surface.CoatMask = 0; surface.Emission = float3(0, 0, 0); surface.Smoothness = _SampleTexture2D_8F5727BE_B_6; surface.Occlusion = 1; surface.Alpha = _SampleTexture2D_1F3A9BAF_A_7; surface.AlphaClipThreshold = _Property_C43CA9EC_Out_0; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- VertexDescriptionInputs AttributesMeshToVertexDescriptionInputs(AttributesMesh input) { VertexDescriptionInputs output; ZERO_INITIALIZE(VertexDescriptionInputs, output); // output.ObjectSpaceNormal = input.normalOS; // output.WorldSpaceNormal = TransformObjectToWorldNormal(input.normalOS); // output.ViewSpaceNormal = TransformWorldToViewDir(output.WorldSpaceNormal); // output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.ObjectSpaceTangent = input.tangentOS; // output.WorldSpaceTangent = TransformObjectToWorldDir(input.tangentOS.xyz); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.ObjectSpaceBiTangent = normalize(cross(input.normalOS, input.tangentOS) * (input.tangentOS.w > 0.0f ? 1.0f : -1.0f) * GetOddNegativeScale()); // output.WorldSpaceBiTangent = TransformObjectToWorldDir(output.ObjectSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); // output.ObjectSpacePosition = input.positionOS; // output.WorldSpacePosition = TransformObjectToWorld(input.positionOS); // output.ViewSpacePosition = TransformWorldToView(output.WorldSpacePosition); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(TransformObjectToWorld(input.positionOS)); // output.WorldSpaceViewDirection = GetWorldSpaceNormalizeViewDir(output.WorldSpacePosition); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(output.WorldSpacePosition), _ProjectionParams.x); // output.uv0 = input.uv0; // output.uv1 = input.uv1; // output.uv2 = input.uv2; // output.uv3 = input.uv3; // output.VertexColor = input.color; return output; } AttributesMesh ApplyMeshModification(AttributesMesh input, float3 timeParameters) { // build graph inputs VertexDescriptionInputs vertexDescriptionInputs = AttributesMeshToVertexDescriptionInputs(input); // Override time paramters with used one (This is required to correctly handle motion vector for vertex animation based on time) // vertexDescriptionInputs.TimeParameters = timeParameters; // evaluate vertex graph VertexDescription vertexDescription = VertexDescriptionFunction(vertexDescriptionInputs); // copy graph output to the results // input.positionOS = vertexDescription.VertexPosition; // input.normalOS = vertexDescription.VertexNormal; // input.tangentOS.xyz = vertexDescription.VertexTangent; //input.uv0.xy = vertexDescription.VertexUV; return input; } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // 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.tangentToWorld = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; // output.tangentToWorld = BuildTangentToWorld(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 _DOUBLESIDED_ON && SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #elif SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); // output.WorldSpaceNormal = normalize(input.tangentToWorld[2].xyz); // output.ObjectSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_M); // transposed multiplication by inverse matrix to handle normal scale // output.ViewSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V); // transposed multiplication by inverse matrix to handle normal scale output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.WorldSpaceTangent = input.tangentToWorld[0].xyz; // output.ObjectSpaceTangent = TransformWorldToObjectDir(output.WorldSpaceTangent); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.WorldSpaceBiTangent = input.tangentToWorld[1].xyz; // output.ObjectSpaceBiTangent = TransformWorldToObjectDir(output.WorldSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); // output.WorldSpaceViewDirection = normalize(viewWS); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.WorldSpacePosition = input.positionRWS; output.ObjectSpacePosition = TransformWorldToObject(input.positionRWS); // output.ViewSpacePosition = TransformWorldToView(input.positionRWS); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(input.positionRWS); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(input.positionRWS), _ProjectionParams.x); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; // output.uv2 = input.texCoord2; // output.uv3 = input.texCoord3; // output.VertexColor = input.color; // output.FaceSign = input.isFrontFace; // output.TimeParameters = _TimeParameters.xyz; // This is mainly for LW as HD overwrite this value return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { UNITY_SETUP_INSTANCE_ID(input); VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS) { // 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.specularOcclusion = surfaceDescription.SpecularOcclusion; // surfaceData.metallic = surfaceDescription.Metallic; // surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask; surfaceData.thickness = surfaceDescription.Thickness; surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash); // surfaceData.specularColor = surfaceDescription.Specular; surfaceData.coatMask = surfaceDescription.CoatMask; // surfaceData.anisotropy = surfaceDescription.Anisotropy; // surfaceData.iridescenceMask = surfaceDescription.IridescenceMask; // surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness; #ifdef _HAS_REFRACTION if (_EnableSSRefraction) { // surfaceData.ior = surfaceDescription.RefractionIndex; // surfaceData.transmittanceColor = surfaceDescription.RefractionColor; // surfaceData.atDistance = surfaceDescription.RefractionDistance; surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha); surfaceDescription.Alpha = 1.0; } else { surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; surfaceDescription.Alpha = 1.0; } #else surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; #endif // These static material feature allow compile time optimization surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD; #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION; #endif #ifdef _MATERIAL_FEATURE_ANISOTROPY surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY; #endif // surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT; #ifdef _MATERIAL_FEATURE_IRIDESCENCE surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE; #endif #ifdef _MATERIAL_FEATURE_SPECULAR_COLOR surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR; #endif #if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && 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 #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #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, doubleSidedConstants); bentNormalWS = surfaceData.normalWS; // GetNormalWS(fragInputs, surfaceDescription.BentNormal, bentNormalWS, doubleSidedConstants); surfaceData.geomNormalWS = fragInputs.tangentToWorld[2]; surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT // surfaceData.tangentWS = TransformTangentToWorld(surfaceDescription.Tangent, fragInputs.tangentToWorld); 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 #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; #endif #if HAVE_DECALS if (_EnableDecals) { DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); } #endif #ifdef _ENABLE_GEOMETRIC_SPECULAR_AA surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold); #endif #ifdef DEBUG_DISPLAY if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE) { // TODO: need to update mip info surfaceData.metallic = 0; } // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.tangentToWorld, 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 LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x); #endif #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #endif ApplyDoubleSidedFlipOrMirror(fragInputs, doubleSidedConstants); 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.. DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThreshold); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPrepass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPostpass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdShadow); // ApplyDepthOffsetPositionInput(V, surfaceDescription.DepthOffset, GetViewForwardDir(), GetWorldToHClipMatrix(), posInput); float3 bentNormalWS; BuildSurfaceData(fragInputs, surfaceDescription, V, posInput, surfaceData, bentNormalWS); // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(posInput, surfaceDescription.Alpha, bentNormalWS, -fragInputs.tangentToWorld[2], fragInputs.texCoord1, fragInputs.texCoord2, builtinData); // override sampleBakedGI: // builtinData.bakeDiffuseLighting = surfaceDescription.BakedGI; // builtinData.backBakeDiffuseLighting = surfaceDescription.BakedBackGI; builtinData.emissiveColor = surfaceDescription.Emission; // builtinData.depthOffset = surfaceDescription.DepthOffset; #if (SHADERPASS == SHADERPASS_DISTORTION) builtinData.distortion = surfaceDescription.Distortion; builtinData.distortionBlur = surfaceDescription.DistortionBlur; #else builtinData.distortion = float2(0.0, 0.0); builtinData.distortionBlur = 0.0; #endif 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 HDLitPass.template Name "SceneSelectionPass" Tags { "LightMode" = "SceneSelectionPass" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- 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 // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT #pragma shader_feature_local _DOUBLESIDED_ON // #pragma shader_feature_local _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- // #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1 #define _MATERIAL_FEATURE_TRANSMISSION 1 // #define _MATERIAL_FEATURE_ANISOTROPY 1 // #define _MATERIAL_FEATURE_IRIDESCENCE 1 // #define _MATERIAL_FEATURE_SPECULAR_COLOR 1 // #define _ENABLE_FOG_ON_TRANSPARENT 1 // #define _AMBIENT_OCCLUSION 1 // #define _SPECULAR_OCCLUSION_FROM_AO 1 // #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1 // #define _SPECULAR_OCCLUSION_CUSTOM 1 #define _ENERGY_CONSERVING_SPECULAR 1 // #define _ENABLE_GEOMETRIC_SPECULAR_AA 1 // #define _HAS_REFRACTION 1 // #define _REFRACTION_PLANE 1 // #define _REFRACTION_SPHERE 1 #define _DISABLE_DECALS 1 #define _DISABLE_SSR 1 // #define _ADD_PRECOMPUTED_VELOCITY // #define _WRITE_TRANSPARENT_MOTION_VECTOR 1 // #define _DEPTHOFFSET_ON 1 // #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag // 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/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 #pragma editor_sync_compilation #define RAYTRACING_SHADER_GRAPH_HIGH // ACTIVE FIELDS: // DoubleSided // FragInputs.isFrontFace // Material.Translucent // Material.Transmission // AlphaTest // Specular.EnergyConserving // SurfaceDescriptionInputs.TangentSpaceNormal // SurfaceDescriptionInputs.ObjectSpacePosition // SurfaceDescriptionInputs.uv0 // SurfaceDescriptionInputs.uv1 // VertexDescriptionInputs.ObjectSpacePosition // VertexDescriptionInputs.uv0 // VertexDescriptionInputs.uv1 // SurfaceDescription.Alpha // SurfaceDescription.AlphaClipThreshold // features.modifyMesh // VertexDescription.VertexPosition // VertexDescription.VertexNormal // VertexDescription.VertexTangent // VaryingsMeshToPS.cullFace // FragInputs.positionRWS // FragInputs.texCoord0 // FragInputs.texCoord1 // AttributesMesh.positionOS // AttributesMesh.uv0 // AttributesMesh.uv1 // VaryingsMeshToPS.positionRWS // VaryingsMeshToPS.texCoord0 // VaryingsMeshToPS.texCoord1 // Shared Graph Keywords // 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 #define VARYINGS_NEED_CULLFACE #define HAVE_MESH_MODIFICATION // We need isFontFace when using double sided #if defined(_DOUBLESIDED_ON) && !defined(VARYINGS_NEED_CULLFACE) #define VARYINGS_NEED_CULLFACE #endif //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #if (SHADERPASS == SHADERPASS_FORWARD) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #define HAS_LIGHTLOOP #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoopDef.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.hlsl" #else #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.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" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" // Used by SceneSelectionPass int _ObjectId; int _PassValue; //------------------------------------------------------------------------------------- // Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- // Generated Type: AttributesMesh struct AttributesMesh { float3 positionOS : POSITION; float4 uv0 : TEXCOORD0; // optional float4 uv1 : TEXCOORD1; // optional #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : INSTANCEID_SEMANTIC; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: VaryingsMeshToPS struct VaryingsMeshToPS { float4 positionCS : SV_Position; float3 positionRWS; // optional float4 texCoord0; // optional float4 texCoord1; // optional #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; #endif // defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) }; // Generated Type: PackedVaryingsMeshToPS struct PackedVaryingsMeshToPS { float4 positionCS : SV_Position; // unpacked #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float4 interp01 : TEXCOORD1; // auto-packed float4 interp02 : TEXCOORD2; // auto-packed #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; // unpacked #endif // conditional }; // Packed Type: VaryingsMeshToPS PackedVaryingsMeshToPS PackVaryingsMeshToPS(VaryingsMeshToPS input) { PackedVaryingsMeshToPS output; output.positionCS = input.positionCS; output.interp00.xyz = input.positionRWS; output.interp01.xyzw = input.texCoord0; output.interp02.xyzw = input.texCoord1; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToPS VaryingsMeshToPS UnpackVaryingsMeshToPS(PackedVaryingsMeshToPS input) { VaryingsMeshToPS output; output.positionCS = input.positionCS; output.positionRWS = input.interp00.xyz; output.texCoord0 = input.interp01.xyzw; output.texCoord1 = input.interp02.xyzw; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: PackedVaryingsMeshToDS struct PackedVaryingsMeshToDS { #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed }; // Packed Type: VaryingsMeshToDS PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToDS VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _HueVariation; float _Smoothness; float _Cutoff; float _NormalScale; float _WindStrength; float _WindPower; float _ThicknessRemap; float4 _EmissionColor; float _RenderQueueType; float _StencilRef; float _StencilWriteMask; float _StencilRefDepth; float _StencilWriteMaskDepth; float _StencilRefMV; float _StencilWriteMaskMV; float _StencilRefDistortionVec; float _StencilWriteMaskDistortionVec; float _StencilWriteMaskGBuffer; float _StencilRefGBuffer; float _ZTestGBuffer; float _RequireSplitLighting; float _ReceivesSSR; float _SurfaceType; float _BlendMode; float _SrcBlend; float _DstBlend; float _AlphaSrcBlend; float _AlphaDstBlend; float _ZWrite; float _CullMode; float _TransparentSortPriority; float _CullModeForward; float _TransparentCullMode; float _ZTestDepthEqualForOpaque; float _ZTestTransparent; float _TransparentBackfaceEnable; float _AlphaCutoffEnable; float _UseShadowThreshold; float _DoubleSidedEnable; float _DoubleSidedNormalMode; float4 _DoubleSidedConstants; float _DiffusionProfileHash; float4 _DiffusionProfileAsset; CBUFFER_END TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex); float4 _MainTex_TexelSize; TEXTURE2D(_BumpTex); SAMPLER(sampler_BumpTex); float4 _BumpTex_TexelSize; SAMPLER(_SampleTexture2D_1F3A9BAF_Sampler_3_Linear_Repeat); // Vertex Graph Inputs struct VertexDescriptionInputs { float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Vertex Graph Outputs struct VertexDescription { float3 VertexPosition; float3 VertexNormal; float3 VertexTangent; float4 VertexUV; }; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float3 TangentSpaceNormal; // optional float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float Alpha; float AlphaClipThreshold; }; // Shared Graph Node Functions #include "Includes/CTI_HDRP_10_BillboardVertex.hlsl" // Vertex Graph Evaluation VertexDescription VertexDescriptionFunction(VertexDescriptionInputs IN) { VertexDescription description = (VertexDescription)0; float3 positionOut; float3 normalOut; float3 tangentOut; float2 uvOut; float colorVariation; CTIBillboard_float(IN.ObjectSpacePosition, IN.uv0.xy, IN.uv1.xyz, _WindStrength, _WindPower, positionOut, normalOut, tangentOut, uvOut, colorVariation); description.VertexPosition = positionOut; description.VertexNormal = normalOut; description.VertexTangent = tangentOut; description.VertexUV.xy = uvOut; return description; } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float3 positionOut; float3 normalOut; float3 tangentOut; float2 uvOut; float colorVariation; CTIBillboard_float(IN.ObjectSpacePosition, IN.uv0.xy, IN.uv1.xyz, _WindStrength, _WindPower, positionOut, normalOut, tangentOut, uvOut, colorVariation); float4 _SampleTexture2D_1F3A9BAF_RGBA_0 = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv0.xy); float _SampleTexture2D_1F3A9BAF_R_4 = _SampleTexture2D_1F3A9BAF_RGBA_0.r; float _SampleTexture2D_1F3A9BAF_G_5 = _SampleTexture2D_1F3A9BAF_RGBA_0.g; float _SampleTexture2D_1F3A9BAF_B_6 = _SampleTexture2D_1F3A9BAF_RGBA_0.b; float _SampleTexture2D_1F3A9BAF_A_7 = _SampleTexture2D_1F3A9BAF_RGBA_0.a; float _Property_C43CA9EC_Out_0 = _Cutoff; surface.Alpha = _SampleTexture2D_1F3A9BAF_A_7; surface.AlphaClipThreshold = _Property_C43CA9EC_Out_0; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- VertexDescriptionInputs AttributesMeshToVertexDescriptionInputs(AttributesMesh input) { VertexDescriptionInputs output; ZERO_INITIALIZE(VertexDescriptionInputs, output); // output.ObjectSpaceNormal = input.normalOS; // output.WorldSpaceNormal = TransformObjectToWorldNormal(input.normalOS); // output.ViewSpaceNormal = TransformWorldToViewDir(output.WorldSpaceNormal); // output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.ObjectSpaceTangent = input.tangentOS; // output.WorldSpaceTangent = TransformObjectToWorldDir(input.tangentOS.xyz); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.ObjectSpaceBiTangent = normalize(cross(input.normalOS, input.tangentOS) * (input.tangentOS.w > 0.0f ? 1.0f : -1.0f) * GetOddNegativeScale()); // output.WorldSpaceBiTangent = TransformObjectToWorldDir(output.ObjectSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); output.ObjectSpacePosition = input.positionOS; // output.WorldSpacePosition = TransformObjectToWorld(input.positionOS); // output.ViewSpacePosition = TransformWorldToView(output.WorldSpacePosition); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(TransformObjectToWorld(input.positionOS)); // output.WorldSpaceViewDirection = GetWorldSpaceNormalizeViewDir(output.WorldSpacePosition); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(output.WorldSpacePosition), _ProjectionParams.x); output.uv0 = input.uv0; output.uv1 = input.uv1; // output.uv2 = input.uv2; // output.uv3 = input.uv3; // output.VertexColor = input.color; return output; } AttributesMesh ApplyMeshModification(AttributesMesh input, float3 timeParameters) { // build graph inputs VertexDescriptionInputs vertexDescriptionInputs = AttributesMeshToVertexDescriptionInputs(input); // Override time paramters with used one (This is required to correctly handle motion vector for vertex animation based on time) // vertexDescriptionInputs.TimeParameters = timeParameters; // evaluate vertex graph VertexDescription vertexDescription = VertexDescriptionFunction(vertexDescriptionInputs); // copy graph output to the results input.positionOS = vertexDescription.VertexPosition; // input.normalOS = vertexDescription.VertexNormal; // input.tangentOS.xyz = vertexDescription.VertexTangent; input.uv0.xy = vertexDescription.VertexUV.xy; return input; } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // 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.tangentToWorld = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; // output.tangentToWorld = BuildTangentToWorld(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 _DOUBLESIDED_ON && SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #elif SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); // output.WorldSpaceNormal = normalize(input.tangentToWorld[2].xyz); // output.ObjectSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_M); // transposed multiplication by inverse matrix to handle normal scale // output.ViewSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V); // transposed multiplication by inverse matrix to handle normal scale output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.WorldSpaceTangent = input.tangentToWorld[0].xyz; // output.ObjectSpaceTangent = TransformWorldToObjectDir(output.WorldSpaceTangent); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.WorldSpaceBiTangent = input.tangentToWorld[1].xyz; // output.ObjectSpaceBiTangent = TransformWorldToObjectDir(output.WorldSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); // output.WorldSpaceViewDirection = normalize(viewWS); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.WorldSpacePosition = input.positionRWS; output.ObjectSpacePosition = TransformWorldToObject(input.positionRWS); // output.ViewSpacePosition = TransformWorldToView(input.positionRWS); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(input.positionRWS); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(input.positionRWS), _ProjectionParams.x); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; // output.uv2 = input.texCoord2; // output.uv3 = input.texCoord3; // output.VertexColor = input.color; // output.FaceSign = input.isFrontFace; // output.TimeParameters = _TimeParameters.xyz; // This is mainly for LW as HD overwrite this value return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { UNITY_SETUP_INSTANCE_ID(input); VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS) { // 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.specularOcclusion = surfaceDescription.SpecularOcclusion; // surfaceData.metallic = surfaceDescription.Metallic; // surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask; // surfaceData.thickness = surfaceDescription.Thickness; // surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash); // surfaceData.specularColor = surfaceDescription.Specular; // surfaceData.coatMask = surfaceDescription.CoatMask; // surfaceData.anisotropy = surfaceDescription.Anisotropy; // surfaceData.iridescenceMask = surfaceDescription.IridescenceMask; // surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness; #ifdef _HAS_REFRACTION if (_EnableSSRefraction) { // surfaceData.ior = surfaceDescription.RefractionIndex; // surfaceData.transmittanceColor = surfaceDescription.RefractionColor; // surfaceData.atDistance = surfaceDescription.RefractionDistance; surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha); surfaceDescription.Alpha = 1.0; } else { surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; surfaceDescription.Alpha = 1.0; } #else surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; #endif // These static material feature allow compile time optimization surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD; #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION; #endif #ifdef _MATERIAL_FEATURE_ANISOTROPY surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY; #endif // surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT; #ifdef _MATERIAL_FEATURE_IRIDESCENCE surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE; #endif #ifdef _MATERIAL_FEATURE_SPECULAR_COLOR surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR; #endif #if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && 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 #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #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, doubleSidedConstants); bentNormalWS = surfaceData.normalWS; // GetNormalWS(fragInputs, surfaceDescription.BentNormal, bentNormalWS, doubleSidedConstants); surfaceData.geomNormalWS = fragInputs.tangentToWorld[2]; surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT // surfaceData.tangentWS = TransformTangentToWorld(surfaceDescription.Tangent, fragInputs.tangentToWorld); 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 #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; #endif #if HAVE_DECALS if (_EnableDecals) { DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); } #endif #ifdef _ENABLE_GEOMETRIC_SPECULAR_AA surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold); #endif #ifdef DEBUG_DISPLAY if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE) { // TODO: need to update mip info surfaceData.metallic = 0; } // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.tangentToWorld, 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 LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x); #endif #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #endif ApplyDoubleSidedFlipOrMirror(fragInputs, doubleSidedConstants); 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.. DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThreshold); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPrepass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPostpass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdShadow); // ApplyDepthOffsetPositionInput(V, surfaceDescription.DepthOffset, GetViewForwardDir(), GetWorldToHClipMatrix(), posInput); float3 bentNormalWS; BuildSurfaceData(fragInputs, surfaceDescription, V, posInput, surfaceData, bentNormalWS); // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(posInput, surfaceDescription.Alpha, bentNormalWS, -fragInputs.tangentToWorld[2], fragInputs.texCoord1, fragInputs.texCoord2, builtinData); // override sampleBakedGI: // builtinData.bakeDiffuseLighting = surfaceDescription.BakedGI; // builtinData.backBakeDiffuseLighting = surfaceDescription.BakedBackGI; // builtinData.emissiveColor = surfaceDescription.Emission; // builtinData.depthOffset = surfaceDescription.DepthOffset; #if (SHADERPASS == SHADERPASS_DISTORTION) builtinData.distortion = surfaceDescription.Distortion; builtinData.distortionBlur = surfaceDescription.DistortionBlur; #else builtinData.distortion = float2(0.0, 0.0); builtinData.distortionBlur = 0.0; #endif 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 HDLitPass.template Name "DepthOnly" Tags { "LightMode" = "DepthOnly" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Cull [_CullMode] ZWrite On // Stencil setup Stencil { WriteMask [_StencilWriteMaskDepth] Ref [_StencilRefDepth] Comp Always Pass Replace } //------------------------------------------------------------------------------------- // End Render Modes //------------------------------------------------------------------------------------- HLSLPROGRAM #pragma target 4.5 #pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch #pragma multi_compile_instancing #pragma instancing_options renderinglayer #pragma multi_compile _ LOD_FADE_CROSSFADE // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT #pragma shader_feature_local _DOUBLESIDED_ON // #pragma shader_feature_local _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- // #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1 #define _MATERIAL_FEATURE_TRANSMISSION 1 // #define _MATERIAL_FEATURE_ANISOTROPY 1 // #define _MATERIAL_FEATURE_IRIDESCENCE 1 // #define _MATERIAL_FEATURE_SPECULAR_COLOR 1 // #define _ENABLE_FOG_ON_TRANSPARENT 1 // #define _AMBIENT_OCCLUSION 1 // #define _SPECULAR_OCCLUSION_FROM_AO 1 // #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1 // #define _SPECULAR_OCCLUSION_CUSTOM 1 #define _ENERGY_CONSERVING_SPECULAR 1 // #define _ENABLE_GEOMETRIC_SPECULAR_AA 1 // #define _HAS_REFRACTION 1 // #define _REFRACTION_PLANE 1 // #define _REFRACTION_SPHERE 1 #define _DISABLE_DECALS 1 #define _DISABLE_SSR 1 // #define _ADD_PRECOMPUTED_VELOCITY // #define _WRITE_TRANSPARENT_MOTION_VECTOR 1 // #define _DEPTHOFFSET_ON 1 // #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #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" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl" // Need to be here for Gradient struct definition //------------------------------------------------------------------------------------- // Defines //------------------------------------------------------------------------------------- #define SHADERPASS SHADERPASS_DEPTH_ONLY #pragma multi_compile _ WRITE_NORMAL_BUFFER #pragma multi_compile _ WRITE_MSAA_DEPTH #define RAYTRACING_SHADER_GRAPH_HIGH // ACTIVE FIELDS: // DoubleSided // FragInputs.isFrontFace // Material.Translucent // Material.Transmission // AlphaTest // Specular.EnergyConserving // SurfaceDescriptionInputs.TangentSpaceNormal // SurfaceDescriptionInputs.ObjectSpacePosition // SurfaceDescriptionInputs.uv0 // SurfaceDescriptionInputs.uv1 // VertexDescriptionInputs.ObjectSpacePosition // VertexDescriptionInputs.uv0 // VertexDescriptionInputs.uv1 // SurfaceDescription.Normal // SurfaceDescription.Smoothness // SurfaceDescription.Alpha // SurfaceDescription.AlphaClipThreshold // features.modifyMesh // VertexDescription.VertexPosition // VertexDescription.VertexNormal // VertexDescription.VertexTangent // AttributesMesh.normalOS // AttributesMesh.tangentOS // AttributesMesh.uv0 // AttributesMesh.uv1 // AttributesMesh.color // AttributesMesh.uv2 // AttributesMesh.uv3 // FragInputs.tangentToWorld // FragInputs.positionRWS // FragInputs.texCoord0 // FragInputs.texCoord1 // FragInputs.texCoord2 // FragInputs.texCoord3 // FragInputs.color // VaryingsMeshToPS.cullFace // AttributesMesh.positionOS // VaryingsMeshToPS.tangentWS // VaryingsMeshToPS.normalWS // VaryingsMeshToPS.positionRWS // VaryingsMeshToPS.texCoord0 // VaryingsMeshToPS.texCoord1 // VaryingsMeshToPS.texCoord2 // VaryingsMeshToPS.texCoord3 // VaryingsMeshToPS.color // Shared Graph Keywords // 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 #define VARYINGS_NEED_CULLFACE #define HAVE_MESH_MODIFICATION // We need isFontFace when using double sided #if defined(_DOUBLESIDED_ON) && !defined(VARYINGS_NEED_CULLFACE) #define VARYINGS_NEED_CULLFACE #endif //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _HueVariation; float _Smoothness; float _Cutoff; float _NormalScale; float _WindStrength; float _WindPower; float _ThicknessRemap; float4 _EmissionColor; float _RenderQueueType; float _StencilRef; float _StencilWriteMask; float _StencilRefDepth; float _StencilWriteMaskDepth; float _StencilRefMV; float _StencilWriteMaskMV; float _StencilRefDistortionVec; float _StencilWriteMaskDistortionVec; float _StencilWriteMaskGBuffer; float _StencilRefGBuffer; float _ZTestGBuffer; float _RequireSplitLighting; float _ReceivesSSR; float _SurfaceType; float _BlendMode; float _SrcBlend; float _DstBlend; float _AlphaSrcBlend; float _AlphaDstBlend; float _ZWrite; float _CullMode; float _TransparentSortPriority; float _CullModeForward; float _TransparentCullMode; float _ZTestDepthEqualForOpaque; float _ZTestTransparent; float _TransparentBackfaceEnable; float _AlphaCutoffEnable; float _UseShadowThreshold; float _DoubleSidedEnable; float _DoubleSidedNormalMode; float4 _DoubleSidedConstants; float _DiffusionProfileHash; float4 _DiffusionProfileAsset; CBUFFER_END TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex); float4 _MainTex_TexelSize; TEXTURE2D(_BumpTex); SAMPLER(sampler_BumpTex); float4 _BumpTex_TexelSize; SAMPLER(_SampleTexture2D_8F5727BE_Sampler_3_Linear_Repeat); SAMPLER(_SampleTexture2D_1F3A9BAF_Sampler_3_Linear_Repeat); // Used by SceneSelectionPass int _ObjectId; int _PassValue; // Includes #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl" #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" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" //------------------------------------------------------------------------------------- // 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 UNITY_ANY_INSTANCING_ENABLED uint instanceID : INSTANCEID_SEMANTIC; #endif // UNITY_ANY_INSTANCING_ENABLED }; // 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 UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; #endif // defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) }; // Generated Type: PackedVaryingsMeshToPS struct PackedVaryingsMeshToPS { float4 positionCS : SV_Position; // unpacked #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional 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 #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; // unpacked #endif // conditional }; // Packed Type: VaryingsMeshToPS 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 UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToPS 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 UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: PackedVaryingsMeshToDS struct PackedVaryingsMeshToDS { #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed }; // Packed Type: VaryingsMeshToDS PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToDS VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Vertex Graph Inputs struct VertexDescriptionInputs { float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Vertex Graph Outputs struct VertexDescription { float3 VertexPosition; float3 VertexNormal; float3 VertexTangent; float4 VertexUV; }; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float3 TangentSpaceNormal; // optional float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float3 Normal; float Smoothness; float Alpha; float AlphaClipThreshold; }; // Shared Graph Node Functions #include "Includes/CTI_HDRP_10_BillboardVertex.hlsl" void UnpackNormal_float(float4 packedNormal, float scale, out float3 Normal) { Normal.xy = packedNormal.ag * 2 -1; Normal.xy *= scale; //Normal.xy *= -1; // Why this?! Normal.z = sqrt( 1.0f - saturate( dot(Normal.xy, Normal.xy) ) ); } // Vertex Graph Evaluation VertexDescription VertexDescriptionFunction(VertexDescriptionInputs IN) { VertexDescription description = (VertexDescription)0; float3 positionOut; float3 normalOut; float3 tangentOut; float2 uvOut; float colorVariation; CTIBillboard_float(IN.ObjectSpacePosition, IN.uv0.xy, IN.uv1.xyz, _WindStrength, _WindPower, positionOut, normalOut, tangentOut, uvOut, colorVariation); description.VertexPosition = positionOut; description.VertexNormal = normalOut; description.VertexTangent = tangentOut; description.VertexUV.xy = uvOut; return description; } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; // Original wrote to Normal as well?! surface.Alpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv0.xy).a; DoAlphaTest(surface.Alpha, _Cutoff); surface.AlphaClipThreshold = _Cutoff; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- VertexDescriptionInputs AttributesMeshToVertexDescriptionInputs(AttributesMesh input) { VertexDescriptionInputs output; ZERO_INITIALIZE(VertexDescriptionInputs, output); output.ObjectSpacePosition = input.positionOS; // output.WorldSpacePosition = TransformObjectToWorld(input.positionOS); // output.ViewSpacePosition = TransformWorldToView(output.WorldSpacePosition); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(TransformObjectToWorld(input.positionOS)); // output.WorldSpaceViewDirection = GetWorldSpaceNormalizeViewDir(output.WorldSpacePosition); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(output.WorldSpacePosition), _ProjectionParams.x); output.uv0 = input.uv0; output.uv1 = input.uv1; // output.uv2 = input.uv2; // output.uv3 = input.uv3; // output.VertexColor = input.color; return output; } AttributesMesh ApplyMeshModification(AttributesMesh input, float3 timeParameters) { // build graph inputs VertexDescriptionInputs vertexDescriptionInputs = AttributesMeshToVertexDescriptionInputs(input); // Override time paramters with used one (This is required to correctly handle motion vector for vertex animation based on time) // vertexDescriptionInputs.TimeParameters = timeParameters; // evaluate vertex graph VertexDescription vertexDescription = VertexDescriptionFunction(vertexDescriptionInputs); // copy graph output to the results input.positionOS = vertexDescription.VertexPosition; input.normalOS = vertexDescription.VertexNormal; input.tangentOS.xyz = vertexDescription.VertexTangent; input.uv0.xy = vertexDescription.VertexUV.xy; return input; } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // 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.tangentToWorld = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; output.tangentToWorld = BuildTangentToWorld(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 _DOUBLESIDED_ON && SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #elif SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); // output.WorldSpaceNormal = normalize(input.tangentToWorld[2].xyz); // output.ObjectSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_M); // transposed multiplication by inverse matrix to handle normal scale // output.ViewSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V); // transposed multiplication by inverse matrix to handle normal scale output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.WorldSpaceTangent = input.tangentToWorld[0].xyz; // output.ObjectSpaceTangent = TransformWorldToObjectDir(output.WorldSpaceTangent); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.WorldSpaceBiTangent = input.tangentToWorld[1].xyz; // output.ObjectSpaceBiTangent = TransformWorldToObjectDir(output.WorldSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); // output.WorldSpaceViewDirection = normalize(viewWS); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.WorldSpacePosition = input.positionRWS; output.ObjectSpacePosition = TransformWorldToObject(input.positionRWS); // output.ViewSpacePosition = TransformWorldToView(input.positionRWS); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(input.positionRWS); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(input.positionRWS), _ProjectionParams.x); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; // output.uv2 = input.texCoord2; // output.uv3 = input.texCoord3; // output.VertexColor = input.color; // output.FaceSign = input.isFrontFace; // output.TimeParameters = _TimeParameters.xyz; // This is mainly for LW as HD overwrite this value return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { UNITY_SETUP_INSTANCE_ID(input); VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS) { // 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.specularOcclusion = surfaceDescription.SpecularOcclusion; // surfaceData.metallic = surfaceDescription.Metallic; // surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask; // surfaceData.thickness = surfaceDescription.Thickness; // surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash); // surfaceData.specularColor = surfaceDescription.Specular; // surfaceData.coatMask = surfaceDescription.CoatMask; // surfaceData.anisotropy = surfaceDescription.Anisotropy; // surfaceData.iridescenceMask = surfaceDescription.IridescenceMask; // surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness; #ifdef _HAS_REFRACTION if (_EnableSSRefraction) { // surfaceData.ior = surfaceDescription.RefractionIndex; // surfaceData.transmittanceColor = surfaceDescription.RefractionColor; // surfaceData.atDistance = surfaceDescription.RefractionDistance; surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha); surfaceDescription.Alpha = 1.0; } else { surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; surfaceDescription.Alpha = 1.0; } #else surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; #endif // These static material feature allow compile time optimization surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD; #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION; #endif #ifdef _MATERIAL_FEATURE_ANISOTROPY surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY; #endif // surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT; #ifdef _MATERIAL_FEATURE_IRIDESCENCE surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE; #endif #ifdef _MATERIAL_FEATURE_SPECULAR_COLOR surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR; #endif #if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && 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 #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #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, doubleSidedConstants); bentNormalWS = surfaceData.normalWS; // GetNormalWS(fragInputs, surfaceDescription.BentNormal, bentNormalWS, doubleSidedConstants); surfaceData.geomNormalWS = fragInputs.tangentToWorld[2]; surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT // surfaceData.tangentWS = TransformTangentToWorld(surfaceDescription.Tangent, fragInputs.tangentToWorld); 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 #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; #endif #if HAVE_DECALS if (_EnableDecals) { DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); } #endif #ifdef _ENABLE_GEOMETRIC_SPECULAR_AA surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold); #endif #ifdef DEBUG_DISPLAY if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE) { // TODO: need to update mip info surfaceData.metallic = 0; } // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.tangentToWorld, 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 LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x); #endif #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #endif ApplyDoubleSidedFlipOrMirror(fragInputs, doubleSidedConstants); 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.. // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThreshold); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPrepass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPostpass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdShadow); // ApplyDepthOffsetPositionInput(V, surfaceDescription.DepthOffset, GetViewForwardDir(), GetWorldToHClipMatrix(), posInput); float3 bentNormalWS; BuildSurfaceData(fragInputs, surfaceDescription, V, posInput, surfaceData, bentNormalWS); // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(posInput, surfaceDescription.Alpha, bentNormalWS, -fragInputs.tangentToWorld[2], fragInputs.texCoord1, fragInputs.texCoord2, builtinData); // override sampleBakedGI: // builtinData.bakeDiffuseLighting = surfaceDescription.BakedGI; // builtinData.backBakeDiffuseLighting = surfaceDescription.BakedBackGI; // builtinData.emissiveColor = surfaceDescription.Emission; // builtinData.depthOffset = surfaceDescription.DepthOffset; #if (SHADERPASS == SHADERPASS_DISTORTION) builtinData.distortion = surfaceDescription.Distortion; builtinData.distortionBlur = surfaceDescription.DistortionBlur; #else builtinData.distortion = float2(0.0, 0.0); builtinData.distortionBlur = 0.0; #endif 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 HDLitPass.template Name "GBuffer" Tags { "LightMode" = "GBuffer" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Cull [_CullMode] ZTest [_ZTestGBuffer] // Stencil setup Stencil { WriteMask [_StencilWriteMaskGBuffer] Ref [_StencilRefGBuffer] Comp Always Pass Replace } //------------------------------------------------------------------------------------- // End Render Modes //------------------------------------------------------------------------------------- HLSLPROGRAM #pragma target 4.5 #pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch #pragma multi_compile_instancing #pragma instancing_options renderinglayer nolightprobe #pragma multi_compile _ LOD_FADE_CROSSFADE // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT #pragma shader_feature_local _DOUBLESIDED_ON // #pragma shader_feature_local _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- // #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1 #define _MATERIAL_FEATURE_TRANSMISSION 1 // #define _MATERIAL_FEATURE_ANISOTROPY 1 // #define _MATERIAL_FEATURE_IRIDESCENCE 1 // #define _MATERIAL_FEATURE_SPECULAR_COLOR 1 // #define _ENABLE_FOG_ON_TRANSPARENT 1 // #define _AMBIENT_OCCLUSION 1 // #define _SPECULAR_OCCLUSION_FROM_AO 1 // #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1 // #define _SPECULAR_OCCLUSION_CUSTOM 1 #define _ENERGY_CONSERVING_SPECULAR 1 // #define _ENABLE_GEOMETRIC_SPECULAR_AA 1 // #define _HAS_REFRACTION 1 // #define _REFRACTION_PLANE 1 // #define _REFRACTION_SPHERE 1 #define _DISABLE_DECALS 1 #define _DISABLE_SSR 1 // #define _ADD_PRECOMPUTED_VELOCITY // #define _WRITE_TRANSPARENT_MOTION_VECTOR 1 // #define _DEPTHOFFSET_ON 1 // #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #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" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" // Required to be include before we include properties as it define DECLARE_STACK_CB #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphHeader.hlsl" // Need to be here for Gradient struct definition //------------------------------------------------------------------------------------- // Defines //------------------------------------------------------------------------------------- #define SHADERPASS SHADERPASS_GBUFFER #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 #pragma multi_compile _ LIGHT_LAYERS #define RAYTRACING_SHADER_GRAPH_HIGH #ifndef DEBUG_DISPLAY #define SHADERPASS_GBUFFER_BYPASS_ALPHA_TEST #endif // ACTIVE FIELDS: // DoubleSided // FragInputs.isFrontFace // Material.Translucent // Material.Transmission // AlphaTest // Specular.EnergyConserving // SurfaceDescriptionInputs.TangentSpaceNormal // SurfaceDescriptionInputs.ObjectSpacePosition // SurfaceDescriptionInputs.uv0 // SurfaceDescriptionInputs.uv1 // VertexDescriptionInputs.ObjectSpacePosition // VertexDescriptionInputs.uv0 // VertexDescriptionInputs.uv1 // SurfaceDescription.Albedo // SurfaceDescription.Normal // SurfaceDescription.BentNormal // SurfaceDescription.Thickness // SurfaceDescription.DiffusionProfileHash // SurfaceDescription.CoatMask // SurfaceDescription.Emission // SurfaceDescription.Smoothness // SurfaceDescription.Occlusion // SurfaceDescription.Alpha // SurfaceDescription.AlphaClipThreshold // features.modifyMesh // VertexDescription.VertexPosition // VertexDescription.VertexNormal // VertexDescription.VertexTangent // FragInputs.tangentToWorld // FragInputs.positionRWS // FragInputs.texCoord1 // FragInputs.texCoord2 // VaryingsMeshToPS.cullFace // FragInputs.texCoord0 // AttributesMesh.positionOS // AttributesMesh.uv0 // AttributesMesh.uv1 // VaryingsMeshToPS.tangentWS // VaryingsMeshToPS.normalWS // VaryingsMeshToPS.positionRWS // VaryingsMeshToPS.texCoord1 // VaryingsMeshToPS.texCoord2 // VaryingsMeshToPS.texCoord0 // AttributesMesh.tangentOS // AttributesMesh.normalOS // AttributesMesh.uv2 // Shared Graph Keywords // 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 #define VARYINGS_NEED_CULLFACE #define HAVE_MESH_MODIFICATION // We need isFontFace when using double sided #if defined(_DOUBLESIDED_ON) && !defined(VARYINGS_NEED_CULLFACE) #define VARYINGS_NEED_CULLFACE #endif //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _HueVariation; float _Smoothness; float _Cutoff; float _NormalScale; float _WindStrength; float _WindPower; float _ThicknessRemap; float4 _EmissionColor; float _RenderQueueType; float _StencilRef; float _StencilWriteMask; float _StencilRefDepth; float _StencilWriteMaskDepth; float _StencilRefMV; float _StencilWriteMaskMV; float _StencilRefDistortionVec; float _StencilWriteMaskDistortionVec; float _StencilWriteMaskGBuffer; float _StencilRefGBuffer; float _ZTestGBuffer; float _RequireSplitLighting; float _ReceivesSSR; float _SurfaceType; float _BlendMode; float _SrcBlend; float _DstBlend; float _AlphaSrcBlend; float _AlphaDstBlend; float _ZWrite; float _CullMode; float _TransparentSortPriority; float _CullModeForward; float _TransparentCullMode; float _ZTestDepthEqualForOpaque; float _ZTestTransparent; float _TransparentBackfaceEnable; float _AlphaCutoffEnable; float _UseShadowThreshold; float _DoubleSidedEnable; float _DoubleSidedNormalMode; float4 _DoubleSidedConstants; float _DiffusionProfileHash; float4 _DiffusionProfileAsset; CBUFFER_END TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex); float4 _MainTex_TexelSize; TEXTURE2D(_BumpTex); SAMPLER(sampler_BumpTex); float4 _BumpTex_TexelSize; SAMPLER(_SampleTexture2D_1F3A9BAF_Sampler_3_Linear_Repeat); SAMPLER(_SampleTexture2D_8F5727BE_Sampler_3_Linear_Repeat); // -- Property used by ScenePickingPass #ifdef SCENEPICKINGPASS float4 _SelectionID; #endif // -- Properties used by SceneSelectionPass #ifdef SCENESELECTIONPASS int _ObjectId; int _PassValue; #endif // Includes #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl" #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" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" //------------------------------------------------------------------------------------- // 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 #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : INSTANCEID_SEMANTIC; #endif // UNITY_ANY_INSTANCING_ENABLED }; // 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 #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; #endif }; // Generated Type: PackedVaryingsMeshToPS struct PackedVaryingsMeshToPS { float4 positionCS : SV_Position; // unpacked #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional 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 #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; // unpacked #endif // conditional }; // Packed Type: VaryingsMeshToPS 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; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToPS 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; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: PackedVaryingsMeshToDS struct PackedVaryingsMeshToDS { #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed }; // Packed Type: VaryingsMeshToDS PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToDS VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Vertex Graph Inputs struct VertexDescriptionInputs { float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Vertex Graph Outputs struct VertexDescription { float3 VertexPosition; float3 VertexNormal; float3 VertexTangent; float4 VertexUV; }; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float3 TangentSpaceNormal; // optional float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float3 Albedo; float3 Normal; float3 BentNormal; float Thickness; float DiffusionProfileHash; float CoatMask; float3 Emission; float Smoothness; float Occlusion; float Alpha; float AlphaClipThreshold; }; // Shared Graph Node Functions // 0bd5fad30b6e3175bb269301281cdc86 #include "Includes/CTI_HDRP_10_BillboardVertex.hlsl" void UnpackNormal_float(float4 packedNormal, float scale, out float3 Normal) { Normal.xy = packedNormal.ag * 2 -1; Normal.xy *= scale; Normal.z = sqrt( 1.0f - saturate( dot(Normal.xy, Normal.xy) ) ); } // Vertex Graph Evaluation VertexDescription VertexDescriptionFunction(VertexDescriptionInputs IN) { VertexDescription description = (VertexDescription)0; float3 positionOut; float3 normalOut; float3 tangentOut; float2 uvOut; float colorVariation; CTIBillboard_float(IN.ObjectSpacePosition, IN.uv0.xy, IN.uv1.xyz, _WindStrength, _WindPower, positionOut, normalOut, tangentOut, uvOut, colorVariation); description.VertexPosition = positionOut; description.VertexNormal = normalOut; description.VertexTangent = tangentOut; description.VertexUV.xy = uvOut; description.VertexUV.z = colorVariation; return description; } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float4 albedoAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv0.xy); DoAlphaTest(albedoAlpha.a, _Cutoff); float4 combinedSample = SAMPLE_TEXTURE2D(_BumpTex, sampler_BumpTex, IN.uv0.xy); float3 unpackedNormal; UnpackNormal_float(combinedSample, _NormalScale, unpackedNormal); // Fix up down orientation unpackedNormal.y *= -1; surface.Albedo = albedoAlpha.xyz; surface.Albedo = lerp(surface.Albedo, (surface.Albedo + _HueVariation.rgb) * 0.5, IN.uv0.z * _HueVariation.a); surface.Normal = unpackedNormal; surface.BentNormal = IN.TangentSpaceNormal; surface.Thickness = (1.0f - combinedSample.r) * _ThicknessRemap; surface.DiffusionProfileHash = ((asuint(_DiffusionProfileHash) != 0) ? _DiffusionProfileHash : asfloat(uint(1080305144))); surface.CoatMask = 0; surface.Emission = float3(0, 0, 0); surface.Smoothness = combinedSample.b * _Smoothness; surface.Occlusion = 1; surface.Alpha = albedoAlpha.a; surface.AlphaClipThreshold = _Cutoff; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- VertexDescriptionInputs AttributesMeshToVertexDescriptionInputs(AttributesMesh input) { VertexDescriptionInputs output; ZERO_INITIALIZE(VertexDescriptionInputs, output); // output.ObjectSpaceNormal = input.normalOS; // output.WorldSpaceNormal = TransformObjectToWorldNormal(input.normalOS); // output.ViewSpaceNormal = TransformWorldToViewDir(output.WorldSpaceNormal); // output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.ObjectSpaceTangent = input.tangentOS; // output.WorldSpaceTangent = TransformObjectToWorldDir(input.tangentOS.xyz); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.ObjectSpaceBiTangent = normalize(cross(input.normalOS, input.tangentOS) * (input.tangentOS.w > 0.0f ? 1.0f : -1.0f) * GetOddNegativeScale()); // output.WorldSpaceBiTangent = TransformObjectToWorldDir(output.ObjectSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); output.ObjectSpacePosition = input.positionOS; // output.WorldSpacePosition = TransformObjectToWorld(input.positionOS); // output.ViewSpacePosition = TransformWorldToView(output.WorldSpacePosition); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(TransformObjectToWorld(input.positionOS)); // output.WorldSpaceViewDirection = GetWorldSpaceNormalizeViewDir(output.WorldSpacePosition); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(output.WorldSpacePosition), _ProjectionParams.x); output.uv0 = input.uv0; output.uv1 = input.uv1; // output.uv2 = input.uv2; // output.uv3 = input.uv3; // output.VertexColor = input.color; return output; } AttributesMesh ApplyMeshModification(AttributesMesh input, float3 timeParameters) { // build graph inputs VertexDescriptionInputs vertexDescriptionInputs = AttributesMeshToVertexDescriptionInputs(input); // Override time paramters with used one (This is required to correctly handle motion vector for vertex animation based on time) // vertexDescriptionInputs.TimeParameters = timeParameters; // evaluate vertex graph VertexDescription vertexDescription = VertexDescriptionFunction(vertexDescriptionInputs); // copy graph output to the results input.positionOS = vertexDescription.VertexPosition; input.normalOS = vertexDescription.VertexNormal; input.tangentOS.xyz = vertexDescription.VertexTangent; // z contains color variation input.uv0.xyz = vertexDescription.VertexUV.xyz; return input; } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // 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.tangentToWorld = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; output.tangentToWorld = BuildTangentToWorld(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 _DOUBLESIDED_ON && SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #elif SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); // output.WorldSpaceNormal = normalize(input.tangentToWorld[2].xyz); // output.ObjectSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_M); // transposed multiplication by inverse matrix to handle normal scale // output.ViewSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V); // transposed multiplication by inverse matrix to handle normal scale output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.WorldSpaceTangent = input.tangentToWorld[0].xyz; // output.ObjectSpaceTangent = TransformWorldToObjectDir(output.WorldSpaceTangent); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.WorldSpaceBiTangent = input.tangentToWorld[1].xyz; // output.ObjectSpaceBiTangent = TransformWorldToObjectDir(output.WorldSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); // output.WorldSpaceViewDirection = normalize(viewWS); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.WorldSpacePosition = input.positionRWS; output.ObjectSpacePosition = TransformWorldToObject(input.positionRWS); // output.ViewSpacePosition = TransformWorldToView(input.positionRWS); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(input.positionRWS); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(input.positionRWS), _ProjectionParams.x); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; // output.uv2 = input.texCoord2; // output.uv3 = input.texCoord3; // output.VertexColor = input.color; // output.FaceSign = input.isFrontFace; // output.TimeParameters = _TimeParameters.xyz; // This is mainly for LW as HD overwrite this value return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { UNITY_SETUP_INSTANCE_ID(input); VaryingsMeshToPS unpacked = UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS) { // 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.specularOcclusion = surfaceDescription.SpecularOcclusion; // surfaceData.metallic = surfaceDescription.Metallic; // surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask; surfaceData.thickness = surfaceDescription.Thickness; surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash); // surfaceData.specularColor = surfaceDescription.Specular; surfaceData.coatMask = surfaceDescription.CoatMask; // surfaceData.anisotropy = surfaceDescription.Anisotropy; // surfaceData.iridescenceMask = surfaceDescription.IridescenceMask; // surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness; #ifdef _HAS_REFRACTION if (_EnableSSRefraction) { // surfaceData.ior = surfaceDescription.RefractionIndex; // surfaceData.transmittanceColor = surfaceDescription.RefractionColor; // surfaceData.atDistance = surfaceDescription.RefractionDistance; surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha); surfaceDescription.Alpha = 1.0; } else { surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; surfaceDescription.Alpha = 1.0; } #else surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; #endif // These static material feature allow compile time optimization surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD; #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION; #endif #ifdef _MATERIAL_FEATURE_ANISOTROPY surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY; #endif // surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT; #ifdef _MATERIAL_FEATURE_IRIDESCENCE surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE; #endif #ifdef _MATERIAL_FEATURE_SPECULAR_COLOR surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR; #endif #if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && 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 #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #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, doubleSidedConstants); bentNormalWS = surfaceData.normalWS; // GetNormalWS(fragInputs, surfaceDescription.BentNormal, bentNormalWS, doubleSidedConstants); surfaceData.geomNormalWS = fragInputs.tangentToWorld[2]; surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT // surfaceData.tangentWS = TransformTangentToWorld(surfaceDescription.Tangent, fragInputs.tangentToWorld); 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 #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; #endif #if HAVE_DECALS if (_EnableDecals) { DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); } #endif #ifdef _ENABLE_GEOMETRIC_SPECULAR_AA surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold); #endif #ifdef DEBUG_DISPLAY if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE) { // TODO: need to update mip info surfaceData.metallic = 0; } // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.tangentToWorld, 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 LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x); #endif #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #endif ApplyDoubleSidedFlipOrMirror(fragInputs, doubleSidedConstants); 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.. // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThreshold); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPrepass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPostpass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdShadow); // ApplyDepthOffsetPositionInput(V, surfaceDescription.DepthOffset, GetViewForwardDir(), GetWorldToHClipMatrix(), posInput); float3 bentNormalWS; BuildSurfaceData(fragInputs, surfaceDescription, V, posInput, surfaceData, bentNormalWS); // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(posInput, surfaceDescription.Alpha, bentNormalWS, -fragInputs.tangentToWorld[2], fragInputs.texCoord1, fragInputs.texCoord2, builtinData); // override sampleBakedGI: // builtinData.bakeDiffuseLighting = surfaceDescription.BakedGI; // builtinData.backBakeDiffuseLighting = surfaceDescription.BakedBackGI; builtinData.emissiveColor = surfaceDescription.Emission; // builtinData.depthOffset = surfaceDescription.DepthOffset; #if (SHADERPASS == SHADERPASS_DISTORTION) builtinData.distortion = surfaceDescription.Distortion; builtinData.distortionBlur = surfaceDescription.DistortionBlur; #else builtinData.distortion = float2(0.0, 0.0); builtinData.distortionBlur = 0.0; #endif PostInitBuiltinData(V, posInput, surfaceData, builtinData); } //------------------------------------------------------------------------------------- // Pass Includes //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPassGBuffer.hlsl" //------------------------------------------------------------------------------------- // End Pass Includes //------------------------------------------------------------------------------------- ENDHLSL } Pass { // based on HDLitPass.template Name "MotionVectors" Tags { "LightMode" = "MotionVectors" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Cull [_CullMode] ZWrite On // Stencil setup Stencil { WriteMask [_StencilWriteMaskMV] Ref [_StencilRefMV] 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 // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT #pragma shader_feature_local _DOUBLESIDED_ON // #pragma shader_feature_local _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- // #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1 #define _MATERIAL_FEATURE_TRANSMISSION 1 // #define _MATERIAL_FEATURE_ANISOTROPY 1 // #define _MATERIAL_FEATURE_IRIDESCENCE 1 // #define _MATERIAL_FEATURE_SPECULAR_COLOR 1 // #define _ENABLE_FOG_ON_TRANSPARENT 1 // #define _AMBIENT_OCCLUSION 1 // #define _SPECULAR_OCCLUSION_FROM_AO 1 // #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1 // #define _SPECULAR_OCCLUSION_CUSTOM 1 #define _ENERGY_CONSERVING_SPECULAR 1 // #define _ENABLE_GEOMETRIC_SPECULAR_AA 1 // #define _HAS_REFRACTION 1 // #define _REFRACTION_PLANE 1 // #define _REFRACTION_SPHERE 1 #define _DISABLE_DECALS 1 #define _DISABLE_SSR 1 // #define _ADD_PRECOMPUTED_VELOCITY // #define _WRITE_TRANSPARENT_MOTION_VECTOR 1 // #define _DEPTHOFFSET_ON 1 // #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag // 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/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_MOTION_VECTORS #pragma multi_compile _ WRITE_NORMAL_BUFFER #pragma multi_compile _ WRITE_MSAA_DEPTH #define RAYTRACING_SHADER_GRAPH_HIGH // ACTIVE FIELDS: // DoubleSided // Material.Translucent // Material.Transmission // AlphaTest // Specular.EnergyConserving // SurfaceDescriptionInputs.TangentSpaceNormal // SurfaceDescriptionInputs.ObjectSpacePosition // SurfaceDescriptionInputs.uv0 // SurfaceDescriptionInputs.uv1 // VertexDescriptionInputs.ObjectSpacePosition // VertexDescriptionInputs.uv0 // VertexDescriptionInputs.uv1 // SurfaceDescription.Normal // SurfaceDescription.Smoothness // SurfaceDescription.Alpha // SurfaceDescription.AlphaClipThreshold // features.modifyMesh // VertexDescription.VertexPosition // VertexDescription.VertexNormal // VertexDescription.VertexTangent // AttributesMesh.normalOS // AttributesMesh.tangentOS // AttributesMesh.uv0 // AttributesMesh.uv1 // AttributesMesh.color // AttributesMesh.uv2 // AttributesMesh.uv3 // FragInputs.tangentToWorld // FragInputs.positionRWS // FragInputs.texCoord0 // FragInputs.texCoord1 // FragInputs.texCoord2 // FragInputs.texCoord3 // FragInputs.color // AttributesMesh.positionOS // VaryingsMeshToPS.tangentWS // VaryingsMeshToPS.normalWS // VaryingsMeshToPS.positionRWS // VaryingsMeshToPS.texCoord0 // VaryingsMeshToPS.texCoord1 // VaryingsMeshToPS.texCoord2 // VaryingsMeshToPS.texCoord3 // VaryingsMeshToPS.color // Shared Graph Keywords // 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 // #define VARYINGS_NEED_CULLFACE #define HAVE_MESH_MODIFICATION // We need isFontFace when using double sided #if defined(_DOUBLESIDED_ON) && !defined(VARYINGS_NEED_CULLFACE) #define VARYINGS_NEED_CULLFACE #endif //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #if (SHADERPASS == SHADERPASS_FORWARD) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #define HAS_LIGHTLOOP #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoopDef.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.hlsl" #else #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.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" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" // Used by SceneSelectionPass int _ObjectId; int _PassValue; //------------------------------------------------------------------------------------- // 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 UNITY_ANY_INSTANCING_ENABLED uint instanceID : INSTANCEID_SEMANTIC; #endif // UNITY_ANY_INSTANCING_ENABLED }; // 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 UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; #endif // defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) }; // Generated Type: PackedVaryingsMeshToPS struct PackedVaryingsMeshToPS { float4 positionCS : SV_Position; // unpacked #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional 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 #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; // unpacked #endif // conditional }; // Packed Type: VaryingsMeshToPS 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 UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToPS 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 UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: PackedVaryingsMeshToDS struct PackedVaryingsMeshToDS { #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed }; // Packed Type: VaryingsMeshToDS PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToDS VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _HueVariation; float _Smoothness; float _Cutoff; float _NormalScale; float _WindStrength; float _WindPower; float _ThicknessRemap; float4 _EmissionColor; float _RenderQueueType; float _StencilRef; float _StencilWriteMask; float _StencilRefDepth; float _StencilWriteMaskDepth; float _StencilRefMV; float _StencilWriteMaskMV; float _StencilRefDistortionVec; float _StencilWriteMaskDistortionVec; float _StencilWriteMaskGBuffer; float _StencilRefGBuffer; float _ZTestGBuffer; float _RequireSplitLighting; float _ReceivesSSR; float _SurfaceType; float _BlendMode; float _SrcBlend; float _DstBlend; float _AlphaSrcBlend; float _AlphaDstBlend; float _ZWrite; float _CullMode; float _TransparentSortPriority; float _CullModeForward; float _TransparentCullMode; float _ZTestDepthEqualForOpaque; float _ZTestTransparent; float _TransparentBackfaceEnable; float _AlphaCutoffEnable; float _UseShadowThreshold; float _DoubleSidedEnable; float _DoubleSidedNormalMode; float4 _DoubleSidedConstants; float _DiffusionProfileHash; float4 _DiffusionProfileAsset; CBUFFER_END TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex); float4 _MainTex_TexelSize; TEXTURE2D(_BumpTex); SAMPLER(sampler_BumpTex); float4 _BumpTex_TexelSize; SAMPLER(_SampleTexture2D_8F5727BE_Sampler_3_Linear_Repeat); SAMPLER(_SampleTexture2D_1F3A9BAF_Sampler_3_Linear_Repeat); // Vertex Graph Inputs struct VertexDescriptionInputs { float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Vertex Graph Outputs struct VertexDescription { float3 VertexPosition; float3 VertexNormal; float3 VertexTangent; float4 VertexUV; }; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float3 TangentSpaceNormal; // optional float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float3 Normal; float Smoothness; float Alpha; float AlphaClipThreshold; }; // Shared Graph Node Functions #include "Includes/CTI_HDRP_10_BillboardVertex.hlsl" void UnpackNormal_float(float4 packedNormal, float scale, out float3 Normal) { Normal.xy = packedNormal.ag * 2 -1; Normal.xy *= scale; //Normal.xy *= -1; // Why this?! Normal.z = sqrt( 1.0f - saturate( dot(Normal.xy, Normal.xy) ) ); } // Vertex Graph Evaluation VertexDescription VertexDescriptionFunction(VertexDescriptionInputs IN) { VertexDescription description = (VertexDescription)0; float3 positionOut; float3 normalOut; float3 tangentOut; float2 uvOut; float colorVariation; CTIBillboard_float(IN.ObjectSpacePosition, IN.uv0.xy, IN.uv1.xyz, _WindStrength, _WindPower, positionOut, normalOut, tangentOut, uvOut, colorVariation); description.VertexPosition = positionOut; description.VertexNormal = normalOut; description.VertexTangent = tangentOut; description.VertexUV.xy = uvOut; return description; } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float4 _UV_C5101A3_Out_0 = IN.uv0; float4 _UV_F5B876C_Out_0 = IN.uv1; float _Property_B7EA4ECB_Out_0 = _WindStrength; float _Property_AE2D9193_Out_0 = _WindPower; float3 positionOut; float3 normalOut; float3 tangentOut; float2 uvOut; float colorVariation; CTIBillboard_float(IN.ObjectSpacePosition, IN.uv0.xy, IN.uv1.xyz, _WindStrength, _WindPower, positionOut, normalOut, tangentOut, uvOut, colorVariation); float4 _SampleTexture2D_8F5727BE_RGBA_0 = SAMPLE_TEXTURE2D(_BumpTex, sampler_BumpTex, uvOut); float _SampleTexture2D_8F5727BE_R_4 = _SampleTexture2D_8F5727BE_RGBA_0.r; float _SampleTexture2D_8F5727BE_G_5 = _SampleTexture2D_8F5727BE_RGBA_0.g; float _SampleTexture2D_8F5727BE_B_6 = _SampleTexture2D_8F5727BE_RGBA_0.b; float _SampleTexture2D_8F5727BE_A_7 = _SampleTexture2D_8F5727BE_RGBA_0.a; float _Property_F17FAA9B_Out_0 = _NormalScale; float3 _CustomFunction_67BD137E_Normal_1; UnpackNormal_float(_SampleTexture2D_8F5727BE_RGBA_0, _Property_F17FAA9B_Out_0, _CustomFunction_67BD137E_Normal_1); float4 _SampleTexture2D_1F3A9BAF_RGBA_0 = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv0.xy); float _SampleTexture2D_1F3A9BAF_R_4 = _SampleTexture2D_1F3A9BAF_RGBA_0.r; float _SampleTexture2D_1F3A9BAF_G_5 = _SampleTexture2D_1F3A9BAF_RGBA_0.g; float _SampleTexture2D_1F3A9BAF_B_6 = _SampleTexture2D_1F3A9BAF_RGBA_0.b; float _SampleTexture2D_1F3A9BAF_A_7 = _SampleTexture2D_1F3A9BAF_RGBA_0.a; float _Property_C43CA9EC_Out_0 = _Cutoff; surface.Normal = _CustomFunction_67BD137E_Normal_1; surface.Smoothness = _SampleTexture2D_8F5727BE_B_6; surface.Alpha = _SampleTexture2D_1F3A9BAF_A_7; surface.AlphaClipThreshold = _Property_C43CA9EC_Out_0; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- VertexDescriptionInputs AttributesMeshToVertexDescriptionInputs(AttributesMesh input) { VertexDescriptionInputs output; ZERO_INITIALIZE(VertexDescriptionInputs, output); // output.ObjectSpaceNormal = input.normalOS; // output.WorldSpaceNormal = TransformObjectToWorldNormal(input.normalOS); // output.ViewSpaceNormal = TransformWorldToViewDir(output.WorldSpaceNormal); // output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.ObjectSpaceTangent = input.tangentOS; // output.WorldSpaceTangent = TransformObjectToWorldDir(input.tangentOS.xyz); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.ObjectSpaceBiTangent = normalize(cross(input.normalOS, input.tangentOS) * (input.tangentOS.w > 0.0f ? 1.0f : -1.0f) * GetOddNegativeScale()); // output.WorldSpaceBiTangent = TransformObjectToWorldDir(output.ObjectSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); output.ObjectSpacePosition = input.positionOS; // output.WorldSpacePosition = TransformObjectToWorld(input.positionOS); // output.ViewSpacePosition = TransformWorldToView(output.WorldSpacePosition); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(TransformObjectToWorld(input.positionOS)); // output.WorldSpaceViewDirection = GetWorldSpaceNormalizeViewDir(output.WorldSpacePosition); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(output.WorldSpacePosition), _ProjectionParams.x); output.uv0 = input.uv0; output.uv1 = input.uv1; // output.uv2 = input.uv2; // output.uv3 = input.uv3; // output.VertexColor = input.color; return output; } AttributesMesh ApplyMeshModification(AttributesMesh input, float3 timeParameters) { // build graph inputs VertexDescriptionInputs vertexDescriptionInputs = AttributesMeshToVertexDescriptionInputs(input); // Override time paramters with used one (This is required to correctly handle motion vector for vertex animation based on time) // vertexDescriptionInputs.TimeParameters = timeParameters; // evaluate vertex graph VertexDescription vertexDescription = VertexDescriptionFunction(vertexDescriptionInputs); // copy graph output to the results input.positionOS = vertexDescription.VertexPosition; input.normalOS = vertexDescription.VertexNormal; input.tangentOS.xyz = vertexDescription.VertexTangent; input.uv0.xy = vertexDescription.VertexUV.xy; return input; } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // 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.tangentToWorld = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; output.tangentToWorld = BuildTangentToWorld(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 _DOUBLESIDED_ON && SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #elif SHADER_STAGE_FRAGMENT // output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #endif // SHADER_STAGE_FRAGMENT return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); // output.WorldSpaceNormal = normalize(input.tangentToWorld[2].xyz); // output.ObjectSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_M); // transposed multiplication by inverse matrix to handle normal scale // output.ViewSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V); // transposed multiplication by inverse matrix to handle normal scale output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.WorldSpaceTangent = input.tangentToWorld[0].xyz; // output.ObjectSpaceTangent = TransformWorldToObjectDir(output.WorldSpaceTangent); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.WorldSpaceBiTangent = input.tangentToWorld[1].xyz; // output.ObjectSpaceBiTangent = TransformWorldToObjectDir(output.WorldSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); // output.WorldSpaceViewDirection = normalize(viewWS); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.WorldSpacePosition = input.positionRWS; output.ObjectSpacePosition = TransformWorldToObject(input.positionRWS); // output.ViewSpacePosition = TransformWorldToView(input.positionRWS); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(input.positionRWS); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(input.positionRWS), _ProjectionParams.x); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; // output.uv2 = input.texCoord2; // output.uv3 = input.texCoord3; // output.VertexColor = input.color; // output.FaceSign = input.isFrontFace; // output.TimeParameters = _TimeParameters.xyz; // This is mainly for LW as HD overwrite this value return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { UNITY_SETUP_INSTANCE_ID(input); VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS) { // 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.specularOcclusion = surfaceDescription.SpecularOcclusion; // surfaceData.metallic = surfaceDescription.Metallic; // surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask; // surfaceData.thickness = surfaceDescription.Thickness; // surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash); // surfaceData.specularColor = surfaceDescription.Specular; // surfaceData.coatMask = surfaceDescription.CoatMask; // surfaceData.anisotropy = surfaceDescription.Anisotropy; // surfaceData.iridescenceMask = surfaceDescription.IridescenceMask; // surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness; #ifdef _HAS_REFRACTION if (_EnableSSRefraction) { // surfaceData.ior = surfaceDescription.RefractionIndex; // surfaceData.transmittanceColor = surfaceDescription.RefractionColor; // surfaceData.atDistance = surfaceDescription.RefractionDistance; surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha); surfaceDescription.Alpha = 1.0; } else { surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; surfaceDescription.Alpha = 1.0; } #else surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; #endif // These static material feature allow compile time optimization surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD; #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION; #endif #ifdef _MATERIAL_FEATURE_ANISOTROPY surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY; #endif // surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT; #ifdef _MATERIAL_FEATURE_IRIDESCENCE surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE; #endif #ifdef _MATERIAL_FEATURE_SPECULAR_COLOR surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR; #endif #if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && 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 #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #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, doubleSidedConstants); bentNormalWS = surfaceData.normalWS; // GetNormalWS(fragInputs, surfaceDescription.BentNormal, bentNormalWS, doubleSidedConstants); surfaceData.geomNormalWS = fragInputs.tangentToWorld[2]; surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT // surfaceData.tangentWS = TransformTangentToWorld(surfaceDescription.Tangent, fragInputs.tangentToWorld); 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 #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; #endif #if HAVE_DECALS if (_EnableDecals) { DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); } #endif #ifdef _ENABLE_GEOMETRIC_SPECULAR_AA surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold); #endif #ifdef DEBUG_DISPLAY if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE) { // TODO: need to update mip info surfaceData.metallic = 0; } // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.tangentToWorld, 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 LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x); #endif #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #endif ApplyDoubleSidedFlipOrMirror(fragInputs, doubleSidedConstants); 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.. DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThreshold); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPrepass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPostpass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdShadow); // ApplyDepthOffsetPositionInput(V, surfaceDescription.DepthOffset, GetViewForwardDir(), GetWorldToHClipMatrix(), posInput); float3 bentNormalWS; BuildSurfaceData(fragInputs, surfaceDescription, V, posInput, surfaceData, bentNormalWS); // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(posInput, surfaceDescription.Alpha, bentNormalWS, -fragInputs.tangentToWorld[2], fragInputs.texCoord1, fragInputs.texCoord2, builtinData); // override sampleBakedGI: // builtinData.bakeDiffuseLighting = surfaceDescription.BakedGI; // builtinData.backBakeDiffuseLighting = surfaceDescription.BakedBackGI; // builtinData.emissiveColor = surfaceDescription.Emission; // builtinData.depthOffset = surfaceDescription.DepthOffset; #if (SHADERPASS == SHADERPASS_DISTORTION) builtinData.distortion = surfaceDescription.Distortion; builtinData.distortionBlur = surfaceDescription.DistortionBlur; #else builtinData.distortion = float2(0.0, 0.0); builtinData.distortionBlur = 0.0; #endif PostInitBuiltinData(V, posInput, surfaceData, builtinData); } //------------------------------------------------------------------------------------- // Pass Includes //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPassMotionVectors.hlsl" //------------------------------------------------------------------------------------- // End Pass Includes //------------------------------------------------------------------------------------- ENDHLSL } Pass { // based on HDLitPass.template Name "Forward" Tags { "LightMode" = "Forward" } //------------------------------------------------------------------------------------- // Render Modes (Blend, Cull, ZTest, Stencil, etc) //------------------------------------------------------------------------------------- Blend [_SrcBlend] [_DstBlend], [_AlphaSrcBlend] [_AlphaDstBlend] Cull [_CullModeForward] ZTest Equal ZWrite [_ZWrite] // Stencil setup Stencil { WriteMask [_StencilWriteMask] Ref [_StencilRef] Comp Always Pass Replace } ColorMask [_ColorMaskTransparentVel] 1 //------------------------------------------------------------------------------------- // 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 nolightprobe #pragma multi_compile _ LOD_FADE_CROSSFADE // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT #pragma shader_feature_local _DOUBLESIDED_ON // #pragma shader_feature_local _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY //------------------------------------------------------------------------------------- // Variant Definitions (active field translations to HDRP defines) //------------------------------------------------------------------------------------- // #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1 #define _MATERIAL_FEATURE_TRANSMISSION 1 // #define _MATERIAL_FEATURE_ANISOTROPY 1 // #define _MATERIAL_FEATURE_IRIDESCENCE 1 // #define _MATERIAL_FEATURE_SPECULAR_COLOR 1 // #define _ENABLE_FOG_ON_TRANSPARENT 1 // #define _AMBIENT_OCCLUSION 1 // #define _SPECULAR_OCCLUSION_FROM_AO 1 // #define _SPECULAR_OCCLUSION_FROM_AO_BENT_NORMAL 1 // #define _SPECULAR_OCCLUSION_CUSTOM 1 #define _ENERGY_CONSERVING_SPECULAR 1 // #define _ENABLE_GEOMETRIC_SPECULAR_AA 1 // #define _HAS_REFRACTION 1 // #define _REFRACTION_PLANE 1 // #define _REFRACTION_SPHERE 1 #define _DISABLE_DECALS 1 #define _DISABLE_SSR 1 // #define _ADD_PRECOMPUTED_VELOCITY // #define _WRITE_TRANSPARENT_MOTION_VECTOR 1 // #define _DEPTHOFFSET_ON 1 // #define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1 //------------------------------------------------------------------------------------- // End Variant Definitions //------------------------------------------------------------------------------------- #pragma vertex Vert #pragma fragment Frag // 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/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 #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST #pragma multi_compile SHADOW_LOW SHADOW_MEDIUM SHADOW_HIGH #ifndef DEBUG_DISPLAY #define SHADERPASS_FORWARD_BYPASS_ALPHA_TEST #endif // ACTIVE FIELDS: // DoubleSided // FragInputs.isFrontFace // Material.Translucent // Material.Transmission // AlphaTest // Specular.EnergyConserving // SurfaceDescriptionInputs.TangentSpaceNormal // SurfaceDescriptionInputs.ObjectSpacePosition // SurfaceDescriptionInputs.uv0 // SurfaceDescriptionInputs.uv1 // VertexDescriptionInputs.ObjectSpacePosition // VertexDescriptionInputs.uv0 // VertexDescriptionInputs.uv1 // SurfaceDescription.Albedo // SurfaceDescription.Normal // SurfaceDescription.BentNormal // SurfaceDescription.Thickness // SurfaceDescription.DiffusionProfileHash // SurfaceDescription.CoatMask // SurfaceDescription.Emission // SurfaceDescription.Smoothness // SurfaceDescription.Occlusion // SurfaceDescription.Alpha // SurfaceDescription.AlphaClipThreshold // features.modifyMesh // VertexDescription.VertexPosition // VertexDescription.VertexNormal // VertexDescription.VertexTangent // FragInputs.tangentToWorld // FragInputs.positionRWS // FragInputs.texCoord1 // FragInputs.texCoord2 // VaryingsMeshToPS.cullFace // FragInputs.texCoord0 // AttributesMesh.positionOS // AttributesMesh.uv0 // AttributesMesh.uv1 // VaryingsMeshToPS.tangentWS // VaryingsMeshToPS.normalWS // VaryingsMeshToPS.positionRWS // VaryingsMeshToPS.texCoord1 // VaryingsMeshToPS.texCoord2 // VaryingsMeshToPS.texCoord0 // AttributesMesh.tangentOS // AttributesMesh.normalOS // AttributesMesh.uv2 // Shared Graph Keywords // 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 #define VARYINGS_NEED_CULLFACE #define HAVE_MESH_MODIFICATION // We need isFontFace when using double sided #if defined(_DOUBLESIDED_ON) && !defined(VARYINGS_NEED_CULLFACE) #define VARYINGS_NEED_CULLFACE #endif //------------------------------------------------------------------------------------- // End Defines //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderVariables.hlsl" #ifdef DEBUG_DISPLAY #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Debug/DebugDisplay.hlsl" #endif #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Material.hlsl" #if (SHADERPASS == SHADERPASS_FORWARD) #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/Lighting.hlsl" #define HAS_LIGHTLOOP #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoopDef.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Lighting/LightLoop/LightLoop.hlsl" #else #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/Lit.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" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/Material/Lit/LitDecalData.hlsl" #include "Packages/com.unity.render-pipelines.high-definition/Runtime/ShaderLibrary/ShaderGraphFunctions.hlsl" // Used by SceneSelectionPass int _ObjectId; int _PassValue; //------------------------------------------------------------------------------------- // 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 #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : INSTANCEID_SEMANTIC; #endif // UNITY_ANY_INSTANCING_ENABLED }; // 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 #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; #endif // defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) }; // Generated Type: PackedVaryingsMeshToPS struct PackedVaryingsMeshToPS { float4 positionCS : SV_Position; // unpacked #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional 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 #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) FRONT_FACE_TYPE cullFace : FRONT_FACE_SEMANTIC; // unpacked #endif // conditional }; // Packed Type: VaryingsMeshToPS 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; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToPS 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; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional #if defined(SHADER_STAGE_FRAGMENT) && defined(VARYINGS_NEED_CULLFACE) output.cullFace = input.cullFace; #endif // conditional return output; } // Generated Type: VaryingsMeshToDS struct VaryingsMeshToDS { float3 positionRWS; float3 normalWS; #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; #endif // UNITY_ANY_INSTANCING_ENABLED }; // Generated Type: PackedVaryingsMeshToDS struct PackedVaryingsMeshToDS { #if UNITY_ANY_INSTANCING_ENABLED uint instanceID : CUSTOM_INSTANCE_ID; // unpacked #endif // conditional float3 interp00 : TEXCOORD0; // auto-packed float3 interp01 : TEXCOORD1; // auto-packed }; // Packed Type: VaryingsMeshToDS PackedVaryingsMeshToDS PackVaryingsMeshToDS(VaryingsMeshToDS input) { PackedVaryingsMeshToDS output; output.interp00.xyz = input.positionRWS; output.interp01.xyz = input.normalWS; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } // Unpacked Type: VaryingsMeshToDS VaryingsMeshToDS UnpackVaryingsMeshToDS(PackedVaryingsMeshToDS input) { VaryingsMeshToDS output; output.positionRWS = input.interp00.xyz; output.normalWS = input.interp01.xyz; #if UNITY_ANY_INSTANCING_ENABLED output.instanceID = input.instanceID; #endif // conditional return output; } //------------------------------------------------------------------------------------- // End Interpolator Packing And Struct Declarations //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // Graph generated code //------------------------------------------------------------------------------------- // Shared Graph Properties (uniform inputs) CBUFFER_START(UnityPerMaterial) float4 _HueVariation; float _Smoothness; float _Cutoff; float _NormalScale; float _WindStrength; float _WindPower; float _ThicknessRemap; float4 _EmissionColor; float _RenderQueueType; float _StencilRef; float _StencilWriteMask; float _StencilRefDepth; float _StencilWriteMaskDepth; float _StencilRefMV; float _StencilWriteMaskMV; float _StencilRefDistortionVec; float _StencilWriteMaskDistortionVec; float _StencilWriteMaskGBuffer; float _StencilRefGBuffer; float _ZTestGBuffer; float _RequireSplitLighting; float _ReceivesSSR; float _SurfaceType; float _BlendMode; float _SrcBlend; float _DstBlend; float _AlphaSrcBlend; float _AlphaDstBlend; float _ZWrite; float _CullMode; float _TransparentSortPriority; float _CullModeForward; float _TransparentCullMode; float _ZTestDepthEqualForOpaque; float _ZTestTransparent; float _TransparentBackfaceEnable; float _AlphaCutoffEnable; float _UseShadowThreshold; float _DoubleSidedEnable; float _DoubleSidedNormalMode; float4 _DoubleSidedConstants; float _DiffusionProfileHash; float4 _DiffusionProfileAsset; CBUFFER_END TEXTURE2D(_MainTex); SAMPLER(sampler_MainTex); float4 _MainTex_TexelSize; TEXTURE2D(_BumpTex); SAMPLER(sampler_BumpTex); float4 _BumpTex_TexelSize; SAMPLER(_SampleTexture2D_1F3A9BAF_Sampler_3_Linear_Repeat); SAMPLER(_SampleTexture2D_8F5727BE_Sampler_3_Linear_Repeat); // Vertex Graph Inputs struct VertexDescriptionInputs { float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Vertex Graph Outputs struct VertexDescription { float3 VertexPosition; float3 VertexNormal; float3 VertexTangent; float4 VertexUV; }; // Pixel Graph Inputs struct SurfaceDescriptionInputs { float3 TangentSpaceNormal; // optional float3 ObjectSpacePosition; // optional float4 uv0; // optional float4 uv1; // optional }; // Pixel Graph Outputs struct SurfaceDescription { float3 Albedo; float3 Normal; float3 BentNormal; float Thickness; float DiffusionProfileHash; float CoatMask; float3 Emission; float Smoothness; float Occlusion; float Alpha; float AlphaClipThreshold; }; // Shared Graph Node Functions #include "Includes/CTI_HDRP_10_BillboardVertex.hlsl" void UnpackNormal_float(float4 packedNormal, float scale, out float3 Normal) { Normal.xy = packedNormal.ag * 2 -1; Normal.xy *= scale; Normal.z = sqrt( 1.0f - saturate( dot(Normal.xy, Normal.xy) ) ); } // Vertex Graph Evaluation VertexDescription VertexDescriptionFunction(VertexDescriptionInputs IN) { VertexDescription description = (VertexDescription)0; float3 positionOut; float3 normalOut; float3 tangentOut; float2 uvOut; float colorVariation; CTIBillboard_float(IN.ObjectSpacePosition, IN.uv0.xy, IN.uv1.xyz, _WindStrength, _WindPower, positionOut, normalOut, tangentOut, uvOut, colorVariation); description.VertexPosition = positionOut; description.VertexNormal = normalOut; description.VertexTangent = tangentOut; description.VertexUV.xy = uvOut; description.VertexUV.z = colorVariation; return description; } // Pixel Graph Evaluation SurfaceDescription SurfaceDescriptionFunction(SurfaceDescriptionInputs IN) { SurfaceDescription surface = (SurfaceDescription)0; float4 albedoAlpha = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv0.xy); DoAlphaTest(albedoAlpha.a, _Cutoff); float4 combinedSample = SAMPLE_TEXTURE2D(_BumpTex, sampler_BumpTex, IN.uv0.xy); float3 unpackedNormal; UnpackNormal_float(combinedSample, _NormalScale, unpackedNormal); // Fix up down orientation unpackedNormal.y *= -1; surface.Albedo = albedoAlpha.xyz; surface.Albedo = lerp(surface.Albedo, (surface.Albedo + _HueVariation.rgb) * 0.5, IN.uv0.z * _HueVariation.a); surface.Normal = unpackedNormal; surface.BentNormal = IN.TangentSpaceNormal; surface.Thickness = (1.0f - combinedSample.r) * _ThicknessRemap; surface.DiffusionProfileHash = ((asuint(_DiffusionProfileHash) != 0) ? _DiffusionProfileHash : asfloat(uint(1080305144))); surface.CoatMask = 0; surface.Emission = float3(0, 0, 0); surface.Smoothness = combinedSample.b * _Smoothness; surface.Occlusion = 1; surface.Alpha = albedoAlpha.a; surface.AlphaClipThreshold = _Cutoff; return surface; } //------------------------------------------------------------------------------------- // End graph generated code //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- VertexDescriptionInputs AttributesMeshToVertexDescriptionInputs(AttributesMesh input) { VertexDescriptionInputs output; ZERO_INITIALIZE(VertexDescriptionInputs, output); // output.ObjectSpaceNormal = input.normalOS; // output.WorldSpaceNormal = TransformObjectToWorldNormal(input.normalOS); // output.ViewSpaceNormal = TransformWorldToViewDir(output.WorldSpaceNormal); // output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.ObjectSpaceTangent = input.tangentOS; // output.WorldSpaceTangent = TransformObjectToWorldDir(input.tangentOS.xyz); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.ObjectSpaceBiTangent = normalize(cross(input.normalOS, input.tangentOS) * (input.tangentOS.w > 0.0f ? 1.0f : -1.0f) * GetOddNegativeScale()); // output.WorldSpaceBiTangent = TransformObjectToWorldDir(output.ObjectSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); output.ObjectSpacePosition = input.positionOS; // output.WorldSpacePosition = TransformObjectToWorld(input.positionOS); // output.ViewSpacePosition = TransformWorldToView(output.WorldSpacePosition); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(TransformObjectToWorld(input.positionOS)); // output.WorldSpaceViewDirection = GetWorldSpaceNormalizeViewDir(output.WorldSpacePosition); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(output.WorldSpacePosition), _ProjectionParams.x); output.uv0 = input.uv0; output.uv1 = input.uv1; // output.uv2 = input.uv2; // output.uv3 = input.uv3; // output.VertexColor = input.color; return output; } AttributesMesh ApplyMeshModification(AttributesMesh input, float3 timeParameters) { // build graph inputs VertexDescriptionInputs vertexDescriptionInputs = AttributesMeshToVertexDescriptionInputs(input); // Override time paramters with used one (This is required to correctly handle motion vector for vertex animation based on time) // vertexDescriptionInputs.TimeParameters = timeParameters; // evaluate vertex graph VertexDescription vertexDescription = VertexDescriptionFunction(vertexDescriptionInputs); // copy graph output to the results input.positionOS = vertexDescription.VertexPosition; input.normalOS = vertexDescription.VertexNormal; input.tangentOS.xyz = vertexDescription.VertexTangent; // z contains color variation input.uv0.xyz = vertexDescription.VertexUV.xyz; return input; } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : VertexAnimation.template.hlsl //------------------------------------------------------------------------------------- //------------------------------------------------------------------------------------- // 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.tangentToWorld = k_identity3x3; output.positionSS = input.positionCS; // input.positionCS is SV_Position output.positionRWS = input.positionRWS; output.tangentToWorld = BuildTangentToWorld(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 _DOUBLESIDED_ON && SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #elif SHADER_STAGE_FRAGMENT output.isFrontFace = IS_FRONT_VFACE(input.cullFace, true, false); #endif return output; } SurfaceDescriptionInputs FragInputsToSurfaceDescriptionInputs(FragInputs input, float3 viewWS) { SurfaceDescriptionInputs output; ZERO_INITIALIZE(SurfaceDescriptionInputs, output); // output.WorldSpaceNormal = normalize(input.tangentToWorld[2].xyz); // output.ObjectSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_M); // transposed multiplication by inverse matrix to handle normal scale // output.ViewSpaceNormal = mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V); // transposed multiplication by inverse matrix to handle normal scale output.TangentSpaceNormal = float3(0.0f, 0.0f, 1.0f); // output.WorldSpaceTangent = input.tangentToWorld[0].xyz; // output.ObjectSpaceTangent = TransformWorldToObjectDir(output.WorldSpaceTangent); // output.ViewSpaceTangent = TransformWorldToViewDir(output.WorldSpaceTangent); // output.TangentSpaceTangent = float3(1.0f, 0.0f, 0.0f); // output.WorldSpaceBiTangent = input.tangentToWorld[1].xyz; // output.ObjectSpaceBiTangent = TransformWorldToObjectDir(output.WorldSpaceBiTangent); // output.ViewSpaceBiTangent = TransformWorldToViewDir(output.WorldSpaceBiTangent); // output.TangentSpaceBiTangent = float3(0.0f, 1.0f, 0.0f); // output.WorldSpaceViewDirection = normalize(viewWS); // output.ObjectSpaceViewDirection = TransformWorldToObjectDir(output.WorldSpaceViewDirection); // output.ViewSpaceViewDirection = TransformWorldToViewDir(output.WorldSpaceViewDirection); // float3x3 tangentSpaceTransform = float3x3(output.WorldSpaceTangent,output.WorldSpaceBiTangent,output.WorldSpaceNormal); // output.TangentSpaceViewDirection = mul(tangentSpaceTransform, output.WorldSpaceViewDirection); // output.WorldSpacePosition = input.positionRWS; output.ObjectSpacePosition = TransformWorldToObject(input.positionRWS); // output.ViewSpacePosition = TransformWorldToView(input.positionRWS); // output.TangentSpacePosition = float3(0.0f, 0.0f, 0.0f); // output.AbsoluteWorldSpacePosition = GetAbsolutePositionWS(input.positionRWS); // output.ScreenPosition = ComputeScreenPos(TransformWorldToHClip(input.positionRWS), _ProjectionParams.x); output.uv0 = input.texCoord0; output.uv1 = input.texCoord1; // output.uv2 = input.texCoord2; // output.uv3 = input.texCoord3; // output.VertexColor = input.color; // output.FaceSign = input.isFrontFace; // output.TimeParameters = _TimeParameters.xyz; // This is mainly for LW as HD overwrite this value return output; } // existing HDRP code uses the combined function to go directly from packed to frag inputs FragInputs UnpackVaryingsMeshToFragInputs(PackedVaryingsMeshToPS input) { UNITY_SETUP_INSTANCE_ID(input); VaryingsMeshToPS unpacked= UnpackVaryingsMeshToPS(input); return BuildFragInputs(unpacked); } //------------------------------------------------------------------------------------- // END TEMPLATE INCLUDE : SharedCode.template.hlsl //------------------------------------------------------------------------------------- void BuildSurfaceData(FragInputs fragInputs, inout SurfaceDescription surfaceDescription, float3 V, PositionInputs posInput, out SurfaceData surfaceData, out float3 bentNormalWS) { // 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.specularOcclusion = surfaceDescription.SpecularOcclusion; // surfaceData.metallic = surfaceDescription.Metallic; // surfaceData.subsurfaceMask = surfaceDescription.SubsurfaceMask; surfaceData.thickness = surfaceDescription.Thickness; surfaceData.diffusionProfileHash = asuint(surfaceDescription.DiffusionProfileHash); // surfaceData.specularColor = surfaceDescription.Specular; surfaceData.coatMask = surfaceDescription.CoatMask; // surfaceData.anisotropy = surfaceDescription.Anisotropy; // surfaceData.iridescenceMask = surfaceDescription.IridescenceMask; // surfaceData.iridescenceThickness = surfaceDescription.IridescenceThickness; #ifdef _HAS_REFRACTION if (_EnableSSRefraction) { // surfaceData.ior = surfaceDescription.RefractionIndex; // surfaceData.transmittanceColor = surfaceDescription.RefractionColor; // surfaceData.atDistance = surfaceDescription.RefractionDistance; surfaceData.transmittanceMask = (1.0 - surfaceDescription.Alpha); surfaceDescription.Alpha = 1.0; } else { surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; surfaceDescription.Alpha = 1.0; } #else surfaceData.ior = 1.0; surfaceData.transmittanceColor = float3(1.0, 1.0, 1.0); surfaceData.atDistance = 1.0; surfaceData.transmittanceMask = 0.0; #endif // These static material feature allow compile time optimization surfaceData.materialFeatures = MATERIALFEATUREFLAGS_LIT_STANDARD; #ifdef _MATERIAL_FEATURE_SUBSURFACE_SCATTERING surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING; #endif #ifdef _MATERIAL_FEATURE_TRANSMISSION surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_TRANSMISSION; #endif #ifdef _MATERIAL_FEATURE_ANISOTROPY surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_ANISOTROPY; #endif // surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_CLEAR_COAT; #ifdef _MATERIAL_FEATURE_IRIDESCENCE surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_IRIDESCENCE; #endif #ifdef _MATERIAL_FEATURE_SPECULAR_COLOR surfaceData.materialFeatures |= MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR; #endif #if defined (_MATERIAL_FEATURE_SPECULAR_COLOR) && 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 #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #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, doubleSidedConstants); bentNormalWS = surfaceData.normalWS; // GetNormalWS(fragInputs, surfaceDescription.BentNormal, bentNormalWS, doubleSidedConstants); surfaceData.geomNormalWS = fragInputs.tangentToWorld[2]; surfaceData.tangentWS = normalize(fragInputs.tangentToWorld[0].xyz); // The tangent is not normalize in tangentToWorld for mikkt. TODO: Check if it expected that we normalize with Morten. Tag: SURFACE_GRADIENT // surfaceData.tangentWS = TransformTangentToWorld(surfaceDescription.Tangent, fragInputs.tangentToWorld); 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 #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; #endif #if HAVE_DECALS if (_EnableDecals) { DecalSurfaceData decalSurfaceData = GetDecalSurfaceData(posInput, surfaceDescription.Alpha); ApplyDecalToSurfaceData(decalSurfaceData, surfaceData); } #endif #ifdef _ENABLE_GEOMETRIC_SPECULAR_AA surfaceData.perceptualSmoothness = GeometricNormalFiltering(surfaceData.perceptualSmoothness, fragInputs.tangentToWorld[2], surfaceDescription.SpecularAAScreenSpaceVariance, surfaceDescription.SpecularAAThreshold); #endif #ifdef DEBUG_DISPLAY if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE) { // TODO: need to update mip info surfaceData.metallic = 0; } // We need to call ApplyDebugToSurfaceData after filling the surfarcedata and before filling builtinData // as it can modify attribute use for static lighting ApplyDebugToSurfaceData(fragInputs.tangentToWorld, 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 LODDitheringTransition(ComputeFadeMaskSeed(V, posInput.positionSS), unity_LODFade.x); #endif #ifdef _DOUBLESIDED_ON float3 doubleSidedConstants = _DoubleSidedConstants.xyz; #else float3 doubleSidedConstants = float3(1.0, 1.0, 1.0); #endif ApplyDoubleSidedFlipOrMirror(fragInputs, doubleSidedConstants); 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.. DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThreshold); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPrepass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdDepthPostpass); // DoAlphaTest(surfaceDescription.Alpha, surfaceDescription.AlphaClipThresholdShadow); // ApplyDepthOffsetPositionInput(V, surfaceDescription.DepthOffset, GetViewForwardDir(), GetWorldToHClipMatrix(), posInput); float3 bentNormalWS; BuildSurfaceData(fragInputs, surfaceDescription, V, posInput, surfaceData, bentNormalWS); // Builtin Data // For back lighting we use the oposite vertex normal InitBuiltinData(posInput, surfaceDescription.Alpha, bentNormalWS, -fragInputs.tangentToWorld[2], fragInputs.texCoord1, fragInputs.texCoord2, builtinData); // override sampleBakedGI: // builtinData.bakeDiffuseLighting = surfaceDescription.BakedGI; // builtinData.backBakeDiffuseLighting = surfaceDescription.BakedBackGI; builtinData.emissiveColor = surfaceDescription.Emission; // builtinData.depthOffset = surfaceDescription.DepthOffset; #if (SHADERPASS == SHADERPASS_DISTORTION) builtinData.distortion = surfaceDescription.Distortion; builtinData.distortionBlur = surfaceDescription.DistortionBlur; #else builtinData.distortion = float2(0.0, 0.0); builtinData.distortionBlur = 0.0; #endif PostInitBuiltinData(V, posInput, surfaceData, builtinData); } //------------------------------------------------------------------------------------- // Pass Includes //------------------------------------------------------------------------------------- #include "Packages/com.unity.render-pipelines.high-definition/Runtime/RenderPipeline/ShaderPass/ShaderPassForward.hlsl" //------------------------------------------------------------------------------------- // End Pass Includes //------------------------------------------------------------------------------------- ENDHLSL } } //CustomEditor "UnityEditor.Rendering.HighDefinition.HDLitGUI" CustomEditor "Rendering.HighDefinition.LitShaderGraphGUI" FallBack "Hidden/InternalErrorShader" }