The four behaviors of the Unreal Engine flocking algorithm

General Description of the Flocking Algorithm

• Cohesion: Fish search for their neighbors in a radius defined as the Radius of Cohesion. The current positions of all neighbors are summed. The result is divided by the number of neighbors. Thus, the center of mass of the neighbors is obtained. This is the point to which the fish strive for cohesion. To determine the direction of movement of the fish, the current position of the fish is subtracted from the result obtained earlier, and then the resulting vector is normalized.
• Separation: Fish search for their neighbors in a radius defined as the Separation Radius. To calculate the motion vector of an individual fish in a specific separation direction from a school, the difference in the positions of the neighbors and its own position is summed. The result is divided by the number of neighbors and then normalized and multiplied by -1 to change the initial direction of the fish to swim in the opposite direction of the neighbors.
• Alignment: Fish search for their neighbors in a radius defined as the Radius of Alignment. The current speeds of all neighbors are summed, then divided by the number of neighbors. The resulting vector is normalized.
• Reversal: All of the fish can only swim in a given space, the boundaries of which can be specified. The moment a fish crosses a boundary must be identified. If a fish hits a boundary, then the direction of the fish is changed to the opposite vector (thereby keeping the fish within the defined space).

Source Code of the Flocking Algorithm with Comments

     ParallelFor(cnt, [&agents, currentStatesIndex, 
previousStatesIndex, kCoh, kSep, kAlign, rCohesion, rSeparation, 
       rAlignment, maxAccel, maxVel, mapSz, DeltaTime, 
isSingleThread](int32 fishNum) {

 FVector cohesion(FVector::ZeroVector), separation(FVector::ZeroVector), alignment(FVector::ZeroVector);

 int32 cohesionCnt = 0, separationCnt = 0, alignmentCnt = 0;

  for (int i = 0; i < cnt; i++) {

  if (i != fishNum) {

 float distance = FVector::Distance(agents[i][previousStatesIndex].position, agents[fishNum][previousStatesIndex].position); 

 if (distance < rCohesion) {

 cohesion += agents[i][previousStatesIndex].position;

 cohesionCnt++;
     }

  if (distance < rSeparation) {

  separation += agents[i][previousStatesIndex].position - agents[fishNum][previousStatesIndex].position;

  separationCnt++;
     }

 if (distance < rAlignment) {

alignment += agents[i][previousStatesIndex].velocity;

 alignmentCnt++;
                      }
             }

  if (cohesionCnt != 0) {

 cohesion /= cohesionCnt;
     cohesion -= agents[fishNum][previousStatesIndex].position;

 cohesion.Normalize();
     }

  if (separationCnt != 0) {

 separation /= separationCnt;
            separation *= -1.f;

     separation.Normalize();
     }

if (alignmentCnt != 0) {

  alignment /= alignmentCnt;

    alignment.Normalize();
     }

agents[fishNum][currentStatesIndex].acceleration = (cohesion * kCoh + separation * kSep + alignment * kAlign).GetClampedToMaxSize(maxAccel);

  agents[fishNum][currentStatesIndex].acceleration.Z = 0;

 agents[fishNum][currentStatesIndex].velocity += agents[fishNum][currentStatesIndex].acceleration * DeltaTime;

agents[fishNum][currentStatesIndex].velocity =
                 agents[fishNum][currentStatesIndex].velocity.GetClampedToMaxSize(maxVel);

agents[fishNum][currentStatesIndex].position += agents[fishNum][currentStatesIndex].velocity * DeltaTime;

agents[fishNum][currentStatesIndex].velocity = checkMapRange(mapSz,
               agents[fishNum][currentStatesIndex].position, agents[fishNum][currentStatesIndex].velocity);
               }, isSingleThread);

  for (int i = 0; i < cnt; i++) {

 FHitResult hit(ForceInit);
            if (collisionDetected(agents[i][previousStatesIndex].position, agents[i][currentStatesIndex].position, hit)) {

   agents[i][currentStatesIndex].position -= agents[i]  [currentStatesIndex].velocity * DeltaTime;
                   agents[i][currentStatesIndex].velocity *= -1.0; 
                   agents[i][currentStatesIndex].position += agents[i][currentStatesIndex].velocity * DeltaTime;  
            }
     }

for (int i = 0; i < cnt; i++) {  
           FTransform transform; 
            m_instancedStaticMeshComponent->GetInstanceTransform(agents[i][0]->instanceId, transform);

transform.SetLocation(agents[i][0]->position);

FVector direction = agents[i][0].velocity; 
     direction.Normalize();
     transform.SetRotation(FRotationMatrix::MakeFromX(direction).Rotator().Add(0.f, -90.f, 0.f).Quaternion());

   m_instancedStaticMeshComponent->UpdateInstanceTransform(agents[i][0].instanceId, transform, false, false);
     }

m_instancedStaticMeshComponent->ReleasePerInstanceRenderData();
     m_instancedStaticMeshComponent->MarkRenderStateDirty();

  swapFishStatesIndexes();

Complexity of the Algorithm: How Increasing the Number of Fish Affects Productivity

Compute Shader with Comments

   struct TInfo{
              int instanceId;
              float3 position;
              float3 velocity;
              float3 acceleration;
     };

    float getDistance(float3 v1, float3 v2) {
              return sqrt((v2[0]-v1[0])*(v2[0]-v1[0]) + 
       (v2[1]-v1[1])*(v2[1]-v1[1]) + (v2[2]-v1[2])*(v2[2]-v1[2]));
     }
     RWStructuredBuffer data;
     [numthreads(1, 128, 1)]
     void VS_test(uint3 ThreadId : SV_DispatchThreadID)
     {

   int fishCount = constants.fishCount;

int calculationsPerThread = constants.calculationsPerThread;

for (int iteration = 0; iteration < calculationsPerThread; iteration++) {

   int currentThreadId = calculationsPerThread * ThreadId.y + iteration;

   if (currentThreadId >= fishCount)
            return;

 int currentId = fishCount + currentThreadId;

 TInfo currentState = data[currentThreadId + fishCount];

TInfo newState = data[currentThreadId];

 float3 steerCohesion = {0.0f, 0.0f, 0.0f};
     float3 steerSeparation = {0.0f, 0.0f, 0.0f};
     float3 steerAlignment = {0.0f, 0.0f, 0.0f};

   float steerCohesionCnt = 0.0f;
     float steerSeparationCnt = 0.0f;
     float steerAlignmentCnt = 0.0f;

  for (int i = fishCount; i < 2 * fishCount; i++) {

  if (i != currentId) {

  float d = getDistance(data[i].position, currentState.position);

  if (d < constants.radiusCohesion) {

  steerCohesion += data[i].position;

      steerCohesionCnt++;
     }

 if (d < constants.radiusSeparation) {

 steerSeparation += data[i].position - currentState.position;

     steerSeparationCnt++;
     }

if (d < constants.radiusAlignment) {

 steerAlignment += data[i].velocity;

    steerAlignmentCnt++;
                   }
            }
     }

  if (steerCohesionCnt != 0) {

steerCohesion = (steerCohesion / steerCohesionCnt - currentState.position);

     steerCohesion = normalize(steerCohesion);
     }

  if (steerSeparationCnt != 0) {

 steerSeparation = -1.f * (steerSeparation / steerSeparationCnt);

steerSeparation = normalize(steerSeparation);
     }

  if (steerAlignmentCnt != 0) {

 steerAlignment /= steerAlignmentCnt;

 steerAlignment = normalize(steerAlignment);
     }

    newState.acceleration = (steerCohesion * constants.kCohesion + steerSeparation * constants.kSeparation
            + steerAlignment * constants.kAlignment);
     newState.acceleration = clamp(newState.acceleration, -1.0f * constants.maxAcceleration,
            constants.maxAcceleration);

 newState.acceleration[2] = 0.0f;

   newState.velocity += newState.acceleration * variables.DeltaTime;
     newState.velocity = clamp(newState.velocity, -1.0f * constants.maxVelocity, constants.maxVelocity);

  newState.position += newState.velocity * variables.DeltaTime;

           float3 newVelocity = newState.velocity;
                   if (newState.position[0] > constants.mapRangeX || newState.position[0] < -constants.mapRangeX) {
                          newVelocity[0] *= -1.f;
                   }    
                   if (newState.position[1] > constants.mapRangeY || newState.position[1] < -constants.mapRangeY) {
                          newVelocity[1] *= -1.f;
                   }
                   if (newState.position[2] > constants.mapRangeZ || newState.position[2] < -3000.f) {
                          newVelocity[2] *= -1.f;
                   }
                   newState.velocity = newVelocity;
                   data[currentThreadId] = newState;
            }
     }        

EDITOR'S NOTE: