Feat/gpu instancing/roads indirect

Explorer/Assets/DCL/LOD/Systems/LODContainer.cs

@@ -9,13 +9,13 @@
 using DCL.Roads.Systems;
 using ECS;
 using Global;
-using Global.Dynamic;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using DCL.Optimization.Pools;
-using DCL.ResourcesUnloading;
+using DCL.Roads.GPUInstancing;
+using DCL.Roads.GPUInstancing.Playground;
 using UnityEngine;
 using UnityEngine.AddressableAssets;
 
@@ -34,6 +34,8 @@ public class LODContainer : DCLWorldContainer<LODContainer.LODContainerSettings>
         private ProvidedAsset<RoadSettingsAsset> roadSettingsAsset;
         private List<GameObject> roadAssetsPrefabList;
         private ProvidedAsset<LODSettingsAsset> lodSettingsAsset;
+        private GPUInstancingService gpuInstancingService;
+        private RealmData realmData;
 
         public LODPlugin LODPlugin { get; private set; } = null!;
 
@@ -48,18 +50,20 @@ private LODContainer(IAssetsProvisioner assetsProvisioner)
             this.assetsProvisioner = assetsProvisioner;
         }
 
-        public static async UniTask<(LODContainer? container, bool success)> CreateAsync(
-            IAssetsProvisioner assetsProvisioner,
+        public static async UniTask<(LODContainer? container, bool success)> CreateAsync(IAssetsProvisioner assetsProvisioner,
             IDecentralandUrlsSource decentralandUrlsSource,
             StaticContainer staticContainer,
             IPluginSettingsContainer settingsContainer,
             RealmData realmData,
             TextureArrayContainerFactory textureArrayContainerFactory,
             IDebugContainerBuilder debugBuilder,
             bool lodEnabled,
+            GPUInstancingService gpuInstancingService,
             CancellationToken ct)
         {
             var container = new LODContainer(assetsProvisioner);
+            container.gpuInstancingService = gpuInstancingService;
+            container.realmData = realmData;
 
             return await container.InitializeContainerAsync<LODContainer, LODContainerSettings>(settingsContainer, ct, c =>
             {
@@ -104,6 +108,8 @@ public override void Dispose()
         {
             roadSettingsAsset.Dispose();
             lodSettingsAsset.Dispose();
+
+            realmData.RealmType.OnUpdate -= SwitchRoadsInstancedRendering;
         }
 
         protected override async UniTask InitializeInternalAsync(LODContainerSettings lodContainerSettings, CancellationToken ct)
@@ -113,7 +119,21 @@ protected override async UniTask InitializeInternalAsync(LODContainerSettings lo
             roadAssetsPrefabList = new List<GameObject>();
 
             foreach (AssetReferenceGameObject? t in roadSettingsAsset.Value.RoadAssetsReference)
-                roadAssetsPrefabList.Add((await assetsProvisioner.ProvideMainAssetAsync(t, ct: ct)).Value);
+            {
+                var prefab = await assetsProvisioner.ProvideMainAssetAsync(t, ct: ct);
+                prefab.Value.GetComponent<GPUInstancingPrefabData>().HideVisuals();
+                roadAssetsPrefabList.Add(prefab.Value);
+            }
+
+            realmData.RealmType.OnUpdate += SwitchRoadsInstancedRendering;
+        }
+
+        private void SwitchRoadsInstancedRendering(RealmKind realmKind)
+        {
+            if (realmKind == RealmKind.GenesisCity)
+                gpuInstancingService.AddToIndirect(roadSettingsAsset.Value.IndirectCandidates);
+            else
+                gpuInstancingService.Remove(roadSettingsAsset.Value.IndirectCandidates);
         }
 
         [Serializable]

Explorer/Assets/DCL/PerformanceAndDiagnostics/Diagnostics/ReportsHandling/ReportCategory.cs

@@ -299,5 +299,6 @@ public static class ReportCategory
         public const string IN_WORLD_CAMERA = nameof(IN_WORLD_CAMERA);
 
         public const string FRIENDS = nameof(FRIENDS);
+        public const string GPU_INSTANCING = nameof(GPU_INSTANCING);
     }
 }

Explorer/Assets/DCL/PluginSystem/DCL.Plugins.asmdef

@@ -154,7 +154,8 @@
         "GUID:e9db755bba99425db4ca5d30e48b7429",
         "GUID:5462d37de7d4344df8aade58a45b403e",
         "GUID:f3634757d00dab2429c6c11e69404e97",
-        "GUID:09c5cab4669b047398fa5d42a2f64f5b"
+        "GUID:09c5cab4669b047398fa5d42a2f64f5b",
+        "GUID:422b93d277444c569adf5e25ecef10ba"
     ],
     "includePlatforms": [],
     "excludePlatforms": [],

Explorer/Assets/DCL/Rendering/GPUInstanceBatcher/ComputeShaders/ComputeDrawArgs.compute

@@ -0,0 +1,16 @@
+
+#include "Includes/PlatformSpecifications.cginc"
+
+#pragma kernel CSArgsBufferDoubleInstanceCount
+
+uniform RWStructuredBuffer<uint> argsBuffer;
+uniform uint count;
+
+[numthreads(GPUI_THREADS, 1, 1)]
+void CSArgsBufferDoubleInstanceCount(uint2 id : SV_DispatchThreadID)
+{
+    if (id.x >= count)
+        return;
+
+    argsBuffer[id.x * 5 + 1] *= 2;
+}

Explorer/Assets/DCL/Rendering/GPUInstanceBatcher/ComputeShaders/Includes/BoundsFunctions.cginc

@@ -0,0 +1,70 @@
+#ifndef _DCL_BOUNDS_FUNCTIONS_
+#define _DCL_BOUNDS_FUNCTIONS_
+
+// Bounding Box
+// uniform float3 boundsCenter;
+// uniform float3 boundsExtents;
+
+// Bounding Sphere
+
+// Bounding Capsule (Avatar)
+// uniform float4x4 modifierTransform;
+// uniform float modifierRadius;
+// uniform float modifierHeight;
+// uniform float3 modifierAxis;
+
+#include "MathematicsFunctions.cginc"
+
+inline bool TestBoundingBox(float3 position, float3 boundsCentre, float3 boundsExtents)
+{
+    float3 Min = boundsCentre - boundsExtents;
+    float3 Max = boundsCentre + boundsExtents;
+
+    bool bIsInside =    position.x >= Min.x &&
+                        position.x <= Max.x &&
+                        position.y >= Min.y &&
+                        position.y <= Max.y &&
+                        position.z >= Min.z &&
+                        position.z <= Max.z;
+
+    return bIsInside;
+}
+
+inline bool TestBoundingSphere(float3 position, float3 boundsCentre, float radius)
+{
+    return distance(boundsCentre, position) <= radius;
+}
+
+inline bool TestBoundingCapsule(float3 position, float boundsCentre, float height, float radius, float3 axis, float4x4 transform)
+{
+    float pointChange = 0;
+    if (height / 2 > radius)
+    {
+        pointChange = (height / 2) - radius;
+        float4x4 scaled = SetScaleOfMatrix(transform, 1);
+
+        // https://math.stackexchange.com/questions/1905533/find-perpendicular-distance-from-point-to-line-in-3d
+        float3 A = position;
+        float3 B = mul(scaled, float4(boundsCentre.x + axis.x * pointChange, boundsCentre.y + axis.y * pointChange, boundsCentre.z + axis.z * pointChange, 1.0)).xyz;
+        float3 C = mul(scaled, float4(boundsCentre.x - axis.x * pointChange, boundsCentre.y - axis.y * pointChange, boundsCentre.z - axis.z * pointChange, 1.0)).xyz;
+
+        float3 d = (C - B) / distance(C, B);
+        float3 v = A - B;
+        float t = dot(v, d);
+        float3 P = B + t * d;
+
+        float distPB = distance(P, B);
+        float distPC = distance(P, C);
+        float distBC = distance(B, C);
+
+        if (abs(distBC - (distPB + distPC)) < 0.1)
+            return distance(P, A) <= radius;
+        else if (distPB < distPC)
+            return distance(B, A) <= radius;
+        else
+            return distance(C, A) <= radius;
+    }
+    else
+        return distance(boundsCentre + transform._14_24_34, position) <= radius;
+}
+#endif

Explorer/Assets/DCL/Rendering/GPUInstanceBatcher/ComputeShaders/Includes/CameraFunctions.cginc

@@ -0,0 +1,53 @@
+#ifndef _DCL_CAMERA_FUNCTIONS_
+#define _DCL_CAMERA_FUNCTIONS_
+
+#include "InputParams.cginc"
+
+inline void CalculateDistanceAndScreenSize(float4x4 instanceMatrix, out float dist, out float maxViewSize)
+{
+    dist = 0;
+    maxViewSize = 0;
+
+    float3 scale = float3(length(instanceMatrix._11_12_13), length(instanceMatrix._21_22_23), length(instanceMatrix._31_32_33));
+    dist = abs(distance(instanceMatrix._14_24_34, camPos));
+    maxViewSize = max(max(boundsExtents.x * scale.x, boundsExtents.y * scale.y), boundsExtents.z * scale.z) / (dist * halfAngle * 2);
+}
+
+inline uint4 CalculateRequiredLODs(uint nLODCount, float4x4 mLODScreenSpaceSizes, float fShadowDistance, float fScreenSpaceSize, float fDistance, bool bIsVisible, bool bIsShadowVisible)
+{
+    uint4 output = uint4(8,8,0,8);
+    for (uint i = 0; i < nLODCount; ++i)
+    {
+        if (bIsVisible)
+        {
+            if (fScreenSpaceSize > mLODScreenSpaceSizes[i] && fScreenSpaceSize < mLODScreenSpaceSizes[i+8])
+            {
+                output[0] = i;
+                if (i < nLODCount-1)
+                {
+                    if (fScreenSpaceSize > mLODScreenSpaceSizes[i+1] && fScreenSpaceSize < mLODScreenSpaceSizes[i+8+1])
+                    {
+                        output[1] = i+1;
+                        output[2] = uint((fScreenSpaceSize - mLODScreenSpaceSizes[i+1]) / (mLODScreenSpaceSizes[i] - mLODScreenSpaceSizes[i+1]) * 255);
+                    }
+                }
+                else
+                {
+                    float fPercentageOfFinalLOD = (fScreenSpaceSize / (mLODScreenSpaceSizes[i] - mLODScreenSpaceSizes[i+8]));
+                    float fLastTenPercentDither = clamp((fPercentageOfFinalLOD - 0.9f), 0.0f, 0.1f) * 10.0f;
+                    output[2] = uint(fLastTenPercentDither * 255);
+                }
+                if (bIsShadowVisible)
+                {
+                    if (fDistance < fShadowDistance)
+                        output[3] = i;
+                }
+                break;
+            }
+        }
+    }
+    return output;
+}
+
+
+#endif