Add Post

Author: To-steak

docs/posts/Unity_ECS Test.md

@@ -23,7 +23,7 @@ ECS에 대해 간단히 소개하자면 이렇다.
 
 조작하려는 데이터(IComponentData)를 Unity 게임 오브젝트에 부착(Authoring)할 수 있도록 하고(Baker) 동작을 수행(ISystem)하도록 지시한다.
 
-설계할 환경은 10만 개의 총알과 적 개체이다.
+설계할 환경은 10만 개의 총알과 2,000마리의 적 개체이다.
 
 ##### 총알(Bullet)
 ```csharp
@@ -209,6 +209,249 @@ Profiler를 통해 중간 점검을 해본다.
 - Mesh를 Sphere에서 Cube로 바꾸고, 머티리얼의 `Shadow Receive`를 끄고, `GPU Instancing` 을 활성화 했다.
 ![04](/images/Unity_ECS%20Test/04.png)
 - 이제 한 프레임에 12.47ms 로 약 80fps의 출력을 확인할 수 있다.
-- 삼각형의 숫자가 2.4M (240만 개)
+- 삼각형의 숫자가 2.4M (240만 개)로 줄어듦을 확인할 수 있다.
 
-### 충돌 시스템
+### 충돌 시스템
+```csharp
+public override void Update(float deltaTime)
+{
+  foreach(var stageObject in GameStage.currentStage.stageObjects )
+  {
+    if( stageObject is Enemy enemy)
+    {
+      float distanceToEnemy = Vector3.length(pos - enemy.pos);
+      if( distanceToEnemy < radius )
+      {
+        // 적이 총알에 맞았을 때의 처리
+        GameStage.currentStage.RemoveStageObject(this);
+
+        enemy.AddDamage(this.power);
+      }
+    }
+  }
+}
+```
+- 해당 의사코드를 그대로 구현한 `WorstCollisionSystem`을 제작할 것이다.
+- 해당 코드는 모든 총알이 개별적으로 갖는다.
+- 시간복잡도 O(m * n) 을 갖는다.
+
+##### WorstCollisionSystem
+```cs
+partial struct WorstCollisionSystem : ISystem
+{
+    [BurstCompile]
+    public void OnUpdate(ref SystemState state)
+    {
+        var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
+        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);
+
+        foreach (var (bulletTransform, bullet, bulletEntity) in SystemAPI.Query<RefRO<LocalTransform>, RefRO<Bullet>>().WithEntityAccess())
+        {
+            foreach (var (enemyTransform, enemy, enemyEntity) in SystemAPI.Query<RefRO<LocalTransform>, RefRO<Enemy>>().WithEntityAccess())
+            {
+                float3 bulletPos = bulletTransform.ValueRO.Position;
+                float3 enemyPos = enemyTransform.ValueRO.Position;
+
+                float distance = math.distance(bulletPos, enemyPos);
+                float collisionRadius = bullet.ValueRO.Radius;
+                float bulletDamage = bullet.ValueRO.Power;
+
+                if (distance <= collisionRadius)
+                {
+                    ecb.DestroyEntity(enemyEntity);
+                    // todo: enemyEntity에게 bulletDamage 입히기
+                    break;
+                }
+            }
+        }
+    }
+}
+```
+- 세상의 총알과 적을 `SystemAPI.Query<>`로 가져와 거리를 비교한다.
+- 총알의 거리에 들면 적 개체를 `DestroyEntity()`한다.
+![Worst_Coll](/images/Unity_ECS%20Test/Worst_Coll.png)
+- Profiler로 확인했을 때, 282ms 중 263ms를 차지한다.(약 3.54fps)
+
+##### BestCollisionSystem
+공간 분할 알고리즘을 적용하여 `HashMap<격자 번호, 적 개체>`에 저장한다.<br>
+총알의 입장에서 총알 주위 9칸(3 * 3) 격자에 적 개체가 있는지 확인하고 없다면 충돌 검사를 하지 않는다.
+```cs
+partial struct BestCollisionSystem : ISystem
+{
+    private const float CELL_SIZE = 10f;
+
+    [BurstCompile]
+    public void OnUpdate(ref SystemState state)
+    {
+        var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
+        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);
+
+        var enemyGrid = new NativeParallelMultiHashMap<int2, EnemyGridData>(1000, Allocator.Temp);
+
+        foreach (var (enemyTransform, enemy, enemyEntity) in SystemAPI.Query<RefRO<LocalTransform>, RefRO<Enemy>>().WithEntityAccess())
+        {
+            float3 position = enemyTransform.ValueRO.Position;
+            int2 cellCoord = new int2((int)math.floor(position.x / CELL_SIZE), (int)math.floor(position.z / CELL_SIZE));
+
+            enemyGrid.Add(cellCoord, new EnemyGridData
+            {
+                Entity = enemyEntity,
+                Position = position
+            });
+        }
+
+        foreach (var (bulletTransform, bullet, bulletEntity) in SystemAPI.Query<RefRO<LocalTransform>, RefRO<Bullet>>().WithEntityAccess())
+        {
+            float3 position = bulletTransform.ValueRO.Position;
+            float radius = bullet.ValueRO.Radius;
+            int2 cellCoord = new int2((int)math.floor(position.x / CELL_SIZE), (int)math.floor(position.z / CELL_SIZE));
+
+            bool hit = false;
+
+            for (int i = -1; i <= 1; i++)
+            {
+                for (int j = -1; j <= 1; j++)
+                {
+                    int2 checkCell = cellCoord + new int2(i, j);
+
+                    if (enemyGrid.TryGetFirstValue(checkCell, out var enemyData, out var iterator))
+                    {
+                        do
+                        {
+                            float distance = math.distance(position, enemyData.Position);
+
+                            if (distance <= radius)
+                            {
+                                ecb.DestroyEntity(enemyData.Entity);
+                                hit = true;
+                                break;
+                            }
+                        }
+                        while (enemyGrid.TryGetNextValue(out enemyData, ref iterator));
+                    }
+                    if (hit) break;
+                }
+                if (hit) break;
+            }
+        }
+
+        enemyGrid.Dispose();
+    }
+}
+
+struct EnemyGridData
+{
+    public Entity Entity;
+    public float3 Position;
+}
+```
+- 첫 번째 `foreach`에서 모든 적 개체의 좌표를 `CELL_SIZE`(격자 한 칸의 크기)로 나누어 `HashMap`에 저장한다.
+- 두 번째 `foreach`에서 총알 주변의 3 * 3 격자를 순회하며 총알과의 충돌 판정을 계산한다.
+- 이때, HashMap(`enemyGrid`)에 적이 있든 없든 일단 조회를 한다.
+![Best_Coll](/images/Unity_ECS%20Test/Best_Coll.png)
+- Profiler로 확인했을 때, 13.58ms 중 5.59ms를 차지한다.(약 73.63 fps)
+##### BitCollisionSystem
+`BestCollisionSystem`과 똑같이 공간 분할을 하되 Bit 배열을 사용해서 적 개체가 있는 격자라면 비트를 켠다.<br>
+해시 조회를 하기 전 격자에 적이 없다면(Bit 배열이 0인 경우) 해시 조회를 하지 않는다.
+```cs
+partial struct BitCollisionSystem : ISystem
+{
+    private const float CELL_SIZE = 10f;
+    private const int GRID_SIZE = 200;
+    private const int GRID_OFFSET = 100;
+    private const int TOTAL_CELLS = GRID_SIZE * GRID_SIZE;
+
+    [BurstCompile]
+    public void OnUpdate(ref SystemState state)
+    {
+        var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
+        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);
+        var occupancyBits = new NativeBitArray(TOTAL_CELLS, Allocator.Temp, NativeArrayOptions.ClearMemory);
+        var enemyGrid = new NativeParallelMultiHashMap<int2, EnemyGridData>(1000, Allocator.Temp);
+
+        foreach (var (enemyTransform, enemy, enemyEntity) in SystemAPI.Query<RefRO<LocalTransform>, RefRO<Enemy>>().WithEntityAccess())
+        {
+            float3 position = enemyTransform.ValueRO.Position;
+            int2 cellCoord = new int2((int)math.floor(position.x / CELL_SIZE), (int)math.floor(position.z / CELL_SIZE));
+
+            int x = cellCoord.x + GRID_OFFSET;
+            int z = cellCoord.y + GRID_OFFSET;
+            if (x >= 0 && x < GRID_SIZE && z >= 0 && z < GRID_SIZE)
+            {
+                enemyGrid.Add(cellCoord, new EnemyGridData
+                {
+                    Entity = enemyEntity,
+                    Position = position
+                });
+
+                // GetLinearIndex 인라인
+                int linearIndex = z * GRID_SIZE + x;
+                occupancyBits.Set(linearIndex, true);
+            }
+        }
+
+        foreach (var (bulletTransform, bullet, bulletEntity) in SystemAPI.Query<RefRO<LocalTransform>, RefRO<Bullet>>().WithEntityAccess())
+        {
+            float3 position = bulletTransform.ValueRO.Position;
+            float radius = bullet.ValueRO.Radius;
+            int2 cellCoord = new int2((int)math.floor(position.x / CELL_SIZE), (int)math.floor(position.z / CELL_SIZE));
+            bool hit = false;
+
+            for (int i = -1; i <= 1; i++)
+            {
+                for (int j = -1; j <= 1; j++)
+                {
+                    int2 checkCell = cellCoord + new int2(i, j);
+                    int checkX = checkCell.x + GRID_OFFSET;
+                    int checkZ = checkCell.y + GRID_OFFSET;
+                    
+                    if (checkX < 0 || checkX >= GRID_SIZE || checkZ < 0 || checkZ >= GRID_SIZE)
+                    {
+                        continue;
+                    }
+
+                    int linearIndex = checkZ * GRID_SIZE + checkX;
+
+                    if (!occupancyBits.IsSet(linearIndex))
+                    {
+                        continue;
+                    }
+
+                    if (enemyGrid.TryGetFirstValue(checkCell, out var enemyData, out var iterator))
+                    {
+                        do
+                        {
+                            float distance = math.distance(position, enemyData.Position);
+
+                            if (distance <= radius)
+                            {
+                                ecb.DestroyEntity(enemyData.Entity);
+                                hit = true;
+                                break;
+                            }
+                        }
+                        while (enemyGrid.TryGetNextValue(out enemyData, ref iterator));
+                    }
+                    if (hit) break;
+                }
+                if (hit) break;
+            }
+        }
+
+        occupancyBits.Dispose();
+        enemyGrid.Dispose();
+    }
+}
+```
+- 첫 번째 `foreach`에서 적 위치를 격자에 넣는 것은 동일하지만 추가로 `occupancyBits`에 값을 켜준다.
+- 두 번째 `foreach`에서 3 * 3 격자를 순회할 때, `occupancyBits.IsSet()`값이 0이면 해시 조회(`TryGetFirstValue()`)를 하지 않는다.
+![Bit_Coll](/images/Unity_ECS%20Test/Bit_Coll.png)
+- Profiler로 확인했을 때, 11.03ms 중 2.76ms를 차지한다.(약 90.66 fps)
+### 결과
+- 100,000개의 총알이 있는 세상에서 2,000마리의 적이 있을 때, 모든 총알과의 충돌 계산을 하는 것은 성능이 나쁘다.
+- 공간 분할을 통해 계산할 적의 숫자를 줄이는 것으로 3.54fps에서 73.63fps로의 성능 개선을 이룰 수 있다.
+- 추가로 격자에 적이 없다면 해시 조회를 하지 않아도 되므로 HasMap 조회보다 연산이 빠른 Bit 조회로 적의 유무를 미리 알고 계산을 건너 뛰는 방법을 생각할 수 있다.
+- 계산을 건너뛰게 된다면 73.64fps에서 90.66fps로의 성능 개선을 이룰 수 있다.
+- 하지만 세상에 100,000개 총알 중 적의 비율이 적기 때문에 적과 총알의 비율이 같아지는 순간이 오면 성능이 역전될 수 있다.
+- Unity Editor에서 적의 수를 20,000 정도로 늘리면 `BestCollisionSystem`이 성능이 좋아지게 된다.
+- 하지만 세상의 크기를 반지름이 1,000인 원으로 제한했기 때문에 충돌이 일어나지 않는 경우보다 충돌이 일어나는 경우가 더 빈번하다는 점을 고려해야 한다.