Alles

Assets/MRTemplateAssets/Shaders/Occlusion/OcclusionComputation.hlsl

@@ -0,0 +1,144 @@
+#include "Utils.hlsl"
+
+TEXTURE2D(_EnvironmentConfidenceTexture);
+SAMPLER(sampler_EnvironmentConfidenceTexture);
+
+TEXTURE2D_ARRAY_FLOAT(_EnvironmentDepthTexture);
+SAMPLER(sampler_EnvironmentDepthTexture);
+float2 _EnvironmentDepthTexture_TexelSize;
+
+TEXTURE2D_ARRAY_FLOAT(_EnvironmentDepthTexturePreprocessed);
+SAMPLER(sampler_EnvironmentDepthTexturePreprocessed);
+float4 _EnvironmentDepthTexturePreprocessed_TexelSize;
+
+float4x4 _EnvironmentDepthProjectionMatrices[2];
+
+void SetOcclusionVertOutputs(float4 positionOS, inout float4 positionCS, inout float4 objectPositionWS)
+{
+    objectPositionWS = mul(unity_ObjectToWorld, float4(positionOS.xyz, 1.0));
+    positionCS = mul(UNITY_MATRIX_VP, objectPositionWS);
+}
+
+float SampleEnvironmentDepth(const float2 uv)
+{
+    return SAMPLE_TEXTURE2D_ARRAY(_EnvironmentDepthTexture, sampler_EnvironmentDepthTexture, uv, unity_StereoEyeIndex).r;
+}
+
+float SampleEnvironmentDepthLinear(const float2 uv)
+{
+    const float environmentDepth = SampleEnvironmentDepth(uv);
+
+    #ifdef XR_LINEAR_DEPTH
+        // depth is already linear
+        return environmentDepth;
+    #else
+        return LinearizeDepth(ConvertDepthToSymmetricRange(environmentDepth));
+    #endif
+}
+
+float4 SamplePreprocessedEnvironmentDepth(const float2 uv, const float index)
+{
+    return _EnvironmentDepthTexturePreprocessed.Sample(sampler_EnvironmentDepthTexturePreprocessed, float3(uv, index));
+}
+
+float4 SampleEnvironmentDepthGeneral(const float2 uv)
+{
+    #ifdef XR_SOFT_OCCLUSION
+        return SamplePreprocessedEnvironmentDepth(uv, unity_StereoEyeIndex);
+    #else
+        return float4(SampleEnvironmentDepthLinear(uv), 0, 0, 0);
+    #endif
+}
+
+float GetHardPixelVisibility(const float linearEnvironmentDepth, const float linearSceneDepth)
+{
+    return float (linearEnvironmentDepth > linearSceneDepth);
+}
+
+float GetSoftPixelVisibility(const float4 depthSample, const float linearSceneDepth)
+{
+    const float symmetricSceneDepthNDC = LinearDepthToSymmetricRangeNDC(linearSceneDepth);
+    const float nonSymmetricSceneDepthNDC = ConvertDepthToNonSymmetricRange(symmetricSceneDepthNDC);
+
+    // inversed scale factor is inversely proportional to (nonSymmetricSceneDepthNDC - 1.0f)
+    // at ndc value == 0 formula must return scaleAtZero scale factor
+    const float scaleAtZero = 15.0f; // determined experimentally
+    float invScaleFactor = -scaleAtZero / (nonSymmetricSceneDepthNDC - 1.0f);
+
+    float3 minMaxMidEnvDepths = float3(1.0f - depthSample.x, 1.0f - depthSample.y, depthSample.z + 1.0f - depthSample.x);
+
+    float3 depthDeltas = saturate((minMaxMidEnvDepths - nonSymmetricSceneDepthNDC) * invScaleFactor);
+
+    // blend min and max deltas
+    // min delta -> object fully invisible
+    // max delta -> object fully visible
+    const float kForegroundLevel = 0.1f;
+    const float kBackgroundLevel = 0.9f;
+    const float interp = depthSample.z / depthSample.w;
+    const float blendFactor = smoothstep(kForegroundLevel, kBackgroundLevel, interp);
+    const float differenceThreshold = 0.05f ;
+    const float isBlending = step(differenceThreshold, depthDeltas.y - depthDeltas.x);
+    const float alpha = depthDeltas.z * (1 - isBlending) + lerp(depthDeltas.x, depthDeltas.y, blendFactor) * isBlending;
+
+    return alpha;
+}
+
+float GetToleranceBasedPixelVisibility(const float linearEnvironmentDepth, const float linearSceneDepth)
+{
+    const float depthNearMin = 0.0;
+    const float depthNearMax = 0.05;
+    const float depthFarMin = 4.5;
+    const float depthFarMax = 6.5;
+    const float depthCloseToleranceThreshold = 3.5;
+    const float depthFarToleranceThreshold = 5.5;
+    const float toleranceClose = 0.02;
+    const float toleranceFurthest = 0.5;
+    const float toleranceGamma = 1;
+
+    const float delta = linearSceneDepth - linearEnvironmentDepth;
+
+    // |____|_______|____________|_____|
+    // 0  nMin   nMax         fmin   fmax
+    //d                            ^
+
+    const float trustDepthNear = NormalizeWithinBounds(linearEnvironmentDepth, depthNearMin, depthNearMax);
+    const float trustDepthFar = 1 - NormalizeWithinBounds(linearEnvironmentDepth, depthFarMin, depthFarMax);
+    const float sceneAssetVisibility = 1 - NormalizeWithinBounds(linearSceneDepth, depthFarMin, depthFarMax);
+    const float tolerance_t = NormalizeWithinBounds(linearEnvironmentDepth, depthCloseToleranceThreshold, depthFarToleranceThreshold);
+    const float tolerance = toleranceClose + pow(tolerance_t, toleranceGamma) * (toleranceFurthest - toleranceClose);
+
+    //gradually change visibility 0 to 1 on depth delta values <= tolerance.
+    const float closeProximityVisibility = saturate(1 - (delta + tolerance) / (2 * tolerance) * trustDepthFar);
+    return sceneAssetVisibility * max(max(closeProximityVisibility, 0), 1 - trustDepthNear);
+}
+
+float ComputePixelVisibility(const float4 environmentDepth, const float linearSceneDepth)
+{
+    #ifdef XR_SOFT_OCCLUSION
+        return GetSoftPixelVisibility(environmentDepth, linearSceneDepth);
+    #elif XR_HARD_OCCLUSION
+        return GetHardPixelVisibility(environmentDepth.x, linearSceneDepth);
+    #else
+        return GetToleranceBasedPixelVisibility(environmentDepth.x, linearSceneDepth);
+    #endif
+
+    return 1;
+}
+
+void SetOcclusion(float4 objectPositionWS, inout float4 color)
+{
+    const float4 clipSpaceDepthRelativePos = mul(_EnvironmentDepthProjectionMatrices[unity_StereoEyeIndex], objectPositionWS);
+    const float2 uv = (clipSpaceDepthRelativePos.xy / clipSpaceDepthRelativePos.w + 1.0f) * 0.5f;
+
+    if (all(uv < 0.0) || all(uv > 1.0))
+    {
+        return;
+    }
+
+    const float4 environmentDepth = SampleEnvironmentDepthGeneral(uv);
+    const float sceneDepthNDC = clipSpaceDepthRelativePos.z / clipSpaceDepthRelativePos.w;
+    const float linearSceneDepth = LinearizeDepth(sceneDepthNDC);
+
+    color.a *= ComputePixelVisibility(environmentDepth, linearSceneDepth);
+    color.rgb *= color.a;
+}

Assets/MRTemplateAssets/Shaders/Occlusion/OcclusionComputation.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: d1fb59a4bbefcdc4ca8e0cfd9eca8d24
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTemplateAssets/Shaders/Occlusion/OcclusionInputOutput.hlsl

@@ -0,0 +1,10 @@
+struct OcclusionAttributes
+{
+    float4 positionOS : POSITION;
+};
+
+struct OcclusionVaryings
+{
+    float4 positionCS : SV_POSITION;
+    float4 objectPositionWS : TEXCOORD0;
+};

Assets/MRTemplateAssets/Shaders/Occlusion/OcclusionInputOutput.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 3a5bbeb8efe23a14c84c435f4db0f366
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTemplateAssets/Shaders/Occlusion/OcclusionSimpleLit.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 39cb2e721fae497499ddea5dea274f96
+timeCreated: 1729717388

Assets/MRTemplateAssets/Shaders/Occlusion/OcclusionSimpleLit/OcclusionSimpleLit.shader

@@ -0,0 +1,471 @@
+// Shader targeted for low end devices. Single Pass Forward Rendering.
+Shader "Occlusion/OcclusionSimpleLit"
+{
+    // Keep properties of StandardSpecular shader for upgrade reasons.
+    Properties
+    {
+        [MainTexture] _BaseMap("Base Map (RGB) Smoothness / Alpha (A)", 2D) = "white" {}
+        [MainColor]   _BaseColor("Base Color", Color) = (1, 1, 1, 1)
+
+        _Cutoff("Alpha Clipping", Range(0.0, 1.0)) = 0.5
+
+        _Smoothness("Smoothness", Range(0.0, 1.0)) = 0.5
+        _SpecColor("Specular Color", Color) = (0.5, 0.5, 0.5, 0.5)
+        _SpecGlossMap("Specular Map", 2D) = "white" {}
+        _SmoothnessSource("Smoothness Source", Float) = 0.0
+        _SpecularHighlights("Specular Highlights", Float) = 1.0
+
+        [HideInInspector] _BumpScale("Scale", Float) = 1.0
+        [NoScaleOffset] _BumpMap("Normal Map", 2D) = "bump" {}
+
+        [HDR] _EmissionColor("Emission Color", Color) = (0,0,0)
+        [NoScaleOffset]_EmissionMap("Emission Map", 2D) = "white" {}
+
+        // Blending state
+        _Surface("__surface", Float) = 0.0
+        _Blend("__blend", Float) = 0.0
+        _Cull("__cull", Float) = 2.0
+        [ToggleUI] _AlphaClip("__clip", Float) = 0.0
+        [HideInInspector] _SrcBlend("__src", Float) = 1.0
+        [HideInInspector] _DstBlend("__dst", Float) = 0.0
+        [HideInInspector] _SrcBlendAlpha("__srcA", Float) = 1.0
+        [HideInInspector] _DstBlendAlpha("__dstA", Float) = 0.0
+        [HideInInspector] _ZWrite("__zw", Float) = 1.0
+        [HideInInspector] _BlendModePreserveSpecular("_BlendModePreserveSpecular", Float) = 1.0
+        [HideInInspector] _AlphaToMask("__alphaToMask", Float) = 0.0
+        [HideInInspector] _AddPrecomputedVelocity("_AddPrecomputedVelocity", Float) = 0.0
+
+        [ToggleUI] _ReceiveShadows("Receive Shadows", Float) = 1.0
+        // Editmode props
+        _QueueOffset("Queue offset", Float) = 0.0
+
+        // ObsoleteProperties
+        [HideInInspector] _MainTex("BaseMap", 2D) = "white" {}
+        [HideInInspector] _Color("Base Color", Color) = (1, 1, 1, 1)
+        [HideInInspector] _Shininess("Smoothness", Float) = 0.0
+        [HideInInspector] _GlossinessSource("GlossinessSource", Float) = 0.0
+        [HideInInspector] _SpecSource("SpecularHighlights", Float) = 0.0
+
+        [HideInInspector][NoScaleOffset]unity_Lightmaps("unity_Lightmaps", 2DArray) = "" {}
+        [HideInInspector][NoScaleOffset]unity_LightmapsInd("unity_LightmapsInd", 2DArray) = "" {}
+        [HideInInspector][NoScaleOffset]unity_ShadowMasks("unity_ShadowMasks", 2DArray) = "" {}
+    }
+
+    SubShader
+    {
+        Tags
+        {
+            "RenderType" = "Opaque"
+            "RenderPipeline" = "UniversalPipeline"
+            "UniversalMaterialType" = "SimpleLit"
+            "IgnoreProjector" = "True"
+        }
+        LOD 300
+
+        Pass
+        {
+            Name "ForwardLit"
+            Tags
+            {
+                "LightMode" = "UniversalForward"
+            }
+
+            // -------------------------------------
+            // Render State Commands
+            // Use same blending / depth states as Standard shader
+            Blend[_SrcBlend][_DstBlend], [_SrcBlendAlpha][_DstBlendAlpha]
+            ZWrite[_ZWrite]
+            Cull[_Cull]
+            AlphaToMask[_AlphaToMask]
+
+            HLSLPROGRAM
+            #pragma target 2.0
+
+            // -------------------------------------
+            // Shader Stages
+            #pragma vertex LitPassVertexSimple
+            #pragma fragment LitPassFragmentSimple
+
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature_local _NORMALMAP
+            #pragma shader_feature_local_fragment _EMISSION
+            #pragma shader_feature_local _RECEIVE_SHADOWS_OFF
+            #pragma shader_feature_local_fragment _SURFACE_TYPE_TRANSPARENT
+            #pragma shader_feature_local_fragment _ALPHATEST_ON
+            #pragma shader_feature_local_fragment _ _ALPHAPREMULTIPLY_ON _ALPHAMODULATE_ON
+            #pragma shader_feature_local_fragment _ _SPECGLOSSMAP _SPECULAR_COLOR
+            #pragma shader_feature_local_fragment _GLOSSINESS_FROM_BASE_ALPHA
+
+            // -------------------------------------
+            // Universal Pipeline keywords
+            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
+            #pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
+            #pragma multi_compile _ EVALUATE_SH_MIXED EVALUATE_SH_VERTEX
+            #pragma multi_compile _ LIGHTMAP_SHADOW_MIXING
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile _ _LIGHT_LAYERS
+            #pragma multi_compile _ _FORWARD_PLUS
+            #pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
+            #pragma multi_compile_fragment _ _SHADOWS_SOFT
+            #pragma multi_compile_fragment _ _SHADOWS_SOFT_LOW _SHADOWS_SOFT_MEDIUM _SHADOWS_SOFT_HIGH
+            #pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION
+            #pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3
+            #pragma multi_compile_fragment _ _LIGHT_COOKIES
+            #include_with_pragmas "Packages/com.unity.render-pipelines.core/ShaderLibrary/FoveatedRenderingKeywords.hlsl"
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ProbeVolumeVariants.hlsl"
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl"
+
+            // -------------------------------------
+            // Unity defined keywords
+            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
+            #pragma multi_compile _ LIGHTMAP_ON
+            #pragma multi_compile _ DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ USE_LEGACY_LIGHTMAPS
+            #pragma multi_compile_fragment _ DEBUG_DISPLAY
+            #pragma multi_compile _ LOD_FADE_CROSSFADE
+
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+            #pragma instancing_options renderinglayer
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl"
+
+            // Occlusion features
+            #pragma multi_compile _ XR_LINEAR_DEPTH
+            #pragma multi_compile _ XR_HARD_OCCLUSION XR_SOFT_OCCLUSION
+
+            //--------------------------------------
+            // Defines
+            #define BUMP_SCALE_NOT_SUPPORTED 1
+
+            // -------------------------------------
+            // Includes
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
+            #include "OcclusionSimpleLitForwardPass.hlsl"
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "ShadowCaster"
+            Tags
+            {
+                "LightMode" = "ShadowCaster"
+            }
+
+            // -------------------------------------
+            // Render State Commands
+            ZWrite On
+            ZTest LEqual
+            ColorMask 0
+            Cull[_Cull]
+
+            HLSLPROGRAM
+            #pragma target 2.0
+
+            // -------------------------------------
+            // Shader Stages
+            #pragma vertex ShadowPassVertex
+            #pragma fragment ShadowPassFragment
+
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature_local _ALPHATEST_ON
+            #pragma shader_feature_local_fragment _GLOSSINESS_FROM_BASE_ALPHA
+
+            // -------------------------------------
+            // Unity defined keywords
+            #pragma multi_compile _ LOD_FADE_CROSSFADE
+
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl"
+
+            // This is used during shadow map generation to differentiate between directional and punctual light shadows, as they use different formulas to apply Normal Bias
+            #pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
+
+            // -------------------------------------
+            // Includes
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/ShadowCasterPass.hlsl"
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "GBuffer"
+            Tags
+            {
+                "LightMode" = "UniversalGBuffer"
+            }
+
+            // -------------------------------------
+            // Render State Commands
+            ZWrite[_ZWrite]
+            ZTest LEqual
+            Cull[_Cull]
+
+            HLSLPROGRAM
+            #pragma target 4.5
+
+            // Deferred Rendering Path does not support the OpenGL-based graphics API:
+            // Desktop OpenGL, OpenGL ES 3.0, WebGL 2.0.
+            #pragma exclude_renderers gles3 glcore
+
+            // -------------------------------------
+            // Shader Stages
+            #pragma vertex LitPassVertexSimple
+            #pragma fragment LitPassFragmentSimple
+
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature_local_fragment _ALPHATEST_ON
+            //#pragma shader_feature _ALPHAPREMULTIPLY_ON
+            #pragma shader_feature_local_fragment _ _SPECGLOSSMAP _SPECULAR_COLOR
+            #pragma shader_feature_local_fragment _GLOSSINESS_FROM_BASE_ALPHA
+            #pragma shader_feature_local _NORMALMAP
+            #pragma shader_feature_local_fragment _EMISSION
+            #pragma shader_feature_local _RECEIVE_SHADOWS_OFF
+
+            // -------------------------------------
+            // Universal Pipeline keywords
+            #pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
+            //#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
+            //#pragma multi_compile _ _ADDITIONAL_LIGHT_SHADOWS
+            #pragma multi_compile_fragment _ _SHADOWS_SOFT
+            #pragma multi_compile_fragment _ _SHADOWS_SOFT_LOW _SHADOWS_SOFT_MEDIUM _SHADOWS_SOFT_HIGH
+            #pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ProbeVolumeVariants.hlsl"
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl"
+
+            // -------------------------------------
+            // Unity defined keywords
+            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
+            #pragma multi_compile _ LIGHTMAP_ON
+            #pragma multi_compile _ DYNAMICLIGHTMAP_ON
+            #pragma multi_compile _ USE_LEGACY_LIGHTMAPS
+            #pragma multi_compile _ LIGHTMAP_SHADOW_MIXING
+            #pragma multi_compile _ SHADOWS_SHADOWMASK
+            #pragma multi_compile_fragment _ _GBUFFER_NORMALS_OCT
+            #pragma multi_compile_fragment _ _RENDER_PASS_ENABLED
+            #pragma multi_compile _ LOD_FADE_CROSSFADE
+
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+            #pragma instancing_options renderinglayer
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl"
+
+            //--------------------------------------
+            // Defines
+            #define BUMP_SCALE_NOT_SUPPORTED 1
+
+            // -------------------------------------
+            // Includes
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitGBufferPass.hlsl"
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "DepthOnly"
+            Tags
+            {
+                "LightMode" = "DepthOnly"
+            }
+
+            // -------------------------------------
+            // Render State Commands
+            ZWrite On
+            ColorMask R
+            Cull[_Cull]
+
+            HLSLPROGRAM
+            #pragma target 2.0
+
+            // -------------------------------------
+            // Shader Stages
+            #pragma vertex DepthOnlyVertex
+            #pragma fragment DepthOnlyFragment
+
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature_local _ALPHATEST_ON
+            #pragma shader_feature_local_fragment _GLOSSINESS_FROM_BASE_ALPHA
+
+            // -------------------------------------
+            // Unity defined keywords
+            #pragma multi_compile _ LOD_FADE_CROSSFADE
+
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl"
+
+            // -------------------------------------
+            // Includes
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/DepthOnlyPass.hlsl"
+            ENDHLSL
+        }
+
+        // This pass is used when drawing to a _CameraNormalsTexture texture
+        Pass
+        {
+            Name "DepthNormals"
+            Tags
+            {
+                "LightMode" = "DepthNormals"
+            }
+
+            // -------------------------------------
+            // Render State Commands
+            ZWrite On
+            Cull[_Cull]
+
+            HLSLPROGRAM
+            #pragma target 2.0
+
+            // -------------------------------------
+            // Shader Stages
+            #pragma vertex DepthNormalsVertex
+            #pragma fragment DepthNormalsFragment
+
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature_local _NORMALMAP
+            #pragma shader_feature_local _ALPHATEST_ON
+            #pragma shader_feature_local_fragment _GLOSSINESS_FROM_BASE_ALPHA
+
+            // -------------------------------------
+            // Unity defined keywords
+            #pragma multi_compile _ LOD_FADE_CROSSFADE
+
+            // Universal Pipeline keywords
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/RenderingLayers.hlsl"
+
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DOTS.hlsl"
+
+            // -------------------------------------
+            // Includes
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitDepthNormalsPass.hlsl"
+            ENDHLSL
+        }
+
+        // This pass it not used during regular rendering, only for lightmap baking.
+        Pass
+        {
+            Name "Meta"
+            Tags
+            {
+                "LightMode" = "Meta"
+            }
+
+            // -------------------------------------
+            // Render State Commands
+            Cull Off
+
+            HLSLPROGRAM
+            #pragma target 2.0
+
+            // -------------------------------------
+            // Shader Stages
+            #pragma vertex UniversalVertexMeta
+            #pragma fragment UniversalFragmentMetaSimple
+
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature_local_fragment _EMISSION
+            #pragma shader_feature_local_fragment _SPECGLOSSMAP
+            #pragma shader_feature EDITOR_VISUALIZATION
+
+            // -------------------------------------
+            // Includes
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitMetaPass.hlsl"
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "Universal2D"
+            Tags
+            {
+                "LightMode" = "Universal2D"
+                "RenderType" = "Transparent"
+                "Queue" = "Transparent"
+            }
+
+            HLSLPROGRAM
+            #pragma target 2.0
+
+            // -------------------------------------
+            // Shader Stages
+            #pragma vertex vert
+            #pragma fragment frag
+
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature_local_fragment _ALPHATEST_ON
+            #pragma shader_feature_local_fragment _ALPHAPREMULTIPLY_ON
+
+            // -------------------------------------
+            // Includes
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/Utils/Universal2D.hlsl"
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "MotionVectors"
+            Tags { "LightMode" = "MotionVectors" }
+            ColorMask RG
+
+            HLSLPROGRAM
+            #pragma shader_feature_local _ALPHATEST_ON
+            #pragma multi_compile _ LOD_FADE_CROSSFADE
+            #pragma shader_feature_local_vertex _ADD_PRECOMPUTED_VELOCITY
+
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ObjectMotionVectors.hlsl"
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Name "XRMotionVectors"
+            Tags { "LightMode" = "XRMotionVectors" }
+            ColorMask RGBA
+
+            // Stencil write for obj motion pixels
+            Stencil
+            {
+                WriteMask 1
+                Ref 1
+                Comp Always
+                Pass Replace
+            }
+
+            HLSLPROGRAM
+            #pragma shader_feature_local _ALPHATEST_ON
+            #pragma multi_compile _ LOD_FADE_CROSSFADE
+            #pragma shader_feature_local_vertex _ADD_PRECOMPUTED_VELOCITY
+            #define APLICATION_SPACE_WARP_MOTION 1
+            #include "Packages/com.unity.render-pipelines.universal/Shaders/SimpleLitInput.hlsl"
+            #include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ObjectMotionVectors.hlsl"
+            ENDHLSL
+        }
+    }
+
+    Fallback  "Universal Render Pipeline/Simple Lit"
+    CustomEditor "UnityEditor.Rendering.Universal.ShaderGUI.SimpleLitShader"
+}

Assets/MRTemplateAssets/Shaders/Occlusion/OcclusionSimpleLit/OcclusionSimpleLit.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 394bcf679cb659a46aa1d3dec30186e3
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTemplateAssets/Shaders/Occlusion/OcclusionSimpleLit/OcclusionSimpleLitForwardPass.hlsl

@@ -0,0 +1,234 @@
+#ifndef UNIVERSAL_SIMPLE_LIT_PASS_INCLUDED
+#define UNIVERSAL_SIMPLE_LIT_PASS_INCLUDED
+
+#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
+#include "../OcclusionComputation.hlsl"
+#include "../OcclusionInputOutput.hlsl"
+#if defined(LOD_FADE_CROSSFADE)
+    #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/LODCrossFade.hlsl"
+#endif
+
+struct Attributes : OcclusionAttributes
+{
+    float3 normalOS      : NORMAL;
+    float4 tangentOS     : TANGENT;
+    float2 texcoord      : TEXCOORD0;
+    float2 staticLightmapUV    : TEXCOORD1;
+    float2 dynamicLightmapUV    : TEXCOORD2;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct Varyings : OcclusionVaryings
+{
+    float2 uv                       : TEXCOORD1;
+
+    float3 positionWS                  : TEXCOORD2;    // xyz: posWS
+
+    #ifdef _NORMALMAP
+        half4 normalWS                 : TEXCOORD3;    // xyz: normal, w: viewDir.x
+        half4 tangentWS                : TEXCOORD4;    // xyz: tangent, w: viewDir.y
+        half4 bitangentWS              : TEXCOORD5;    // xyz: bitangent, w: viewDir.z
+    #else
+        half3  normalWS                : TEXCOORD6;
+    #endif
+
+    #ifdef _ADDITIONAL_LIGHTS_VERTEX
+        half4 fogFactorAndVertexLight  : TEXCOORD7; // x: fogFactor, yzw: vertex light
+    #else
+        half  fogFactor                 : TEXCOORD8;
+    #endif
+
+    #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
+        float4 shadowCoord             : TEXCOORD9;
+    #endif
+
+    DECLARE_LIGHTMAP_OR_SH(staticLightmapUV, vertexSH, 10);
+
+#ifdef DYNAMICLIGHTMAP_ON
+    float2  dynamicLightmapUV : TEXCOORD11; // Dynamic lightmap UVs
+#endif
+
+#ifdef USE_APV_PROBE_OCCLUSION
+    float4 probeOcclusion : TEXCOORD12;
+#endif
+
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+    UNITY_VERTEX_OUTPUT_STEREO
+};
+
+void InitializeInputData(Varyings input, half3 normalTS, out InputData inputData)
+{
+    inputData = (InputData)0;
+
+    inputData.positionWS = input.positionWS;
+#if defined(DEBUG_DISPLAY)
+    inputData.positionCS = input.positionCS;
+#endif
+
+    #ifdef _NORMALMAP
+        half3 viewDirWS = half3(input.normalWS.w, input.tangentWS.w, input.bitangentWS.w);
+        inputData.tangentToWorld = half3x3(input.tangentWS.xyz, input.bitangentWS.xyz, input.normalWS.xyz);
+        inputData.normalWS = TransformTangentToWorld(normalTS, inputData.tangentToWorld);
+    #else
+        half3 viewDirWS = GetWorldSpaceNormalizeViewDir(inputData.positionWS);
+        inputData.normalWS = input.normalWS;
+    #endif
+
+    inputData.normalWS = NormalizeNormalPerPixel(inputData.normalWS);
+    viewDirWS = SafeNormalize(viewDirWS);
+
+    inputData.viewDirectionWS = viewDirWS;
+
+    #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
+        inputData.shadowCoord = input.shadowCoord;
+    #elif defined(MAIN_LIGHT_CALCULATE_SHADOWS)
+        inputData.shadowCoord = TransformWorldToShadowCoord(inputData.positionWS);
+    #else
+        inputData.shadowCoord = float4(0, 0, 0, 0);
+    #endif
+
+    #ifdef _ADDITIONAL_LIGHTS_VERTEX
+        inputData.fogCoord = InitializeInputDataFog(float4(inputData.positionWS, 1.0), input.fogFactorAndVertexLight.x);
+        inputData.vertexLighting = input.fogFactorAndVertexLight.yzw;
+    #else
+        inputData.fogCoord = InitializeInputDataFog(float4(inputData.positionWS, 1.0), input.fogFactor);
+        inputData.vertexLighting = half3(0, 0, 0);
+    #endif
+
+    inputData.normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(input.positionCS);
+
+    #if defined(DEBUG_DISPLAY)
+    #if defined(DYNAMICLIGHTMAP_ON)
+    inputData.dynamicLightmapUV = input.dynamicLightmapUV.xy;
+    #endif
+    #if defined(LIGHTMAP_ON)
+    inputData.staticLightmapUV = input.staticLightmapUV;
+    #else
+    inputData.vertexSH = input.vertexSH;
+    #endif
+    #if defined(USE_APV_PROBE_OCCLUSION)
+    inputData.probeOcclusion = input.probeOcclusion;
+    #endif
+    #endif
+}
+
+void InitializeBakedGIData(Varyings input, inout InputData inputData)
+{
+#if defined(DYNAMICLIGHTMAP_ON)
+    inputData.bakedGI = SAMPLE_GI(input.staticLightmapUV, input.dynamicLightmapUV, input.vertexSH, inputData.normalWS);
+    inputData.shadowMask = SAMPLE_SHADOWMASK(input.staticLightmapUV);
+#elif !defined(LIGHTMAP_ON) && (defined(PROBE_VOLUMES_L1) || defined(PROBE_VOLUMES_L2))
+    inputData.bakedGI = SAMPLE_GI(input.vertexSH,
+        GetAbsolutePositionWS(inputData.positionWS),
+        inputData.normalWS,
+        inputData.viewDirectionWS,
+        input.positionCS.xy,
+        input.probeOcclusion,
+        inputData.shadowMask);
+#else
+    inputData.bakedGI = SAMPLE_GI(input.staticLightmapUV, input.vertexSH, inputData.normalWS);
+    inputData.shadowMask = SAMPLE_SHADOWMASK(input.staticLightmapUV);
+#endif
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//                  Vertex and Fragment functions                            //
+///////////////////////////////////////////////////////////////////////////////
+
+// Used in Standard (Simple Lighting) shader
+Varyings LitPassVertexSimple(Attributes input)
+{
+    Varyings output = (Varyings)0;
+
+    UNITY_SETUP_INSTANCE_ID(input);
+    UNITY_TRANSFER_INSTANCE_ID(input, output);
+    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
+
+    VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
+    VertexNormalInputs normalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);
+
+#if defined(_FOG_FRAGMENT)
+        half fogFactor = 0;
+#else
+        half fogFactor = ComputeFogFactor(vertexInput.positionCS.z);
+#endif
+
+    output.uv = TRANSFORM_TEX(input.texcoord, _BaseMap);
+    output.positionWS.xyz = vertexInput.positionWS;
+    output.positionCS = vertexInput.positionCS;
+
+#ifdef _NORMALMAP
+    half3 viewDirWS = GetWorldSpaceViewDir(vertexInput.positionWS);
+    output.normalWS = half4(normalInput.normalWS, viewDirWS.x);
+    output.tangentWS = half4(normalInput.tangentWS, viewDirWS.y);
+    output.bitangentWS = half4(normalInput.bitangentWS, viewDirWS.z);
+#else
+    output.normalWS = NormalizeNormalPerVertex(normalInput.normalWS);
+#endif
+
+    OUTPUT_LIGHTMAP_UV(input.staticLightmapUV, unity_LightmapST, output.staticLightmapUV);
+#ifdef DYNAMICLIGHTMAP_ON
+    output.dynamicLightmapUV = input.dynamicLightmapUV.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
+#endif
+    OUTPUT_SH4(vertexInput.positionWS, output.normalWS.xyz, GetWorldSpaceNormalizeViewDir(vertexInput.positionWS), output.vertexSH, output.probeOcclusion);
+
+    #ifdef _ADDITIONAL_LIGHTS_VERTEX
+        half3 vertexLight = VertexLighting(vertexInput.positionWS, normalInput.normalWS);
+        output.fogFactorAndVertexLight = half4(fogFactor, vertexLight);
+    #else
+        output.fogFactor = fogFactor;
+    #endif
+
+    #if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
+        output.shadowCoord = GetShadowCoord(vertexInput);
+    #endif
+
+    SetOcclusionVertOutputs(input.positionOS, output.positionCS, output.objectPositionWS);
+
+    return output;
+}
+
+// Used for StandardSimpleLighting shader
+void LitPassFragmentSimple(
+    Varyings input
+    , out half4 outColor : SV_Target0
+#ifdef _WRITE_RENDERING_LAYERS
+    , out float4 outRenderingLayers : SV_Target1
+#endif
+)
+{
+    UNITY_SETUP_INSTANCE_ID(input);
+    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
+
+    SurfaceData surfaceData;
+    InitializeSimpleLitSurfaceData(input.uv, surfaceData);
+
+#ifdef LOD_FADE_CROSSFADE
+    LODFadeCrossFade(input.positionCS);
+#endif
+
+    InputData inputData;
+    InitializeInputData(input, surfaceData.normalTS, inputData);
+    SETUP_DEBUG_TEXTURE_DATA(inputData, UNDO_TRANSFORM_TEX(input.uv, _BaseMap));
+
+#if defined(_DBUFFER)
+    ApplyDecalToSurfaceData(input.positionCS, surfaceData, inputData);
+#endif
+
+    InitializeBakedGIData(input, inputData);
+
+    half4 color = UniversalFragmentBlinnPhong(inputData, surfaceData);
+    color.rgb = MixFog(color.rgb, inputData.fogCoord);
+    color.a = OutputAlpha(color.a, IsSurfaceTypeTransparent(_Surface));
+
+    SetOcclusion(input.objectPositionWS, color);
+
+    outColor = color;
+
+#ifdef _WRITE_RENDERING_LAYERS
+    uint renderingLayers = GetMeshRenderingLayer();
+    outRenderingLayers = float4(EncodeMeshRenderingLayer(renderingLayers), 0, 0, 0);
+#endif
+}
+
+#endif

Assets/MRTemplateAssets/Shaders/Occlusion/OcclusionSimpleLit/OcclusionSimpleLitForwardPass.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 268c0a01b77e00e4980fcdfa657c2e95
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/MRTemplateAssets/Shaders/Occlusion/Utils.hlsl

@@ -0,0 +1,56 @@
+float2 _NdcLinearConversionParameters;
+
+float NormalizeWithinBounds(const float v, const float min, const float max)
+{
+    return saturate((v - min) / (max - min));
+}
+
+//symmetric range is [-1:1] (OpenGL)
+float ConvertDepthToSymmetricRange(const float depthNDC)
+{
+    return depthNDC * 2.0 - 1.0;
+}
+
+//non-symmetric range is [0:1] (Vulcan, DirectX, Metal)
+float ConvertDepthToNonSymmetricRange(const float depthNDC)
+{
+    return (depthNDC + 1.0) * 0.5;
+}
+
+float LinearizeDepth(const float symmetricRangeDepthNdc)
+{
+    return _NdcLinearConversionParameters.x / (symmetricRangeDepthNdc + _NdcLinearConversionParameters.y);
+}
+
+float LinearDepthToSymmetricRangeNDC(const float linearDepth)
+{
+    return _NdcLinearConversionParameters.x / linearDepth - _NdcLinearConversionParameters.y;
+}
+
+float4 DebugDepthDistance(const float linearDepth)
+{
+    const float4 colors[9] =
+    {
+        float4(1, 1, 1, 1),         // White, 0 meter
+        float4(1, 0, 0, 1),         // Red, 1 meter
+        float4(1, 0.125, 0, 1),     // Orange, 2 meters
+        float4(1, 1, 0, 1),         // Yellow, 3 meters
+        float4(0, 1, 0, 1),         // Green, 4 meters
+        float4(0.5, 0.5, 0, 1),     // Cyan, 5 meters
+        float4(0, 0, 1, 1),         // Blue, 6 meters
+        float4(0.375, 0.375, 1, 1), // Magenta, 7 meters
+        float4(0.7, 0.25, 1, 1)     // Pink, 8 meters
+    };
+
+    float step = 1;
+    float tempD = step;
+
+    while (tempD < linearDepth && tempD < 10)
+    {
+        tempD += step;
+    }
+
+    int colIndex = (int) (tempD / step) - 1;
+    colIndex = clamp(colIndex, 0, 7);
+    return lerp(colors[colIndex], colors[colIndex + 1], (1 - (tempD - linearDepth)) / step);
+}

Assets/MRTemplateAssets/Shaders/Occlusion/Utils.hlsl.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a9df531dab4d0654c8c6415921314b82
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: