【Unity】Boidsアルゴリズムを用いて魚の群集シミュレーションを実装する

    for (uint blockIndex = 0; blockIndex < (uint) _MaxBoidNum; blockIndex += SIMULATION_BLOCK_SIZE)
    {

      ・・・略・・・

            // 分離: 近づきすぎたら離れる
            if (distance <= _SeparationDistance)
            {
                separationPositionSum += diffPosition;
                separationCount++;
            }

            ・・・略・・・

    }

    ・・・略・・・

    if (separationCount > 0)
    {
        const float3 separationPosition = separationPositionSum / (float) separationCount;
        force += separationPosition * _SeparationCoefficient;
    }

    for (uint blockIndex = 0; blockIndex < (uint) _MaxBoidNum; blockIndex += SIMULATION_BLOCK_SIZE)
    {

      ・・・略・・・

            // 整列: 近くの向きに合わせる
            if (distance <= _AlignmentDistance)
            {
                alignmentVelocitySum += targetVelocity;
                alignmentCount++;
            }

            ・・・略・・・

    }

    ・・・略・・・

    if (alignmentCount > 0)
    {
        const float3 alignmentVelocity = alignmentVelocitySum / (float) alignmentCount;
        force += alignmentVelocity * _AlignmentCoefficient;
    }

    for (uint blockIndex = 0; blockIndex < (uint) _MaxBoidNum; blockIndex += SIMULATION_BLOCK_SIZE)
    {

      ・・・略・・・

            // 結合: 近くのboidsの重心に近づく
            if (distance <= _CohesionDistance)
            {
                cohesionPositionSum += targetPosition;
                cohesionCount++;
            }

    }

    ・・・略・・・

    if (cohesionCount > 0)
    {
        const float3 cohesionPosition = cohesionPositionSum / (float) cohesionCount;
        force += (cohesionPosition - inPosition) * _CohesionCoefficient;
    }

[numthreads(SIMULATION_BLOCK_SIZE, 1, 1)]
void IntegrateCS(uint3 dtId : SV_DispatchThreadID)
{
    // 現在のデータを取得
    const unsigned int inIndex = dtId.x;
    BoidData inData = _BoidDataBufferWrite[inIndex];
    float3 force = _BoidForceBufferRead[inIndex];

    // 境界処理: 壁際に来たら反発力を加える
    float3 inPosition = inData.position;
    float3 wc = _SimulationAreaCenter.xyz;
    float3 ws = _SimulationAreaSize.xyz;
    float3 avoidance = float3(0, 0, 0);
    avoidance.x = (inPosition.x < wc.x - ws.x * 0.5) ? avoidance.x + 1.0 : avoidance.x;
    avoidance.x = (inPosition.x > wc.x + ws.x * 0.5) ? avoidance.x - 1.0 : avoidance.x;
    avoidance.y = (inPosition.y < wc.y - ws.y * 0.5) ? avoidance.y + 1.0 : avoidance.y;
    avoidance.y = (inPosition.y > wc.y + ws.y * 0.5) ? avoidance.y - 1.0 : avoidance.y;
    avoidance.z = (inPosition.z < wc.z - ws.z * 0.5) ? avoidance.z + 1.0 : avoidance.z;
    avoidance.z = (inPosition.z > wc.z + ws.z * 0.5) ? avoidance.z - 1.0 : avoidance.z;
    force += avoidance * _AvoidWallWeight;

    // 操舵力を速度に適用して位置を更新
    inData.velocity += force * _DeltaTime;
    inData.velocity = limit(inData.velocity, _MaxSpeed);
    inData.position += inData.velocity * _DeltaTime;

    // 計算結果を書き込む
    _BoidDataBufferWrite[inIndex] = inData;
}

// GPUインスタンシングによる描画(3D)
Shader "Custom/Boids3DRender"
{
    Properties
    {
        _Color ("Color", Color) = (1,1,1,1)
        _MainTex ("Albedo (RGB)", 2D) = "white" {}
    }
    SubShader
    {
        Tags {
        	"RenderType" = "Opaque"
        }
        LOD 200

        // 裏面描画
        Cull Off

        CGPROGRAM
        #pragma surface surf Standard vertex:vert SimpleLambert
        #pragma instancing_options procedural:setup
        #pragma target 3.0

        struct Input
        {
            float2 uv_MainTex;
        };

        sampler2D _MainTex;
        fixed4 _Color;

        // Boidオブジェクトの大きさ
        float3 _BoidScale;

        // Boidデータの構造体
        struct BoidData
        {
            float3 velocity; // 速度
            float3 position; // 位置
        };

        #ifdef UNITY_PROCEDURAL_INSTANCING_ENABLED
        StructuredBuffer<BoidData> _BoidDataBuffer;
        #endif

		// 角度を回転行列に変換(3D)
        // (クォータニオンによる計算の方がいいかも？)
		float4x4 radianToRotationMatrix(float3 angles)
		{
			const float cy = cos(angles.y); float sy = sin(angles.y);
			const float cx = cos(angles.x); float sx = sin(angles.x);
			const float cz = cos(angles.z); float sz = sin(angles.z);
			// Ry-Rx-Rz (Yaw Pitch Roll)
			return float4x4(
				cy * cz + sy * sx * sz, -cy * sz + sy * sx * cz, sy * cx, 0,
				cx * sz, cx * cz, -sx, 0,
				-sy * cz + cy * sx * sz, sy * sz + cy * sx * cz, cy * cx, 0,
				0, 0, 0, 1
			);
		}

        void setup()
		{
		}

        void vert(inout appdata_full v)
        {
        	#ifdef UNITY_PROCEDURAL_INSTANCING_ENABLED

        	// Boidデータを取得
        	BoidData boidData = _BoidDataBuffer[unity_InstanceID];
        	float3 boidPosition = boidData.position.xyz;
        	float3 boidScale = _BoidScale;

        	// オブジェクト座標 -> ワールド座標に変換する行列を定義
        	float4x4 object2world = (float4x4) 0;

			// scale
        	object2world._11_22_33_44 = float4(boidScale.xyz, 1.0);

        	// rotation
        	float rotX = -asin(boidData.velocity.y / (length(boidData.velocity.xyz) + 1e-8));
        	float rotY = atan2(boidData.velocity.x, boidData.velocity.z);
	        float4x4 rotMatrix = radianToRotationMatrix(float3(rotX, rotY, 0));
        	object2world = mul(rotMatrix, object2world);

			// position
        	object2world._14_24_34 += boidPosition.xyz;

        	// 行列から頂点、法線を設定
        	v.vertex = mul(object2world, v.vertex);
        	v.normal = normalize(mul(object2world, v.normal));

        	#endif
        }

        void surf (Input IN, inout SurfaceOutputStandard o)
        {
            fixed4 c = tex2D (_MainTex, IN.uv_MainTex) * _Color;
			clip(c.a - 0.1); // 透明部分は非表示
            o.Albedo = c.rgb;
        }
        ENDCG
    }
    FallBack "Diffuse"
}

        /// <summary>
        /// GPUインスタンシングのための引数データ
        /// </summary>
        protected GraphicsBuffer.IndirectDrawIndexedArgs[] _gpuInstanceArgs;

        /// <summary>
        /// GPUインスタンシングのための引数バッファ
        /// </summary>
        protected GraphicsBuffer _gpuInstanceArgsBuffer;

・・・略・・・

        /// <summary>
        /// バッファ初期化
        /// </summary>
        private void InitBuffer()
        {
            // GraphicsBuffer.Target: https://docs.unity3d.com/ScriptReference/GraphicsBuffer.Target.html
            var commandCount = 1;
            _gpuInstanceArgs = new GraphicsBuffer.IndirectDrawIndexedArgs[commandCount];
            _gpuInstanceArgsBuffer = new GraphicsBuffer(GraphicsBuffer.Target.IndirectArguments, commandCount, GraphicsBuffer.IndirectDrawIndexedArgs.size);
        }

        /// <summary>
        /// メッシュ描画
        /// </summary>
        protected abstract void OnRenderMesh();

        /// <summary>
        /// バッファ解放
        /// </summary>
        private void ReleaseBuffer()
        {
            if (_gpuInstanceArgsBuffer != null)
            {
                _gpuInstanceArgsBuffer.Release();
                _gpuInstanceArgsBuffer = null;
            }
        }

        /// <summary>
        /// メッシュ描画
        /// https://docs.unity3d.com/ScriptReference/Graphics.RenderMeshIndirect.html
        /// </summary>
        protected override void OnRenderMesh()
        {
            if (_boidsRenderMesh == null
                || _boidsRenderMaterial == null
                || !SystemInfo.supportsInstancing)
            {
                return;
            }

            // シミュレーションデータの取得
            uint maxBoidsCount = (uint) _boids3DSimulation.MaxBoidsNum;
            GraphicsBuffer boidsDataBuffer = _boids3DSimulation.BoidsDataBuffer;
            Vector3 simulationAreaCenter = _boids3DSimulation.SimulationAreaCenter;
            Vector3 simulationAreaSize = _boids3DSimulation.SimulationAreaSize;

            // 引数バッファにインデックス数、生成数を設定
            var numIndices = _boidsRenderMesh.GetIndexCount(0);
            _gpuInstanceArgs[0].indexCountPerInstance = numIndices;
            _gpuInstanceArgs[0].instanceCount = maxBoidsCount;
            _gpuInstanceArgsBuffer.SetData(_gpuInstanceArgs);

            // マテリアルに描画用のデータを設定
            var renderParams = new RenderParams(_boidsRenderMaterial);
            renderParams.matProps = new MaterialPropertyBlock();
            renderParams.matProps.SetBuffer("_BoidDataBuffer", boidsDataBuffer);
            renderParams.matProps.SetVector("_BoidScale", _boidScale);
            renderParams.worldBounds = new Bounds(simulationAreaCenter, simulationAreaSize);

            // メッシュ描画
            Graphics.RenderMeshIndirect(
                renderParams,
                _boidsRenderMesh,
                _gpuInstanceArgsBuffer);
        }

// Boidデータ格納用シェアードメモリ
groupshared BoidData shared_boid_data[SIMULATION_BLOCK_SIZE];

[numthreads(SIMULATION_BLOCK_SIZE, 1, 1)]
void ForceCS(uint3 dtId : SV_DispatchThreadID, uint groupIndex: SV_GroupIndex)
{
    // 現在のデータを取得
    const unsigned int inIndex = dtId.x;
    const float3 inPosition = _BoidDataBufferRead[inIndex].position;

    // 操舵力計算用の変数を初期化
    float3 separationPositionSum = float3(0.0, 0.0, 0.0);
    float3 alignmentVelocitySum = float3(0.0, 0.0, 0.0);
    float3 cohesionPositionSum = float3(0.0, 0.0, 0.0);
    int separationCount = 0;
    int alignmentCount = 0;
    int cohesionCount = 0;

    [loop]
    for (uint blockIndex = 0; blockIndex < (uint) _MaxBoidNum; blockIndex += SIMULATION_BLOCK_SIZE)
    {
        // ブロックサイズ分のBoidデータをシェアードメモリに格納
        shared_boid_data[groupIndex] = _BoidDataBufferRead[blockIndex + groupIndex];
        GroupMemoryBarrierWithGroupSync(); // グループ内のスレッドが全て到着するまで待機

        // シェアードメモリから全てのブロック内のオブジェクトをチェック
        for (int targetBoidIndex = 0; targetBoidIndex < SIMULATION_BLOCK_SIZE; targetBoidIndex++)
        {
            const float3 targetPosition = shared_boid_data[targetBoidIndex].position;
            const float3 targetVelocity = shared_boid_data[targetBoidIndex].velocity;

            // 自身との距離を取得
            const float3 diffPosition = inPosition - targetPosition;
            const float distance = sqrt(dot(diffPosition, diffPosition));
            if (distance <= 0.0)
            {
                continue;
            }

            // 分離: 近づきすぎたら離れる
            if (distance <= _SeparationDistance)
            {
                separationPositionSum += diffPosition;
                separationCount++;
            }

            // 整列: 近くの向きに合わせる
            if (distance <= _AlignmentDistance)
            {
                alignmentVelocitySum += targetVelocity;
                alignmentCount++;
            }

            // 結合: 近くのboidsの重心に近づく
            if (distance <= _CohesionDistance)
            {
                cohesionPositionSum += targetPosition;
                cohesionCount++;
            }
        }

        // グループ内のスレッドが全て到着してから次のグループへ進む
        GroupMemoryBarrierWithGroupSync();
    }

    // 平均を取り加える力を計算する
    float3 force = float3(0, 0, 0);
    if (separationCount > 0)
    {
        const float3 separationPosition = separationPositionSum / (float) separationCount;
        force += separationPosition * _SeparationCoefficient;
    }
    if (alignmentCount > 0)
    {
        const float3 alignmentVelocity = alignmentVelocitySum / (float) alignmentCount;
        force += alignmentVelocity * _AlignmentCoefficient;
    }
    if (cohesionCount > 0)
    {
        const float3 cohesionPosition = cohesionPositionSum / (float) cohesionCount;
        force += (cohesionPosition - inPosition) * _CohesionCoefficient;
    }

    // 最終的な結果を書き込み
    force = limit(force, _MaxSteerForce);
    _BoidForceBufferWrite[inIndex] = force;
}

[numthreads(SIMULATION_BLOCK_SIZE, 1, 1)]
void IntegrateCS(uint3 dtId : SV_DispatchThreadID)
{
    // 現在のデータを取得
    const unsigned int inIndex = dtId.x;
    BoidData inData = _BoidDataBufferWrite[inIndex];
    float3 force = _BoidForceBufferRead[inIndex];

    // 境界処理: 壁際に来たら反発力を加える
    float3 inPosition = inData.position;
    float3 wc = _SimulationAreaCenter.xyz;
    float3 ws = _SimulationAreaSize.xyz;
    float3 avoidance = float3(0, 0, 0);
    avoidance.x = (inPosition.x < wc.x - ws.x * 0.5) ? avoidance.x + 1.0 : avoidance.x;
    avoidance.x = (inPosition.x > wc.x + ws.x * 0.5) ? avoidance.x - 1.0 : avoidance.x;
    avoidance.y = (inPosition.y < wc.y - ws.y * 0.5) ? avoidance.y + 1.0 : avoidance.y;
    avoidance.y = (inPosition.y > wc.y + ws.y * 0.5) ? avoidance.y - 1.0 : avoidance.y;
    avoidance.z = (inPosition.z < wc.z - ws.z * 0.5) ? avoidance.z + 1.0 : avoidance.z;
    avoidance.z = (inPosition.z > wc.z + ws.z * 0.5) ? avoidance.z - 1.0 : avoidance.z;
    force += avoidance * _AvoidWallWeight;

    // 操舵力を速度に適用して位置を更新
    inData.velocity += force * _DeltaTime;
    inData.velocity = limit(inData.velocity, _MaxSpeed);
    inData.position += inData.velocity * _DeltaTime;

    // 計算結果を書き込む
    _BoidDataBufferWrite[inIndex] = inData;
}

        /// <summary>
        /// シミュレーション実行
        /// </summary>
        protected override void OnSimulation()
        {
            ComputeShader cs = _boidsCs;
            var csId = -1;

            // スレッドグループ数
            var threadGroupSize = Mathf.CeilToInt(MaxBoidsNum / SimulationBlockSize);

            // 操舵力の計算
            csId = cs.FindKernel("ForceCS");
            cs.SetInt("_MaxBoidNum", MaxBoidsNum);
            cs.SetFloat("_MaxSpeed", _maxSpeed);
            cs.SetFloat("_MaxSteerForce", _maxSteerForce);
            cs.SetFloat("_SeparationDistance", _separationDistance);
            cs.SetFloat("_AlignmentDistance", _alignmentDistance);
            cs.SetFloat("_CohesionDistance", _cohesionDistance);
            cs.SetFloat("_SeparationCoefficient", _separationCoefficient);
            cs.SetFloat("_AlignmentCoefficient", _alignmentCoefficient);
            cs.SetFloat("_CohesionCoefficient", _cohesionCoefficient);
            cs.SetVector("_SimulationAreaCenter", SimulationAreaCenter);
            cs.SetVector("_SimulationAreaSize", SimulationAreaSize);
            cs.SetFloat("_AvoidWallWeight", _avoidWallWeight);
            cs.SetBuffer(csId, "_BoidDataBufferRead", _boidsDataBuffer);
            cs.SetBuffer(csId, "_BoidForceBufferWrite", _boidsForceBuffer);
            cs.Dispatch(csId, threadGroupSize, 1, 1);

            // 速度と位置を計算
            csId = cs.FindKernel("IntegrateCS");
            cs.SetFloat("_DeltaTime", Time.deltaTime);
            cs.SetBuffer(csId, "_BoidDataBufferWrite", _boidsDataBuffer);
            cs.SetBuffer(csId, "_BoidForceBufferRead", _boidsForceBuffer);
            cs.Dispatch(csId, threadGroupSize, 1, 1);
        }

// Boidデータの構造体
struct BoidData
{
    float3 velocity; // 速度
    float3 position; // 位置
};

// スレッドグループのスレッドサイズ
#define SIMULATION_BLOCK_SIZE 256

// 構造体データのバッファ
StructuredBuffer<BoidData> _BoidDataBufferRead;
RWStructuredBuffer<BoidData> _BoidDataBufferWrite;

// 操舵力のバッファ
StructuredBuffer<float3> _BoidForceBufferRead;
RWStructuredBuffer<float3> _BoidForceBufferWrite;

// スクリプトから受け取るパラメータ郡
int _MaxBoidNum;  // Boid最大オブジェクト数
float _DeltaTime; // 前フレームから経過した時間

float _MaxSpeed;       // 速度の最大値
float _MaxSteerForce;  // 操舵する力の最大値

float _SeparationDistance; // 分離: 適用する他の個体との距離
float _AlignmentDistance;  // 整列: 適用する他の個体との距離
float _CohesionDistance;   // 結合: 適用する他の個体との距離

float _SeparationCoefficient; // 分離: 適用時の重み係数
float _AlignmentCoefficient;  // 整列: 適用時の重み係数
float _CohesionCoefficient;   // 結合: 適用時の重み係数

float4 _SimulationAreaCenter; // シミュレーション範囲の中心座標
float4 _SimulationAreaSize;   // シミュレーション範囲のサイズ
float _AvoidWallWeight;       // 壁を避ける強さの重み