/// <summary>
/// Decompresses buffer passed using LZF decompression algorithm.
/// </summary>
/// <param name="input">Input buffer to decompress.</param>
/// <param name="decompressedSize">Actual original decompressed size, if known. In case
/// size is not final, resizes output automatically.</param>
/// <returns>Decompressed buffer.</returns>
public static unsafe byte[] Decompress(NativeArray <byte> input, int decompressedSize = 0)
{
int inputCount = input.Length;
int outputCount = decompressedSize <= 0 ? input.Length << 1 : decompressedSize;
var output = new NativeArray <byte>(outputCount);
int finalCount = 0;
byte[] result = null;
try
{
finalCount = Decompress(input.GetPointer(), inputCount, output.GetPointer(), outputCount);
while (finalCount == 0)
{
output.Free();
outputCount <<= 1;
output = new NativeArray <byte>(outputCount);
finalCount = Decompress(input.GetPointer(), inputCount, output.GetPointer(), outputCount);
}
}
finally
{
result = new byte[finalCount];
if (finalCount > 0)
{
Marshal.Copy((IntPtr)output.GetPointer(), result, 0, finalCount);
}
output.Free();
}
return(result);
}
// Resolves the distance of the nearest obstacle and target and stores the cell index.
public void ExecuteFirst(int index)
{
var ptr = CellDatas.GetPointer(index);
var position = ptr->Separation / ptr->Count;
NearestPosition(ObstaclePositions, position, out var obstaclePositionIndex, out var obstacleDistance);
ptr->ObstaclePositionIndex = obstaclePositionIndex;
ptr->ObstacleDistance = obstacleDistance;
NearestPosition(TargetPositions, position, out var targetPositionIndex, out _);
ptr->TargetPositionIndex = targetPositionIndex;
ptr->Index = index;
}
public void Execute(ref Transform3D transform3D, ref BoidState boidState)
{
if (boidState.IsDied)
{
return;
}
var len = obstaclePositions.m_Length;
if (len == 0)
{
return;
}
var ptr = obstaclePositions.GetPointer(0);
for (int i = 0; i < len; ++i, ++ptr)
{
var dist = (transform3D.Position - ptr->Position).sqrMagnitude;
var sqrScale = ptr->Scale * ptr->Scale;
if (dist < MinSqrMagnitude * sqrScale)
{
boidState.IsDied = true;
boidState.IsScored = false;
boidState.SinkTimer = SinkTime;
boidState.Killer = obstacleIdxs[i];
}
}
}
public void Execute(int index, [ReadOnly] ref Transform3D transform3D, [ReadOnly] ref BoidTag Tag)
{
var ptr = CellAry.GetPointer(index);
ptr->Separation = transform3D.Position;
ptr->Alignment = transform3D.Forward;
ptr->Count = 1;
}
public void Execute(int index, [ReadOnly] ref LocalToWorld localToWorld)
{
var ptr = cellPtr0.GetPointer(index);
ptr->Separation = localToWorld.Position;
ptr->Alignment = localToWorld.Forward;
ptr->Count = 1;
}
// Resolves the distance of the nearest obstacle and target and stores the cell index.
public void ExecuteFirst(int index)
{
var ptr = cellDatas.GetPointer(index);
var position = ptr->Separation / ptr->Count;
int obstaclePositionIndex;
LFloat obstacleDistance;
NearestPosition(obstaclePositions, position, out obstaclePositionIndex, out obstacleDistance);
ptr->ObstaclePositionIndex = obstaclePositionIndex;
ptr->ObstacleDistance = obstacleDistance;
int targetPositionIndex;
LFloat targetDistance;
NearestPosition(targetPositions, position, out targetPositionIndex, out targetDistance);
ptr->TargetPositionIndex = targetPositionIndex;
ptr->Index = index;
}
public NativeEnumerable(NativeArray <TSource> array, long offset, long length)
{
if (array.IsCreated && length > 0)
{
if (offset >= 0)
{
this.Ptr = array.GetPointer() + offset;
this.Length = length;
}
else
{
this.Ptr = array.GetPointer();
this.Length = length + offset;
}
}
else
{
this.Ptr = null;
this.Length = 0;
}
}
public void Execute(int index, ref Transform3D transform3D, ref BoidState boidState)
{
if (boidState.IsDied)
{
return;
}
var forward = transform3D.Forward;
var currentPosition = transform3D.Position;
var cellIndex = CellDatas.GetPointer(index)->Index;
var ptr = CellDatas.GetPointer(cellIndex);
var neighborCount = ptr->Count;
var alignment = ptr->Alignment;
var separation = ptr->Separation;
var nearestObstacleDistance = ptr->ObstacleDistance;
var nearestObstaclePositionIndex = ptr->ObstaclePositionIndex;
var nearestTargetPositionIndex = ptr->TargetPositionIndex;
var nearestObstaclePosition = *(ObstaclePositions.GetPointer(nearestObstaclePositionIndex));
var nearestTargetPosition = *(TargetPositions.GetPointer(nearestTargetPositionIndex));
// steering calculations based on the boids algorithm
var obstacleSteering = currentPosition - nearestObstaclePosition;
var avoidObstacleHeading = (nearestObstaclePosition + math.normalizesafe(obstacleSteering)
* Settings.ObstacleAversionDistance) - currentPosition;
var targetHeading = Settings.TargetWeight
* math.normalizesafe(nearestTargetPosition - currentPosition);
var nearestObstacleDistanceFromRadius = nearestObstacleDistance - Settings.ObstacleAversionDistance;
var alignmentResult = Settings.AlignmentWeight
* math.normalizesafe((alignment / neighborCount) - forward);
var separationResult = Settings.SeparationWeight
* math.normalizesafe((currentPosition * neighborCount) - separation);
var normalHeading = math.normalizesafe(alignmentResult + separationResult + targetHeading);
var targetForward = math.select(normalHeading, avoidObstacleHeading,
nearestObstacleDistanceFromRadius < 0);
var nextHeading = math.normalizesafe(forward + DeltaTime * (targetForward - forward));
// updates based on the new heading
transform3D.Position = transform3D.Position + (nextHeading * (Settings.MoveSpeed * DeltaTime));
transform3D.Forward = nextHeading;
}
public NativeEnumerable(NativeArray <TSource> array)
{
if (array.IsCreated)
{
this.Ptr = array.GetPointer();
this.Length = array.Length;
}
else
{
this.Ptr = null;
this.Length = 0;
}
}
/// <summary>
/// Compresses buffer passed using LZF compression algorithm.
/// </summary>
/// <param name="input">Input buffer to compress.</param>
/// <returns>Compressed buffer.</returns>
public static unsafe byte[] Compress(byte[] input)
{
if (input == null || input.Length == 0)
return(new byte[0]);
fixed(byte *inputPtr = input)
{
int inputCount = input.Length;
int outputCount = input.Length << 1;
var output = new NativeArray <byte>(outputCount);
int finalCount = 0;
byte[] result = null;
try
{
finalCount = Compress(inputPtr, inputCount, output.GetPointer(), outputCount);
while (finalCount == 0)
{
output.Free();
outputCount <<= 1;
output = new NativeArray <byte>(outputCount);
finalCount = Compress(inputPtr, inputCount, output.GetPointer(), outputCount);
}
}
finally
{
result = new byte[finalCount];
if (finalCount > 0)
{
Marshal.Copy((IntPtr)output.GetPointer(), result, 0, finalCount);
}
output.Free();
}
return(result);
}
}
public NativeEnumerable(NativeArray <T> array)
{
if (array.IsCreated)
{
Ptr = array.GetPointer();
Length = array.Length;
}
else
{
Ptr = null;
Length = 0;
}
}
public void Execute()
{
{
var ptr = _CampAry.GetPointer(0);
var len = _CampAry.Length;
for (int i = 0, idx = 0; i < len; i++, ++ptr)
{
if (ptr->_entity._active)
{
Execute(ref ptr->Unit);
idx++;
}
}
}
{
var ptr = _PlayerAry.GetPointer(0);
var len = _PlayerAry.Length;
for (int i = 0, idx = 0; i < len; i++, ++ptr)
{
if (ptr->_entity._active)
{
Execute(ref ptr->Unit);
idx++;
}
}
}
{
var ptr = _EnemyAry.GetPointer(0);
var len = _EnemyAry.Length;
for (int i = 0, idx = 0; i < len; i++, ++ptr)
{
if (ptr->_entity._active)
{
Execute(ref ptr->Unit);
idx++;
}
}
}
{
var ptr = _BulletAry.GetPointer(0);
var len = _BulletAry.Length;
for (int i = 0, idx = 0; i < len; i++, ++ptr)
{
if (ptr->_entity._active)
{
Execute(ref ptr->Unit);
idx++;
}
}
}
}
public void Execute()
{
{
var ptr = _BoidAry.GetPointer(0);
var len = _BoidAry.Length;
for (int i = 0, idx = 0; i < len; i++, ++ptr)
{
if (ptr->_entity._active)
{
Execute(idx, ref ptr->LocalToWorld);
idx++;
}
}
}
}
public void Execute()
{
{
var ptr = _BoidAry.GetPointer(0);
var len = _BoidAry.Length;
for (int i = 0, idx = 0; i < len; i++, ++ptr)
{
if (ptr->_entity._active)
{
Execute(ref ptr->Transform, ref ptr->State);
idx++;
}
}
}
}
public void Execute(int index, ref LocalToWorld localToWorld)
{
var forward = localToWorld.Forward;
var currentPosition = localToWorld.Position;
var cellIndex = cellDatas.GetPointer(index)->Index;
var ptr = cellDatas.GetPointer(cellIndex);
var neighborCount = ptr->Count;
var alignment = ptr->Alignment;
var separation = ptr->Separation;
var nearestObstacleDistance = ptr->ObstacleDistance;
var nearestObstaclePositionIndex = ptr->ObstaclePositionIndex;
var nearestTargetPositionIndex = ptr->TargetPositionIndex;
var nearestObstaclePosition = *(obstaclePositions.GetPointer(nearestObstaclePositionIndex));
var nearestTargetPosition = *(targetPositions.GetPointer(nearestTargetPositionIndex));
// steering calculations based on the boids algorithm
var obstacleSteering = currentPosition - nearestObstaclePosition;
var avoidObstacleHeading = (nearestObstaclePosition + math.normalizesafe(obstacleSteering)
* settings.ObstacleAversionDistance) - currentPosition;
var targetHeading = settings.TargetWeight
* math.normalizesafe(nearestTargetPosition - currentPosition);
var nearestObstacleDistanceFromRadius = nearestObstacleDistance - settings.ObstacleAversionDistance;
var alignmentResult = settings.AlignmentWeight
* math.normalizesafe((alignment / neighborCount) - forward);
var separationResult = settings.SeparationWeight
* math.normalizesafe((currentPosition * neighborCount) - separation);
var normalHeading = math.normalizesafe(alignmentResult + separationResult + targetHeading);
var targetForward = math.select(normalHeading, avoidObstacleHeading,
nearestObstacleDistanceFromRadius < 0);
var nextHeading = math.normalizesafe(forward + DeltaTime * (targetForward - forward));
// updates based on the new heading
localToWorld.Position = localToWorld.Position + (nextHeading * (settings.MoveSpeed * DeltaTime));
localToWorld.Forward = nextHeading;
}
public static NativeEnumerable <T> Create(NativeArray <T> array, long offset, long length)
{
NativeEnumerable <T> answer = default;
if (array.IsCreated && length > 0)
{
if (offset >= 0)
{
answer.Ptr = array.GetPointer() + offset;
answer.Length = length;
}
else
{
answer.Ptr = array.GetPointer();
answer.Length = length + offset;
}
}
else
{
answer.Ptr = null;
answer.Length = 0;
}
return(answer);
}
public void Execute(Unity.Entities.Entity entity, int index,
ref Unity.Transforms.LocalToWorld localToWorld, ref EntityRef entityRef)
{
var ptr = allBoids.GetPointer(entityRef._index);
if (ptr->EntityRef == entityRef)
{
localToWorld = new Unity.Transforms.LocalToWorld {
Value = float4x4.TRS(
ptr->LocalToWorld.Position.ToVector3(),
quaternion.LookRotationSafe(ptr->LocalToWorld.Forward.ToVector3(), Unity.Mathematics.math.up()),
new Unity.Mathematics.float3(1.0f, 1.0f, 1.0f)
)
};
}
}
void NearestPosition(NativeArray <LVector3> targets, LVector3 position,
out int nearestPositionIndex, out LFloat nearestDistance)
{
nearestPositionIndex = 0;
var ptr = targets.GetPointer(0);
var len = targets.m_Length;
nearestDistance = math.lengthsq(position - *ptr);
++ptr;
for (int i = 1; i < len; i++, ++ptr)
{
var distance = math.lengthsq(position - *ptr);
var nearest = distance < nearestDistance;
nearestDistance = math.select(nearestDistance, distance, nearest);
nearestPositionIndex = math.select(nearestPositionIndex, new LFloat(i), nearest);
}
nearestDistance = LMath.Sqrt(nearestDistance);
}
public void Execute(Entity *entity, ref SpawnerData spawner, ref AssetData assetData)
{
var count = spawner.Count;
var center = spawner.Position;
var radius = spawner.Radius;
var spawnPositions = new NativeArray <LVector3>(count, Allocator.Temp,
NativeArrayOptions.UninitializedMemory);
GeneratePoints.RandomPointsInUnitCube(spawnPositions);
var pointPtr = spawnPositions.GetPointer(0);
var context = _context;
for (int i = 0; i < count; ++i, ++pointPtr)
{
var boidPtr = context.PostCmdCreateBoid();
boidPtr->LocalToWorld.Position = center + (*pointPtr * radius);
boidPtr->LocalToWorld.Forward = *pointPtr;
boidPtr->AssetData.AssetId = assetData.AssetId;
}
spawnPositions.Dispose();
context.PostCmdDestroyEntity(entity);
}
