From 1c65edb0f62b9f697e9c6b00bb1675cf7843ce66 Mon Sep 17 00:00:00 2001 From: kivss <131788033+kivss@users.noreply.github.com> Date: Sun, 5 Apr 2026 04:49:25 +0800 Subject: [PATCH 1/2] Update DTM_Trail_TrailBody_02.mat --- .../Materials/Track/DTM_Trail_TrailBody_02.mat | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Assets/ThemeBundles/DepartureToMultiverse/Materials/Track/DTM_Trail_TrailBody_02.mat b/Assets/ThemeBundles/DepartureToMultiverse/Materials/Track/DTM_Trail_TrailBody_02.mat index d3ea5684..0558213a 100644 --- a/Assets/ThemeBundles/DepartureToMultiverse/Materials/Track/DTM_Trail_TrailBody_02.mat +++ b/Assets/ThemeBundles/DepartureToMultiverse/Materials/Track/DTM_Trail_TrailBody_02.mat @@ -62,8 +62,8 @@ Material: m_Scale: {x: 1, y: 1} m_Offset: {x: 0, y: 0} - _MainTexture: - m_Texture: {fileID: 2800000, guid: fe0f51232d3c144e98a40dcef497dca2, type: 3} - m_Scale: {x: 1, y: 1} + m_Texture: {fileID: 2800000, guid: f7c43c04eaf5cc94da06bd3230b69ee0, type: 3} + m_Scale: {x: -1, y: 1} m_Offset: {x: 0, y: 0} - _MaskTex: m_Texture: {fileID: 0} From 298ed1eaa2df58a8daae89c98668e15ba66730a5 Mon Sep 17 00:00:00 2001 From: kivss <131788033+kivss@users.noreply.github.com> Date: Sun, 5 Apr 2026 17:59:57 +0800 Subject: [PATCH 2/2] hold1 --- Assets/000_assets/shader/hold 1.shader | 2559 +++++++++++++++++ Assets/000_assets/shader/hold 1.shader.meta | 11 + .../Materials/Notes/M_holda.mat | 176 ++ .../Materials/Notes/M_holda.mat.meta | 8 + 4 files changed, 2754 insertions(+) create mode 100644 Assets/000_assets/shader/hold 1.shader create mode 100644 Assets/000_assets/shader/hold 1.shader.meta create mode 100644 Assets/ThemeBundles/DepartureToMultiverse/Materials/Notes/M_holda.mat create mode 100644 Assets/ThemeBundles/DepartureToMultiverse/Materials/Notes/M_holda.mat.meta diff --git a/Assets/000_assets/shader/hold 1.shader b/Assets/000_assets/shader/hold 1.shader new file mode 100644 index 00000000..5f99a9d0 --- /dev/null +++ b/Assets/000_assets/shader/hold 1.shader @@ -0,0 +1,2559 @@ +// Made with Amplify Shader Editor v1.9.9.4 +// Available at the Unity Asset Store - http://u3d.as/y3X +Shader "Soullies/hold1" +{ + Properties + { + [HideInInspector] _AlphaCutoff("Alpha Cutoff ", Range(0, 1)) = 0.5 + [HideInInspector] _EmissionColor("Emission Color", Color) = (1,1,1,1) + _IOR_ins( "IOR_ins", Float ) = 0 + [HDR] _IN( "IN", Color ) = ( 0, 0, 0, 1 ) + [HDR] _OUT( "OUT", Color ) = ( 1, 1, 1, 1 ) + _edge( "edge", Float ) = 0.2 + _MainAlpha( "MainAlpha", Float ) = 0 + _front( "front", Color ) = ( 1, 1, 1, 0 ) + _behind( "behind", Color ) = ( 0.4528302, 0.4528302, 0.4528302, 0 ) + + + //_TessPhongStrength( "Tess Phong Strength", Range( 0, 1 ) ) = 0.5 + //_TessValue( "Tess Max Tessellation", Range( 1, 32 ) ) = 16 + //_TessMin( "Tess Min Distance", Float ) = 10 + //_TessMax( "Tess Max Distance", Float ) = 25 + //_TessEdgeLength ( "Tess Edge length", Range( 2, 50 ) ) = 16 + //_TessMaxDisp( "Tess Max Displacement", Float ) = 25 + + [HideInInspector] _QueueOffset("_QueueOffset", Float) = 0 + [HideInInspector] _QueueControl("_QueueControl", Float) = -1 + + [HideInInspector][NoScaleOffset] unity_Lightmaps("unity_Lightmaps", 2DArray) = "" {} + [HideInInspector][NoScaleOffset] unity_LightmapsInd("unity_LightmapsInd", 2DArray) = "" {} + [HideInInspector][NoScaleOffset] unity_ShadowMasks("unity_ShadowMasks", 2DArray) = "" {} + + //[HideInInspector][ToggleUI] _AddPrecomputedVelocity("Add Precomputed Velocity", Float) = 1 + [HideInInspector][ToggleOff] _ReceiveShadows("Receive Shadows", Float) = 1 + + //[HideInInspector] _XRMotionVectorsPass("_XRMotionVectorsPass", Float) = 1 + } + + SubShader + { + LOD 0 + + + + Tags { "RenderPipeline"="UniversalPipeline" "RenderType"="Transparent" "Queue"="Transparent" "UniversalMaterialType"="Unlit" } + + Cull Back + AlphaToMask Off + + + + HLSLINCLUDE + #pragma target 4.5 + #pragma prefer_hlslcc gles + // ensure rendering platforms toggle list is visible + + #if ( SHADER_TARGET > 35 ) && defined( SHADER_API_GLES3 ) + #error For WebGL2/GLES3, please set your shader target to 3.5 via SubShader options. URP shaders in ASE use target 4.5 by default. + #endif + + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Filtering.hlsl" + + #ifndef ASE_TESS_FUNCS + #define ASE_TESS_FUNCS + float4 FixedTess( float tessValue ) + { + return tessValue; + } + + float CalcDistanceTessFactor (float4 vertex, float minDist, float maxDist, float tess, float4x4 o2w, float3 cameraPos ) + { + float3 wpos = mul(o2w,vertex).xyz; + float dist = distance (wpos, cameraPos); + float f = clamp(1.0 - (dist - minDist) / (maxDist - minDist), 0.01, 1.0) * tess; + return f; + } + + float4 CalcTriEdgeTessFactors (float3 triVertexFactors) + { + float4 tess; + tess.x = 0.5 * (triVertexFactors.y + triVertexFactors.z); + tess.y = 0.5 * (triVertexFactors.x + triVertexFactors.z); + tess.z = 0.5 * (triVertexFactors.x + triVertexFactors.y); + tess.w = (triVertexFactors.x + triVertexFactors.y + triVertexFactors.z) / 3.0f; + return tess; + } + + float CalcEdgeTessFactor (float3 wpos0, float3 wpos1, float edgeLen, float3 cameraPos, float4 scParams ) + { + float dist = distance (0.5 * (wpos0+wpos1), cameraPos); + float len = distance(wpos0, wpos1); + float f = max(len * scParams.y / (edgeLen * dist), 1.0); + return f; + } + + float DistanceFromPlane (float3 pos, float4 plane) + { + float d = dot (float4(pos,1.0f), plane); + return d; + } + + bool WorldViewFrustumCull (float3 wpos0, float3 wpos1, float3 wpos2, float cullEps, float4 planes[6] ) + { + float4 planeTest; + planeTest.x = (( DistanceFromPlane(wpos0, planes[0]) > -cullEps) ? 1.0f : 0.0f ) + + (( DistanceFromPlane(wpos1, planes[0]) > -cullEps) ? 1.0f : 0.0f ) + + (( DistanceFromPlane(wpos2, planes[0]) > -cullEps) ? 1.0f : 0.0f ); + planeTest.y = (( DistanceFromPlane(wpos0, planes[1]) > -cullEps) ? 1.0f : 0.0f ) + + (( DistanceFromPlane(wpos1, planes[1]) > -cullEps) ? 1.0f : 0.0f ) + + (( DistanceFromPlane(wpos2, planes[1]) > -cullEps) ? 1.0f : 0.0f ); + planeTest.z = (( DistanceFromPlane(wpos0, planes[2]) > -cullEps) ? 1.0f : 0.0f ) + + (( DistanceFromPlane(wpos1, planes[2]) > -cullEps) ? 1.0f : 0.0f ) + + (( DistanceFromPlane(wpos2, planes[2]) > -cullEps) ? 1.0f : 0.0f ); + planeTest.w = (( DistanceFromPlane(wpos0, planes[3]) > -cullEps) ? 1.0f : 0.0f ) + + (( DistanceFromPlane(wpos1, planes[3]) > -cullEps) ? 1.0f : 0.0f ) + + (( DistanceFromPlane(wpos2, planes[3]) > -cullEps) ? 1.0f : 0.0f ); + return !all (planeTest); + } + + float4 DistanceBasedTess( float4 v0, float4 v1, float4 v2, float tess, float minDist, float maxDist, float4x4 o2w, float3 cameraPos ) + { + float3 f; + f.x = CalcDistanceTessFactor (v0,minDist,maxDist,tess,o2w,cameraPos); + f.y = CalcDistanceTessFactor (v1,minDist,maxDist,tess,o2w,cameraPos); + f.z = CalcDistanceTessFactor (v2,minDist,maxDist,tess,o2w,cameraPos); + + return CalcTriEdgeTessFactors (f); + } + + float4 EdgeLengthBasedTess( float4 v0, float4 v1, float4 v2, float edgeLength, float4x4 o2w, float3 cameraPos, float4 scParams ) + { + float3 pos0 = mul(o2w,v0).xyz; + float3 pos1 = mul(o2w,v1).xyz; + float3 pos2 = mul(o2w,v2).xyz; + float4 tess; + tess.x = CalcEdgeTessFactor (pos1, pos2, edgeLength, cameraPos, scParams); + tess.y = CalcEdgeTessFactor (pos2, pos0, edgeLength, cameraPos, scParams); + tess.z = CalcEdgeTessFactor (pos0, pos1, edgeLength, cameraPos, scParams); + tess.w = (tess.x + tess.y + tess.z) / 3.0f; + return tess; + } + + float4 EdgeLengthBasedTessCull( float4 v0, float4 v1, float4 v2, float edgeLength, float maxDisplacement, float4x4 o2w, float3 cameraPos, float4 scParams, float4 planes[6] ) + { + float3 pos0 = mul(o2w,v0).xyz; + float3 pos1 = mul(o2w,v1).xyz; + float3 pos2 = mul(o2w,v2).xyz; + float4 tess; + + if (WorldViewFrustumCull(pos0, pos1, pos2, maxDisplacement, planes)) + { + tess = 0.0f; + } + else + { + tess.x = CalcEdgeTessFactor (pos1, pos2, edgeLength, cameraPos, scParams); + tess.y = CalcEdgeTessFactor (pos2, pos0, edgeLength, cameraPos, scParams); + tess.z = CalcEdgeTessFactor (pos0, pos1, edgeLength, cameraPos, scParams); + tess.w = (tess.x + tess.y + tess.z) / 3.0f; + } + return tess; + } + #endif //ASE_TESS_FUNCS + ENDHLSL + + + Pass + { + + Name "Forward" + Tags { "LightMode"="UniversalForwardOnly" } + + Blend SrcAlpha OneMinusSrcAlpha, One OneMinusSrcAlpha + ZWrite Off + ZTest LEqual + Offset 0 , 0 + ColorMask RGBA + + + + HLSLPROGRAM + + #define _ALPHATEST_ON 1 + #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION + #pragma multi_compile_instancing + #pragma instancing_options renderinglayer + #pragma multi_compile _ LOD_FADE_CROSSFADE + #define ASE_FOG 1 + #define _SURFACE_TYPE_TRANSPARENT 1 + #define ASE_VERSION 19904 + #define ASE_SRP_VERSION -1 + + + #pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3 + + #pragma multi_compile_fragment _ DEBUG_DISPLAY + + #pragma vertex vert + #pragma fragment frag + + #define SHADERPASS SHADERPASS_UNLIT + + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Fog.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRendering.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DBuffer.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl" + + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Debug/Debugging3D.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/SurfaceData.hlsl" + + #if defined(LOD_FADE_CROSSFADE) + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/LODCrossFade.hlsl" + #endif + + #define ASE_NEEDS_WORLD_NORMAL + #define ASE_NEEDS_FRAG_WORLD_NORMAL + #define ASE_NEEDS_FRAG_WORLD_VIEW_DIR + #define ASE_NEEDS_TEXTURE_COORDINATES0 + + + #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE) && (SHADER_TARGET >= 45) + #define ASE_SV_DEPTH SV_DepthLessEqual + #define ASE_SV_POSITION_QUALIFIERS linear noperspective centroid + #else + #define ASE_SV_DEPTH SV_Depth + #define ASE_SV_POSITION_QUALIFIERS + #endif + + struct Attributes + { + float4 positionOS : POSITION; + half3 normalOS : NORMAL; + float4 ase_color : COLOR; + float4 ase_texcoord : TEXCOORD0; + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct PackedVaryings + { + ASE_SV_POSITION_QUALIFIERS float4 positionCS : SV_POSITION; + float4 positionWSAndFogFactor : TEXCOORD0; + half3 normalWS : TEXCOORD1; + float4 ase_color : COLOR; + float4 ase_texcoord2 : TEXCOORD2; + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + + CBUFFER_START(UnityPerMaterial) + float4 _IN; + float4 _OUT; + float4 _front; + float4 _behind; + float _IOR_ins; + float _edge; + float _MainAlpha; + #ifdef ASE_TESSELLATION + float _TessPhongStrength; + float _TessValue; + float _TessMin; + float _TessMax; + float _TessEdgeLength; + float _TessMaxDisp; + #endif + CBUFFER_END + + + + + PackedVaryings VertexFunction( Attributes input ) + { + PackedVaryings output = (PackedVaryings)0; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output); + + output.ase_color = input.ase_color; + output.ase_texcoord2.xy = input.ase_texcoord.xy; + + //setting value to unused interpolator channels and avoid initialization warnings + output.ase_texcoord2.zw = 0; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + float3 defaultVertexValue = input.positionOS.xyz; + #else + float3 defaultVertexValue = float3(0, 0, 0); + #endif + + float3 vertexValue = defaultVertexValue; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + input.positionOS.xyz = vertexValue; + #else + input.positionOS.xyz += vertexValue; + #endif + + input.normalOS = input.normalOS; + + VertexPositionInputs vertexInput = GetVertexPositionInputs( input.positionOS.xyz ); + VertexNormalInputs normalInput = GetVertexNormalInputs( input.normalOS ); + + float fogFactor = 0; + #if defined(ASE_FOG) && !defined(_FOG_FRAGMENT) + fogFactor = ComputeFogFactor(vertexInput.positionCS.z); + #endif + + output.positionCS = vertexInput.positionCS; + output.positionWSAndFogFactor = float4( vertexInput.positionWS, fogFactor ); + output.normalWS = normalInput.normalWS; + return output; + } + + #if defined(ASE_TESSELLATION) + struct VertexControl + { + float4 positionOS : INTERNALTESSPOS; + half3 normalOS : NORMAL; + float4 ase_color : COLOR; + float4 ase_texcoord : TEXCOORD0; + + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct TessellationFactors + { + float edge[3] : SV_TessFactor; + float inside : SV_InsideTessFactor; + }; + + VertexControl vert ( Attributes input ) + { + VertexControl output; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + output.positionOS = input.positionOS; + output.normalOS = input.normalOS; + output.ase_color = input.ase_color; + output.ase_texcoord = input.ase_texcoord; + return output; + } + + TessellationFactors TessellationFunction (InputPatch input) + { + TessellationFactors output; + float4 tf = 1; + float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax; + float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp; + #if defined(ASE_FIXED_TESSELLATION) + tf = FixedTess( tessValue ); + #elif defined(ASE_DISTANCE_TESSELLATION) + tf = DistanceBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos ); + #elif defined(ASE_LENGTH_TESSELLATION) + tf = EdgeLengthBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams ); + #elif defined(ASE_LENGTH_CULL_TESSELLATION) + tf = EdgeLengthBasedTessCull(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes ); + #endif + output.edge[0] = tf.x; output.edge[1] = tf.y; output.edge[2] = tf.z; output.inside = tf.w; + return output; + } + + [domain("tri")] + [partitioning("fractional_odd")] + [outputtopology("triangle_cw")] + [patchconstantfunc("TessellationFunction")] + [outputcontrolpoints(3)] + VertexControl HullFunction(InputPatch patch, uint id : SV_OutputControlPointID) + { + return patch[id]; + } + + [domain("tri")] + PackedVaryings DomainFunction(TessellationFactors factors, OutputPatch patch, float3 bary : SV_DomainLocation) + { + Attributes output = (Attributes) 0; + output.positionOS = patch[0].positionOS * bary.x + patch[1].positionOS * bary.y + patch[2].positionOS * bary.z; + output.normalOS = patch[0].normalOS * bary.x + patch[1].normalOS * bary.y + patch[2].normalOS * bary.z; + output.ase_color = patch[0].ase_color * bary.x + patch[1].ase_color * bary.y + patch[2].ase_color * bary.z; + output.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z; + #if defined(ASE_PHONG_TESSELLATION) + float3 pp[3]; + for (int i = 0; i < 3; ++i) + pp[i] = output.positionOS.xyz - patch[i].normalOS * (dot(output.positionOS.xyz, patch[i].normalOS) - dot(patch[i].positionOS.xyz, patch[i].normalOS)); + float phongStrength = _TessPhongStrength; + output.positionOS.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * output.positionOS.xyz; + #endif + UNITY_TRANSFER_INSTANCE_ID(patch[0], output); + return VertexFunction(output); + } + #else + PackedVaryings vert ( Attributes input ) + { + return VertexFunction( input ); + } + #endif + + half4 frag ( PackedVaryings input + #if defined( ASE_DEPTH_WRITE_ON ) + ,out float outputDepth : ASE_SV_DEPTH + #endif + #ifdef _WRITE_RENDERING_LAYERS + , out uint outRenderingLayers : SV_Target1 + #endif + ) : SV_Target + { + UNITY_SETUP_INSTANCE_ID(input); + UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input); + + #if defined( _SURFACE_TYPE_TRANSPARENT ) + const bool isTransparent = true; + #else + const bool isTransparent = false; + #endif + + #if defined(LOD_FADE_CROSSFADE) + LODFadeCrossFade( input.positionCS ); + #endif + + #if defined(MAIN_LIGHT_CALCULATE_SHADOWS) + float4 shadowCoord = TransformWorldToShadowCoord( input.positionWSAndFogFactor.xyz ); + #else + float4 shadowCoord = float4(0, 0, 0, 0); + #endif + + float3 PositionWS = input.positionWSAndFogFactor.xyz; + float3 PositionRWS = GetCameraRelativePositionWS( PositionWS ); + half3 ViewDirWS = GetWorldSpaceNormalizeViewDir( PositionWS ); + float4 ShadowCoord = shadowCoord; + float4 ScreenPosNorm = float4( GetNormalizedScreenSpaceUV( input.positionCS ), input.positionCS.zw ); + float4 ClipPos = ComputeClipSpacePosition( ScreenPosNorm.xy, input.positionCS.z ) * input.positionCS.w; + float4 ScreenPos = ComputeScreenPos( ClipPos ); + half3 NormalWS = normalize( input.normalWS ); + + float3 normalizeResult65 = normalize( NormalWS ); + float3 worldSpaceViewDir64 = ( _WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4( 0,0,0,1 ) ).xyz ); + float3 normalizeResult66 = normalize( worldSpaceViewDir64 ); + float dotResult67 = dot( normalizeResult65 , normalizeResult66 ); + float smoothstepResult71 = smoothstep( ( 1.0 - _IOR_ins ) , 1.0 , ( 1.0 - abs( dotResult67 ) )); + float3 normalizeResult199 = normalize( ViewDirWS ); + float dotResult200 = dot( NormalWS , normalizeResult199 ); + float4 lerpResult86 = lerp( _IN , _OUT , ( smoothstepResult71 + ( abs( dotResult200 ) < _edge ? 1.0 : 0.0 ) )); + float2 texCoord235 = input.ase_texcoord2.xy * float2( 1,1 ) + float2( 0,0 ); + float temp_output_236_0 = (texCoord235).y; + float3 lerpResult238 = lerp( _front.rgb , _behind.rgb , temp_output_236_0); + + float lerpResult243 = lerp( _front.a , _behind.a , temp_output_236_0); + + float3 BakedAlbedo = 0; + float3 BakedEmission = 0; + float3 Color = ( lerpResult86 * input.ase_color * float4( lerpResult238 , 0.0 ) ).rgb; + float Alpha = saturate( ( ( lerpResult86 + (-1.0 + ( _MainAlpha - 0.0 ) * ( 1.0 - -1.0 ) / ( 1.0 - 0.0 ) ) ) * lerpResult243 ) ).r; + float AlphaClipThreshold = 0.5; + float AlphaClipThresholdShadow = 0.5; + + #if defined( ASE_DEPTH_WRITE_ON ) + float DeviceDepth = input.positionCS.z; + #endif + + #if defined( _ALPHATEST_ON ) + AlphaDiscard( Alpha, AlphaClipThreshold ); + #endif + + #if defined(MAIN_LIGHT_CALCULATE_SHADOWS) && defined(ASE_CHANGES_WORLD_POS) + ShadowCoord = TransformWorldToShadowCoord( PositionWS ); + #endif + + InputData inputData = (InputData)0; + inputData.positionWS = PositionWS; + inputData.positionCS = float4( input.positionCS.xy, ClipPos.zw / ClipPos.w ); + inputData.normalizedScreenSpaceUV = ScreenPosNorm.xy; + inputData.normalWS = NormalWS; + inputData.viewDirectionWS = ViewDirWS; + + #if defined(_SCREEN_SPACE_OCCLUSION) && !defined(_SURFACE_TYPE_TRANSPARENT) + float2 normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(input.positionCS); + AmbientOcclusionFactor aoFactor = GetScreenSpaceAmbientOcclusion(normalizedScreenSpaceUV); + Color.rgb *= aoFactor.directAmbientOcclusion; + #endif + + #ifdef ASE_FOG + inputData.fogCoord = InitializeInputDataFog(float4(inputData.positionWS, 1.0), input.positionWSAndFogFactor.w); + #endif + + #if defined(_DBUFFER) + ApplyDecalToBaseColor(input.positionCS, Color); + #endif + + #ifdef ASE_FOG + #ifdef TERRAIN_SPLAT_ADDPASS + Color.rgb = MixFogColor(Color.rgb, half3(0,0,0), inputData.fogCoord); + #else + Color.rgb = MixFog(Color.rgb, inputData.fogCoord); + #endif + #endif + + #if defined( ASE_DEPTH_WRITE_ON ) + outputDepth = DeviceDepth; + #endif + + #ifdef _WRITE_RENDERING_LAYERS + outRenderingLayers = EncodeMeshRenderingLayer(); + #endif + + #if defined( ASE_OPAQUE_KEEP_ALPHA ) + return half4( Color, Alpha ); + #else + return half4( Color, OutputAlpha( Alpha, isTransparent ) ); + #endif + } + ENDHLSL + } + + + Pass + { + + Name "ShadowCaster" + Tags { "LightMode"="ShadowCaster" } + + ZWrite On + ZTest LEqual + AlphaToMask Off + ColorMask 0 + + HLSLPROGRAM + + #define _ALPHATEST_ON 1 + #pragma multi_compile_instancing + #pragma multi_compile _ LOD_FADE_CROSSFADE + #define ASE_FOG 1 + #define _SURFACE_TYPE_TRANSPARENT 1 + #define ASE_VERSION 19904 + #define ASE_SRP_VERSION -1 + + + #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW + + #pragma vertex vert + #pragma fragment frag + + #define SHADERPASS SHADERPASS_SHADOWCASTER + + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" + + #if defined(LOD_FADE_CROSSFADE) + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/LODCrossFade.hlsl" + #endif + + #define ASE_NEEDS_VERT_NORMAL + #define ASE_NEEDS_TEXTURE_COORDINATES0 + + + #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE) && (SHADER_TARGET >= 45) + #define ASE_SV_DEPTH SV_DepthLessEqual + #define ASE_SV_POSITION_QUALIFIERS linear noperspective centroid + #else + #define ASE_SV_DEPTH SV_Depth + #define ASE_SV_POSITION_QUALIFIERS + #endif + + struct Attributes + { + float4 positionOS : POSITION; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct PackedVaryings + { + ASE_SV_POSITION_QUALIFIERS float4 positionCS : SV_POSITION; + float4 ase_texcoord : TEXCOORD0; + float4 ase_texcoord1 : TEXCOORD1; + float4 ase_texcoord2 : TEXCOORD2; + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + + CBUFFER_START(UnityPerMaterial) + float4 _IN; + float4 _OUT; + float4 _front; + float4 _behind; + float _IOR_ins; + float _edge; + float _MainAlpha; + #ifdef ASE_TESSELLATION + float _TessPhongStrength; + float _TessValue; + float _TessMin; + float _TessMax; + float _TessEdgeLength; + float _TessMaxDisp; + #endif + CBUFFER_END + + + + + float3 _LightDirection; + float3 _LightPosition; + + PackedVaryings VertexFunction( Attributes input ) + { + PackedVaryings output; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO( output ); + + float3 ase_normalWS = TransformObjectToWorldNormal( input.normalOS ); + output.ase_texcoord.xyz = ase_normalWS; + float3 ase_positionWS = TransformObjectToWorld( ( input.positionOS ).xyz ); + output.ase_texcoord1.xyz = ase_positionWS; + + output.ase_texcoord2.xy = input.ase_texcoord.xy; + + //setting value to unused interpolator channels and avoid initialization warnings + output.ase_texcoord.w = 0; + output.ase_texcoord1.w = 0; + output.ase_texcoord2.zw = 0; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + float3 defaultVertexValue = input.positionOS.xyz; + #else + float3 defaultVertexValue = float3(0, 0, 0); + #endif + + float3 vertexValue = defaultVertexValue; + #ifdef ASE_ABSOLUTE_VERTEX_POS + input.positionOS.xyz = vertexValue; + #else + input.positionOS.xyz += vertexValue; + #endif + + input.normalOS = input.normalOS; + + float3 positionWS = TransformObjectToWorld( input.positionOS.xyz ); + half3 normalWS = TransformObjectToWorldDir(input.normalOS); + + #if _CASTING_PUNCTUAL_LIGHT_SHADOW + float3 lightDirectionWS = normalize(_LightPosition - positionWS); + #else + float3 lightDirectionWS = _LightDirection; + #endif + + float4 positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, lightDirectionWS)); + + #if UNITY_REVERSED_Z + positionCS.z = min(positionCS.z, UNITY_NEAR_CLIP_VALUE); + #else + positionCS.z = max(positionCS.z, UNITY_NEAR_CLIP_VALUE); + #endif + + output.positionCS = positionCS; + return output; + } + + #if defined(ASE_TESSELLATION) + struct VertexControl + { + float4 positionOS : INTERNALTESSPOS; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct TessellationFactors + { + float edge[3] : SV_TessFactor; + float inside : SV_InsideTessFactor; + }; + + VertexControl vert ( Attributes input ) + { + VertexControl output; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + output.positionOS = input.positionOS; + output.normalOS = input.normalOS; + output.ase_texcoord = input.ase_texcoord; + return output; + } + + TessellationFactors TessellationFunction (InputPatch input) + { + TessellationFactors output; + float4 tf = 1; + float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax; + float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp; + #if defined(ASE_FIXED_TESSELLATION) + tf = FixedTess( tessValue ); + #elif defined(ASE_DISTANCE_TESSELLATION) + tf = DistanceBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos ); + #elif defined(ASE_LENGTH_TESSELLATION) + tf = EdgeLengthBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams ); + #elif defined(ASE_LENGTH_CULL_TESSELLATION) + tf = EdgeLengthBasedTessCull(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes ); + #endif + output.edge[0] = tf.x; output.edge[1] = tf.y; output.edge[2] = tf.z; output.inside = tf.w; + return output; + } + + [domain("tri")] + [partitioning("fractional_odd")] + [outputtopology("triangle_cw")] + [patchconstantfunc("TessellationFunction")] + [outputcontrolpoints(3)] + VertexControl HullFunction(InputPatch patch, uint id : SV_OutputControlPointID) + { + return patch[id]; + } + + [domain("tri")] + PackedVaryings DomainFunction(TessellationFactors factors, OutputPatch patch, float3 bary : SV_DomainLocation) + { + Attributes output = (Attributes) 0; + output.positionOS = patch[0].positionOS * bary.x + patch[1].positionOS * bary.y + patch[2].positionOS * bary.z; + output.normalOS = patch[0].normalOS * bary.x + patch[1].normalOS * bary.y + patch[2].normalOS * bary.z; + output.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z; + #if defined(ASE_PHONG_TESSELLATION) + float3 pp[3]; + for (int i = 0; i < 3; ++i) + pp[i] = output.positionOS.xyz - patch[i].normalOS * (dot(output.positionOS.xyz, patch[i].normalOS) - dot(patch[i].positionOS.xyz, patch[i].normalOS)); + float phongStrength = _TessPhongStrength; + output.positionOS.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * output.positionOS.xyz; + #endif + UNITY_TRANSFER_INSTANCE_ID(patch[0], output); + return VertexFunction(output); + } + #else + PackedVaryings vert ( Attributes input ) + { + return VertexFunction( input ); + } + #endif + + half4 frag(PackedVaryings input + #if defined( ASE_DEPTH_WRITE_ON ) + ,out float outputDepth : ASE_SV_DEPTH + #endif + ) : SV_Target + { + UNITY_SETUP_INSTANCE_ID( input ); + UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX( input ); + + float4 ScreenPosNorm = float4( GetNormalizedScreenSpaceUV( input.positionCS ), input.positionCS.zw ); + float4 ClipPos = ComputeClipSpacePosition( ScreenPosNorm.xy, input.positionCS.z ) * input.positionCS.w; + float4 ScreenPos = ComputeScreenPos( ClipPos ); + + float3 ase_normalWS = input.ase_texcoord.xyz; + float3 normalizeResult65 = normalize( ase_normalWS ); + float3 worldSpaceViewDir64 = ( _WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4( 0,0,0,1 ) ).xyz ); + float3 normalizeResult66 = normalize( worldSpaceViewDir64 ); + float dotResult67 = dot( normalizeResult65 , normalizeResult66 ); + float smoothstepResult71 = smoothstep( ( 1.0 - _IOR_ins ) , 1.0 , ( 1.0 - abs( dotResult67 ) )); + float3 ase_positionWS = input.ase_texcoord1.xyz; + float3 ase_viewVectorWS = ( _WorldSpaceCameraPos.xyz - ase_positionWS ); + float3 ase_viewDirWS = normalize( ase_viewVectorWS ); + float3 normalizeResult199 = normalize( ase_viewDirWS ); + float dotResult200 = dot( ase_normalWS , normalizeResult199 ); + float4 lerpResult86 = lerp( _IN , _OUT , ( smoothstepResult71 + ( abs( dotResult200 ) < _edge ? 1.0 : 0.0 ) )); + float2 texCoord235 = input.ase_texcoord2.xy * float2( 1,1 ) + float2( 0,0 ); + float temp_output_236_0 = (texCoord235).y; + float lerpResult243 = lerp( _front.a , _behind.a , temp_output_236_0); + + + float Alpha = saturate( ( ( lerpResult86 + (-1.0 + ( _MainAlpha - 0.0 ) * ( 1.0 - -1.0 ) / ( 1.0 - 0.0 ) ) ) * lerpResult243 ) ).r; + float AlphaClipThreshold = 0.5; + float AlphaClipThresholdShadow = 0.5; + + #if defined( ASE_DEPTH_WRITE_ON ) + float DeviceDepth = input.positionCS.z; + #endif + + #if defined( _ALPHATEST_ON ) + #if defined( _ALPHATEST_SHADOW_ON ) + AlphaDiscard( Alpha, AlphaClipThresholdShadow ); + #else + AlphaDiscard( Alpha, AlphaClipThreshold ); + #endif + #endif + + #if defined(LOD_FADE_CROSSFADE) + LODFadeCrossFade( input.positionCS ); + #endif + + #if defined( ASE_DEPTH_WRITE_ON ) + outputDepth = DeviceDepth; + #endif + + return 0; + } + ENDHLSL + } + + + Pass + { + + Name "DepthOnly" + Tags { "LightMode"="DepthOnly" } + + ZWrite On + ColorMask R + AlphaToMask Off + + HLSLPROGRAM + + #define _ALPHATEST_ON 1 + #pragma multi_compile_instancing + #pragma multi_compile _ LOD_FADE_CROSSFADE + #define ASE_FOG 1 + #define _SURFACE_TYPE_TRANSPARENT 1 + #define ASE_VERSION 19904 + #define ASE_SRP_VERSION -1 + + + #pragma vertex vert + #pragma fragment frag + + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" + + #if defined(LOD_FADE_CROSSFADE) + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/LODCrossFade.hlsl" + #endif + + #define ASE_NEEDS_VERT_NORMAL + #define ASE_NEEDS_TEXTURE_COORDINATES0 + + + #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE) && (SHADER_TARGET >= 45) + #define ASE_SV_DEPTH SV_DepthLessEqual + #define ASE_SV_POSITION_QUALIFIERS linear noperspective centroid + #else + #define ASE_SV_DEPTH SV_Depth + #define ASE_SV_POSITION_QUALIFIERS + #endif + + struct Attributes + { + float4 positionOS : POSITION; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct PackedVaryings + { + ASE_SV_POSITION_QUALIFIERS float4 positionCS : SV_POSITION; + float4 ase_texcoord : TEXCOORD0; + float4 ase_texcoord1 : TEXCOORD1; + float4 ase_texcoord2 : TEXCOORD2; + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + + CBUFFER_START(UnityPerMaterial) + float4 _IN; + float4 _OUT; + float4 _front; + float4 _behind; + float _IOR_ins; + float _edge; + float _MainAlpha; + #ifdef ASE_TESSELLATION + float _TessPhongStrength; + float _TessValue; + float _TessMin; + float _TessMax; + float _TessEdgeLength; + float _TessMaxDisp; + #endif + CBUFFER_END + + + + + PackedVaryings VertexFunction( Attributes input ) + { + PackedVaryings output = (PackedVaryings)0; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output); + + float3 ase_normalWS = TransformObjectToWorldNormal( input.normalOS ); + output.ase_texcoord.xyz = ase_normalWS; + float3 ase_positionWS = TransformObjectToWorld( ( input.positionOS ).xyz ); + output.ase_texcoord1.xyz = ase_positionWS; + + output.ase_texcoord2.xy = input.ase_texcoord.xy; + + //setting value to unused interpolator channels and avoid initialization warnings + output.ase_texcoord.w = 0; + output.ase_texcoord1.w = 0; + output.ase_texcoord2.zw = 0; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + float3 defaultVertexValue = input.positionOS.xyz; + #else + float3 defaultVertexValue = float3(0, 0, 0); + #endif + + float3 vertexValue = defaultVertexValue; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + input.positionOS.xyz = vertexValue; + #else + input.positionOS.xyz += vertexValue; + #endif + + VertexPositionInputs vertexInput = GetVertexPositionInputs( input.positionOS.xyz ); + + output.positionCS = vertexInput.positionCS; + return output; + } + + #if defined(ASE_TESSELLATION) + struct VertexControl + { + float4 positionOS : INTERNALTESSPOS; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct TessellationFactors + { + float edge[3] : SV_TessFactor; + float inside : SV_InsideTessFactor; + }; + + VertexControl vert ( Attributes input ) + { + VertexControl output; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + output.positionOS = input.positionOS; + output.normalOS = input.normalOS; + output.ase_texcoord = input.ase_texcoord; + return output; + } + + TessellationFactors TessellationFunction (InputPatch input) + { + TessellationFactors output; + float4 tf = 1; + float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax; + float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp; + #if defined(ASE_FIXED_TESSELLATION) + tf = FixedTess( tessValue ); + #elif defined(ASE_DISTANCE_TESSELLATION) + tf = DistanceBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos ); + #elif defined(ASE_LENGTH_TESSELLATION) + tf = EdgeLengthBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams ); + #elif defined(ASE_LENGTH_CULL_TESSELLATION) + tf = EdgeLengthBasedTessCull(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes ); + #endif + output.edge[0] = tf.x; output.edge[1] = tf.y; output.edge[2] = tf.z; output.inside = tf.w; + return output; + } + + [domain("tri")] + [partitioning("fractional_odd")] + [outputtopology("triangle_cw")] + [patchconstantfunc("TessellationFunction")] + [outputcontrolpoints(3)] + VertexControl HullFunction(InputPatch patch, uint id : SV_OutputControlPointID) + { + return patch[id]; + } + + [domain("tri")] + PackedVaryings DomainFunction(TessellationFactors factors, OutputPatch patch, float3 bary : SV_DomainLocation) + { + Attributes output = (Attributes) 0; + output.positionOS = patch[0].positionOS * bary.x + patch[1].positionOS * bary.y + patch[2].positionOS * bary.z; + output.normalOS = patch[0].normalOS * bary.x + patch[1].normalOS * bary.y + patch[2].normalOS * bary.z; + output.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z; + #if defined(ASE_PHONG_TESSELLATION) + float3 pp[3]; + for (int i = 0; i < 3; ++i) + pp[i] = output.positionOS.xyz - patch[i].normalOS * (dot(output.positionOS.xyz, patch[i].normalOS) - dot(patch[i].positionOS.xyz, patch[i].normalOS)); + float phongStrength = _TessPhongStrength; + output.positionOS.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * output.positionOS.xyz; + #endif + UNITY_TRANSFER_INSTANCE_ID(patch[0], output); + return VertexFunction(output); + } + #else + PackedVaryings vert ( Attributes input ) + { + return VertexFunction( input ); + } + #endif + + half4 frag(PackedVaryings input + #if defined( ASE_DEPTH_WRITE_ON ) + ,out float outputDepth : ASE_SV_DEPTH + #endif + ) : SV_Target + { + UNITY_SETUP_INSTANCE_ID(input); + UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX( input ); + + float4 ScreenPosNorm = float4( GetNormalizedScreenSpaceUV( input.positionCS ), input.positionCS.zw ); + float4 ClipPos = ComputeClipSpacePosition( ScreenPosNorm.xy, input.positionCS.z ) * input.positionCS.w; + float4 ScreenPos = ComputeScreenPos( ClipPos ); + + float3 ase_normalWS = input.ase_texcoord.xyz; + float3 normalizeResult65 = normalize( ase_normalWS ); + float3 worldSpaceViewDir64 = ( _WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4( 0,0,0,1 ) ).xyz ); + float3 normalizeResult66 = normalize( worldSpaceViewDir64 ); + float dotResult67 = dot( normalizeResult65 , normalizeResult66 ); + float smoothstepResult71 = smoothstep( ( 1.0 - _IOR_ins ) , 1.0 , ( 1.0 - abs( dotResult67 ) )); + float3 ase_positionWS = input.ase_texcoord1.xyz; + float3 ase_viewVectorWS = ( _WorldSpaceCameraPos.xyz - ase_positionWS ); + float3 ase_viewDirWS = normalize( ase_viewVectorWS ); + float3 normalizeResult199 = normalize( ase_viewDirWS ); + float dotResult200 = dot( ase_normalWS , normalizeResult199 ); + float4 lerpResult86 = lerp( _IN , _OUT , ( smoothstepResult71 + ( abs( dotResult200 ) < _edge ? 1.0 : 0.0 ) )); + float2 texCoord235 = input.ase_texcoord2.xy * float2( 1,1 ) + float2( 0,0 ); + float temp_output_236_0 = (texCoord235).y; + float lerpResult243 = lerp( _front.a , _behind.a , temp_output_236_0); + + + float Alpha = saturate( ( ( lerpResult86 + (-1.0 + ( _MainAlpha - 0.0 ) * ( 1.0 - -1.0 ) / ( 1.0 - 0.0 ) ) ) * lerpResult243 ) ).r; + float AlphaClipThreshold = 0.5; + + #if defined( ASE_DEPTH_WRITE_ON ) + float DeviceDepth = input.positionCS.z; + #endif + + #if defined( _ALPHATEST_ON ) + AlphaDiscard( Alpha, AlphaClipThreshold ); + #endif + + #if defined(LOD_FADE_CROSSFADE) + LODFadeCrossFade( input.positionCS ); + #endif + + #if defined( ASE_DEPTH_WRITE_ON ) + outputDepth = DeviceDepth; + #endif + + return 0; + } + ENDHLSL + } + + + Pass + { + + Name "SceneSelectionPass" + Tags { "LightMode"="SceneSelectionPass" } + + Cull Off + AlphaToMask Off + + HLSLPROGRAM + + #define _ALPHATEST_ON 1 + #define ASE_FOG 1 + #define _SURFACE_TYPE_TRANSPARENT 1 + #define ASE_VERSION 19904 + #define ASE_SRP_VERSION -1 + + + #pragma vertex vert + #pragma fragment frag + + #define ATTRIBUTES_NEED_NORMAL + #define ATTRIBUTES_NEED_TANGENT + #define SHADERPASS SHADERPASS_DEPTHONLY + + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRendering.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl" + + #define ASE_NEEDS_VERT_NORMAL + #define ASE_NEEDS_TEXTURE_COORDINATES0 + + + struct Attributes + { + float4 positionOS : POSITION; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct PackedVaryings + { + float4 positionCS : SV_POSITION; + float4 ase_texcoord : TEXCOORD0; + float4 ase_texcoord1 : TEXCOORD1; + float4 ase_texcoord2 : TEXCOORD2; + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + + CBUFFER_START(UnityPerMaterial) + float4 _IN; + float4 _OUT; + float4 _front; + float4 _behind; + float _IOR_ins; + float _edge; + float _MainAlpha; + #ifdef ASE_TESSELLATION + float _TessPhongStrength; + float _TessValue; + float _TessMin; + float _TessMax; + float _TessEdgeLength; + float _TessMaxDisp; + #endif + CBUFFER_END + + + + + int _ObjectId; + int _PassValue; + + struct SurfaceDescription + { + float Alpha; + float AlphaClipThreshold; + }; + + PackedVaryings VertexFunction(Attributes input ) + { + PackedVaryings output; + ZERO_INITIALIZE(PackedVaryings, output); + + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output); + + float3 ase_normalWS = TransformObjectToWorldNormal( input.normalOS ); + output.ase_texcoord.xyz = ase_normalWS; + float3 ase_positionWS = TransformObjectToWorld( ( input.positionOS ).xyz ); + output.ase_texcoord1.xyz = ase_positionWS; + + output.ase_texcoord2.xy = input.ase_texcoord.xy; + + //setting value to unused interpolator channels and avoid initialization warnings + output.ase_texcoord.w = 0; + output.ase_texcoord1.w = 0; + output.ase_texcoord2.zw = 0; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + float3 defaultVertexValue = input.positionOS.xyz; + #else + float3 defaultVertexValue = float3(0, 0, 0); + #endif + + float3 vertexValue = defaultVertexValue; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + input.positionOS.xyz = vertexValue; + #else + input.positionOS.xyz += vertexValue; + #endif + + VertexPositionInputs vertexInput = GetVertexPositionInputs( input.positionOS.xyz ); + + output.positionCS = vertexInput.positionCS; + return output; + } + + #if defined(ASE_TESSELLATION) + struct VertexControl + { + float4 positionOS : INTERNALTESSPOS; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct TessellationFactors + { + float edge[3] : SV_TessFactor; + float inside : SV_InsideTessFactor; + }; + + VertexControl vert ( Attributes input ) + { + VertexControl output; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + output.positionOS = input.positionOS; + output.normalOS = input.normalOS; + output.ase_texcoord = input.ase_texcoord; + return output; + } + + TessellationFactors TessellationFunction (InputPatch input) + { + TessellationFactors output; + float4 tf = 1; + float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax; + float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp; + #if defined(ASE_FIXED_TESSELLATION) + tf = FixedTess( tessValue ); + #elif defined(ASE_DISTANCE_TESSELLATION) + tf = DistanceBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos ); + #elif defined(ASE_LENGTH_TESSELLATION) + tf = EdgeLengthBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams ); + #elif defined(ASE_LENGTH_CULL_TESSELLATION) + tf = EdgeLengthBasedTessCull(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes ); + #endif + output.edge[0] = tf.x; output.edge[1] = tf.y; output.edge[2] = tf.z; output.inside = tf.w; + return output; + } + + [domain("tri")] + [partitioning("fractional_odd")] + [outputtopology("triangle_cw")] + [patchconstantfunc("TessellationFunction")] + [outputcontrolpoints(3)] + VertexControl HullFunction(InputPatch patch, uint id : SV_OutputControlPointID) + { + return patch[id]; + } + + [domain("tri")] + PackedVaryings DomainFunction(TessellationFactors factors, OutputPatch patch, float3 bary : SV_DomainLocation) + { + Attributes output = (Attributes) 0; + output.positionOS = patch[0].positionOS * bary.x + patch[1].positionOS * bary.y + patch[2].positionOS * bary.z; + output.normalOS = patch[0].normalOS * bary.x + patch[1].normalOS * bary.y + patch[2].normalOS * bary.z; + output.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z; + #if defined(ASE_PHONG_TESSELLATION) + float3 pp[3]; + for (int i = 0; i < 3; ++i) + pp[i] = output.positionOS.xyz - patch[i].normalOS * (dot(output.positionOS.xyz, patch[i].normalOS) - dot(patch[i].positionOS.xyz, patch[i].normalOS)); + float phongStrength = _TessPhongStrength; + output.positionOS.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * output.positionOS.xyz; + #endif + UNITY_TRANSFER_INSTANCE_ID(patch[0], output); + return VertexFunction(output); + } + #else + PackedVaryings vert ( Attributes input ) + { + return VertexFunction( input ); + } + #endif + + half4 frag(PackedVaryings input ) : SV_Target + { + SurfaceDescription surfaceDescription = (SurfaceDescription)0; + + float3 ase_normalWS = input.ase_texcoord.xyz; + float3 normalizeResult65 = normalize( ase_normalWS ); + float3 worldSpaceViewDir64 = ( _WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4( 0,0,0,1 ) ).xyz ); + float3 normalizeResult66 = normalize( worldSpaceViewDir64 ); + float dotResult67 = dot( normalizeResult65 , normalizeResult66 ); + float smoothstepResult71 = smoothstep( ( 1.0 - _IOR_ins ) , 1.0 , ( 1.0 - abs( dotResult67 ) )); + float3 ase_positionWS = input.ase_texcoord1.xyz; + float3 ase_viewVectorWS = ( _WorldSpaceCameraPos.xyz - ase_positionWS ); + float3 ase_viewDirWS = normalize( ase_viewVectorWS ); + float3 normalizeResult199 = normalize( ase_viewDirWS ); + float dotResult200 = dot( ase_normalWS , normalizeResult199 ); + float4 lerpResult86 = lerp( _IN , _OUT , ( smoothstepResult71 + ( abs( dotResult200 ) < _edge ? 1.0 : 0.0 ) )); + float2 texCoord235 = input.ase_texcoord2.xy * float2( 1,1 ) + float2( 0,0 ); + float temp_output_236_0 = (texCoord235).y; + float lerpResult243 = lerp( _front.a , _behind.a , temp_output_236_0); + + + surfaceDescription.Alpha = saturate( ( ( lerpResult86 + (-1.0 + ( _MainAlpha - 0.0 ) * ( 1.0 - -1.0 ) / ( 1.0 - 0.0 ) ) ) * lerpResult243 ) ).r; + surfaceDescription.AlphaClipThreshold = 0.5; + + #if _ALPHATEST_ON + float alphaClipThreshold = 0.01f; + #if ALPHA_CLIP_THRESHOLD + alphaClipThreshold = surfaceDescription.AlphaClipThreshold; + #endif + clip(surfaceDescription.Alpha - alphaClipThreshold); + #endif + + half4 outColor = half4(_ObjectId, _PassValue, 1.0, 1.0); + return outColor; + } + ENDHLSL + } + + + Pass + { + + Name "ScenePickingPass" + Tags { "LightMode"="Picking" } + + AlphaToMask Off + + HLSLPROGRAM + + #define _ALPHATEST_ON 1 + #define ASE_FOG 1 + #define _SURFACE_TYPE_TRANSPARENT 1 + #define ASE_VERSION 19904 + #define ASE_SRP_VERSION -1 + + + #pragma vertex vert + #pragma fragment frag + + #define ATTRIBUTES_NEED_NORMAL + #define ATTRIBUTES_NEED_TANGENT + + #define SHADERPASS SHADERPASS_DEPTHONLY + + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRendering.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl" + + #if defined(LOD_FADE_CROSSFADE) + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/LODCrossFade.hlsl" + #endif + + #define ASE_NEEDS_VERT_NORMAL + #define ASE_NEEDS_TEXTURE_COORDINATES0 + + + struct Attributes + { + float4 positionOS : POSITION; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct PackedVaryings + { + float4 positionCS : SV_POSITION; + float4 ase_texcoord : TEXCOORD0; + float4 ase_texcoord1 : TEXCOORD1; + float4 ase_texcoord2 : TEXCOORD2; + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + + CBUFFER_START(UnityPerMaterial) + float4 _IN; + float4 _OUT; + float4 _front; + float4 _behind; + float _IOR_ins; + float _edge; + float _MainAlpha; + #ifdef ASE_TESSELLATION + float _TessPhongStrength; + float _TessValue; + float _TessMin; + float _TessMax; + float _TessEdgeLength; + float _TessMaxDisp; + #endif + CBUFFER_END + + + + + float4 _SelectionID; + + struct SurfaceDescription + { + float Alpha; + float AlphaClipThreshold; + }; + + PackedVaryings VertexFunction(Attributes input ) + { + PackedVaryings output; + ZERO_INITIALIZE(PackedVaryings, output); + + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output); + + float3 ase_normalWS = TransformObjectToWorldNormal( input.normalOS ); + output.ase_texcoord.xyz = ase_normalWS; + float3 ase_positionWS = TransformObjectToWorld( ( input.positionOS ).xyz ); + output.ase_texcoord1.xyz = ase_positionWS; + + output.ase_texcoord2.xy = input.ase_texcoord.xy; + + //setting value to unused interpolator channels and avoid initialization warnings + output.ase_texcoord.w = 0; + output.ase_texcoord1.w = 0; + output.ase_texcoord2.zw = 0; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + float3 defaultVertexValue = input.positionOS.xyz; + #else + float3 defaultVertexValue = float3(0, 0, 0); + #endif + + float3 vertexValue = defaultVertexValue; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + input.positionOS.xyz = vertexValue; + #else + input.positionOS.xyz += vertexValue; + #endif + + VertexPositionInputs vertexInput = GetVertexPositionInputs( input.positionOS.xyz ); + + output.positionCS = vertexInput.positionCS; + return output; + } + + #if defined(ASE_TESSELLATION) + struct VertexControl + { + float4 positionOS : INTERNALTESSPOS; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct TessellationFactors + { + float edge[3] : SV_TessFactor; + float inside : SV_InsideTessFactor; + }; + + VertexControl vert ( Attributes input ) + { + VertexControl output; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + output.positionOS = input.positionOS; + output.normalOS = input.normalOS; + output.ase_texcoord = input.ase_texcoord; + return output; + } + + TessellationFactors TessellationFunction (InputPatch input) + { + TessellationFactors output; + float4 tf = 1; + float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax; + float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp; + #if defined(ASE_FIXED_TESSELLATION) + tf = FixedTess( tessValue ); + #elif defined(ASE_DISTANCE_TESSELLATION) + tf = DistanceBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos ); + #elif defined(ASE_LENGTH_TESSELLATION) + tf = EdgeLengthBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams ); + #elif defined(ASE_LENGTH_CULL_TESSELLATION) + tf = EdgeLengthBasedTessCull(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes ); + #endif + output.edge[0] = tf.x; output.edge[1] = tf.y; output.edge[2] = tf.z; output.inside = tf.w; + return output; + } + + [domain("tri")] + [partitioning("fractional_odd")] + [outputtopology("triangle_cw")] + [patchconstantfunc("TessellationFunction")] + [outputcontrolpoints(3)] + VertexControl HullFunction(InputPatch patch, uint id : SV_OutputControlPointID) + { + return patch[id]; + } + + [domain("tri")] + PackedVaryings DomainFunction(TessellationFactors factors, OutputPatch patch, float3 bary : SV_DomainLocation) + { + Attributes output = (Attributes) 0; + output.positionOS = patch[0].positionOS * bary.x + patch[1].positionOS * bary.y + patch[2].positionOS * bary.z; + output.normalOS = patch[0].normalOS * bary.x + patch[1].normalOS * bary.y + patch[2].normalOS * bary.z; + output.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z; + #if defined(ASE_PHONG_TESSELLATION) + float3 pp[3]; + for (int i = 0; i < 3; ++i) + pp[i] = output.positionOS.xyz - patch[i].normalOS * (dot(output.positionOS.xyz, patch[i].normalOS) - dot(patch[i].positionOS.xyz, patch[i].normalOS)); + float phongStrength = _TessPhongStrength; + output.positionOS.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * output.positionOS.xyz; + #endif + UNITY_TRANSFER_INSTANCE_ID(patch[0], output); + return VertexFunction(output); + } + #else + PackedVaryings vert ( Attributes input ) + { + return VertexFunction( input ); + } + #endif + + half4 frag(PackedVaryings input ) : SV_Target + { + SurfaceDescription surfaceDescription = (SurfaceDescription)0; + + float3 ase_normalWS = input.ase_texcoord.xyz; + float3 normalizeResult65 = normalize( ase_normalWS ); + float3 worldSpaceViewDir64 = ( _WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4( 0,0,0,1 ) ).xyz ); + float3 normalizeResult66 = normalize( worldSpaceViewDir64 ); + float dotResult67 = dot( normalizeResult65 , normalizeResult66 ); + float smoothstepResult71 = smoothstep( ( 1.0 - _IOR_ins ) , 1.0 , ( 1.0 - abs( dotResult67 ) )); + float3 ase_positionWS = input.ase_texcoord1.xyz; + float3 ase_viewVectorWS = ( _WorldSpaceCameraPos.xyz - ase_positionWS ); + float3 ase_viewDirWS = normalize( ase_viewVectorWS ); + float3 normalizeResult199 = normalize( ase_viewDirWS ); + float dotResult200 = dot( ase_normalWS , normalizeResult199 ); + float4 lerpResult86 = lerp( _IN , _OUT , ( smoothstepResult71 + ( abs( dotResult200 ) < _edge ? 1.0 : 0.0 ) )); + float2 texCoord235 = input.ase_texcoord2.xy * float2( 1,1 ) + float2( 0,0 ); + float temp_output_236_0 = (texCoord235).y; + float lerpResult243 = lerp( _front.a , _behind.a , temp_output_236_0); + + + surfaceDescription.Alpha = saturate( ( ( lerpResult86 + (-1.0 + ( _MainAlpha - 0.0 ) * ( 1.0 - -1.0 ) / ( 1.0 - 0.0 ) ) ) * lerpResult243 ) ).r; + surfaceDescription.AlphaClipThreshold = 0.5; + + #if _ALPHATEST_ON + float alphaClipThreshold = 0.01f; + #if ALPHA_CLIP_THRESHOLD + alphaClipThreshold = surfaceDescription.AlphaClipThreshold; + #endif + clip(surfaceDescription.Alpha - alphaClipThreshold); + #endif + + half4 outColor = 0; + outColor = unity_SelectionID; + + return outColor; + } + + ENDHLSL + } + + + Pass + { + + Name "DepthNormals" + Tags { "LightMode"="DepthNormalsOnly" } + + ZTest LEqual + ZWrite On + + HLSLPROGRAM + + #define _ALPHATEST_ON 1 + #pragma multi_compile_instancing + #pragma multi_compile _ LOD_FADE_CROSSFADE + #define ASE_FOG 1 + #define _SURFACE_TYPE_TRANSPARENT 1 + #define ASE_VERSION 19904 + #define ASE_SRP_VERSION -1 + + + #pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT + + #pragma vertex vert + #pragma fragment frag + + #define ATTRIBUTES_NEED_NORMAL + #define ATTRIBUTES_NEED_TANGENT + #define VARYINGS_NEED_NORMAL_WS + + #define SHADERPASS SHADERPASS_DEPTHNORMALSONLY + + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRendering.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl" + + #if defined(LOD_FADE_CROSSFADE) + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/LODCrossFade.hlsl" + #endif + + #define ASE_NEEDS_WORLD_NORMAL + #define ASE_NEEDS_FRAG_WORLD_NORMAL + #define ASE_NEEDS_TEXTURE_COORDINATES0 + + + #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE) && (SHADER_TARGET >= 45) + #define ASE_SV_DEPTH SV_DepthLessEqual + #define ASE_SV_POSITION_QUALIFIERS linear noperspective centroid + #else + #define ASE_SV_DEPTH SV_Depth + #define ASE_SV_POSITION_QUALIFIERS + #endif + + struct Attributes + { + float4 positionOS : POSITION; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct PackedVaryings + { + ASE_SV_POSITION_QUALIFIERS float4 positionCS : SV_POSITION; + half3 normalWS : TEXCOORD0; + float4 ase_texcoord1 : TEXCOORD1; + float4 ase_texcoord2 : TEXCOORD2; + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + + CBUFFER_START(UnityPerMaterial) + float4 _IN; + float4 _OUT; + float4 _front; + float4 _behind; + float _IOR_ins; + float _edge; + float _MainAlpha; + #ifdef ASE_TESSELLATION + float _TessPhongStrength; + float _TessValue; + float _TessMin; + float _TessMax; + float _TessEdgeLength; + float _TessMaxDisp; + #endif + CBUFFER_END + + + + + struct SurfaceDescription + { + float Alpha; + float AlphaClipThreshold; + }; + + PackedVaryings VertexFunction( Attributes input ) + { + PackedVaryings output; + ZERO_INITIALIZE(PackedVaryings, output); + + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output); + + float3 ase_positionWS = TransformObjectToWorld( ( input.positionOS ).xyz ); + output.ase_texcoord1.xyz = ase_positionWS; + + output.ase_texcoord2.xy = input.ase_texcoord.xy; + + //setting value to unused interpolator channels and avoid initialization warnings + output.ase_texcoord1.w = 0; + output.ase_texcoord2.zw = 0; + #ifdef ASE_ABSOLUTE_VERTEX_POS + float3 defaultVertexValue = input.positionOS.xyz; + #else + float3 defaultVertexValue = float3(0, 0, 0); + #endif + + float3 vertexValue = defaultVertexValue; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + input.positionOS.xyz = vertexValue; + #else + input.positionOS.xyz += vertexValue; + #endif + + input.normalOS = input.normalOS; + + VertexPositionInputs vertexInput = GetVertexPositionInputs( input.positionOS.xyz ); + VertexNormalInputs normalInput = GetVertexNormalInputs( input.normalOS ); + + output.positionCS = vertexInput.positionCS; + output.normalWS = normalInput.normalWS; + return output; + } + + #if defined(ASE_TESSELLATION) + struct VertexControl + { + float4 positionOS : INTERNALTESSPOS; + half3 normalOS : NORMAL; + float4 ase_texcoord : TEXCOORD0; + + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct TessellationFactors + { + float edge[3] : SV_TessFactor; + float inside : SV_InsideTessFactor; + }; + + VertexControl vert ( Attributes input ) + { + VertexControl output; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + output.positionOS = input.positionOS; + output.normalOS = input.normalOS; + output.ase_texcoord = input.ase_texcoord; + return output; + } + + TessellationFactors TessellationFunction (InputPatch input) + { + TessellationFactors output; + float4 tf = 1; + float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax; + float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp; + #if defined(ASE_FIXED_TESSELLATION) + tf = FixedTess( tessValue ); + #elif defined(ASE_DISTANCE_TESSELLATION) + tf = DistanceBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos ); + #elif defined(ASE_LENGTH_TESSELLATION) + tf = EdgeLengthBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams ); + #elif defined(ASE_LENGTH_CULL_TESSELLATION) + tf = EdgeLengthBasedTessCull(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes ); + #endif + output.edge[0] = tf.x; output.edge[1] = tf.y; output.edge[2] = tf.z; output.inside = tf.w; + return output; + } + + [domain("tri")] + [partitioning("fractional_odd")] + [outputtopology("triangle_cw")] + [patchconstantfunc("TessellationFunction")] + [outputcontrolpoints(3)] + VertexControl HullFunction(InputPatch patch, uint id : SV_OutputControlPointID) + { + return patch[id]; + } + + [domain("tri")] + PackedVaryings DomainFunction(TessellationFactors factors, OutputPatch patch, float3 bary : SV_DomainLocation) + { + Attributes output = (Attributes) 0; + output.positionOS = patch[0].positionOS * bary.x + patch[1].positionOS * bary.y + patch[2].positionOS * bary.z; + output.normalOS = patch[0].normalOS * bary.x + patch[1].normalOS * bary.y + patch[2].normalOS * bary.z; + output.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z; + #if defined(ASE_PHONG_TESSELLATION) + float3 pp[3]; + for (int i = 0; i < 3; ++i) + pp[i] = output.positionOS.xyz - patch[i].normalOS * (dot(output.positionOS.xyz, patch[i].normalOS) - dot(patch[i].positionOS.xyz, patch[i].normalOS)); + float phongStrength = _TessPhongStrength; + output.positionOS.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * output.positionOS.xyz; + #endif + UNITY_TRANSFER_INSTANCE_ID(patch[0], output); + return VertexFunction(output); + } + #else + PackedVaryings vert ( Attributes input ) + { + return VertexFunction( input ); + } + #endif + + void frag(PackedVaryings input + , out half4 outNormalWS : SV_Target0 + #if defined( ASE_DEPTH_WRITE_ON ) + ,out float outputDepth : ASE_SV_DEPTH + #endif + #ifdef _WRITE_RENDERING_LAYERS + , out uint outRenderingLayers : SV_Target1 + #endif + ) + { + UNITY_SETUP_INSTANCE_ID(input); + UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX( input ); + + half3 NormalWS = normalize( input.normalWS ); + float4 ScreenPosNorm = float4( GetNormalizedScreenSpaceUV( input.positionCS ), input.positionCS.zw ); + float4 ClipPos = ComputeClipSpacePosition( ScreenPosNorm.xy, input.positionCS.z ) * input.positionCS.w; + float4 ScreenPos = ComputeScreenPos( ClipPos ); + + float3 normalizeResult65 = normalize( NormalWS ); + float3 worldSpaceViewDir64 = ( _WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4( 0,0,0,1 ) ).xyz ); + float3 normalizeResult66 = normalize( worldSpaceViewDir64 ); + float dotResult67 = dot( normalizeResult65 , normalizeResult66 ); + float smoothstepResult71 = smoothstep( ( 1.0 - _IOR_ins ) , 1.0 , ( 1.0 - abs( dotResult67 ) )); + float3 ase_positionWS = input.ase_texcoord1.xyz; + float3 ase_viewVectorWS = ( _WorldSpaceCameraPos.xyz - ase_positionWS ); + float3 ase_viewDirWS = normalize( ase_viewVectorWS ); + float3 normalizeResult199 = normalize( ase_viewDirWS ); + float dotResult200 = dot( NormalWS , normalizeResult199 ); + float4 lerpResult86 = lerp( _IN , _OUT , ( smoothstepResult71 + ( abs( dotResult200 ) < _edge ? 1.0 : 0.0 ) )); + float2 texCoord235 = input.ase_texcoord2.xy * float2( 1,1 ) + float2( 0,0 ); + float temp_output_236_0 = (texCoord235).y; + float lerpResult243 = lerp( _front.a , _behind.a , temp_output_236_0); + + + float Alpha = saturate( ( ( lerpResult86 + (-1.0 + ( _MainAlpha - 0.0 ) * ( 1.0 - -1.0 ) / ( 1.0 - 0.0 ) ) ) * lerpResult243 ) ).r; + float AlphaClipThreshold = 0.5; + + #if defined( ASE_DEPTH_WRITE_ON ) + float DeviceDepth = input.positionCS.z; + #endif + + #ifdef _ALPHATEST_ON + clip(Alpha - AlphaClipThreshold); + #endif + + #if defined(LOD_FADE_CROSSFADE) + LODFadeCrossFade( input.positionCS ); + #endif + + #if defined( ASE_DEPTH_WRITE_ON ) + outputDepth = DeviceDepth; + #endif + + #if defined(_GBUFFER_NORMALS_OCT) + float2 octNormalWS = PackNormalOctQuadEncode(NormalWS); + float2 remappedOctNormalWS = saturate(octNormalWS * 0.5 + 0.5); + half3 packedNormalWS = PackFloat2To888(remappedOctNormalWS); + outNormalWS = half4(packedNormalWS, 0.0); + #else + outNormalWS = half4(NormalizeNormalPerPixel( NormalWS ), 0.0); + #endif + + #ifdef _WRITE_RENDERING_LAYERS + outRenderingLayers = EncodeMeshRenderingLayer(); + #endif + } + ENDHLSL + } + + + Pass + { + + Name "MotionVectors" + Tags { "LightMode"="MotionVectors" } + + ColorMask RG + + HLSLPROGRAM + + #define _ALPHATEST_ON 1 + #pragma multi_compile _ LOD_FADE_CROSSFADE + #define ASE_FOG 1 + #define _SURFACE_TYPE_TRANSPARENT 1 + #define ASE_VERSION 19904 + #define ASE_SRP_VERSION -1 + + + #pragma vertex vert + #pragma fragment frag + + #define SHADERPASS SHADERPASS_MOTION_VECTORS + + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" + #include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRendering.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl" + + #if defined(LOD_FADE_CROSSFADE) + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/LODCrossFade.hlsl" + #endif + + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/MotionVectorsCommon.hlsl" + + #define ASE_NEEDS_VERT_NORMAL + #define ASE_NEEDS_FRAG_WORLD_POSITION + #define ASE_NEEDS_TEXTURE_COORDINATES0 + + + #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE) && (SHADER_TARGET >= 45) + #define ASE_SV_DEPTH SV_DepthLessEqual + #define ASE_SV_POSITION_QUALIFIERS linear noperspective centroid + #else + #define ASE_SV_DEPTH SV_Depth + #define ASE_SV_POSITION_QUALIFIERS + #endif + + struct Attributes + { + float4 positionOS : POSITION; + float3 positionOld : TEXCOORD4; + #if _ADD_PRECOMPUTED_VELOCITY + float3 alembicMotionVector : TEXCOORD5; + #endif + half3 normalOS : NORMAL; + half4 tangentOS : TANGENT; + float4 ase_texcoord : TEXCOORD0; + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct PackedVaryings + { + float4 positionCS : SV_POSITION; + float4 positionCSNoJitter : TEXCOORD0; + float4 previousPositionCSNoJitter : TEXCOORD1; + float3 positionWS : TEXCOORD2; + float4 ase_texcoord3 : TEXCOORD3; + float4 ase_texcoord4 : TEXCOORD4; + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + + CBUFFER_START(UnityPerMaterial) + float4 _IN; + float4 _OUT; + float4 _front; + float4 _behind; + float _IOR_ins; + float _edge; + float _MainAlpha; + #ifdef ASE_TRANSMISSION + float _TransmissionShadow; + #endif + #ifdef ASE_TRANSLUCENCY + float _TransStrength; + float _TransNormal; + float _TransScattering; + float _TransDirect; + float _TransAmbient; + float _TransShadow; + #endif + #ifdef ASE_TESSELLATION + float _TessPhongStrength; + float _TessValue; + float _TessMin; + float _TessMax; + float _TessEdgeLength; + float _TessMaxDisp; + #endif + CBUFFER_END + + #ifdef SCENEPICKINGPASS + float4 _SelectionID; + #endif + + #ifdef SCENESELECTIONPASS + int _ObjectId; + int _PassValue; + #endif + + + + + PackedVaryings VertexFunction( Attributes input ) + { + PackedVaryings output = (PackedVaryings)0; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output); + + float3 ase_normalWS = TransformObjectToWorldNormal( input.normalOS ); + output.ase_texcoord3.xyz = ase_normalWS; + + output.ase_texcoord4.xy = input.ase_texcoord.xy; + + //setting value to unused interpolator channels and avoid initialization warnings + output.ase_texcoord3.w = 0; + output.ase_texcoord4.zw = 0; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + float3 defaultVertexValue = input.positionOS.xyz; + #else + float3 defaultVertexValue = float3(0, 0, 0); + #endif + + float3 vertexValue = defaultVertexValue; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + input.positionOS.xyz = vertexValue; + #else + input.positionOS.xyz += vertexValue; + #endif + + VertexPositionInputs vertexInput = GetVertexPositionInputs( input.positionOS.xyz ); + + #if defined(APPLICATION_SPACE_WARP_MOTION) + output.positionCSNoJitter = mul(_NonJitteredViewProjMatrix, mul(UNITY_MATRIX_M, input.positionOS)); + output.positionCS = output.positionCSNoJitter; + #else + output.positionCS = vertexInput.positionCS; + output.positionCSNoJitter = mul(_NonJitteredViewProjMatrix, mul(UNITY_MATRIX_M, input.positionOS)); + #endif + + float4 prevPos = ( unity_MotionVectorsParams.x == 1 ) ? float4( input.positionOld, 1 ) : input.positionOS; + + #if _ADD_PRECOMPUTED_VELOCITY + prevPos = prevPos - float4(input.alembicMotionVector, 0); + #endif + + output.previousPositionCSNoJitter = mul( _PrevViewProjMatrix, mul( UNITY_PREV_MATRIX_M, prevPos ) ); + output.positionWS = vertexInput.positionWS; + return output; + } + + PackedVaryings vert ( Attributes input ) + { + return VertexFunction( input ); + } + + half4 frag( PackedVaryings input + #if defined( ASE_DEPTH_WRITE_ON ) + ,out float outputDepth : ASE_SV_DEPTH + #endif + ) : SV_Target + { + UNITY_SETUP_INSTANCE_ID(input); + UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX( input ); + + float3 PositionWS = input.positionWS; + float3 PositionRWS = GetCameraRelativePositionWS( PositionWS ); + float4 ScreenPosNorm = float4( GetNormalizedScreenSpaceUV( input.positionCS ), input.positionCS.zw ); + float4 ClipPos = ComputeClipSpacePosition( ScreenPosNorm.xy, input.positionCS.z ) * input.positionCS.w; + + float3 ase_normalWS = input.ase_texcoord3.xyz; + float3 normalizeResult65 = normalize( ase_normalWS ); + float3 worldSpaceViewDir64 = ( _WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4( 0,0,0,1 ) ).xyz ); + float3 normalizeResult66 = normalize( worldSpaceViewDir64 ); + float dotResult67 = dot( normalizeResult65 , normalizeResult66 ); + float smoothstepResult71 = smoothstep( ( 1.0 - _IOR_ins ) , 1.0 , ( 1.0 - abs( dotResult67 ) )); + float3 ase_viewVectorWS = ( _WorldSpaceCameraPos.xyz - PositionWS ); + float3 ase_viewDirWS = normalize( ase_viewVectorWS ); + float3 normalizeResult199 = normalize( ase_viewDirWS ); + float dotResult200 = dot( ase_normalWS , normalizeResult199 ); + float4 lerpResult86 = lerp( _IN , _OUT , ( smoothstepResult71 + ( abs( dotResult200 ) < _edge ? 1.0 : 0.0 ) )); + float2 texCoord235 = input.ase_texcoord4.xy * float2( 1,1 ) + float2( 0,0 ); + float temp_output_236_0 = (texCoord235).y; + float lerpResult243 = lerp( _front.a , _behind.a , temp_output_236_0); + + + float Alpha = saturate( ( ( lerpResult86 + (-1.0 + ( _MainAlpha - 0.0 ) * ( 1.0 - -1.0 ) / ( 1.0 - 0.0 ) ) ) * lerpResult243 ) ).r; + float AlphaClipThreshold = 0.5; + + #if defined( ASE_DEPTH_WRITE_ON ) + float DeviceDepth = input.positionCS.z; + #endif + + #ifdef _ALPHATEST_ON + clip(Alpha - AlphaClipThreshold); + #endif + + #if defined( ASE_CHANGES_WORLD_POS ) + float3 positionOS = mul( GetWorldToObjectMatrix(), float4( PositionWS, 1.0 ) ).xyz; + float3 previousPositionWS = mul( GetPrevObjectToWorldMatrix(), float4( positionOS, 1.0 ) ).xyz; + input.positionCSNoJitter = mul( _NonJitteredViewProjMatrix, float4( PositionWS, 1.0 ) ); + input.previousPositionCSNoJitter = mul( _PrevViewProjMatrix, float4( previousPositionWS, 1.0 ) ); + #endif + + #if defined( LOD_FADE_CROSSFADE ) + LODFadeCrossFade( input.positionCS ); + #endif + + #if defined( ASE_DEPTH_WRITE_ON ) + outputDepth = DeviceDepth; + #endif + + #if defined(APPLICATION_SPACE_WARP_MOTION) + return float4( CalcAswNdcMotionVectorFromCsPositions( input.positionCSNoJitter, input.previousPositionCSNoJitter ), 1 ); + #else + return float4( CalcNdcMotionVectorFromCsPositions( input.positionCSNoJitter, input.previousPositionCSNoJitter ), 0, 0 ); + #endif + } + ENDHLSL + } + + + Pass + { + + Name "GBuffer" + Tags { "LightMode"="UniversalGBuffer" } + + Blend SrcAlpha OneMinusSrcAlpha, One OneMinusSrcAlpha + ZWrite Off + ZTest LEqual + Offset 0 , 0 + ColorMask RGBA + + + + HLSLPROGRAM + + + #define _ALPHATEST_ON 1 + #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION + #define ASE_FOG 1 + #define _SURFACE_TYPE_TRANSPARENT 1 + #define ASE_VERSION 19904 + #define ASE_SRP_VERSION -1 + + + + #pragma multi_compile _ DOTS_INSTANCING_ON + + + #pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3 + #pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT + #pragma multi_compile_fragment _ _RENDER_PASS_ENABLED + + + #pragma multi_compile_fragment _ _WRITE_RENDERING_LAYERS + + + #pragma vertex vert + #pragma fragment frag + + #define SHADERPASS SHADERPASS_GBUFFER + + + + + + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Texture.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Input.hlsl" + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl" + + + #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRendering.hlsl" + + + + #if ASE_SRP_VERSION >=140009 + #include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl" + #endif + + + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ShaderGraphFunctions.hlsl" + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DBuffer.hlsl" + #include "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShaderPass.hlsl" + + #if defined(LOD_FADE_CROSSFADE) + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/LODCrossFade.hlsl" + #endif + + #if defined(UNITY_INSTANCING_ENABLED) && defined(_TERRAIN_INSTANCED_PERPIXEL_NORMAL) + #define ENABLE_TERRAIN_PERPIXEL_NORMAL + #endif + + #define ASE_NEEDS_WORLD_NORMAL + #define ASE_NEEDS_FRAG_WORLD_NORMAL + #define ASE_NEEDS_FRAG_WORLD_VIEW_DIR + #define ASE_NEEDS_TEXTURE_COORDINATES0 + + + #if defined(ASE_EARLY_Z_DEPTH_OPTIMIZE) && (SHADER_TARGET >= 45) + #define ASE_SV_DEPTH SV_DepthLessEqual + #define ASE_SV_POSITION_QUALIFIERS linear noperspective centroid + #else + #define ASE_SV_DEPTH SV_Depth + #define ASE_SV_POSITION_QUALIFIERS + #endif + + struct Attributes + { + float4 positionOS : POSITION; + half3 normalOS : NORMAL; + float4 ase_color : COLOR; + float4 ase_texcoord : TEXCOORD0; + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct PackedVaryings + { + ASE_SV_POSITION_QUALIFIERS float4 positionCS : SV_POSITION; + float3 positionWS : TEXCOORD0; + half3 normalWS : TEXCOORD1; + float4 ase_color : COLOR; + float4 ase_texcoord2 : TEXCOORD2; + UNITY_VERTEX_INPUT_INSTANCE_ID + UNITY_VERTEX_OUTPUT_STEREO + }; + + CBUFFER_START(UnityPerMaterial) + float4 _IN; + float4 _OUT; + float4 _front; + float4 _behind; + float _IOR_ins; + float _edge; + float _MainAlpha; + #ifdef ASE_TRANSMISSION + float _TransmissionShadow; + #endif + #ifdef ASE_TRANSLUCENCY + float _TransStrength; + float _TransNormal; + float _TransScattering; + float _TransDirect; + float _TransAmbient; + float _TransShadow; + #endif + #ifdef ASE_TESSELLATION + float _TessPhongStrength; + float _TessValue; + float _TessMin; + float _TessMax; + float _TessEdgeLength; + float _TessMaxDisp; + #endif + CBUFFER_END + + #ifdef SCENEPICKINGPASS + float4 _SelectionID; + #endif + + #ifdef SCENESELECTIONPASS + int _ObjectId; + int _PassValue; + #endif + + + + #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/GBufferOutput.hlsl" + + + PackedVaryings VertexFunction( Attributes input ) + { + PackedVaryings output = (PackedVaryings)0; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output); + + output.ase_color = input.ase_color; + output.ase_texcoord2.xy = input.ase_texcoord.xy; + + //setting value to unused interpolator channels and avoid initialization warnings + output.ase_texcoord2.zw = 0; + #ifdef ASE_ABSOLUTE_VERTEX_POS + float3 defaultVertexValue = input.positionOS.xyz; + #else + float3 defaultVertexValue = float3(0, 0, 0); + #endif + + float3 vertexValue = defaultVertexValue; + + #ifdef ASE_ABSOLUTE_VERTEX_POS + input.positionOS.xyz = vertexValue; + #else + input.positionOS.xyz += vertexValue; + #endif + + VertexPositionInputs vertexInput = GetVertexPositionInputs( input.positionOS.xyz ); + VertexNormalInputs normalInput = GetVertexNormalInputs( input.normalOS ); + + output.positionCS = vertexInput.positionCS; + output.positionWS = vertexInput.positionWS; + output.normalWS = normalInput.normalWS; + return output; + } + + #if defined(ASE_TESSELLATION) + struct VertexControl + { + float4 positionOS : INTERNALTESSPOS; + half3 normalOS : NORMAL; + float4 ase_color : COLOR; + float4 ase_texcoord : TEXCOORD0; + + UNITY_VERTEX_INPUT_INSTANCE_ID + }; + + struct TessellationFactors + { + float edge[3] : SV_TessFactor; + float inside : SV_InsideTessFactor; + }; + + VertexControl vert ( Attributes input ) + { + VertexControl output; + UNITY_SETUP_INSTANCE_ID(input); + UNITY_TRANSFER_INSTANCE_ID(input, output); + output.positionOS = input.positionOS; + output.normalOS = input.normalOS; + output.ase_color = input.ase_color; + output.ase_texcoord = input.ase_texcoord; + return output; + } + + TessellationFactors TessellationFunction (InputPatch input) + { + TessellationFactors output; + float4 tf = 1; + float tessValue = _TessValue; float tessMin = _TessMin; float tessMax = _TessMax; + float edgeLength = _TessEdgeLength; float tessMaxDisp = _TessMaxDisp; + #if defined(ASE_FIXED_TESSELLATION) + tf = FixedTess( tessValue ); + #elif defined(ASE_DISTANCE_TESSELLATION) + tf = DistanceBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, tessValue, tessMin, tessMax, GetObjectToWorldMatrix(), _WorldSpaceCameraPos ); + #elif defined(ASE_LENGTH_TESSELLATION) + tf = EdgeLengthBasedTess(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams ); + #elif defined(ASE_LENGTH_CULL_TESSELLATION) + tf = EdgeLengthBasedTessCull(input[0].positionOS, input[1].positionOS, input[2].positionOS, edgeLength, tessMaxDisp, GetObjectToWorldMatrix(), _WorldSpaceCameraPos, _ScreenParams, unity_CameraWorldClipPlanes ); + #endif + output.edge[0] = tf.x; output.edge[1] = tf.y; output.edge[2] = tf.z; output.inside = tf.w; + return output; + } + + [domain("tri")] + [partitioning("fractional_odd")] + [outputtopology("triangle_cw")] + [patchconstantfunc("TessellationFunction")] + [outputcontrolpoints(3)] + VertexControl HullFunction(InputPatch patch, uint id : SV_OutputControlPointID) + { + return patch[id]; + } + + [domain("tri")] + PackedVaryings DomainFunction(TessellationFactors factors, OutputPatch patch, float3 bary : SV_DomainLocation) + { + Attributes output = (Attributes) 0; + output.positionOS = patch[0].positionOS * bary.x + patch[1].positionOS * bary.y + patch[2].positionOS * bary.z; + output.normalOS = patch[0].normalOS * bary.x + patch[1].normalOS * bary.y + patch[2].normalOS * bary.z; + output.ase_color = patch[0].ase_color * bary.x + patch[1].ase_color * bary.y + patch[2].ase_color * bary.z; + output.ase_texcoord = patch[0].ase_texcoord * bary.x + patch[1].ase_texcoord * bary.y + patch[2].ase_texcoord * bary.z; + #if defined(ASE_PHONG_TESSELLATION) + float3 pp[3]; + for (int i = 0; i < 3; ++i) + pp[i] = output.positionOS.xyz - patch[i].normalOS * (dot(output.positionOS.xyz, patch[i].normalOS) - dot(patch[i].positionOS.xyz, patch[i].normalOS)); + float phongStrength = _TessPhongStrength; + output.positionOS.xyz = phongStrength * (pp[0]*bary.x + pp[1]*bary.y + pp[2]*bary.z) + (1.0f-phongStrength) * output.positionOS.xyz; + #endif + UNITY_TRANSFER_INSTANCE_ID(patch[0], output); + return VertexFunction(output); + } + #else + PackedVaryings vert ( Attributes input ) + { + return VertexFunction( input ); + } + #endif + + GBufferFragOutput frag ( PackedVaryings input + #if defined( ASE_DEPTH_WRITE_ON ) + ,out float outputDepth : ASE_SV_DEPTH + #endif + ) + { + UNITY_SETUP_INSTANCE_ID(input); + UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input); + + #if defined(LOD_FADE_CROSSFADE) + LODFadeCrossFade( input.positionCS ); + #endif + + float3 PositionWS = input.positionWS; + float3 ViewDirWS = GetWorldSpaceNormalizeViewDir( PositionWS ); + float4 ScreenPosNorm = float4( GetNormalizedScreenSpaceUV( input.positionCS ), input.positionCS.zw ); + float4 ClipPos = ComputeClipSpacePosition( ScreenPosNorm.xy, input.positionCS.z ) * input.positionCS.w; + float4 ScreenPos = ComputeScreenPos( ClipPos ); + half3 NormalWS = normalize( input.normalWS ); + + float3 normalizeResult65 = normalize( NormalWS ); + float3 worldSpaceViewDir64 = ( _WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4( 0,0,0,1 ) ).xyz ); + float3 normalizeResult66 = normalize( worldSpaceViewDir64 ); + float dotResult67 = dot( normalizeResult65 , normalizeResult66 ); + float smoothstepResult71 = smoothstep( ( 1.0 - _IOR_ins ) , 1.0 , ( 1.0 - abs( dotResult67 ) )); + float3 normalizeResult199 = normalize( ViewDirWS ); + float dotResult200 = dot( NormalWS , normalizeResult199 ); + float4 lerpResult86 = lerp( _IN , _OUT , ( smoothstepResult71 + ( abs( dotResult200 ) < _edge ? 1.0 : 0.0 ) )); + float2 texCoord235 = input.ase_texcoord2.xy * float2( 1,1 ) + float2( 0,0 ); + float temp_output_236_0 = (texCoord235).y; + float3 lerpResult238 = lerp( _front.rgb , _behind.rgb , temp_output_236_0); + + float lerpResult243 = lerp( _front.a , _behind.a , temp_output_236_0); + + + float3 Color = ( lerpResult86 * input.ase_color * float4( lerpResult238 , 0.0 ) ).rgb; + float Alpha = saturate( ( ( lerpResult86 + (-1.0 + ( _MainAlpha - 0.0 ) * ( 1.0 - -1.0 ) / ( 1.0 - 0.0 ) ) ) * lerpResult243 ) ).r; + float AlphaClipThreshold = 0.5; + float AlphaClipThresholdShadow = 0.5; + + #if defined( ASE_DEPTH_WRITE_ON ) + float DeviceDepth = input.positionCS.z; + #endif + + #ifdef _ALPHATEST_ON + clip(Alpha - AlphaClipThreshold); + #endif + + InputData inputData = (InputData)0; + inputData.positionWS = PositionWS; + inputData.positionCS = float4( input.positionCS.xy, ClipPos.zw / ClipPos.w ); + inputData.normalizedScreenSpaceUV = ScreenPosNorm.xy; + inputData.normalWS = NormalWS; + inputData.viewDirectionWS = ViewDirWS; + + #if defined(_DBUFFER) + ApplyDecalToBaseColor(input.positionCS, Color); + #endif + + #if defined( ASE_DEPTH_WRITE_ON ) + outputDepth = DeviceDepth; + #endif + + SurfaceData surfaceData = (SurfaceData)0; + surfaceData.albedo = Color; + surfaceData.alpha = Alpha; + + #if defined( _SCREEN_SPACE_OCCLUSION ) // GBuffer never has transparents + float2 normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV( input.positionCS ); + AmbientOcclusionFactor aoFactor = GetScreenSpaceAmbientOcclusion( normalizedScreenSpaceUV ); + surfaceData.occlusion = aoFactor.directAmbientOcclusion; + #else + surfaceData.occlusion = 1; + #endif + + return PackGBuffersSurfaceData( surfaceData, inputData, float3( 0, 0, 0 ) ); + } + + ENDHLSL + } + + } + + CustomEditor "UnityEditor.ShaderGraphUnlitGUI" + FallBack "Hidden/Shader Graph/FallbackError" + + Fallback Off +} +/*ASEBEGIN +Version=19904 +Node;AmplifyShaderEditor.WorldNormalVector, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;63;-1600,-320;Inherit;False;False;1;0;FLOAT3;0,0,1;False;4;FLOAT3;0;FLOAT;1;FLOAT;2;FLOAT;3 +Node;AmplifyShaderEditor.WorldSpaceViewDirHlpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;64;-1648,-128;Inherit;False;1;0;FLOAT4;0,0,0,1;False;4;FLOAT3;0;FLOAT;1;FLOAT;2;FLOAT;3 +Node;AmplifyShaderEditor.NormalizeNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;65;-1392,-288;Inherit;False;False;1;0;FLOAT3;0,0,0;False;1;FLOAT3;0 +Node;AmplifyShaderEditor.NormalizeNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;66;-1376,-96;Inherit;False;False;1;0;FLOAT3;0,0,0;False;1;FLOAT3;0 +Node;AmplifyShaderEditor.ViewDirInputsCoordNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;198;-1472,256;Inherit;False;World;False;0;4;FLOAT3;0;FLOAT;1;FLOAT;2;FLOAT;3 +Node;AmplifyShaderEditor.DotProductOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;67;-1136,-176;Inherit;False;2;0;FLOAT3;0,0,0;False;1;FLOAT3;0,0,0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.WorldNormalVector, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;195;-1456,32;Inherit;False;False;1;0;FLOAT3;0,0,1;False;4;FLOAT3;0;FLOAT;1;FLOAT;2;FLOAT;3 +Node;AmplifyShaderEditor.NormalizeNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;199;-1232,288;Inherit;False;False;1;0;FLOAT3;0,0,0;False;1;FLOAT3;0 +Node;AmplifyShaderEditor.AbsOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;69;-1008,-192;Inherit;True;1;0;FLOAT;0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.DotProductOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;200;-1040,256;Inherit;False;2;0;FLOAT3;0,0,0;False;1;FLOAT3;0,0,0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.RangedFloatNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;72;-944,80;Inherit;False;Property;_IOR_ins;IOR_ins;0;0;Create;True;0;0;0;False;0;False;0;1;0;0;0;1;FLOAT;0 +Node;AmplifyShaderEditor.SimpleSubtractOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;74;-768,32;Inherit;False;2;0;FLOAT;1;False;1;FLOAT;0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.SimpleSubtractOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;70;-752,-176;Inherit;False;2;0;FLOAT;1;False;1;FLOAT;0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.AbsOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;202;-864,272;Inherit;False;1;0;FLOAT;0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.RangedFloatNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;205;-864,352;Inherit;False;Property;_edge;edge;3;0;Create;True;0;0;0;False;0;False;0.2;0.4;0;0;0;1;FLOAT;0 +Node;AmplifyShaderEditor.RangedFloatNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;222;304,688;Inherit;False;Property;_MainAlpha;MainAlpha;4;0;Create;True;0;0;0;False;0;False;0;1;0;0;0;1;FLOAT;0 +Node;AmplifyShaderEditor.TextureCoordinatesNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;235;-1536,576;Inherit;False;0;-1;2;3;2;SAMPLER2D;;False;0;FLOAT2;1,1;False;1;FLOAT2;0,0;False;5;FLOAT2;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4 +Node;AmplifyShaderEditor.SmoothstepOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;71;-512,-144;Inherit;False;3;0;FLOAT;0;False;1;FLOAT;0;False;2;FLOAT;1;False;1;FLOAT;0 +Node;AmplifyShaderEditor.Compare, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;203;-640,224;Inherit;False;4;4;0;FLOAT;0;False;1;FLOAT;0;False;2;FLOAT;1;False;3;FLOAT;0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.TFHCRemapNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;231;528,576;Inherit;False;5;0;FLOAT;0;False;1;FLOAT;0;False;2;FLOAT;1;False;3;FLOAT;-1;False;4;FLOAT;1;False;1;FLOAT;0 +Node;AmplifyShaderEditor.ComponentMaskNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;236;-1216,560;Inherit;True;False;True;True;True;1;0;FLOAT2;0,0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.SimpleAddOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;206;-102.1213,328.8957;Inherit;False;2;2;0;FLOAT;0;False;1;FLOAT;0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.ColorNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;87;64,-32;Inherit;False;Property;_IN;IN;1;1;[HDR];Create;True;0;0;0;False;0;False;0,0,0,1;0.007843138,0.01960784,0.04313726,1;True;True;0;6;COLOR;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4;FLOAT3;5 +Node;AmplifyShaderEditor.ColorNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;239;-912,704;Inherit;False;Property;_front;front;5;0;Create;True;0;0;0;False;0;False;1,1,1,0;0,0,0,0;True;True;0;6;COLOR;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4;FLOAT3;5 +Node;AmplifyShaderEditor.ColorNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;240;-704,896;Inherit;False;Property;_behind;behind;6;0;Create;True;0;0;0;False;0;False;0.4528302,0.4528302,0.4528302,0;0,0,0,0;True;True;0;6;COLOR;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4;FLOAT3;5 +Node;AmplifyShaderEditor.SimpleAddOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;223;816,592;Inherit;False;2;2;0;COLOR;0,0,0,0;False;1;FLOAT;0;False;1;COLOR;0 +Node;AmplifyShaderEditor.ColorNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;88;144,368;Inherit;False;Property;_OUT;OUT;2;1;[HDR];Create;True;0;0;0;False;0;False;1,1,1,1;0.8055493,2.033361,2.996078,1;True;True;0;6;COLOR;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4;FLOAT3;5 +Node;AmplifyShaderEditor.LerpOp, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;243;-208,848;Inherit;False;3;0;FLOAT;0;False;1;FLOAT;0;False;2;FLOAT;0;False;1;FLOAT;0 +Node;AmplifyShaderEditor.LerpOp, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;86;480,160;Inherit;False;3;0;COLOR;0,0,0,0;False;1;COLOR;0,0,0,0;False;2;FLOAT;0;False;1;COLOR;0 +Node;AmplifyShaderEditor.VertexColorNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;92;720,16;Inherit;False;0;5;COLOR;0;FLOAT;1;FLOAT;2;FLOAT;3;FLOAT;4 +Node;AmplifyShaderEditor.SimpleMultiplyOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;242;1024,656;Inherit;False;2;2;0;COLOR;0,0,0,0;False;1;FLOAT;0;False;1;COLOR;0 +Node;AmplifyShaderEditor.LerpOp, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;238;-400,640;Inherit;False;3;0;FLOAT3;0,0,0;False;1;FLOAT3;0,0,0;False;2;FLOAT;0;False;1;FLOAT3;0 +Node;AmplifyShaderEditor.SimpleMultiplyOpNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;93;1040,176;Inherit;False;3;3;0;COLOR;0,0,0,0;False;1;COLOR;0,0,0,0;False;2;FLOAT3;0,0,0;False;1;COLOR;0 +Node;AmplifyShaderEditor.SaturateNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;224;1195.572,532.3324;Inherit;False;1;0;COLOR;0,0,0,0;False;1;COLOR;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;19;1072,-32;Float;False;False;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;ExtraPrePass;0;0;ExtraPrePass;5;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;True;1;1;False;;0;False;;0;1;False;;0;False;;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;True;True;True;True;0;False;;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;0;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;21;1072,-32;Float;False;False;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;ShadowCaster;0;2;ShadowCaster;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;False;False;True;False;False;False;False;0;False;;False;False;False;False;False;False;False;False;False;True;1;False;;True;3;False;;False;True;1;LightMode=ShadowCaster;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;22;1072,-32;Float;False;False;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;DepthOnly;0;3;DepthOnly;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;False;False;True;True;False;False;False;0;False;;False;False;False;False;False;False;False;False;False;True;1;False;;False;False;True;1;LightMode=DepthOnly;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;23;1072,-32;Float;False;False;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;Meta;0;4;Meta;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;2;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;1;LightMode=Meta;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;24;1072,-32;Float;False;False;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;Universal2D;0;5;Universal2D;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;True;1;1;False;;0;False;;0;1;False;;0;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;True;True;True;True;0;False;;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;1;False;;True;3;False;;True;True;0;False;;0;False;;True;1;LightMode=Universal2D;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;25;1072,-32;Float;False;False;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;SceneSelectionPass;0;6;SceneSelectionPass;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;2;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;1;LightMode=SceneSelectionPass;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;26;1072,-32;Float;False;False;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;ScenePickingPass;0;7;ScenePickingPass;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;1;LightMode=Picking;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;27;1072,-32;Float;False;False;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;DepthNormals;0;8;DepthNormals;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;1;False;;True;3;False;;False;True;1;LightMode=DepthNormalsOnly;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;28;1072,-32;Float;False;False;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;DepthNormalsOnly;0;9;DepthNormalsOnly;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;1;False;;True;3;False;;False;True;1;LightMode=DepthNormalsOnly;False;True;9;d3d11;metal;vulkan;xboxone;xboxseries;playstation;ps4;ps5;switch;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;232;1232,292;Float;False;False;-1;3;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;MotionVectors;0;10;MotionVectors;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;True;True;False;False;0;False;;False;False;False;False;False;False;False;False;False;False;False;False;True;1;LightMode=MotionVectors;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;233;1232,292;Float;False;False;-1;3;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;XRMotionVectors;0;11;XRMotionVectors;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;True;True;True;True;0;False;;False;False;False;False;False;False;False;True;True;1;False;;255;False;;1;False;;7;False;;3;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;1;LightMode=XRMotionVectors;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;234;1232,292;Float;False;False;-1;3;UnityEditor.ShaderGraphUnlitGUI;0;1;New Amplify Shader;2992e84f91cbeb14eab234972e07ea9d;True;GBuffer;0;12;GBuffer;0;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Opaque=RenderType;Queue=Geometry=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;True;1;5;False;;10;False;;1;1;False;;10;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;True;True;True;True;0;False;;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;True;2;False;;True;3;False;;True;True;0;False;;0;False;;True;1;LightMode=UniversalGBuffer;False;False;0;;0;0;Standard;0;False;0 +Node;AmplifyShaderEditor.TemplateMultiPassMasterNode, AmplifyShaderEditor, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null;20;1488,192;Float;False;True;-1;2;UnityEditor.ShaderGraphUnlitGUI;0;13;Soullies/hold1;2992e84f91cbeb14eab234972e07ea9d;True;Forward;0;1;Forward;9;False;False;False;False;False;False;False;False;False;False;False;False;True;0;False;;False;True;0;False;;False;False;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;False;False;False;False;True;4;RenderPipeline=UniversalPipeline;RenderType=Transparent=RenderType;Queue=Transparent=Queue=0;UniversalMaterialType=Unlit;True;5;True;12;all;0;False;True;1;5;False;;10;False;;1;1;False;;10;False;;False;False;False;False;False;False;False;False;False;False;False;False;False;False;True;True;True;True;True;0;False;;False;False;False;False;False;False;False;True;False;0;False;;255;False;;255;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;0;False;;True;True;2;False;;True;3;False;;True;True;0;False;;0;False;;True;1;LightMode=UniversalForwardOnly;False;False;0;;0;0;Standard;30;Surface;1;638880746015847296; Keep Alpha;0;0; Blend;0;0;Two Sided;1;638882497197827444;Alpha Clipping;1;0; Use Shadow Threshold;0;0;Forward Only;0;0;Cast Shadows;1;0;Receive Shadows;1;0;Receive SSAO;1;0;Motion Vectors;1;0; Add Precomputed Velocity;0;0; XR Motion Vectors;0;0;GPU Instancing;1;0;LOD CrossFade;1;0;Built-in Fog;1;0;Meta Pass;0;0;Extra Pre Pass;0;0;Tessellation;0;0; Phong;0;0; Strength;0.5,False,;0; Type;0;0; Tess;16,False,;0; Min;10,False,;0; Max;25,False,;0; Edge Length;16,False,;0; Max Displacement;25,False,;0;Write Depth;0;0; Early Z;0;0;Vertex Position;1;0;0;13;False;True;True;True;False;False;True;True;True;False;True;False;True;False;;False;0 +WireConnection;65;0;63;0 +WireConnection;66;0;64;0 +WireConnection;67;0;65;0 +WireConnection;67;1;66;0 +WireConnection;199;0;198;0 +WireConnection;69;0;67;0 +WireConnection;200;0;195;0 +WireConnection;200;1;199;0 +WireConnection;74;1;72;0 +WireConnection;70;1;69;0 +WireConnection;202;0;200;0 +WireConnection;71;0;70;0 +WireConnection;71;1;74;0 +WireConnection;203;0;202;0 +WireConnection;203;1;205;0 +WireConnection;231;0;222;0 +WireConnection;236;0;235;0 +WireConnection;206;0;71;0 +WireConnection;206;1;203;0 +WireConnection;223;0;86;0 +WireConnection;223;1;231;0 +WireConnection;243;0;239;4 +WireConnection;243;1;240;4 +WireConnection;243;2;236;0 +WireConnection;86;0;87;0 +WireConnection;86;1;88;0 +WireConnection;86;2;206;0 +WireConnection;242;0;223;0 +WireConnection;242;1;243;0 +WireConnection;238;0;239;5 +WireConnection;238;1;240;5 +WireConnection;238;2;236;0 +WireConnection;93;0;86;0 +WireConnection;93;1;92;0 +WireConnection;93;2;238;0 +WireConnection;224;0;242;0 +WireConnection;20;2;93;0 +WireConnection;20;3;224;0 +ASEEND*/ +//CHKSM=8FABDEDE6424CAF13D0AAC2B48148B3424C39970 \ No newline at end of file diff --git a/Assets/000_assets/shader/hold 1.shader.meta b/Assets/000_assets/shader/hold 1.shader.meta new file mode 100644 index 00000000..b4723d64 --- /dev/null +++ b/Assets/000_assets/shader/hold 1.shader.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0903d036eb16e7c4e85a655b164ab7c2 +ShaderImporter: + externalObjects: {} + defaultTextures: + - _mainTex: {fileID: 2800000, guid: 325d33c6d266f0e448f60efb34dde7b1, type: 3} + - _dissolve: {fileID: 2800000, guid: 3e826cfc16029dc45981831227fd6fde, type: 3} + nonModifiableTextures: [] + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/ThemeBundles/DepartureToMultiverse/Materials/Notes/M_holda.mat b/Assets/ThemeBundles/DepartureToMultiverse/Materials/Notes/M_holda.mat new file mode 100644 index 00000000..b23c09a5 --- /dev/null +++ b/Assets/ThemeBundles/DepartureToMultiverse/Materials/Notes/M_holda.mat @@ -0,0 +1,176 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!114 &-1962591172073477845 +MonoBehaviour: + m_ObjectHideFlags: 11 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_GameObject: {fileID: 0} + m_Enabled: 1 + m_EditorHideFlags: 0 + m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3} + m_Name: + m_EditorClassIdentifier: + version: 7 +--- !u!21 &2100000 +Material: + serializedVersion: 8 + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInstance: {fileID: 0} + m_PrefabAsset: {fileID: 0} + m_Name: M_holda + m_Shader: {fileID: 4800000, guid: 0903d036eb16e7c4e85a655b164ab7c2, type: 3} + m_Parent: {fileID: 0} + m_ModifiedSerializedProperties: 0 + m_ValidKeywords: [] + m_InvalidKeywords: [] + m_LightmapFlags: 4 + m_EnableInstancingVariants: 1 + m_DoubleSidedGI: 0 + m_CustomRenderQueue: -1 + stringTagMap: {} + disabledShaderPasses: [] + m_LockedProperties: + m_SavedProperties: + serializedVersion: 3 + m_TexEnvs: + - _BaseMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _BumpMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailAlbedoMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailMask: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _DetailNormalMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _EmissionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MainTex: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _MetallicGlossMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _OcclusionMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _ParallaxMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _SpecGlossMap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _dissvolemap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _texcoord: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - _vertexmap: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_Lightmaps: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_LightmapsInd: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + - unity_ShadowMasks: + m_Texture: {fileID: 0} + m_Scale: {x: 1, y: 1} + m_Offset: {x: 0, y: 0} + m_Ints: [] + m_Floats: + - _AlphaClip: 0 + - _AlphaCutoff: 0.5 + - _AlphaToMask: 0 + - _Blend: 0 + - _BlendModePreserveSpecular: 1 + - _BumpScale: 1 + - _ClearCoatMask: 0 + - _ClearCoatSmoothness: 0 + - _Cull: 2 + - _Cutoff: 0.5 + - _DetailAlbedoMapScale: 1 + - _DetailNormalMapScale: 1 + - _DstBlend: 0 + - _DstBlendAlpha: 0 + - _EdgeValue: 0.378 + - _EnvironmentReflections: 1 + - _Float0: 0.84 + - _Float1: 1.41 + - _Float2: 12.91 + - _GlossMapScale: 0 + - _Glossiness: 0 + - _GlossyReflections: 0 + - _IOR_ins: 0.71 + - _MainAlpha: 1 + - _Metallic: 0 + - _OcclusionStrength: 1 + - _Opacity: 0 + - _Parallax: 0.005 + - _QueueControl: 1 + - _QueueOffset: 0 + - _ReceiveShadows: 1 + - _Smoothness: 0.5 + - _SmoothnessTextureChannel: 0 + - _SpecularHighlights: 1 + - _SrcBlend: 1 + - _SrcBlendAlpha: 1 + - _Surface: 0 + - _Width: 1.05 + - _WorkflowMode: 1 + - _ZWrite: 1 + - _alpha: 1 + - _alpha1: 2.42 + - _edge: 0 + - _line_angle: 7.11 + - _line_density: 1.14 + - _line_width: 0 + - _roll_speed: 0 + - _speed: 0 + - _vertexoffset: 0 + m_Colors: + - _BaseColor: {r: 1, g: 1, b: 1, a: 1} + - _Color: {r: 1, g: 1, b: 1, a: 1} + - _Color0: {r: 0.17036504, g: 0.24301589, b: 0.91823894, a: 1} + - _Color1: {r: 0.8742138, g: 0.068727314, b: 0.09242657, a: 1} + - _ColorA: {r: 0.08490568, g: 0.005206483, b: 0.005206483, a: 0} + - _ColorB: {r: 2.270603, g: 0.9966403, b: 0.4177054, a: 0} + - _EmissionColor: {r: 0, g: 0, b: 0, a: 1} + - _IN: {r: 0.007843138, g: 0.019607844, b: 0.043137256, a: 1} + - _ImageColor: {r: 1, g: 1, b: 1, a: 0} + - _LINE: {r: 0.10062885, g: 0.10062885, b: 0.10062885, a: 1} + - _OUT: {r: 0.10355599, g: 0.19449627, b: 0.27672952, a: 1} + - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1} + - _Vector0: {r: -0.05, g: 1, b: 0, a: 0} + - _behind: {r: 0.5345911, g: 0.1563426, b: 0.53424823, a: 1} + - _colorremap: {r: 0.5, g: 1, b: 0, a: 1} + - _front: {r: 0.7704402, g: 0.8828097, b: 1, a: 1} + m_BuildTextureStacks: [] + m_AllowLocking: 1 diff --git a/Assets/ThemeBundles/DepartureToMultiverse/Materials/Notes/M_holda.mat.meta b/Assets/ThemeBundles/DepartureToMultiverse/Materials/Notes/M_holda.mat.meta new file mode 100644 index 00000000..b364d397 --- /dev/null +++ b/Assets/ThemeBundles/DepartureToMultiverse/Materials/Notes/M_holda.mat.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 3e126463e67a7984c87ef1bde201de64 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 2100000 + userData: + assetBundleName: + assetBundleVariant: