Adaug proiectul Unity

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/Default Lens Flare (SRP).asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: bd7eaf3bd49c39f4cb77bd809459aa72
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/FallbackShader.shader

@@ -0,0 +1,41 @@
+Shader "Hidden/Core/FallbackError"
+{
+    SubShader
+    {
+        Pass
+        {
+            CGPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma target 2.0
+            #pragma multi_compile _ STEREO_INSTANCING_ON STEREO_MULTIVIEW_ON
+            #pragma editor_sync_compilation
+            #include "UnityCG.cginc"
+
+            struct appdata_t {
+                float4 vertex : POSITION;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct v2f {
+                float4 vertex : SV_POSITION;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            v2f vert (appdata_t v)
+            {
+                v2f o;
+                UNITY_SETUP_INSTANCE_ID(v);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+                o.vertex = UnityObjectToClipPos(v.vertex);
+                return o;
+            }
+            fixed4 frag (v2f i) : SV_Target
+            {
+                return fixed4(1,0,1,1);
+            }
+            ENDCG
+        }
+    }
+    Fallback Off
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/FallbackShader.shader.meta

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

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 270b22cf3fe09dc4ea4fe92d629d8bce
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/DebugOccluder.shader

@@ -0,0 +1,67 @@
+Shader "Hidden/Core/DebugOccluder"
+{
+    HLSLINCLUDE
+        #pragma target 4.5
+        #pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch switch2 webgpu
+        //#pragma enable_debug_symbols
+
+        #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+
+        float2 _ValidRange;
+        SamplerState ltc_linear_clamp_sampler;
+
+        struct Attributes
+        {
+            uint vertexID : VERTEXID_SEMANTIC;
+        };
+
+        struct Varyings
+        {
+            float4 positionCS : SV_POSITION;
+            float2 texcoord : TEXCOORD0;
+        };
+
+        Varyings Vert(Attributes input)
+        {
+            Varyings output;
+            output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
+            output.texcoord = GetFullScreenTriangleTexCoord(input.vertexID);
+            return output;
+        }
+
+        float4 GetOutputColor(float occluderValue)
+        {
+            float value = saturate((occluderValue - _ValidRange.x) * _ValidRange.y);
+            return float4(value.xxx, 1);
+        }
+
+    ENDHLSL
+
+    SubShader
+    {
+        Tags{ "RenderPipeline" = "HDRenderPipeline"}
+        Pass
+        {
+            Name "DebugOccluder"
+            ZTest Off
+            Blend One Zero
+            Cull Off
+            ZWrite On
+
+            HLSLPROGRAM
+
+            TEXTURE2D(_OccluderTexture);
+
+            #pragma vertex Vert
+            #pragma fragment Fragment
+
+            float4 Fragment(Varyings input) : SV_Target
+            {
+                return GetOutputColor(SAMPLE_TEXTURE2D(_OccluderTexture, ltc_linear_clamp_sampler, input.texcoord).x);
+            }
+
+            ENDHLSL
+        }
+    }
+    Fallback Off
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/DebugOccluder.shader.meta

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

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/DebugOcclusionTest.shader

@@ -0,0 +1,105 @@
+Shader "Hidden/Core/DebugOcclusionTest"
+{
+    SubShader
+    {
+        Tags{ "RenderPipeline" = "HDRenderPipeline" }
+        Pass
+        {
+            ZWrite Off
+            Cull Off
+            ZTest Always
+            Blend SrcAlpha OneMinusSrcAlpha
+
+            HLSLPROGRAM
+            #pragma target 4.5
+            #pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch switch2 webgpu
+
+            #pragma vertex Vert
+            #pragma fragment Frag
+            //#pragma enable_debug_symbols
+
+            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Debug.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureXR.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/Culling/InstanceOcclusionCuller.cs.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/Culling/OcclusionCullingDebugShaderVariables.cs.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/Culling/OcclusionCullingCommon.cs.hlsl"
+
+            StructuredBuffer<uint> _OcclusionDebugOverlay;
+
+            struct Attributes
+            {
+                uint vertexID : SV_VertexID;
+                UNITY_VERTEX_INPUT_INSTANCE_ID
+            };
+
+            struct Varyings
+            {
+                float4 positionCS : SV_POSITION;
+                float2 uv : TEXCOORD0;
+                UNITY_VERTEX_OUTPUT_STEREO
+            };
+
+            Varyings Vert(Attributes input)
+            {
+                Varyings output;
+                UNITY_SETUP_INSTANCE_ID(input);
+                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
+                output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
+                output.uv = GetFullScreenTriangleTexCoord(input.vertexID) * _DepthSizeInOccluderPixels.xy;
+                return output;
+            }
+
+            // c.f. OverlayHeatMap
+            float4 OverlayHeapMapColor(float cost, float costScreenTotal, float opacity)
+            {
+                // adjust color range. max clamp is to avoid scaling if 12 colors are enough.
+                float colorRangeScale = 1.0 / max(1.0, costScreenTotal / (float)DEBUG_COLORS_COUNT);
+                int colorIndex = (int)(1.0 + cost * colorRangeScale);
+
+                colorIndex = clamp(colorIndex, 1, DEBUG_COLORS_COUNT-1); // skip colorIndex 0 (black)
+                float4 col = kDebugColorGradient[colorIndex];
+
+                float4 color = float4(PositivePow(col.rgb, 2.2), opacity * col.a);
+                return color;
+            }
+
+            uint OcclusionDebugOverlayOffset(uint2 coord)
+            {
+                return OCCLUSIONCULLINGCOMMONCONFIG_DEBUG_PYRAMID_OFFSET + coord.x + _OccluderMipLayoutSizeX * coord.y;
+            }
+
+            float4 Frag(Varyings input) : SV_Target
+            {
+                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
+
+                uint2 coord = uint2(input.uv);
+                uint subviewIndex = unity_StereoEyeIndex;
+
+                uint total = 0;
+                for (int i = 0; i < OCCLUSIONCULLINGCOMMONCONFIG_MAX_OCCLUDER_MIPS; ++i)
+                {
+                    int4 mipBounds = _OccluderMipBounds[i];
+                    mipBounds.y += subviewIndex * _OccluderMipLayoutSizeY;
+
+                    uint2 debugCoord = mipBounds.xy + uint2(min(int2(coord >> i), mipBounds.zw - 1));
+
+                    total += _OcclusionDebugOverlay[OcclusionDebugOverlayOffset(debugCoord)];
+                }
+
+                if(total == 0)
+                    return float4(0, 0, 0, 0);
+
+                float cost = log2((float)total);
+
+                uint screenTotal = _OcclusionDebugOverlay[0]; // This should be always >= 1, because total >= 1 at this point.
+
+                float costScreenTotal = log2((float)screenTotal);
+                return OverlayHeapMapColor(cost, costScreenTotal, 0.4);
+            }
+            ENDHLSL
+        }
+    }
+    Fallback Off
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/DebugOcclusionTest.shader.meta

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

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceDataBufferCopyKernels.compute

@@ -0,0 +1,105 @@
+#pragma kernel MainCopyInstances
+
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+#include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/CoreDataSystems/GPUInstanceDataBuffer.cs.hlsl"
+
+//#pragma enable_d3d11_debug_symbols
+
+static const uint kThreadGroupSize = GPUINSTANCEDATABUFFERCONSTANTS_THREAD_GROUP_SIZE;
+static const uint kUIntPerThread = GPUINSTANCEDATABUFFERCONSTANTS_UINT_PER_THREAD;
+static const uint kUIntPerThreadGroup = GPUINSTANCEDATABUFFERCONSTANTS_UINT_PER_THREAD_GROUP;
+static const uint kMaxThreadGroupsPerDispatch = GPUINSTANCEDATABUFFERCONSTANTS_MAX_THREAD_GROUPS_PER_DISPATCH;
+
+int _DispatchThreadGroupBase;
+int _InputComponentsCount;
+
+StructuredBuffer<uint> _InputThreadGroupBeginIndices;
+StructuredBuffer<uint> _InputComponentDataAddresses;
+StructuredBuffer<uint> _OutputComponentDataAddresses;
+StructuredBuffer<uint> _OutputComponentDataUIntSizes;
+
+ByteAddressBuffer _InputBuffer;
+RWByteAddressBuffer _OutputBuffer;
+
+//@ Check performance.
+uint BinarySearchComponentDataIndex(uint globalGroupIndex, out uint2 groupRange)
+{
+    uint left = 0;
+    uint right = _InputComponentsCount - 1;
+    uint index = 0;
+
+    while (left <= right)
+    {
+        index = (left + right) / 2;
+        groupRange.x = _InputThreadGroupBeginIndices[index];
+        groupRange.y = _InputThreadGroupBeginIndices[index + 1];
+        if (globalGroupIndex >= groupRange.x && globalGroupIndex < groupRange.y)
+            break;
+        else if (globalGroupIndex < groupRange.x)
+            right = index - 1;
+        else
+            left = index + 1;
+    }
+
+    return index;
+}
+
+[numthreads(kThreadGroupSize, 1, 1)]
+void MainCopyInstances(uint groupThreadID : SV_GroupThreadID, uint groupID : SV_GroupID)
+{
+    uint globalGroupIndex = _DispatchThreadGroupBase + groupID;
+
+    uint2 groupRange;
+    uint index = BinarySearchComponentDataIndex(globalGroupIndex, groupRange);
+    uint inputComponentDataAddress = _InputComponentDataAddresses[index];
+    uint outputComponentDataAddress = _OutputComponentDataAddresses[index];
+    uint componentDataUIntSize = _OutputComponentDataUIntSizes[index];
+
+    uint groupOffset = globalGroupIndex - groupRange.x;
+    uint groupInputDataAddress = inputComponentDataAddress + groupOffset * kUIntPerThreadGroup * 4;
+    uint groupOutputDataAddress = outputComponentDataAddress + groupOffset * kUIntPerThreadGroup * 4;
+
+    bool isLastGroup = globalGroupIndex == groupRange.y - 1;
+
+    uint localData[kUIntPerThread];
+
+    if (!isLastGroup)
+    {
+        uint i = 0;
+
+        [loop]
+        for (i = 0; i < kUIntPerThread; ++i)
+        {
+            uint threadDataUIntOffset = kThreadGroupSize * i + groupThreadID;
+            localData[i] = _InputBuffer.Load(groupInputDataAddress + threadDataUIntOffset * 4);
+        }
+        [loop]
+        for (i = 0; i < kUIntPerThread; ++i)
+        {
+            uint threadDataUIntOffset = kThreadGroupSize * i + groupThreadID;
+            _OutputBuffer.Store(groupOutputDataAddress + threadDataUIntOffset * 4, localData[i]);
+        }
+    }
+    else
+    {
+        uint i = 0;
+        uint groupDataUIntSize = min(componentDataUIntSize - groupOffset * kUIntPerThreadGroup, kUIntPerThreadGroup);
+
+        [loop]
+        for (i = 0; i < kUIntPerThread; ++i)
+        {
+            uint threadDataUIntOffset = kThreadGroupSize * i + groupThreadID;
+            if (threadDataUIntOffset >= groupDataUIntSize)
+                break;
+            localData[i] = _InputBuffer.Load(groupInputDataAddress + threadDataUIntOffset * 4);
+        }
+        [loop]
+        for (i = 0; i < kUIntPerThread; ++i)
+        {
+            uint threadDataUIntOffset = kThreadGroupSize * i + groupThreadID;
+            if (threadDataUIntOffset >= groupDataUIntSize)
+                break;
+            _OutputBuffer.Store(groupOutputDataAddress + threadDataUIntOffset * 4, localData[i]);
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceDataBufferCopyKernels.compute.meta

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

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceDataBufferUploadKernels.compute

@@ -0,0 +1,51 @@
+#pragma kernel MainUploadScatterInstances
+
+//#pragma enable_d3d11_debug_symbols
+
+int _InputComponentsCount;
+int _InputInstancesCount;
+ByteAddressBuffer _InputInstanceData;
+ByteAddressBuffer _InputInstanceIndices;
+ByteAddressBuffer _InputComponentAddresses;
+ByteAddressBuffer _OutputComponentByteCounts;
+ByteAddressBuffer _OutputComponentIndices;
+ByteAddressBuffer _OutputComponentInstanceIndexRanges;
+ByteAddressBuffer _OutputComponentIsPerInstance;
+ByteAddressBuffer _OutputComponentAddresses;
+RWByteAddressBuffer _OutputBuffer;
+
+[numthreads(64, 1, 1)]
+void MainUploadScatterInstances(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    uint inputInstanceIndex = dispatchThreadID.x;
+    
+    if (inputInstanceIndex >= (uint) _InputInstancesCount)
+        return;
+
+    uint outputInstanceIndex = _InputInstanceIndices.Load(inputInstanceIndex << 2);
+
+    [loop]
+    for (int inputComponent = 0; inputComponent < _InputComponentsCount; ++inputComponent)
+    {
+        uint outputComponent = _OutputComponentIndices.Load(inputComponent << 2);
+        uint instanceIndexRangeBegin = _OutputComponentInstanceIndexRanges.Load(outputComponent * 8);
+        uint instanceIndexRangeEnd = _OutputComponentInstanceIndexRanges.Load(outputComponent * 8 + 4);
+
+        // Not every instance has all the components.
+        if (outputInstanceIndex < instanceIndexRangeBegin || outputInstanceIndex >= instanceIndexRangeEnd)
+            continue;
+        
+        uint inputComponentAddress = _InputComponentAddresses.Load(inputComponent << 2);
+        uint componentByteSize = _OutputComponentByteCounts.Load(outputComponent << 2);
+        uint outputComponentAddress = _OutputComponentAddresses.Load(outputComponent << 2);
+
+        // Some components are shared between all instances.
+        uint isPerInstanceComponent = _OutputComponentIsPerInstance.Load(outputComponent << 2);
+
+        uint inputAddress = inputComponentAddress + inputInstanceIndex * componentByteSize * isPerInstanceComponent;
+        uint outputAddress = outputComponentAddress + outputInstanceIndex * componentByteSize * isPerInstanceComponent;
+        
+        for (uint uintIndex = 0; uintIndex < componentByteSize / 4u; ++uintIndex)
+            _OutputBuffer.Store(outputAddress + uintIndex * 4, _InputInstanceData.Load(inputAddress + uintIndex * 4));
+    }
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceDataBufferUploadKernels.compute.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 53864816eb00f2343b60e1a2c5a262ef
+ComputeShaderImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceOcclusionCullingKernels.compute

@@ -0,0 +1,216 @@
+#pragma kernel ResetDrawArgs
+#pragma kernel CopyInstances
+#pragma kernel CullInstances
+
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+#include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/Culling/InstanceOcclusionCuller.cs.hlsl"
+#include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/Culling/InstanceOcclusionCullerShaderVariables.cs.hlsl"
+
+#pragma multi_compile _ USE_ARRAY
+#pragma multi_compile _ OCCLUSION_DEBUG
+#include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/Culling/OcclusionCullingCommon.hlsl"
+
+#pragma multi_compile _ OCCLUSION_FIRST_PASS OCCLUSION_SECOND_PASS
+
+#if defined(OCCLUSION_FIRST_PASS) || defined(OCCLUSION_SECOND_PASS)
+#define OCCLUSION_ANY_PASS
+#endif
+
+#define DRAW_ARGS_PARAMETER_COUNT                   5
+#define DRAW_ARGS_INSTANCE_COUNT_PARAMETER_OFFSET   1
+#define DRAW_ARGS_INDEX(N)                          (DRAW_ARGS_PARAMETER_COUNT*(_DrawInfoAllocIndex + (N)))
+#define DRAW_ARGS_INDEX_INDIRECT_DISPATCH           DRAW_ARGS_INDEX(_DrawInfoCount)
+#define DRAW_ARGS_INDEX_INSTANCE_COUNTER            (DRAW_ARGS_INDEX_INDIRECT_DISPATCH + 3)
+
+#define INSTANCE_INFO_OFFSET_SECOND_PASS(N)     (_InstanceInfoCount + (N))
+
+// buffers allocate 2 sets of instance info per instance (for the second pass)
+#define INSTANCE_ALLOC_INDEX                    (_InstanceInfoAllocIndex/2)
+
+#define THREAD_GROUP_SIZE 64
+
+StructuredBuffer<IndirectDrawInfo> _DrawInfo;
+RWStructuredBuffer<IndirectInstanceInfo> _InstanceInfo;
+RWStructuredBuffer<uint> _DispatchArgs;
+RWStructuredBuffer<uint> _DrawArgs;
+RWByteAddressBuffer _InstanceIndices;
+ByteAddressBuffer _InstanceDataBuffer;
+RWStructuredBuffer<int> _OcclusionDebugCounters;
+
+IndirectDrawInfo LoadDrawInfo(uint drawInfoOffset)
+{
+    return _DrawInfo[_DrawInfoAllocIndex + drawInfoOffset];
+}
+
+uint GetInstanceInfoCount()
+{
+#ifdef OCCLUSION_SECOND_PASS
+    return _DrawArgs[DRAW_ARGS_INDEX_INSTANCE_COUNTER];
+#else
+    return _InstanceInfoCount;
+#endif
+}
+
+IndirectInstanceInfo LoadInstanceInfo(uint instanceInfoOffset)
+{
+#ifdef OCCLUSION_SECOND_PASS
+    return _InstanceInfo[_InstanceInfoAllocIndex + INSTANCE_INFO_OFFSET_SECOND_PASS(instanceInfoOffset)];
+#else
+    return _InstanceInfo[_InstanceInfoAllocIndex + instanceInfoOffset];
+#endif
+}
+
+SphereBound LoadInstanceBoundingSphere(uint instanceID)
+{
+    float4 data = asfloat(_InstanceDataBuffer.Load4(_BoundingSphereInstanceDataAddress + instanceID * 16));
+    SphereBound b;
+    b.center = data.xyz;
+    b.radius = data.w;
+    return b;
+}
+
+[numthreads(THREAD_GROUP_SIZE, 1, 1)]
+void ResetDrawArgs(uint drawInfoOffset : SV_DispatchThreadID)
+{
+    if (drawInfoOffset < _DrawInfoCount)
+    {
+        IndirectDrawInfo drawInfo = LoadDrawInfo(drawInfoOffset);
+
+        uint argsBase = DRAW_ARGS_INDEX(drawInfoOffset);
+        _DrawArgs[argsBase + 0] = drawInfo.indexCount;   // IndirectDrawIndexedArgs.indexCountPerInstance
+        _DrawArgs[argsBase + 1] = 0;                     // IndirectDrawIndexedArgs.instanceCount
+        _DrawArgs[argsBase + 2] = drawInfo.firstIndex;   // IndirectDrawIndexedArgs.startIndex
+        _DrawArgs[argsBase + 3] = drawInfo.baseVertex;   // IndirectDrawIndexedArgs.baseVertexIndex
+        _DrawArgs[argsBase + 4] = 0;                     // IndirectDrawIndexedArgs.startInstance
+    }
+
+    if (drawInfoOffset == 0)
+    {
+#ifdef OCCLUSION_SECOND_PASS
+        // convert to compute dispatch args
+        uint argsBase = 0;
+        _DispatchArgs[argsBase + 0] = (_DrawArgs[DRAW_ARGS_INDEX_INSTANCE_COUNTER] + (THREAD_GROUP_SIZE-1)) / THREAD_GROUP_SIZE;
+        _DispatchArgs[argsBase + 1] = 1;
+        _DispatchArgs[argsBase + 2] = 1;
+#else
+        // zero the instance count
+        _DrawArgs[DRAW_ARGS_INDEX_INSTANCE_COUNTER] = 0;
+#endif
+    }
+}
+
+[numthreads(THREAD_GROUP_SIZE, 1, 1)]
+void CopyInstances(uint dispatchIdx : SV_DispatchThreadID)
+{
+    if (dispatchIdx < _DrawInfoCount)
+    {
+        IndirectDrawInfo drawInfo = LoadDrawInfo(dispatchIdx);
+
+        uint argsBase = DRAW_ARGS_INDEX(dispatchIdx);
+        _DrawArgs[argsBase + 0] = drawInfo.indexCount;   // IndirectDrawIndexedArgs.indexCountPerInstance
+        _DrawArgs[argsBase + 1] = (drawInfo.maxInstanceCountAndTopology >> 3) << _InstanceMultiplierShift;  // IndirectDrawIndexedArgs.instanceCount
+        _DrawArgs[argsBase + 2] = drawInfo.firstIndex;   // IndirectDrawIndexedArgs.startIndex
+        _DrawArgs[argsBase + 3] = drawInfo.baseVertex;   // IndirectDrawIndexedArgs.baseVertexIndex
+        _DrawArgs[argsBase + 4] = 0;                     // IndirectDrawIndexedArgs.startInstance
+    }
+
+    if (dispatchIdx < _InstanceInfoCount)
+    {
+        IndirectInstanceInfo instanceInfo = LoadInstanceInfo(dispatchIdx);
+
+        uint writeIndex = INSTANCE_ALLOC_INDEX + dispatchIdx;
+        _InstanceIndices.Store(writeIndex << 2, instanceInfo.instanceIndexAndCrossFade);
+    }
+}
+
+uint GetPrimitiveCount(uint indexCount, uint topology, bool nativeQuads)
+{
+    switch (topology)
+    {
+    case /*MeshTopology.Triangles*/ 0: return indexCount / 3;
+    case /*MeshTopology.Quads*/ 2: return nativeQuads ? (indexCount / 4) : (indexCount / 4 * 2);
+    case /*MeshTopology.Lines*/ 3: return indexCount / 2;
+    case /*MeshTopology.LineStrip*/ 4: return (indexCount >= 1) ? (indexCount - 1) : 0;
+    case /*MeshTopology.Points*/ 5: return indexCount;
+    default: return 0;
+    }
+}
+
+[numthreads(THREAD_GROUP_SIZE, 1, 1)]
+void CullInstances(uint instanceInfoOffset : SV_DispatchThreadID)
+{
+    uint instanceInfoCount = GetInstanceInfoCount();
+    if (instanceInfoOffset < instanceInfoCount)
+    {
+        IndirectInstanceInfo instanceInfo = LoadInstanceInfo(instanceInfoOffset);
+        uint drawOffset = instanceInfo.drawOffsetAndSplitMask >> 8;
+        uint splitMask = instanceInfo.drawOffsetAndSplitMask & 0xff;
+
+        // early out if none of these culling splits are visible
+        // TODO: plumb through other state per draw command to filter here?
+        if ((splitMask & _CullingSplitMask) == 0)
+            return;
+
+        bool isVisible = true;
+
+#ifdef OCCLUSION_ANY_PASS
+        int instanceID = instanceInfo.instanceIndexAndCrossFade & 0xffffff;
+        SphereBound boundingSphere = LoadInstanceBoundingSphere(instanceID);
+
+        bool isOccludedInAll = true;
+        for (int testIndex = 0; testIndex < _OcclusionTestCount; ++testIndex)
+        {
+            // unpack the culling split index and subview index for this test
+            int splitIndex = (_CullingSplitIndices >> (4 * testIndex)) & 0xf;
+            int subviewIndex = (_OccluderSubviewIndices >> (4 * testIndex)) & 0xf;
+
+            // skip if this draw call is not present in this split index
+            if (((1 << splitIndex) & splitMask) == 0)
+                continue;
+
+            // occlusion test against the corresponding subview
+            if (IsOcclusionVisible(boundingSphere, subviewIndex))
+                isOccludedInAll = false;
+        }
+        isVisible = !isOccludedInAll;
+
+#ifdef OCCLUSION_FIRST_PASS
+        // if we failed the occlusion check, then add to the list for the second pass
+        if (!isVisible)
+        {
+            uint writeIndex = 0;
+            InterlockedAdd(_DrawArgs[DRAW_ARGS_INDEX_INSTANCE_COUNTER], 1, writeIndex);
+            _InstanceInfo[_InstanceInfoAllocIndex + INSTANCE_INFO_OFFSET_SECOND_PASS(writeIndex)] = instanceInfo;
+        }
+#endif
+#endif
+
+        // track stats if necessary
+        if (_DebugCounterIndex >= 0)
+        {
+            // TODO: sum each within wave, first thread in wave issues atomic add to memory
+            int counterIndex = isVisible ? INSTANCEOCCLUSIONTESTDEBUGCOUNTER_INSTANCES_NOT_OCCLUDED : INSTANCEOCCLUSIONTESTDEBUGCOUNTER_INSTANCES_OCCLUDED;
+            InterlockedAdd(_OcclusionDebugCounters[_DebugCounterIndex*INSTANCEOCCLUSIONTESTDEBUGCOUNTER_COUNT + counterIndex], 1);
+
+            IndirectDrawInfo drawInfo = LoadDrawInfo(drawOffset);
+            uint argsBase = DRAW_ARGS_INDEX(drawOffset);
+            uint indexCount = _DrawArgs[argsBase + 0]; // IndirectDrawIndexedArgs.indexCountPerInstance
+            uint topology = drawInfo.maxInstanceCountAndTopology & 7;
+            uint primitiveCount = GetPrimitiveCount(indexCount, topology, false);
+            counterIndex = isVisible ? INSTANCEOCCLUSIONTESTDEBUGCOUNTER_PRIMITIVES_NOT_OCCLUDED : INSTANCEOCCLUSIONTESTDEBUGCOUNTER_PRIMITIVES_OCCLUDED;
+            InterlockedAdd(_OcclusionDebugCounters[_DebugCounterIndex*INSTANCEOCCLUSIONTESTDEBUGCOUNTER_COUNT + counterIndex], primitiveCount);
+        }
+
+        if (isVisible)
+        {
+            uint argsBase = DRAW_ARGS_INDEX(drawOffset);
+            uint offsetWithinDraw = 0;
+            InterlockedAdd(_DrawArgs[argsBase + DRAW_ARGS_INSTANCE_COUNT_PARAMETER_OFFSET], 1 << _InstanceMultiplierShift, offsetWithinDraw);   // IndirectDrawIndexedArgs.instanceCount
+            offsetWithinDraw = offsetWithinDraw >> _InstanceMultiplierShift;
+
+            IndirectDrawInfo drawInfo = LoadDrawInfo(drawOffset);
+            uint writeIndex = drawInfo.firstInstanceGlobalIndex + offsetWithinDraw;
+            _InstanceIndices.Store(writeIndex << 2, instanceInfo.instanceIndexAndCrossFade);
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceOcclusionCullingKernels.compute.meta

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

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceTransformUpdateKernels.compute

@@ -0,0 +1,256 @@
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+#include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/CoreDataSystems/InstanceTransformUpdateDefs.cs.hlsl"
+
+#pragma kernel ScatterInitTransformMain
+#pragma kernel ScatterUpdateTransformMain
+#pragma kernel ScatterUpdateMotionMain
+#pragma kernel ScatterUpdateProbesMain
+
+#pragma multi_compile_local _ PROCESS_BOUNDING_SPHERES
+
+int _TransformUpdateQueueCount;
+int _TransformUpdateOutputL2WVec4Offset;
+int _TransformUpdateOutputW2LVec4Offset;
+int _TransformUpdateOutputPrevL2WVec4Offset;
+int _TransformUpdateOutputPrevW2LVec4Offset;
+int _BoundingSphereOutputVec4Offset;
+
+StructuredBuffer<TransformUpdatePacket> _TransformUpdateDataQueue;
+ByteAddressBuffer _TransformUpdateIndexQueue;
+StructuredBuffer<float4> _BoundingSphereDataQueue;
+RWByteAddressBuffer _OutputTransformBuffer;
+
+float4x4 UnpackMatrix(float4 p1, float4 p2, float4 p3)
+{
+    return float4x4(
+        p1.x, p1.w, p2.z, p3.y,
+        p1.y, p2.x, p2.w, p3.z,
+        p1.z, p2.y, p3.x, p3.w,
+        0.0,  0.0,  0.0,  1.0
+    );
+}
+
+float4 PackMatrix0(float4x4 m) { return m._m00_m10_m20_m01; }
+float4 PackMatrix1(float4x4 m) { return m._m11_m21_m02_m12; }
+float4 PackMatrix2(float4x4 m) { return m._m22_m03_m13_m23; }
+
+float3x3 Inverse3x3(float3x3 m)
+{
+    float3 row0 = m[0];
+    float3 row1 = m[1];
+    float3 row2 = m[2];
+
+    float3 col0 = cross(row1, row2);
+    float3 col1 = cross(row2, row0);
+    float3 col2 = cross(row0, row1);
+
+    float det = dot(row0, col0);
+
+    return transpose(float3x3(col0, col1, col2)/det);
+}
+
+float4x4 AffineInverse3D(float4x4 m)
+{
+    float3x3 R = (float3x3)m;
+    float3 T = m._m03_m13_m23;
+
+    float3x3 invR = Inverse3x3(R);
+    float3 invT = -mul(invR, T);
+
+    return float4x4(
+        invR._m00, invR._m01, invR._m02, invT.x,
+        invR._m10, invR._m11, invR._m12, invT.y,
+        invR._m20, invR._m21, invR._m22, invT.z,
+        0.0f, 0.0f, 0.0f, 1.0f);
+}
+
+[numthreads(64, 1, 1)]
+void ScatterInitTransformMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    if (dispatchThreadID.x >= (uint)_TransformUpdateQueueCount)
+        return;
+
+    uint queueIndex = dispatchThreadID.x;
+    uint queueByteIndex = queueIndex << 2;
+    uint outputIndex = _TransformUpdateIndexQueue.Load(queueByteIndex);
+
+    uint byteOutputL2WOffset = _TransformUpdateOutputL2WVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+    uint byteOutputW2LOffset = _TransformUpdateOutputW2LVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+    uint byteOutputPrevL2WOffset = _TransformUpdateOutputPrevL2WVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+    uint byteOutputPrevW2LOffset = _TransformUpdateOutputPrevW2LVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+
+    TransformUpdatePacket l2wUpdatePacket = _TransformUpdateDataQueue[queueIndex * 2];
+    TransformUpdatePacket l2wPrevUpdatePacket = _TransformUpdateDataQueue[queueIndex * 2 + 1];
+
+    float4x4 l2w = UnpackMatrix(l2wUpdatePacket.localToWorld0, l2wUpdatePacket.localToWorld1, l2wUpdatePacket.localToWorld2);
+    float4x4 l2wPrev = UnpackMatrix(l2wPrevUpdatePacket.localToWorld0, l2wPrevUpdatePacket.localToWorld1, l2wPrevUpdatePacket.localToWorld2);
+
+    float4x4 w2l = AffineInverse3D(l2w);
+    float4x4 w2lPrev = AffineInverse3D(l2wPrev);
+
+#ifdef PROCESS_FLIP_GPUDRIVEN_WINDING
+    UpdateInstanceFlipWindingFlag(l2w, outputIndex);
+#endif
+
+    // initialize current transforms
+    _OutputTransformBuffer.Store4(byteOutputL2WOffset + 0, asuint(PackMatrix0(l2w)));
+    _OutputTransformBuffer.Store4(byteOutputL2WOffset + 16, asuint(PackMatrix1(l2w)));
+    _OutputTransformBuffer.Store4(byteOutputL2WOffset + 32, asuint(PackMatrix2(l2w)));
+    _OutputTransformBuffer.Store4(byteOutputW2LOffset + 0, asuint(PackMatrix0(w2l)));
+    _OutputTransformBuffer.Store4(byteOutputW2LOffset + 16, asuint(PackMatrix1(w2l)));
+    _OutputTransformBuffer.Store4(byteOutputW2LOffset + 32, asuint(PackMatrix2(w2l)));
+
+    // initialize previous transforms
+    _OutputTransformBuffer.Store4(byteOutputPrevL2WOffset + 0, asuint(PackMatrix0(l2wPrev)));
+    _OutputTransformBuffer.Store4(byteOutputPrevL2WOffset + 16, asuint(PackMatrix1(l2wPrev)));
+    _OutputTransformBuffer.Store4(byteOutputPrevL2WOffset + 32, asuint(PackMatrix2(l2wPrev)));
+    _OutputTransformBuffer.Store4(byteOutputPrevW2LOffset + 0, asuint(PackMatrix0(w2lPrev)));
+    _OutputTransformBuffer.Store4(byteOutputPrevW2LOffset + 16, asuint(PackMatrix1(w2lPrev)));
+    _OutputTransformBuffer.Store4(byteOutputPrevW2LOffset + 32, asuint(PackMatrix2(w2lPrev)));
+
+#ifdef PROCESS_BOUNDING_SPHERES
+    uint byteOutputBoundingSphereOffset = _BoundingSphereOutputVec4Offset * 4 + outputIndex * 4 * 4;
+    float4 updateSphereValue = _BoundingSphereDataQueue[queueIndex];
+    _OutputTransformBuffer.Store4(byteOutputBoundingSphereOffset, asuint(updateSphereValue));
+#endif
+}
+
+[numthreads(64, 1, 1)]
+void ScatterUpdateTransformMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    if (dispatchThreadID.x >= (uint)_TransformUpdateQueueCount)
+        return;
+
+    uint queueIndex = dispatchThreadID.x;
+    uint queueByteIndex = queueIndex << 2;
+    uint outputIndex = _TransformUpdateIndexQueue.Load(queueByteIndex);
+
+    uint byteOutputL2WOffset = _TransformUpdateOutputL2WVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+    uint byteOutputW2LOffset = _TransformUpdateOutputW2LVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+    uint byteOutputPrevL2WOffset = _TransformUpdateOutputPrevL2WVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+    uint byteOutputPrevW2LOffset = _TransformUpdateOutputPrevW2LVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+
+    // copy the current world transform to the previous one
+    uint4 prevLocalToWorld0 = _OutputTransformBuffer.Load4(byteOutputL2WOffset + 0);
+    uint4 prevLocalToWorld1 = _OutputTransformBuffer.Load4(byteOutputL2WOffset + 16);
+    uint4 prevLocalToWorld2 = _OutputTransformBuffer.Load4(byteOutputL2WOffset + 32);
+    uint4 prevWorldToLocal0 = _OutputTransformBuffer.Load4(byteOutputW2LOffset + 0);
+    uint4 prevWorldToLocal1 = _OutputTransformBuffer.Load4(byteOutputW2LOffset + 16);
+    uint4 prevWorldToLocal2 = _OutputTransformBuffer.Load4(byteOutputW2LOffset + 32);
+
+    _OutputTransformBuffer.Store4(byteOutputPrevL2WOffset + 0, prevLocalToWorld0);
+    _OutputTransformBuffer.Store4(byteOutputPrevL2WOffset + 16, prevLocalToWorld1);
+    _OutputTransformBuffer.Store4(byteOutputPrevL2WOffset + 32, prevLocalToWorld2);
+    _OutputTransformBuffer.Store4(byteOutputPrevW2LOffset + 0, prevWorldToLocal0);
+    _OutputTransformBuffer.Store4(byteOutputPrevW2LOffset + 16, prevWorldToLocal1);
+    _OutputTransformBuffer.Store4(byteOutputPrevW2LOffset + 32, prevWorldToLocal2);
+
+    TransformUpdatePacket updatePacket = _TransformUpdateDataQueue[queueIndex];
+
+    float4x4 l2w = UnpackMatrix(updatePacket.localToWorld0, updatePacket.localToWorld1, updatePacket.localToWorld2);
+    float4x4 w2l = AffineInverse3D(l2w);
+
+#ifdef PROCESS_FLIP_GPUDRIVEN_WINDING
+    UpdateInstanceFlipWindingFlag(l2w, outputIndex);
+#endif
+
+    // update current world transform
+    _OutputTransformBuffer.Store4(byteOutputL2WOffset + 0,  asuint(PackMatrix0(l2w)));
+    _OutputTransformBuffer.Store4(byteOutputL2WOffset + 16, asuint(PackMatrix1(l2w)));
+    _OutputTransformBuffer.Store4(byteOutputL2WOffset + 32, asuint(PackMatrix2(l2w)));
+    _OutputTransformBuffer.Store4(byteOutputW2LOffset + 0,  asuint(PackMatrix0(w2l)));
+    _OutputTransformBuffer.Store4(byteOutputW2LOffset + 16, asuint(PackMatrix1(w2l)));
+    _OutputTransformBuffer.Store4(byteOutputW2LOffset + 32, asuint(PackMatrix2(w2l)));
+
+#ifdef PROCESS_BOUNDING_SPHERES
+    uint byteOutputBoundingSphereOffset = _BoundingSphereOutputVec4Offset * 4 + outputIndex * 4 * 4;
+    float4 updateSphereValue = _BoundingSphereDataQueue[queueIndex];
+    _OutputTransformBuffer.Store4(byteOutputBoundingSphereOffset, asuint(updateSphereValue));
+#endif
+}
+
+[numthreads(64, 1, 1)]
+void ScatterUpdateMotionMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    if (dispatchThreadID.x >= (uint)_TransformUpdateQueueCount)
+        return;
+
+    uint queueIndex = dispatchThreadID.x;
+    uint queueByteIndex = queueIndex << 2;
+    uint outputIndex = _TransformUpdateIndexQueue.Load(queueByteIndex);
+
+    uint byteOutputL2WOffset = _TransformUpdateOutputL2WVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+    uint byteOutputW2LOffset = _TransformUpdateOutputW2LVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+    uint byteOutputPrevL2WOffset = _TransformUpdateOutputPrevL2WVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+    uint byteOutputPrevW2LOffset = _TransformUpdateOutputPrevW2LVec4Offset * 4 + outputIndex * 4 * 4 * 3;
+
+    // copy the current world transform to the previous one
+    uint4 prevLocalToWorld0 = _OutputTransformBuffer.Load4(byteOutputL2WOffset + 0);
+    uint4 prevLocalToWorld1 = _OutputTransformBuffer.Load4(byteOutputL2WOffset + 16);
+    uint4 prevLocalToWorld2 = _OutputTransformBuffer.Load4(byteOutputL2WOffset + 32);
+    uint4 prevWorldToLocal0 = _OutputTransformBuffer.Load4(byteOutputW2LOffset + 0);
+    uint4 prevWorldToLocal1 = _OutputTransformBuffer.Load4(byteOutputW2LOffset + 16);
+    uint4 prevWorldToLocal2 = _OutputTransformBuffer.Load4(byteOutputW2LOffset + 32);
+
+    _OutputTransformBuffer.Store4(byteOutputPrevL2WOffset + 0, prevLocalToWorld0);
+    _OutputTransformBuffer.Store4(byteOutputPrevL2WOffset + 16, prevLocalToWorld1);
+    _OutputTransformBuffer.Store4(byteOutputPrevL2WOffset + 32, prevLocalToWorld2);
+    _OutputTransformBuffer.Store4(byteOutputPrevW2LOffset + 0, prevWorldToLocal0);
+    _OutputTransformBuffer.Store4(byteOutputPrevW2LOffset + 16, prevWorldToLocal1);
+    _OutputTransformBuffer.Store4(byteOutputPrevW2LOffset + 32, prevWorldToLocal2);
+}
+
+int _ProbeUpdateQueueCount;
+int _SHUpdateVec4Offset;
+int _ProbeOcclusionUpdateVec4Offset;
+
+StructuredBuffer<SHUpdatePacket> _ProbeUpdateDataQueue;
+StructuredBuffer<float4> _ProbeOcclusionUpdateDataQueue;
+ByteAddressBuffer _ProbeUpdateIndexQueue;
+RWByteAddressBuffer _OutputProbeBuffer;
+
+struct SHProperties
+{
+    float4 SHAr;
+    float4 SHAg;
+    float4 SHAb;
+    float4 SHBr;
+    float4 SHBg;
+    float4 SHBb;
+    float4 SHC;
+};
+
+SHProperties UnpackShUpdate(SHUpdatePacket sh)
+{
+    SHProperties p;
+    p.SHAr = float4(sh.shr3, sh.shr1, sh.shr2, sh.shr0 - sh.shr6);//GetSHA(sh, 0);
+    p.SHAg = float4(sh.shg3, sh.shg1, sh.shg2, sh.shg0 - sh.shg6);//GetSHA(sh, 1);
+    p.SHAb = float4(sh.shb3, sh.shb1, sh.shb2, sh.shb0 - sh.shb6);//GetSHA(sh, 2);
+    p.SHBr = float4(sh.shr4, sh.shr5, sh.shr6 * 3.0f, sh.shr7);//GetSHB(sh, 0);
+    p.SHBg = float4(sh.shg4, sh.shg5, sh.shg6 * 3.0f, sh.shg7);//GetSHB(sh, 1);
+    p.SHBb = float4(sh.shb4, sh.shb5, sh.shb6 * 3.0f, sh.shb7);//GetSHB(sh, 2);
+    p.SHC = float4(sh.shr8, sh.shg8, sh.shb8, 1.0);//GetSHC(sh);
+    return p;
+}
+
+[numthreads(64, 1, 1)]
+void ScatterUpdateProbesMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    if (dispatchThreadID.x >= (uint)_ProbeUpdateQueueCount)
+            return;
+
+    uint outputIndex = _ProbeUpdateIndexQueue.Load(dispatchThreadID.x << 2);
+    SHUpdatePacket updatePacket = _ProbeUpdateDataQueue[dispatchThreadID.x];
+    SHProperties sh = UnpackShUpdate(updatePacket);
+    float4 occlusionData = _ProbeOcclusionUpdateDataQueue[dispatchThreadID.x];
+    uint bytesPerSH = 8 * 4 * 4;
+    uint baseSHOffset = outputIndex * bytesPerSH;
+    _OutputProbeBuffer.Store4(_SHUpdateVec4Offset * 4 + baseSHOffset + 0 * 16, asuint(sh.SHAr));
+    _OutputProbeBuffer.Store4(_SHUpdateVec4Offset * 4 + baseSHOffset + 1 * 16, asuint(sh.SHAg));
+    _OutputProbeBuffer.Store4(_SHUpdateVec4Offset * 4 + baseSHOffset + 2 * 16, asuint(sh.SHAb));
+    _OutputProbeBuffer.Store4(_SHUpdateVec4Offset * 4 + baseSHOffset + 3 * 16, asuint(sh.SHBr));
+    _OutputProbeBuffer.Store4(_SHUpdateVec4Offset * 4 + baseSHOffset + 4 * 16, asuint(sh.SHBg));
+    _OutputProbeBuffer.Store4(_SHUpdateVec4Offset * 4 + baseSHOffset + 5 * 16, asuint(sh.SHBb));
+    _OutputProbeBuffer.Store4(_SHUpdateVec4Offset * 4 + baseSHOffset + 6 * 16, asuint(sh.SHC));
+    _OutputProbeBuffer.Store4(_SHUpdateVec4Offset * 4 + baseSHOffset + 7 * 16, asuint(occlusionData));
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceTransformUpdateKernels.compute.meta

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

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceWindDataUpdateKernels.compute

@@ -0,0 +1,31 @@
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+#include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/CoreDataSystems/InstanceWindDataUpdateDefs.cs.hlsl"
+
+#pragma kernel WindDataCopyHistoryMain
+
+uint _WindDataQueueCount;
+int4 _WindParamAddressArray[MAX_WIND_PARAMS_COUNT];
+int4 _WindHistoryParamAddressArray[MAX_WIND_PARAMS_COUNT];
+
+ByteAddressBuffer _WindDataUpdateIndexQueue;
+RWByteAddressBuffer _WindDataBuffer;
+
+[numthreads(64, 1, 1)]
+void WindDataCopyHistoryMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    if (dispatchThreadID.x >= _WindDataQueueCount)
+        return;
+
+    uint instanceIndex = _WindDataUpdateIndexQueue.Load(dispatchThreadID.x << 2);
+    uint instanceByteOffset = instanceIndex * 16;
+
+    uint4 windParams[MAX_WIND_PARAMS_COUNT];
+
+    UNITY_UNROLL
+    for (int i = 0; i < MAX_WIND_PARAMS_COUNT; ++i)
+        windParams[i] = _WindDataBuffer.Load4(_WindParamAddressArray[i].x + instanceByteOffset);
+    
+    UNITY_UNROLL
+    for (int j = 0; j < MAX_WIND_PARAMS_COUNT; ++j)
+        _WindDataBuffer.Store4(_WindHistoryParamAddressArray[j].x + instanceByteOffset, windParams[j]);
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/InstanceWindDataUpdateKernels.compute.meta

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

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/OccluderDepthPyramidKernels.compute

@@ -0,0 +1,194 @@
+#pragma kernel OccluderDepthDownscale
+
+#pragma only_renderers d3d11 playstation xboxone xboxseries vulkan metal switch switch2 webgpu
+
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+#include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/Culling/OccluderDepthPyramidConstants.cs.hlsl"
+#include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/Culling/OcclusionTestCommon.hlsl"
+
+#pragma multi_compile _ USE_SRC
+#pragma multi_compile _ SRC_IS_ARRAY
+#pragma multi_compile _ SRC_IS_MSAA
+
+RW_TEXTURE2D(float, _DstDepth);
+
+#ifdef USE_SRC
+    #ifdef SRC_IS_MSAA
+        #ifdef SRC_IS_ARRAY
+            #ifndef SHADER_API_WEBGPU // Texture2DMSArray is not supported by WebGPU
+                Texture2DMSArray<float> _SrcDepth;
+            #endif
+        #else
+            Texture2DMS<float> _SrcDepth;
+        #endif
+    #else
+        #ifdef SRC_IS_ARRAY
+            TEXTURE2D_ARRAY(_SrcDepth);
+        #else
+            TEXTURE2D(_SrcDepth);
+        #endif
+    #endif
+#endif
+
+float LoadDepth(int2 coord, int srcSliceIndex)
+{
+#ifdef USE_SRC
+    #ifdef SRC_IS_MSAA
+        #ifdef SRC_IS_ARRAY
+            #ifdef SHADER_API_WEBGPU // Texture2DMSArray is not supported by WebGPU
+                return 0.0;
+            #else
+                return LOAD_TEXTURE2D_ARRAY_MSAA(_SrcDepth, coord, srcSliceIndex, 0).x;
+            #endif
+        #else
+            return LOAD_TEXTURE2D_MSAA(_SrcDepth, coord, 0).x;
+        #endif
+    #else
+        #ifdef SRC_IS_ARRAY
+            return _SrcDepth[int3(coord, srcSliceIndex)].x;
+        #else
+            return _SrcDepth[coord].x;
+        #endif
+    #endif
+#else
+    return _DstDepth[coord].x;
+#endif
+}
+
+uint2 CoordInTileByIndex(uint i)
+{
+    // decode i = [yxxyyx] (we want each pair of bits to have an x and a y)
+    return uint2(
+        (i & 1) | ((i >> 2) & 6),
+        ((i >> 1) & 3) | ((i >> 3) & 4));
+}
+
+groupshared float s_farDepth[32];
+
+void SubgroupMergeDepths(uint threadID : SV_GroupThreadID, uint bitIndex, inout float farDepth)
+{
+    uint highIndex = threadID >> (bitIndex + 1);
+    uint lowIndex = threadID & ((1 << (bitIndex + 1)) - 1);
+
+    if (lowIndex == (1 << bitIndex))
+        s_farDepth[highIndex] = farDepth;
+#if !defined(SHADER_API_WEBGPU)
+    GroupMemoryBarrierWithGroupSync();
+#endif
+
+    if (lowIndex == 0)
+        farDepth = FarthestDepth(farDepth, s_farDepth[highIndex]);
+#if !defined(SHADER_API_WEBGPU)
+    GroupMemoryBarrierWithGroupSync();
+#endif
+}
+
+int2 DestMipOffset(int mipIndex, int dstSubviewIndex)
+{
+    uint2 mipOffset = _MipOffsetAndSize[mipIndex].xy;
+    mipOffset.y += dstSubviewIndex * _OccluderMipLayoutSizeY;
+    return int2(mipOffset);
+}
+
+int2 DestMipSize(int mipIndex)
+{
+    return int2(_MipOffsetAndSize[mipIndex].zw);
+}
+
+bool IsSilhouetteCulled(int2 coord, int updateIndex)
+{
+    int2 srcSize = DestMipSize(0);
+    float2 posNDC = float2(
+        (coord.x + 0.5f) / (float)srcSize.x,
+        (coord.y + 0.5f) / (float)srcSize.y);
+    float3 posWS = ComputeWorldSpacePosition(posNDC, 0.2f, _InvViewProjMatrix[updateIndex]);
+
+    for (uint i = 0; i < _SilhouettePlaneCount; ++i)
+    {
+        float4 plane = _SilhouettePlanes[i];
+        if (dot(plane.xyz, posWS) + plane.w < 0.0f)
+            return true;
+    }
+    return false;
+}
+
+// Downsample a depth texture by taking the min value of sampled pixels
+[numthreads(64, 1, 1)]
+void OccluderDepthDownscale(uint threadID : SV_GroupThreadID, uint3 groupID : SV_GroupID)
+{
+    // assign threads to pixels in a swizzle-like pattern
+    int2 dstCoord1 = (groupID.xy << 3) | CoordInTileByIndex(threadID);
+    int updateIndex = groupID.z;
+
+    int srcSliceIndex = (_SrcSliceIndices >> (4*updateIndex)) & 0xf;
+    int dstSubviewIndex = (_DstSubviewIndices >> (4*updateIndex)) & 0xf;
+
+#if USE_SRC
+    int2 loadOffset = int2(_SrcOffset[updateIndex].xy);
+#else
+    int2 loadOffset = DestMipOffset(0, dstSubviewIndex);
+#endif
+    int2 srcCoord = dstCoord1 << 1;
+    int2 srcLimit = DestMipSize(0) - 1;
+
+    float p00 = LoadDepth(loadOffset + min(srcCoord + int2(0, 0), srcLimit), srcSliceIndex);
+    float p10 = LoadDepth(loadOffset + min(srcCoord + int2(1, 0), srcLimit), srcSliceIndex);
+    float p01 = LoadDepth(loadOffset + min(srcCoord + int2(0, 1), srcLimit), srcSliceIndex);
+    float p11 = LoadDepth(loadOffset + min(srcCoord + int2(1, 1), srcLimit), srcSliceIndex);
+
+#ifdef USE_SRC
+    if (IsSilhouetteCulled(srcCoord + int2(0, 0), updateIndex))
+        p00 = 1.f - UNITY_RAW_FAR_CLIP_VALUE;
+    if (IsSilhouetteCulled(srcCoord + int2(1, 0), updateIndex))
+        p10 = 1.f - UNITY_RAW_FAR_CLIP_VALUE;
+    if (IsSilhouetteCulled(srcCoord + int2(0, 1), updateIndex))
+        p01 = 1.f - UNITY_RAW_FAR_CLIP_VALUE;
+    if (IsSilhouetteCulled(srcCoord + int2(1, 1), updateIndex))
+        p11 = 1.f - UNITY_RAW_FAR_CLIP_VALUE;
+#endif
+
+    float farDepth = FarthestDepth(float4(p00, p10, p01, p11));
+
+    // write dst0
+    if (all(dstCoord1 < DestMipSize(1)))
+        _DstDepth[DestMipOffset(1, dstSubviewIndex) + dstCoord1] = farDepth;
+
+    // merge towards thread 0 in subgroup size 4
+    if (2 <= _MipCount)
+    {
+        SubgroupMergeDepths(threadID, 0, farDepth);
+        SubgroupMergeDepths(threadID, 1, farDepth);
+        if ((threadID & 0x3) == 0)
+        {
+            int2 dstCoord2 = dstCoord1 >> 1;
+            if (all(dstCoord2 < DestMipSize(2)))
+                _DstDepth[DestMipOffset(2, dstSubviewIndex) + dstCoord2] = farDepth;
+        }
+    }
+
+    // merge towards thread 0 in subgroup size 16
+    if (3 <= _MipCount)
+    {
+        SubgroupMergeDepths(threadID, 2, farDepth);
+        SubgroupMergeDepths(threadID, 3, farDepth);
+        if ((threadID & 0xf) == 0)
+        {
+            int2 dstCoord3 = dstCoord1 >> 2;
+            if (all(dstCoord3 < DestMipSize(3)))
+                _DstDepth[DestMipOffset(3, dstSubviewIndex) + dstCoord3] = farDepth;
+        }
+    }
+
+    // merge to thread 0
+    if (4 <= _MipCount)
+    {
+        SubgroupMergeDepths(threadID, 4, farDepth);
+        SubgroupMergeDepths(threadID, 5, farDepth);
+        if ((threadID & 0x3f) == 0)
+        {
+            int2 dstCoord4 = dstCoord1 >> 3;
+            if (all(dstCoord4 < DestMipSize(4)))
+                _DstDepth[DestMipOffset(4, dstSubviewIndex) + dstCoord4] = farDepth;
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/OccluderDepthPyramidKernels.compute.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 08b2b5fb307b0d249860612774a987da
+ComputeShaderImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/OcclusionCullingDebug.compute

@@ -0,0 +1,26 @@
+#pragma kernel ClearOcclusionDebug
+
+#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
+
+#define OCCLUSION_DEBUG 1
+
+#include "Packages/com.unity.render-pipelines.core/Runtime/GPUDriven/Culling/OcclusionCullingCommon.hlsl"
+
+[numthreads(8, 8, 1)]
+void ClearOcclusionDebug(uint2 dispatchIndex : SV_DispatchThreadID, uint3 groupId : SV_GroupID)
+{
+#ifdef OCCLUSION_DEBUG
+    int clearSliceIndex = groupId.z;
+
+    for (int i = 0; i < OCCLUSIONCULLINGCOMMONCONFIG_MAX_OCCLUDER_MIPS; ++i)
+    {
+        uint4 bounds = _OccluderMipBounds[i];
+        bounds.y += clearSliceIndex * _OccluderMipLayoutSizeY;
+        if (all(dispatchIndex < bounds.zw))
+            _OcclusionDebugOverlay[OcclusionDebugOverlayOffset(bounds.xy + dispatchIndex)] = 0;
+    }
+
+    if (all(dispatchIndex == 0) && clearSliceIndex == 0)
+        _OcclusionDebugOverlay[0] = 0;
+#endif
+}

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/GPUDriven/OcclusionCullingDebug.compute.meta

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

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/Mesh.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 68ed7b91fd1483d40861e1ada55a57bc
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/Mesh/BackgroundMesh.fbx.meta

@@ -0,0 +1,110 @@
+fileFormatVersion: 2
+guid: b9ae429aca254fa41966db24b9e53232
+ModelImporter:
+  serializedVersion: 24200
+  internalIDToNameTable: []
+  externalObjects: {}
+  materials:
+    materialImportMode: 2
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    removeConstantScaleCurves: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 0
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    sortHierarchyByName: 1
+    importPhysicalCameras: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    nodeNameCollisionStrategy: 1
+    fileIdsGeneration: 2
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    keepQuads: 0
+    weldVertices: 1
+    bakeAxisConversion: 0
+    preserveHierarchy: 0
+    skinWeightsMode: 0
+    maxBonesPerVertex: 4
+    minBoneWeight: 0.001
+    optimizeBones: 1
+    generateMeshLods: 0
+    meshLodGenerationFlags: 0
+    maximumMeshLod: -1
+    meshOptimizationFlags: -1
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVMarginMethod: 1
+    secondaryUVMinLightmapResolution: 40
+    secondaryUVMinObjectScale: 1
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    strictVertexDataChecks: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  referencedClips: []
+  importAnimation: 1
+  humanDescription:
+    serializedVersion: 3
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    globalScale: 1
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  autoGenerateAvatarMappingIfUnspecified: 1
+  animationType: 2
+  humanoidOversampling: 1
+  avatarSetup: 0
+  addHumanoidExtraRootOnlyWhenUsingAvatar: 1
+  importBlendShapeDeformPercent: 1
+  remapMaterialsIfMaterialImportModeIsNone: 0
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/Mesh/SamplesFixture.fbx.meta

@@ -0,0 +1,110 @@
+fileFormatVersion: 2
+guid: b28fa67a0ff82c5478f27368dc627683
+ModelImporter:
+  serializedVersion: 24200
+  internalIDToNameTable: []
+  externalObjects: {}
+  materials:
+    materialImportMode: 2
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    removeConstantScaleCurves: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 0
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    sortHierarchyByName: 1
+    importPhysicalCameras: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    nodeNameCollisionStrategy: 1
+    fileIdsGeneration: 2
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    keepQuads: 0
+    weldVertices: 1
+    bakeAxisConversion: 0
+    preserveHierarchy: 0
+    skinWeightsMode: 0
+    maxBonesPerVertex: 4
+    minBoneWeight: 0.001
+    optimizeBones: 1
+    generateMeshLods: 0
+    meshLodGenerationFlags: 0
+    maximumMeshLod: -1
+    meshOptimizationFlags: -1
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVMarginMethod: 1
+    secondaryUVMinLightmapResolution: 40
+    secondaryUVMinObjectScale: 1
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    strictVertexDataChecks: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  referencedClips: []
+  importAnimation: 1
+  humanDescription:
+    serializedVersion: 3
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    globalScale: 1
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  autoGenerateAvatarMappingIfUnspecified: 1
+  animationType: 2
+  humanoidOversampling: 1
+  avatarSetup: 0
+  addHumanoidExtraRootOnlyWhenUsingAvatar: 1
+  importBlendShapeDeformPercent: 1
+  remapMaterialsIfMaterialImportModeIsNone: 0
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/Mesh/SamplesFloorSpotlight.fbx.meta

@@ -0,0 +1,110 @@
+fileFormatVersion: 2
+guid: 1dbf28c1bb322474d981b2dc555e28b0
+ModelImporter:
+  serializedVersion: 24200
+  internalIDToNameTable: []
+  externalObjects: {}
+  materials:
+    materialImportMode: 2
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    removeConstantScaleCurves: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 0
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    sortHierarchyByName: 1
+    importPhysicalCameras: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    nodeNameCollisionStrategy: 1
+    fileIdsGeneration: 2
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    keepQuads: 0
+    weldVertices: 1
+    bakeAxisConversion: 0
+    preserveHierarchy: 0
+    skinWeightsMode: 0
+    maxBonesPerVertex: 4
+    minBoneWeight: 0.001
+    optimizeBones: 1
+    generateMeshLods: 0
+    meshLodGenerationFlags: 0
+    maximumMeshLod: -1
+    meshOptimizationFlags: -1
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVMarginMethod: 1
+    secondaryUVMinLightmapResolution: 40
+    secondaryUVMinObjectScale: 1
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    strictVertexDataChecks: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  referencedClips: []
+  importAnimation: 1
+  humanDescription:
+    serializedVersion: 3
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    globalScale: 1
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  autoGenerateAvatarMappingIfUnspecified: 1
+  animationType: 2
+  humanoidOversampling: 1
+  avatarSetup: 0
+  addHumanoidExtraRootOnlyWhenUsingAvatar: 1
+  importBlendShapeDeformPercent: 1
+  remapMaterialsIfMaterialImportModeIsNone: 0
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/Mesh/SamplesSpotlightModel.fbx.meta

@@ -0,0 +1,110 @@
+fileFormatVersion: 2
+guid: 4e8732d4875cc0647b52b55a218072b6
+ModelImporter:
+  serializedVersion: 24200
+  internalIDToNameTable: []
+  externalObjects: {}
+  materials:
+    materialImportMode: 2
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    removeConstantScaleCurves: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 0
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    sortHierarchyByName: 1
+    importPhysicalCameras: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    nodeNameCollisionStrategy: 1
+    fileIdsGeneration: 2
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    keepQuads: 0
+    weldVertices: 1
+    bakeAxisConversion: 0
+    preserveHierarchy: 0
+    skinWeightsMode: 0
+    maxBonesPerVertex: 4
+    minBoneWeight: 0.001
+    optimizeBones: 1
+    generateMeshLods: 0
+    meshLodGenerationFlags: 0
+    maximumMeshLod: -1
+    meshOptimizationFlags: -1
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVMarginMethod: 1
+    secondaryUVMinLightmapResolution: 40
+    secondaryUVMinObjectScale: 1
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    strictVertexDataChecks: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  referencedClips: []
+  importAnimation: 1
+  humanDescription:
+    serializedVersion: 3
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    globalScale: 1
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  autoGenerateAvatarMappingIfUnspecified: 1
+  animationType: 2
+  humanoidOversampling: 1
+  avatarSetup: 0
+  addHumanoidExtraRootOnlyWhenUsingAvatar: 1
+  importBlendShapeDeformPercent: 1
+  remapMaterialsIfMaterialImportModeIsNone: 0
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.core@13460d8ea9e5/Runtime/RenderPipelineResources/Mesh/UnityMaterialBall.fbx.meta

@@ -0,0 +1,112 @@
+fileFormatVersion: 2
+guid: 39857cfad1651644682ff5b772e6e697
+ModelImporter:
+  serializedVersion: 22102
+  internalIDToNameTable: []
+  externalObjects:
+  - first:
+      type: UnityEngine:Material
+      assembly: UnityEngine.CoreModule
+      name: 10 - Default
+    second: {fileID: 2100000, guid: e0f7961861aa5ae4a97805f16f8306b7, type: 2}
+  materials:
+    materialImportMode: 0
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    removeConstantScaleCurves: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 0
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    sortHierarchyByName: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    nodeNameCollisionStrategy: 0
+    fileIdsGeneration: 2
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    keepQuads: 0
+    weldVertices: 1
+    bakeAxisConversion: 0
+    preserveHierarchy: 0
+    skinWeightsMode: 0
+    maxBonesPerVertex: 4
+    minBoneWeight: 0.001
+    optimizeBones: 1
+    meshOptimizationFlags: -1
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVMarginMethod: 1
+    secondaryUVMinLightmapResolution: 40
+    secondaryUVMinObjectScale: 1
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    strictVertexDataChecks: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  referencedClips: []
+  importAnimation: 1
+  humanDescription:
+    serializedVersion: 3
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    globalScale: 1
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  autoGenerateAvatarMappingIfUnspecified: 1
+  animationType: 2
+  humanoidOversampling: 1
+  avatarSetup: 0
+  addHumanoidExtraRootOnlyWhenUsingAvatar: 1
+  importBlendShapeDeformPercent: 0
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: