#pragma warning restore 649
#endif
public void Execute(ArchetypeChunk archetypeChunk, int chunkIndex, int firstEntityIndex)
{
var hybridChunkInfoArray = archetypeChunk.GetNativeArray(HybridChunkInfo);
var chunkHeaderArray = archetypeChunk.GetNativeArray(ChunkHeader);
for (var entityIndex = 0; entityIndex < archetypeChunk.Count; entityIndex++)
{
var hybridChunkInfo = hybridChunkInfoArray[entityIndex];
if (!hybridChunkInfo.Valid)
{
continue;
}
var chunkHeader = chunkHeaderArray[entityIndex];
#if UNITY_EDITOR
Stats[ThreadIndex].Stats[CullingStats.kLodTotal]++;
#endif
var internalBatchIndex = hybridChunkInfo.InternalIndex;
var chunkInstanceCount = chunkHeader.ArchetypeChunk.Count;
var isOrtho = LODParams.isOrtho;
ref var chunkCullingData = ref hybridChunkInfo.CullingData;
ChunkInstanceLodEnabled chunkEntityLodEnabled = chunkCullingData.InstanceLodEnableds;
#if UNITY_EDITOR
ChunkInstanceLodEnabled oldEntityLodEnabled = chunkEntityLodEnabled;
#endif
var forceLowLOD = ForceLowLOD[internalBatchIndex];
if (0 == (chunkCullingData.Flags & HybridChunkCullingData.kFlagHasLodData))
{
#if UNITY_EDITOR
Stats[ThreadIndex].Stats[CullingStats.kLodNoRequirements]++;
#endif
chunkEntityLodEnabled.Enabled[0] = 0;
chunkEntityLodEnabled.Enabled[1] = 0;
chunkCullingData.ForceLowLODPrevious = forceLowLOD;
for (int i = 0; i < chunkInstanceCount; ++i)
{
int wordIndex = i >> 6;
int bitIndex = i & 63;
chunkEntityLodEnabled.Enabled[wordIndex] |= 1ul << bitIndex;
}
}
else
{
int diff = (int)chunkCullingData.MovementGraceFixed16 - CameraMoveDistanceFixed16;
chunkCullingData.MovementGraceFixed16 = (ushort)math.max(0, diff);
var graceExpired = chunkCullingData.MovementGraceFixed16 == 0;
var forceLodChanged = forceLowLOD != chunkCullingData.ForceLowLODPrevious;
if (graceExpired || forceLodChanged || DistanceScaleChanged)
{
chunkEntityLodEnabled.Enabled[0] = 0;
chunkEntityLodEnabled.Enabled[1] = 0;
#if UNITY_EDITOR
Stats[ThreadIndex].Stats[CullingStats.kLodChunksTested]++;
#endif
var chunk = chunkHeader.ArchetypeChunk;
var rootLodRequirements = chunk.GetNativeArray(RootLodRequirements);
var instanceLodRequirements = chunk.GetNativeArray(InstanceLodRequirements);
float graceDistance = float.MaxValue;
for (int i = 0; i < chunkInstanceCount; i++)
{
var rootLodRequirement = rootLodRequirements[i];
var rootLodDistance =
math.select(
DistanceScale *
math.length(LODParams.cameraPos - rootLodRequirement.LOD.WorldReferencePosition),
DistanceScale, isOrtho);
float rootMinDist = math.select(rootLodRequirement.LOD.MinDist, 0.0f, forceLowLOD == 1);
float rootMaxDist = rootLodRequirement.LOD.MaxDist;
graceDistance = math.min(math.abs(rootLodDistance - rootMinDist), graceDistance);
graceDistance = math.min(math.abs(rootLodDistance - rootMaxDist), graceDistance);
var rootLodIntersect = (rootLodDistance < rootMaxDist) && (rootLodDistance >= rootMinDist);
if (rootLodIntersect)
{
var instanceLodRequirement = instanceLodRequirements[i];
var instanceDistance =
math.select(
DistanceScale *
math.length(LODParams.cameraPos -
instanceLodRequirement.WorldReferencePosition), DistanceScale,
isOrtho);
var instanceLodIntersect =
(instanceDistance < instanceLodRequirement.MaxDist) &&
(instanceDistance >= instanceLodRequirement.MinDist);
graceDistance = math.min(math.abs(instanceDistance - instanceLodRequirement.MinDist),
graceDistance);
graceDistance = math.min(math.abs(instanceDistance - instanceLodRequirement.MaxDist),
graceDistance);
if (instanceLodIntersect)
{
var index = i;
var wordIndex = index >> 6;
var bitIndex = index & 0x3f;
var lodWord = chunkEntityLodEnabled.Enabled[wordIndex];
lodWord |= 1UL << bitIndex;
chunkEntityLodEnabled.Enabled[wordIndex] = lodWord;
}
}
}
chunkCullingData.MovementGraceFixed16 = Fixed16CamDistance.FromFloatFloor(graceDistance);
chunkCullingData.ForceLowLODPrevious = forceLowLOD;
}
}
#if UNITY_EDITOR
if (oldEntityLodEnabled.Enabled[0] != chunkEntityLodEnabled.Enabled[0] ||
oldEntityLodEnabled.Enabled[1] != chunkEntityLodEnabled.Enabled[1])
{
Stats[ThreadIndex].Stats[CullingStats.kLodChanged]++;
}
#endif
chunkCullingData.InstanceLodEnableds = chunkEntityLodEnabled;
hybridChunkInfoArray[entityIndex] = hybridChunkInfo;
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
NativeArray <PhysicsCollider> chunkColliders = chunk.GetNativeArray(PhysicsColliderType);
NativeArray <LocalToWorld> chunkLocalToWorlds = chunk.GetNativeArray(LocalToWorldType);
// NativeArray<Translation> chunkPositions = chunk.GetNativeArray(PositionType);
// NativeArray<Rotation> chunkRotations = chunk.GetNativeArray(RotationType);
NativeArray <TransformPredictedState> chunkTransforms = chunk.GetNativeArray(TransformType);
NativeArray <Entity> chunkEntities = chunk.GetNativeArray(EntityType);
NativeArray <PhysicsCustomTags> chunkCustomTags = chunk.GetNativeArray(PhysicsCustomTagsType);
int instanceCount = chunk.Count;
int rbIndex = FirstBodyIndex + firstEntityIndex;
bool hasChunkPhysicsColliderType = chunk.Has(PhysicsColliderType);
bool hasChunkPhysicsCustomTagsType = chunk.Has(PhysicsCustomTagsType);
bool hasChunkParentType = chunk.Has(ParentType);
bool hasChunkLocalToWorldType = chunk.Has(LocalToWorldType);
// bool hasChunkPositionType = chunk.Has(PositionType);
// bool hasChunkRotationType = chunk.Has(RotationType);
bool hasChunkTransformType = chunk.Has(TransformType);
RigidTransform worldFromBody = RigidTransform.identity;
for (int i = 0; i < instanceCount; i++, rbIndex++)
{
// if entities are in a transform hierarchy then Translation/Rotation are in the space of their parents
// in that case, LocalToWorld is the only common denominator for world space
if (hasChunkParentType)
{
if (hasChunkLocalToWorldType)
{
var localToWorld = chunkLocalToWorlds[i];
worldFromBody = Math.DecomposeRigidBodyTransform(localToWorld.Value);
}
}
else
{
if (hasChunkTransformType)
{
worldFromBody.pos = chunkTransforms[i].Position;
}
else if (hasChunkLocalToWorldType)
{
worldFromBody.pos = chunkLocalToWorlds[i].Position;
}
if (hasChunkTransformType)
{
worldFromBody.rot = chunkTransforms[i].Rotation;
}
else if (hasChunkLocalToWorldType)
{
var localToWorld = chunkLocalToWorlds[i];
worldFromBody.rot = Math.DecomposeRigidBodyOrientation(localToWorld.Value);
}
}
RigidBodies[rbIndex] = new RigidBody
{
WorldFromBody = new RigidTransform(worldFromBody.rot, worldFromBody.pos),
Collider = hasChunkPhysicsColliderType ? chunkColliders[i].Value : default,
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
var deserializerState = new GhostDeserializerState
{
GhostMap = GhostMap
};
var ghostEntityArray = chunk.GetNativeArray(ghostEntityType);
var ghostSnapshotDataArray = chunk.GetBufferAccessor(ghostSnapshotDataType);
var predictedGhostComponentArray = chunk.GetNativeArray(predictedGhostComponentType);
var ghostRotationArray = chunk.GetNativeArray(ghostRotationType);
var ghostTranslationArray = chunk.GetNativeArray(ghostTranslationType);
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var minMaxOffset = ThreadIndex * (JobsUtility.CacheLineSize / 4);
#endif
for (int entityIndex = 0; entityIndex < ghostEntityArray.Length; ++entityIndex)
{
var snapshot = ghostSnapshotDataArray[entityIndex];
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var latestTick = snapshot.GetLatestTick();
if (latestTick != 0)
{
if (minMaxSnapshotTick[minMaxOffset] == 0 || SequenceHelpers.IsNewer(minMaxSnapshotTick[minMaxOffset], latestTick))
{
minMaxSnapshotTick[minMaxOffset] = latestTick;
}
if (minMaxSnapshotTick[minMaxOffset + 1] == 0 || SequenceHelpers.IsNewer(latestTick, minMaxSnapshotTick[minMaxOffset + 1]))
{
minMaxSnapshotTick[minMaxOffset + 1] = latestTick;
}
}
#endif
LagCubeSnapshotData snapshotData;
snapshot.GetDataAtTick(targetTick, out snapshotData);
var predictedData = predictedGhostComponentArray[entityIndex];
var lastPredictedTickInst = lastPredictedTick;
if (lastPredictedTickInst == 0 || predictedData.AppliedTick != snapshotData.Tick)
{
lastPredictedTickInst = snapshotData.Tick;
}
else if (!SequenceHelpers.IsNewer(lastPredictedTickInst, snapshotData.Tick))
{
lastPredictedTickInst = snapshotData.Tick;
}
if (minPredictedTick[ThreadIndex] == 0 || SequenceHelpers.IsNewer(minPredictedTick[ThreadIndex], lastPredictedTickInst))
{
minPredictedTick[ThreadIndex] = lastPredictedTickInst;
}
predictedGhostComponentArray[entityIndex] = new PredictedGhostComponent {
AppliedTick = snapshotData.Tick, PredictionStartTick = lastPredictedTickInst
};
if (lastPredictedTickInst != snapshotData.Tick)
{
continue;
}
var ghostRotation = ghostRotationArray[entityIndex];
var ghostTranslation = ghostTranslationArray[entityIndex];
ghostRotation.Value = snapshotData.GetRotationValue(deserializerState);
ghostTranslation.Value = snapshotData.GetTranslationValue(deserializerState);
ghostRotationArray[entityIndex] = ghostRotation;
ghostTranslationArray[entityIndex] = ghostTranslation;
}
}
public void CopyToSnapshot(ArchetypeChunk chunk, int ent, uint tick, ref Char_CapsuleSnapshotData snapshot, GhostSerializerState serializerState)
{
snapshot.tick = tick;
var chunkDataCharacterInterpolatedData = chunk.GetNativeArray(ghostCharacterInterpolatedDataType);
var chunkDataCharacterPredictedData = chunk.GetNativeArray(ghostCharacterPredictedDataType);
var chunkDataCharacterReplicatedData = chunk.GetNativeArray(ghostCharacterReplicatedDataType);
var chunkDataCharacterControllerGroundSupportData = chunk.GetNativeArray(ghostCharacterControllerGroundSupportDataType);
var chunkDataCharacterControllerMoveResult = chunk.GetNativeArray(ghostCharacterControllerMoveResultType);
var chunkDataCharacterControllerVelocity = chunk.GetNativeArray(ghostCharacterControllerVelocityType);
var chunkDataHealthStateData = chunk.GetNativeArray(ghostHealthStateDataType);
var chunkDataInventoryState = chunk.GetNativeArray(ghostInventoryStateType);
var chunkDataPlayerOwnerPlayerId = chunk.GetNativeArray(ghostPlayerOwnerPlayerIdType);
var chunkDataPlayerControlledState = chunk.GetNativeArray(ghostPlayerControlledStateType);
var chunkDataLinkedEntityGroup = chunk.GetBufferAccessor(ghostLinkedEntityGroupType);
snapshot.SetCharacterInterpolatedDataPosition(chunkDataCharacterInterpolatedData[ent].Position, serializerState);
snapshot.SetCharacterInterpolatedDatarotation(chunkDataCharacterInterpolatedData[ent].rotation, serializerState);
snapshot.SetCharacterInterpolatedDataaimYaw(chunkDataCharacterInterpolatedData[ent].aimYaw, serializerState);
snapshot.SetCharacterInterpolatedDataaimPitch(chunkDataCharacterInterpolatedData[ent].aimPitch, serializerState);
snapshot.SetCharacterInterpolatedDatamoveYaw(chunkDataCharacterInterpolatedData[ent].moveYaw, serializerState);
snapshot.SetCharacterInterpolatedDatacharAction(chunkDataCharacterInterpolatedData[ent].charAction, serializerState);
snapshot.SetCharacterInterpolatedDatacharActionTick(chunkDataCharacterInterpolatedData[ent].charActionTick, serializerState);
snapshot.SetCharacterInterpolatedDatadamageTick(chunkDataCharacterInterpolatedData[ent].damageTick, serializerState);
snapshot.SetCharacterInterpolatedDatadamageDirection(chunkDataCharacterInterpolatedData[ent].damageDirection, serializerState);
snapshot.SetCharacterInterpolatedDatasprinting(chunkDataCharacterInterpolatedData[ent].sprinting, serializerState);
snapshot.SetCharacterInterpolatedDatasprintWeight(chunkDataCharacterInterpolatedData[ent].sprintWeight, serializerState);
snapshot.SetCharacterInterpolatedDatacrouchWeight(chunkDataCharacterInterpolatedData[ent].crouchWeight, serializerState);
snapshot.SetCharacterInterpolatedDataselectorTargetSource(chunkDataCharacterInterpolatedData[ent].selectorTargetSource, serializerState);
snapshot.SetCharacterInterpolatedDatamoveAngleLocal(chunkDataCharacterInterpolatedData[ent].moveAngleLocal, serializerState);
snapshot.SetCharacterInterpolatedDatashootPoseWeight(chunkDataCharacterInterpolatedData[ent].shootPoseWeight, serializerState);
snapshot.SetCharacterInterpolatedDatalocomotionVector(chunkDataCharacterInterpolatedData[ent].locomotionVector, serializerState);
snapshot.SetCharacterInterpolatedDatalocomotionPhase(chunkDataCharacterInterpolatedData[ent].locomotionPhase, serializerState);
snapshot.SetCharacterInterpolatedDatabanking(chunkDataCharacterInterpolatedData[ent].banking, serializerState);
snapshot.SetCharacterInterpolatedDatalandAnticWeight(chunkDataCharacterInterpolatedData[ent].landAnticWeight, serializerState);
snapshot.SetCharacterInterpolatedDataturnStartAngle(chunkDataCharacterInterpolatedData[ent].turnStartAngle, serializerState);
snapshot.SetCharacterInterpolatedDataturnDirection(chunkDataCharacterInterpolatedData[ent].turnDirection, serializerState);
snapshot.SetCharacterInterpolatedDatasquashTime(chunkDataCharacterInterpolatedData[ent].squashTime, serializerState);
snapshot.SetCharacterInterpolatedDatasquashWeight(chunkDataCharacterInterpolatedData[ent].squashWeight, serializerState);
snapshot.SetCharacterInterpolatedDatainAirTime(chunkDataCharacterInterpolatedData[ent].inAirTime, serializerState);
snapshot.SetCharacterInterpolatedDatajumpTime(chunkDataCharacterInterpolatedData[ent].jumpTime, serializerState);
snapshot.SetCharacterInterpolatedDatasimpleTime(chunkDataCharacterInterpolatedData[ent].simpleTime, serializerState);
snapshot.SetCharacterInterpolatedDatafootIkOffset(chunkDataCharacterInterpolatedData[ent].footIkOffset, serializerState);
snapshot.SetCharacterInterpolatedDatafootIkNormalLeft(chunkDataCharacterInterpolatedData[ent].footIkNormalLeft, serializerState);
snapshot.SetCharacterInterpolatedDatafootIkNormalRight(chunkDataCharacterInterpolatedData[ent].footIkNormalRight, serializerState);
snapshot.SetCharacterInterpolatedDatafootIkWeight(chunkDataCharacterInterpolatedData[ent].footIkWeight, serializerState);
snapshot.SetCharacterInterpolatedDatablendOutAim(chunkDataCharacterInterpolatedData[ent].blendOutAim, serializerState);
snapshot.SetCharacterPredictedDatatick(chunkDataCharacterPredictedData[ent].tick, serializerState);
snapshot.SetCharacterPredictedDataposition(chunkDataCharacterPredictedData[ent].position, serializerState);
snapshot.SetCharacterPredictedDatavelocity(chunkDataCharacterPredictedData[ent].velocity, serializerState);
snapshot.SetCharacterPredictedDatasprinting(chunkDataCharacterPredictedData[ent].sprinting, serializerState);
snapshot.SetCharacterPredictedDatacameraProfile(chunkDataCharacterPredictedData[ent].cameraProfile, serializerState);
snapshot.SetCharacterPredictedDatadamageTick(chunkDataCharacterPredictedData[ent].damageTick, serializerState);
snapshot.SetCharacterPredictedDatadamageDirection(chunkDataCharacterPredictedData[ent].damageDirection, serializerState);
snapshot.SetCharacterReplicatedDataheroTypeIndex(chunkDataCharacterReplicatedData[ent].heroTypeIndex, serializerState);
snapshot.SetCharacterControllerGroundSupportDataSurfaceNormal(chunkDataCharacterControllerGroundSupportData[ent].SurfaceNormal, serializerState);
snapshot.SetCharacterControllerGroundSupportDataSurfaceVelocity(chunkDataCharacterControllerGroundSupportData[ent].SurfaceVelocity, serializerState);
snapshot.SetCharacterControllerGroundSupportDataSupportedState(chunkDataCharacterControllerGroundSupportData[ent].SupportedState, serializerState);
snapshot.SetCharacterControllerMoveResultMoveResult(chunkDataCharacterControllerMoveResult[ent].MoveResult, serializerState);
snapshot.SetCharacterControllerVelocityVelocity(chunkDataCharacterControllerVelocity[ent].Velocity, serializerState);
snapshot.SetHealthStateDatahealth(chunkDataHealthStateData[ent].health, serializerState);
snapshot.SetInventoryStateactiveSlot(chunkDataInventoryState[ent].activeSlot, serializerState);
snapshot.SetPlayerOwnerPlayerIdValue(chunkDataPlayerOwnerPlayerId[ent].Value, serializerState);
snapshot.SetPlayerControlledStateresetCommandTick(chunkDataPlayerControlledState[ent].resetCommandTick, serializerState);
snapshot.SetPlayerControlledStateresetCommandLookYaw(chunkDataPlayerControlledState[ent].resetCommandLookYaw, serializerState);
snapshot.SetPlayerControlledStateresetCommandLookPitch(chunkDataPlayerControlledState[ent].resetCommandLookPitch, serializerState);
snapshot.SetChild0AbilityAbilityControlbehaviorState(ghostChild0AbilityAbilityControlType[chunkDataLinkedEntityGroup[ent][1].Value].behaviorState, serializerState);
snapshot.SetChild0AbilityAbilityControlrequestDeactivate(ghostChild0AbilityAbilityControlType[chunkDataLinkedEntityGroup[ent][1].Value].requestDeactivate, serializerState);
snapshot.SetChild0AbilityMovementInterpolatedStatecharLocoState(ghostChild0AbilityMovementInterpolatedStateType[chunkDataLinkedEntityGroup[ent][1].Value].charLocoState, serializerState);
snapshot.SetChild0AbilityMovementInterpolatedStatecharLocoTick(ghostChild0AbilityMovementInterpolatedStateType[chunkDataLinkedEntityGroup[ent][1].Value].charLocoTick, serializerState);
snapshot.SetChild0AbilityMovementInterpolatedStatecrouching(ghostChild0AbilityMovementInterpolatedStateType[chunkDataLinkedEntityGroup[ent][1].Value].crouching, serializerState);
snapshot.SetChild0AbilityMovementPredictedStatelocoState(ghostChild0AbilityMovementPredictedStateType[chunkDataLinkedEntityGroup[ent][1].Value].locoState, serializerState);
snapshot.SetChild0AbilityMovementPredictedStatelocoStartTick(ghostChild0AbilityMovementPredictedStateType[chunkDataLinkedEntityGroup[ent][1].Value].locoStartTick, serializerState);
snapshot.SetChild0AbilityMovementPredictedStatejumpCount(ghostChild0AbilityMovementPredictedStateType[chunkDataLinkedEntityGroup[ent][1].Value].jumpCount, serializerState);
snapshot.SetChild0AbilityMovementPredictedStatecrouching(ghostChild0AbilityMovementPredictedStateType[chunkDataLinkedEntityGroup[ent][1].Value].crouching, serializerState);
snapshot.SetChild1AbilityAbilityControlbehaviorState(ghostChild1AbilityAbilityControlType[chunkDataLinkedEntityGroup[ent][2].Value].behaviorState, serializerState);
snapshot.SetChild1AbilityAbilityControlrequestDeactivate(ghostChild1AbilityAbilityControlType[chunkDataLinkedEntityGroup[ent][2].Value].requestDeactivate, serializerState);
snapshot.SetChild2AbilityAbilityControlbehaviorState(ghostChild2AbilityAbilityControlType[chunkDataLinkedEntityGroup[ent][3].Value].behaviorState, serializerState);
snapshot.SetChild2AbilityAbilityControlrequestDeactivate(ghostChild2AbilityAbilityControlType[chunkDataLinkedEntityGroup[ent][3].Value].requestDeactivate, serializerState);
snapshot.SetChild2AbilityDashPredictedStatelocoState(ghostChild2AbilityDashPredictedStateType[chunkDataLinkedEntityGroup[ent][3].Value].locoState, serializerState);
snapshot.SetChild2AbilityDashPredictedStatelocoStartTick(ghostChild2AbilityDashPredictedStateType[chunkDataLinkedEntityGroup[ent][3].Value].locoStartTick, serializerState);
snapshot.SetChild2AbilityDashPredictedStatestartVelocity(ghostChild2AbilityDashPredictedStateType[chunkDataLinkedEntityGroup[ent][3].Value].startVelocity, serializerState);
snapshot.SetChild3AbilityAbilityControlbehaviorState(ghostChild3AbilityAbilityControlType[chunkDataLinkedEntityGroup[ent][4].Value].behaviorState, serializerState);
snapshot.SetChild3AbilityAbilityControlrequestDeactivate(ghostChild3AbilityAbilityControlType[chunkDataLinkedEntityGroup[ent][4].Value].requestDeactivate, serializerState);
snapshot.SetChild3AbilityClimbPredictedStatelocoState(ghostChild3AbilityClimbPredictedStateType[chunkDataLinkedEntityGroup[ent][4].Value].locoState, serializerState);
snapshot.SetChild3AbilityClimbPredictedStateSurfaceNormal(ghostChild3AbilityClimbPredictedStateType[chunkDataLinkedEntityGroup[ent][4].Value].SurfaceNormal, serializerState);
snapshot.SetChild3AbilityClimbPredictedStateSurfaceVelocity(ghostChild3AbilityClimbPredictedStateType[chunkDataLinkedEntityGroup[ent][4].Value].SurfaceVelocity, serializerState);
snapshot.SetChild3AbilityClimbPredictedStateSupportedState(ghostChild3AbilityClimbPredictedStateType[chunkDataLinkedEntityGroup[ent][4].Value].SupportedState, serializerState);
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
var shipPos = chunk.GetNativeArray(positionType);
var shipSphere = chunk.GetNativeArray(sphereType);
var shipPlayerId = chunk.GetNativeArray(playerIdType);
var shipEntity = chunk.GetNativeArray(entityType);
for (int ship = 0; ship < shipPos.Length; ++ship)
{
int alive = 1;
var firstPos = shipPos[ship].Value.xy;
var firstRadius = shipSphere[ship].radius;
if (firstPos.x - firstRadius < 0 || firstPos.y - firstRadius < 0 ||
firstPos.x + firstRadius > level[0].width ||
firstPos.y + firstRadius > level[0].height)
{
if (shipPlayerId.IsCreated)
{
playerClearQueue.Enqueue(shipPlayerId[ship].PlayerEntity);
}
commandBuffer.DestroyEntity(chunkIndex, shipEntity[ship]);
continue;
}
if (serverSettings.Length > 0 && serverSettings[0].damageShips == 0)
{
continue;
}
/*for (int bc = 0; bc < bulletChunks.Length && alive != 0; ++bc)
* {
* var bulletAge = bulletChunks[bc].GetNativeArray(bulletAgeType);
* var bulletPos = bulletChunks[bc].GetNativeArray(positionType);
* var bulletSphere = bulletChunks[bc].GetNativeArray(sphereType);
* for (int bullet = 0; bullet < bulletAge.Length; ++bullet)
* {
* if (bulletAge[bullet].age > bulletAge[bullet].maxAge)
* continue;
* var secondPos = bulletPos[bullet].Value.xy;
* var secondRadius = bulletSphere[bullet].radius;
* if (Intersect(firstRadius, secondRadius, firstPos, secondPos))
* {
* if (shipPlayerId.IsCreated)
* playerClearQueue.Enqueue(shipPlayerId[ship].PlayerEntity);
* commandBuffer.DestroyEntity(chunkIndex, shipEntity[ship]);
* alive = 0;
* break;
* }
* }
* }*/
for (int ac = 0; ac < asteroidChunks.Length && alive != 0; ++ac)
{
var asteroidPos = asteroidChunks[ac].GetNativeArray(positionType);
var asteroidSphere = asteroidChunks[ac].GetNativeArray(sphereType);
for (int asteroid = 0; asteroid < asteroidPos.Length; ++asteroid)
{
var secondPos = asteroidPos[asteroid].Value.xy;
var secondRadius = asteroidSphere[asteroid].radius;
if (Intersect(firstRadius, secondRadius, firstPos, secondPos))
{
if (shipPlayerId.IsCreated)
{
playerClearQueue.Enqueue(shipPlayerId[ship].PlayerEntity);
}
commandBuffer.DestroyEntity(chunkIndex, shipEntity[ship]);
alive = 0;
break;
}
}
}
}
}
public int CalculateImportance(ArchetypeChunk chunk)
{
return(__GHOST_IMPORTANCE__);
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
var chunkInfo = chunk.GetChunkComponentData(HybridChunkInfo);
if (!chunkInfo.Valid)
{
return;
}
var occlusionTestArray = chunk.GetNativeArray(OcclusionTest);
var chunkData = chunkInfo.CullingData;
int internalBatchIndex = chunkInfo.InternalIndex;
int externalBatchIndex = InternalToExternalRemappingTable[internalBatchIndex];
var batch = Batches[externalBatchIndex];
int batchOutputOffset = chunkData.StartIndex;
int batchOutputCount = 0;
var indices = (int *)IndexList.GetUnsafeReadOnlyPtr() + chunkData.StartIndex;
void *mocNative = (void *)mocNativePtrArray[mocNativeIndexToUse];
for (var entityIndex = 0; entityIndex < chunkData.Visible; entityIndex++)
{
// TODO: we could reuse the HLOD logic from the frustum culling code here, but
// this would require some supporting structures and components. For now, we just
// test what was written into the index list.
var index = indices[entityIndex] - chunkData.BatchOffset;
var test = occlusionTestArray[index];
if (!test.enabled)
{
batchOutputCount++;
continue;
}
INTEL_MOC.CullingResult cullingResult = INTEL_MOC.CullingResult.VISIBLE;
cullingResult = INTEL_MOC.MOCNative.TestRect(
mocNative,
test.screenMin.x, test.screenMin.y,
test.screenMax.x, test.screenMax.y, test.screenMin.w);
bool visible = (cullingResult == INTEL_MOC.CullingResult.VISIBLE);
#if UNITY_EDITOR
visible = (visible != displayOccluded);
#endif
int advance = visible ? 1 : 0;
#if UNITY_EDITOR
ref var stats = ref Stats[ThreadIndex];
stats.Stats[CullingStats.kCountOcclusionCulled] += (1 - advance);
stats.Stats[CullingStats.kCountOcclusionInput]++;
#endif
if (!visible)
{
indices[entityIndex] = -1;
}
batchOutputCount += advance;
}
public unsafe void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
NativeArray <PhysicsJoint> chunkJoint = chunk.GetNativeArray(JointComponentType);
NativeArray <Entity> chunkEntities = chunk.GetNativeArray(EntityType);
int instanceCount = chunk.Count;
for (int i = 0; i < instanceCount; i++)
{
PhysicsJoint joint = chunkJoint[i];
Assert.IsTrue(joint.EntityA != joint.EntityB);
// TODO find a reasonable way to look up the constraint body indices
// - stash body index in a component on the entity? But we don't have random access to Entity data in a job
// - make a map from entity to rigid body index? Sounds bad and I don't think there is any NativeArray-based map data structure yet
// If one of the entities is null, use the default static entity
var pair = new BodyIndexPair
{
BodyAIndex = joint.EntityA == Entity.Null ? DefaultStaticBodyIndex : -1,
BodyBIndex = joint.EntityB == Entity.Null ? DefaultStaticBodyIndex : -1
};
// Find the body indices
for (int bodyIndex = 0; bodyIndex < RigidBodies.Length; bodyIndex++)
{
if (joint.EntityA != Entity.Null)
{
if (RigidBodies[bodyIndex].Entity == joint.EntityA)
{
pair.BodyAIndex = bodyIndex;
if (pair.BodyBIndex >= 0)
{
break;
}
}
}
if (joint.EntityB != Entity.Null)
{
if (RigidBodies[bodyIndex].Entity == joint.EntityB)
{
pair.BodyBIndex = bodyIndex;
if (pair.BodyAIndex >= 0)
{
break;
}
}
}
}
Assert.IsTrue(pair.BodyAIndex != -1 && pair.BodyBIndex != -1);
bool isStaticStaticPair = pair.BodyAIndex >= NumDynamicBodies && pair.BodyBIndex >= NumDynamicBodies;
// Mark static-static constrains as invalid since they are not going to affect simulation in any way.
if (isStaticStaticPair)
{
pair = BodyIndexPair.Invalid;
}
Joints[firstEntityIndex + i] = new Joint
{
JointData = (JointData *)joint.JointData.GetUnsafePtr(),
BodyPair = pair,
Entity = chunkEntities[i],
EnableCollision = joint.EnableCollision,
};
}
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
//Writeable.
NativeArray <PathFinding> pathfindingArray = chunk.GetNativeArray(pathFindingComponentHandle);
BufferAccessor <PathNode> pathNodeBufferAccessor = chunk.GetBufferAccessor(pathNodeBufferHandle);
//Read Only.
NativeArray <CurrentTarget> currentTargetArray = chunk.GetNativeArray(currentTargetComponentHandle);
NativeArray <Translation> translationArray = chunk.GetNativeArray(translationComponentHandle);
NativeArray <Entity> entities = chunk.GetNativeArray(entityType);
//Create a copy of the grid for this thread and chunk.
NativeArray2D <MapNode> gridCopy = new NativeArray2D <MapNode>(gridRef.Length0, gridRef.Length1, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
UnsafeUtility.MemCpy(gridCopy.GetUnsafePtr(), gridRef.GetUnsafePtrReadOnly(), gridRef.Length * sizeof(MapNode));
for (int indexInChunk = 0; indexInChunk < chunk.Count; ++indexInChunk)
{
//Writable.
PathFinding pathfinding = pathfindingArray[indexInChunk];
DynamicBuffer <PathNode> path = pathNodeBufferAccessor[indexInChunk];
//Read Only.
Entity entity = entities[indexInChunk];
CurrentTarget currentTarget = currentTargetArray[indexInChunk];
Translation translation = translationArray[indexInChunk];
bool hasPath = chunk.Has(hasPathComponentHandle);
if (!pathfinding.requestedPath)
{
//We only want to remove our has path component if we didn't request a new one, to avoid re-adding later in the job if we find a new path.
if (pathfinding.completedPath)
{
pathfinding.completedPath = false;
ecb.RemoveComponent <HasPathTag>(chunkIndex, entity);
pathfindingArray[indexInChunk] = pathfinding;
}
continue;
}
path.Clear();
pathfinding.currentIndexOnPath = 0;
pathfinding.completedPath = false;
pathfinding.requestedPath = false;
//Calculate the closest nodes to us and our target position.
//Don't search for path if we're already at our target node.
pathfinding.currentNode = FindNearestNode(translation.Value, gridCopy);
pathfinding.targetNode = FindNearestNode(currentTarget.targetData.targetPos, gridCopy);
if (pathfinding.targetNode.Equals(pathfinding.currentNode))
{
pathfindingArray[indexInChunk] = pathfinding;
continue;
}
CalculateGridH(gridCopy, ref pathfinding);
bool pathfound = SearchForPath(pathfinding.currentNode, pathfinding.targetNode, gridCopy);
if (pathfound)
{
ConstructPath(gridCopy, ref pathfinding, ref path);
if (!hasPath)
{
ecb.AddComponent <HasPathTag>(chunkIndex, entity);
}
}
else if (hasPath)
{
ecb.RemoveComponent <HasPathTag>(chunkIndex, entity);
}
pathfindingArray[indexInChunk] = pathfinding;
}
gridCopy.Dispose();
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
var deserializerState = new GhostDeserializerState
{
GhostMap = GhostMap
};
var ghostEntityArray = chunk.GetNativeArray(ghostEntityType);
var ghostSnapshotDataArray = chunk.GetBufferAccessor(ghostSnapshotDataType);
var ghostCharacterInterpolatedDataArray = chunk.GetNativeArray(ghostCharacterInterpolatedDataType);
var ghostCharacterReplicatedDataArray = chunk.GetNativeArray(ghostCharacterReplicatedDataType);
var ghostCharacterControllerGroundSupportDataArray = chunk.GetNativeArray(ghostCharacterControllerGroundSupportDataType);
var ghostCharacterControllerMoveResultArray = chunk.GetNativeArray(ghostCharacterControllerMoveResultType);
var ghostCharacterControllerVelocityArray = chunk.GetNativeArray(ghostCharacterControllerVelocityType);
var ghostHealthStateDataArray = chunk.GetNativeArray(ghostHealthStateDataType);
var ghostInventoryStateArray = chunk.GetNativeArray(ghostInventoryStateType);
var ghostPlayerOwnerPlayerIdArray = chunk.GetNativeArray(ghostPlayerOwnerPlayerIdType);
var ghostPlayerControlledStateArray = chunk.GetNativeArray(ghostPlayerControlledStateType);
var ghostLinkedEntityGroupArray = chunk.GetBufferAccessor(ghostLinkedEntityGroupType);
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var minMaxOffset = ThreadIndex * (JobsUtility.CacheLineSize / 4);
#endif
for (int entityIndex = 0; entityIndex < ghostEntityArray.Length; ++entityIndex)
{
var snapshot = ghostSnapshotDataArray[entityIndex];
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var latestTick = snapshot.GetLatestTick();
if (latestTick != 0)
{
if (minMaxSnapshotTick[minMaxOffset] == 0 || SequenceHelpers.IsNewer(minMaxSnapshotTick[minMaxOffset], latestTick))
{
minMaxSnapshotTick[minMaxOffset] = latestTick;
}
if (minMaxSnapshotTick[minMaxOffset + 1] == 0 || SequenceHelpers.IsNewer(latestTick, minMaxSnapshotTick[minMaxOffset + 1]))
{
minMaxSnapshotTick[minMaxOffset + 1] = latestTick;
}
}
#endif
Char_BanditSnapshotData snapshotData;
snapshot.GetDataAtTick(targetTick, targetTickFraction, out snapshotData);
var ghostCharacterInterpolatedData = ghostCharacterInterpolatedDataArray[entityIndex];
var ghostCharacterReplicatedData = ghostCharacterReplicatedDataArray[entityIndex];
var ghostCharacterControllerGroundSupportData = ghostCharacterControllerGroundSupportDataArray[entityIndex];
var ghostCharacterControllerMoveResult = ghostCharacterControllerMoveResultArray[entityIndex];
var ghostCharacterControllerVelocity = ghostCharacterControllerVelocityArray[entityIndex];
var ghostHealthStateData = ghostHealthStateDataArray[entityIndex];
var ghostInventoryState = ghostInventoryStateArray[entityIndex];
var ghostPlayerOwnerPlayerId = ghostPlayerOwnerPlayerIdArray[entityIndex];
var ghostPlayerControlledState = ghostPlayerControlledStateArray[entityIndex];
var ghostChild0AbilityAbilityControl = ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value];
var ghostChild0AbilityMovementInterpolatedState = ghostAbilityMovementInterpolatedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value];
var ghostChild0AbilityMovementPredictedState = ghostAbilityMovementPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value];
var ghostChild1AbilityAbilityControl = ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][2].Value];
var ghostChild2AbilityAbilityControl = ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][3].Value];
var ghostChild2AbilityDashPredictedState = ghostAbilityDashPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][3].Value];
var ghostChild3AbilityAbilityControl = ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][4].Value];
var ghostChild3AbilityClimbPredictedState = ghostAbilityClimbPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][4].Value];
ghostCharacterInterpolatedData.Position = snapshotData.GetCharacterInterpolatedDataPosition(deserializerState);
ghostCharacterInterpolatedData.rotation = snapshotData.GetCharacterInterpolatedDatarotation(deserializerState);
ghostCharacterInterpolatedData.aimYaw = snapshotData.GetCharacterInterpolatedDataaimYaw(deserializerState);
ghostCharacterInterpolatedData.aimPitch = snapshotData.GetCharacterInterpolatedDataaimPitch(deserializerState);
ghostCharacterInterpolatedData.moveYaw = snapshotData.GetCharacterInterpolatedDatamoveYaw(deserializerState);
ghostCharacterInterpolatedData.charAction = snapshotData.GetCharacterInterpolatedDatacharAction(deserializerState);
ghostCharacterInterpolatedData.charActionTick = snapshotData.GetCharacterInterpolatedDatacharActionTick(deserializerState);
ghostCharacterInterpolatedData.damageTick = snapshotData.GetCharacterInterpolatedDatadamageTick(deserializerState);
ghostCharacterInterpolatedData.damageDirection = snapshotData.GetCharacterInterpolatedDatadamageDirection(deserializerState);
ghostCharacterInterpolatedData.sprinting = snapshotData.GetCharacterInterpolatedDatasprinting(deserializerState);
ghostCharacterInterpolatedData.sprintWeight = snapshotData.GetCharacterInterpolatedDatasprintWeight(deserializerState);
ghostCharacterInterpolatedData.crouchWeight = snapshotData.GetCharacterInterpolatedDatacrouchWeight(deserializerState);
ghostCharacterInterpolatedData.selectorTargetSource = snapshotData.GetCharacterInterpolatedDataselectorTargetSource(deserializerState);
ghostCharacterInterpolatedData.moveAngleLocal = snapshotData.GetCharacterInterpolatedDatamoveAngleLocal(deserializerState);
ghostCharacterInterpolatedData.shootPoseWeight = snapshotData.GetCharacterInterpolatedDatashootPoseWeight(deserializerState);
ghostCharacterInterpolatedData.locomotionVector = snapshotData.GetCharacterInterpolatedDatalocomotionVector(deserializerState);
ghostCharacterInterpolatedData.locomotionPhase = snapshotData.GetCharacterInterpolatedDatalocomotionPhase(deserializerState);
ghostCharacterInterpolatedData.banking = snapshotData.GetCharacterInterpolatedDatabanking(deserializerState);
ghostCharacterInterpolatedData.landAnticWeight = snapshotData.GetCharacterInterpolatedDatalandAnticWeight(deserializerState);
ghostCharacterInterpolatedData.turnStartAngle = snapshotData.GetCharacterInterpolatedDataturnStartAngle(deserializerState);
ghostCharacterInterpolatedData.turnDirection = snapshotData.GetCharacterInterpolatedDataturnDirection(deserializerState);
ghostCharacterInterpolatedData.squashTime = snapshotData.GetCharacterInterpolatedDatasquashTime(deserializerState);
ghostCharacterInterpolatedData.squashWeight = snapshotData.GetCharacterInterpolatedDatasquashWeight(deserializerState);
ghostCharacterInterpolatedData.inAirTime = snapshotData.GetCharacterInterpolatedDatainAirTime(deserializerState);
ghostCharacterInterpolatedData.jumpTime = snapshotData.GetCharacterInterpolatedDatajumpTime(deserializerState);
ghostCharacterInterpolatedData.simpleTime = snapshotData.GetCharacterInterpolatedDatasimpleTime(deserializerState);
ghostCharacterInterpolatedData.footIkOffset = snapshotData.GetCharacterInterpolatedDatafootIkOffset(deserializerState);
ghostCharacterInterpolatedData.footIkNormalLeft = snapshotData.GetCharacterInterpolatedDatafootIkNormalLeft(deserializerState);
ghostCharacterInterpolatedData.footIkNormalRight = snapshotData.GetCharacterInterpolatedDatafootIkNormalRight(deserializerState);
ghostCharacterInterpolatedData.footIkWeight = snapshotData.GetCharacterInterpolatedDatafootIkWeight(deserializerState);
ghostCharacterInterpolatedData.blendOutAim = snapshotData.GetCharacterInterpolatedDatablendOutAim(deserializerState);
ghostCharacterReplicatedData.heroTypeIndex = snapshotData.GetCharacterReplicatedDataheroTypeIndex(deserializerState);
ghostCharacterControllerGroundSupportData.SurfaceNormal = snapshotData.GetCharacterControllerGroundSupportDataSurfaceNormal(deserializerState);
ghostCharacterControllerGroundSupportData.SurfaceVelocity = snapshotData.GetCharacterControllerGroundSupportDataSurfaceVelocity(deserializerState);
ghostCharacterControllerGroundSupportData.SupportedState = snapshotData.GetCharacterControllerGroundSupportDataSupportedState(deserializerState);
ghostCharacterControllerMoveResult.MoveResult = snapshotData.GetCharacterControllerMoveResultMoveResult(deserializerState);
ghostCharacterControllerVelocity.Velocity = snapshotData.GetCharacterControllerVelocityVelocity(deserializerState);
ghostHealthStateData.health = snapshotData.GetHealthStateDatahealth(deserializerState);
ghostInventoryState.activeSlot = snapshotData.GetInventoryStateactiveSlot(deserializerState);
ghostPlayerOwnerPlayerId.Value = snapshotData.GetPlayerOwnerPlayerIdValue(deserializerState);
ghostPlayerControlledState.resetCommandTick = snapshotData.GetPlayerControlledStateresetCommandTick(deserializerState);
ghostPlayerControlledState.resetCommandLookYaw = snapshotData.GetPlayerControlledStateresetCommandLookYaw(deserializerState);
ghostPlayerControlledState.resetCommandLookPitch = snapshotData.GetPlayerControlledStateresetCommandLookPitch(deserializerState);
ghostChild0AbilityAbilityControl.behaviorState = snapshotData.GetChild0AbilityAbilityControlbehaviorState(deserializerState);
ghostChild0AbilityAbilityControl.requestDeactivate = snapshotData.GetChild0AbilityAbilityControlrequestDeactivate(deserializerState);
ghostChild0AbilityMovementInterpolatedState.charLocoState = snapshotData.GetChild0AbilityMovementInterpolatedStatecharLocoState(deserializerState);
ghostChild0AbilityMovementInterpolatedState.charLocoTick = snapshotData.GetChild0AbilityMovementInterpolatedStatecharLocoTick(deserializerState);
ghostChild0AbilityMovementInterpolatedState.crouching = snapshotData.GetChild0AbilityMovementInterpolatedStatecrouching(deserializerState);
ghostChild0AbilityMovementPredictedState.locoState = snapshotData.GetChild0AbilityMovementPredictedStatelocoState(deserializerState);
ghostChild0AbilityMovementPredictedState.locoStartTick = snapshotData.GetChild0AbilityMovementPredictedStatelocoStartTick(deserializerState);
ghostChild0AbilityMovementPredictedState.jumpCount = snapshotData.GetChild0AbilityMovementPredictedStatejumpCount(deserializerState);
ghostChild0AbilityMovementPredictedState.crouching = snapshotData.GetChild0AbilityMovementPredictedStatecrouching(deserializerState);
ghostChild1AbilityAbilityControl.behaviorState = snapshotData.GetChild1AbilityAbilityControlbehaviorState(deserializerState);
ghostChild1AbilityAbilityControl.requestDeactivate = snapshotData.GetChild1AbilityAbilityControlrequestDeactivate(deserializerState);
ghostChild2AbilityAbilityControl.behaviorState = snapshotData.GetChild2AbilityAbilityControlbehaviorState(deserializerState);
ghostChild2AbilityAbilityControl.requestDeactivate = snapshotData.GetChild2AbilityAbilityControlrequestDeactivate(deserializerState);
ghostChild2AbilityDashPredictedState.locoState = snapshotData.GetChild2AbilityDashPredictedStatelocoState(deserializerState);
ghostChild2AbilityDashPredictedState.locoStartTick = snapshotData.GetChild2AbilityDashPredictedStatelocoStartTick(deserializerState);
ghostChild2AbilityDashPredictedState.startVelocity = snapshotData.GetChild2AbilityDashPredictedStatestartVelocity(deserializerState);
ghostChild3AbilityAbilityControl.behaviorState = snapshotData.GetChild3AbilityAbilityControlbehaviorState(deserializerState);
ghostChild3AbilityAbilityControl.requestDeactivate = snapshotData.GetChild3AbilityAbilityControlrequestDeactivate(deserializerState);
ghostChild3AbilityClimbPredictedState.locoState = snapshotData.GetChild3AbilityClimbPredictedStatelocoState(deserializerState);
ghostChild3AbilityClimbPredictedState.SurfaceNormal = snapshotData.GetChild3AbilityClimbPredictedStateSurfaceNormal(deserializerState);
ghostChild3AbilityClimbPredictedState.SurfaceVelocity = snapshotData.GetChild3AbilityClimbPredictedStateSurfaceVelocity(deserializerState);
ghostChild3AbilityClimbPredictedState.SupportedState = snapshotData.GetChild3AbilityClimbPredictedStateSupportedState(deserializerState);
ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value] = ghostChild0AbilityAbilityControl;
ghostAbilityMovementInterpolatedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value] = ghostChild0AbilityMovementInterpolatedState;
ghostAbilityMovementPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value] = ghostChild0AbilityMovementPredictedState;
ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][2].Value] = ghostChild1AbilityAbilityControl;
ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][3].Value] = ghostChild2AbilityAbilityControl;
ghostAbilityDashPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][3].Value] = ghostChild2AbilityDashPredictedState;
ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][4].Value] = ghostChild3AbilityAbilityControl;
ghostAbilityClimbPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][4].Value] = ghostChild3AbilityClimbPredictedState;
ghostCharacterInterpolatedDataArray[entityIndex] = ghostCharacterInterpolatedData;
ghostCharacterReplicatedDataArray[entityIndex] = ghostCharacterReplicatedData;
ghostCharacterControllerGroundSupportDataArray[entityIndex] = ghostCharacterControllerGroundSupportData;
ghostCharacterControllerMoveResultArray[entityIndex] = ghostCharacterControllerMoveResult;
ghostCharacterControllerVelocityArray[entityIndex] = ghostCharacterControllerVelocity;
ghostHealthStateDataArray[entityIndex] = ghostHealthStateData;
ghostInventoryStateArray[entityIndex] = ghostInventoryState;
ghostPlayerOwnerPlayerIdArray[entityIndex] = ghostPlayerOwnerPlayerId;
ghostPlayerControlledStateArray[entityIndex] = ghostPlayerControlledState;
}
}
public unsafe void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
NativeArray <Translation> chunkPositions = chunk.GetNativeArray(PositionType);
NativeArray <Rotation> chunkRotations = chunk.GetNativeArray(RotationType);
NativeArray <PhysicsVelocity> chunkVelocities = chunk.GetNativeArray(PhysicsVelocityType);
NativeArray <PhysicsMass> chunkMasses = chunk.GetNativeArray(PhysicsMassType);
NativeArray <PhysicsDamping> chunkDampings = chunk.GetNativeArray(PhysicsDampingType);
NativeArray <PhysicsGravityFactor> chunkGravityFactors = chunk.GetNativeArray(PhysicsGravityFactorType);
int motionStart = firstEntityIndex;
int instanceCount = chunk.Count;
bool hasChunkPhysicsGravityFactorType = chunk.Has(PhysicsGravityFactorType);
bool hasChunkPhysicsDampingType = chunk.Has(PhysicsDampingType);
bool hasChunkPhysicsMassType = chunk.Has(PhysicsMassType);
// Note: Transform and AngularExpansionFactor could be calculated from PhysicsCollider.MassProperties
// However, to avoid the cost of accessing the collider we assume an infinite mass at the origin of a ~1m^3 box.
// For better performance with spheres, or better behavior for larger and/or more irregular colliders
// you should add a PhysicsMass component to get the true values
var defaultPhysicsMass = new PhysicsMass()
{
Transform = RigidTransform.identity,
InverseMass = 0.0f,
InverseInertia = float3.zero,
AngularExpansionFactor = 1.0f,
};
// Create motion velocities
var defaultInverseInertiaAndMass = new float4(defaultPhysicsMass.InverseInertia, defaultPhysicsMass.InverseMass);
for (int i = 0, motionIndex = motionStart; i < instanceCount; i++, motionIndex++)
{
MotionVelocities[motionIndex] = new MotionVelocity
{
LinearVelocity = chunkVelocities[i].Linear, // world space
AngularVelocity = chunkVelocities[i].Angular, // inertia space
InverseInertiaAndMass = hasChunkPhysicsMassType ? new float4(chunkMasses[i].InverseInertia, chunkMasses[i].InverseMass) : defaultInverseInertiaAndMass,
AngularExpansionFactor = hasChunkPhysicsMassType ? chunkMasses[i].AngularExpansionFactor : defaultPhysicsMass.AngularExpansionFactor,
};
}
// Note: these defaults assume a dynamic body with infinite mass, hence no damping
var defaultPhysicsDamping = new PhysicsDamping()
{
Linear = 0.0f,
Angular = 0.0f,
};
// Note: if a dynamic body infinite mass then assume no gravity should be applied
float defaultGravityFactor = hasChunkPhysicsMassType ? 1.0f : 0.0f;
// Create motion datas
for (int i = 0, motionIndex = motionStart; i < instanceCount; i++, motionIndex++)
{
MotionDatas[motionIndex] = CreateMotionData(
chunkPositions[i], chunkRotations[i],
hasChunkPhysicsMassType ? chunkMasses[i] : defaultPhysicsMass,
hasChunkPhysicsDampingType ? chunkDampings[i] : defaultPhysicsDamping,
hasChunkPhysicsGravityFactorType ? chunkGravityFactors[i].Value : defaultGravityFactor);
}
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
var deserializerState = new GhostDeserializerState
{
GhostMap = GhostMap
};
var ghostEntityArray = chunk.GetNativeArray(ghostEntityType);
var ghostSnapshotDataArray = chunk.GetBufferAccessor(ghostSnapshotDataType);
var predictedGhostComponentArray = chunk.GetNativeArray(predictedGhostComponentType);
var ghostCharacterPredictedDataArray = chunk.GetNativeArray(ghostCharacterPredictedDataType);
var ghostCharacterReplicatedDataArray = chunk.GetNativeArray(ghostCharacterReplicatedDataType);
var ghostCharacterControllerGroundSupportDataArray = chunk.GetNativeArray(ghostCharacterControllerGroundSupportDataType);
var ghostCharacterControllerMoveResultArray = chunk.GetNativeArray(ghostCharacterControllerMoveResultType);
var ghostCharacterControllerVelocityArray = chunk.GetNativeArray(ghostCharacterControllerVelocityType);
var ghostHealthStateDataArray = chunk.GetNativeArray(ghostHealthStateDataType);
var ghostInventoryStateArray = chunk.GetNativeArray(ghostInventoryStateType);
var ghostPlayerOwnerPlayerIdArray = chunk.GetNativeArray(ghostPlayerOwnerPlayerIdType);
var ghostPlayerControlledStateArray = chunk.GetNativeArray(ghostPlayerControlledStateType);
var ghostLinkedEntityGroupArray = chunk.GetBufferAccessor(ghostLinkedEntityGroupType);
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var minMaxOffset = ThreadIndex * (JobsUtility.CacheLineSize / 4);
#endif
for (int entityIndex = 0; entityIndex < ghostEntityArray.Length; ++entityIndex)
{
var snapshot = ghostSnapshotDataArray[entityIndex];
#if UNITY_EDITOR || DEVELOPMENT_BUILD
var latestTick = snapshot.GetLatestTick();
if (latestTick != 0)
{
if (minMaxSnapshotTick[minMaxOffset] == 0 || SequenceHelpers.IsNewer(minMaxSnapshotTick[minMaxOffset], latestTick))
{
minMaxSnapshotTick[minMaxOffset] = latestTick;
}
if (minMaxSnapshotTick[minMaxOffset + 1] == 0 || SequenceHelpers.IsNewer(latestTick, minMaxSnapshotTick[minMaxOffset + 1]))
{
minMaxSnapshotTick[minMaxOffset + 1] = latestTick;
}
}
#endif
Char_BanditSnapshotData snapshotData;
snapshot.GetDataAtTick(targetTick, out snapshotData);
var predictedData = predictedGhostComponentArray[entityIndex];
var lastPredictedTickInst = lastPredictedTick;
if (lastPredictedTickInst == 0 || predictedData.AppliedTick != snapshotData.Tick)
{
lastPredictedTickInst = snapshotData.Tick;
}
else if (!SequenceHelpers.IsNewer(lastPredictedTickInst, snapshotData.Tick))
{
lastPredictedTickInst = snapshotData.Tick;
}
if (minPredictedTick[ThreadIndex] == 0 || SequenceHelpers.IsNewer(minPredictedTick[ThreadIndex], lastPredictedTickInst))
{
minPredictedTick[ThreadIndex] = lastPredictedTickInst;
}
predictedGhostComponentArray[entityIndex] = new PredictedGhostComponent {
AppliedTick = snapshotData.Tick, PredictionStartTick = lastPredictedTickInst
};
if (lastPredictedTickInst != snapshotData.Tick)
{
continue;
}
var ghostCharacterPredictedData = ghostCharacterPredictedDataArray[entityIndex];
var ghostCharacterReplicatedData = ghostCharacterReplicatedDataArray[entityIndex];
var ghostCharacterControllerGroundSupportData = ghostCharacterControllerGroundSupportDataArray[entityIndex];
var ghostCharacterControllerMoveResult = ghostCharacterControllerMoveResultArray[entityIndex];
var ghostCharacterControllerVelocity = ghostCharacterControllerVelocityArray[entityIndex];
var ghostHealthStateData = ghostHealthStateDataArray[entityIndex];
var ghostInventoryState = ghostInventoryStateArray[entityIndex];
var ghostPlayerOwnerPlayerId = ghostPlayerOwnerPlayerIdArray[entityIndex];
var ghostPlayerControlledState = ghostPlayerControlledStateArray[entityIndex];
var ghostChild0AbilityAbilityControl = ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value];
var ghostChild0AbilityMovementInterpolatedState = ghostAbilityMovementInterpolatedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value];
var ghostChild0AbilityMovementPredictedState = ghostAbilityMovementPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value];
var ghostChild1AbilityAbilityControl = ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][2].Value];
var ghostChild2AbilityAbilityControl = ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][3].Value];
var ghostChild2AbilityDashPredictedState = ghostAbilityDashPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][3].Value];
var ghostChild3AbilityAbilityControl = ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][4].Value];
var ghostChild3AbilityClimbPredictedState = ghostAbilityClimbPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][4].Value];
ghostCharacterPredictedData.tick = snapshotData.GetCharacterPredictedDatatick(deserializerState);
ghostCharacterPredictedData.position = snapshotData.GetCharacterPredictedDataposition(deserializerState);
ghostCharacterPredictedData.velocity = snapshotData.GetCharacterPredictedDatavelocity(deserializerState);
ghostCharacterPredictedData.sprinting = snapshotData.GetCharacterPredictedDatasprinting(deserializerState);
ghostCharacterPredictedData.cameraProfile = snapshotData.GetCharacterPredictedDatacameraProfile(deserializerState);
ghostCharacterPredictedData.damageTick = snapshotData.GetCharacterPredictedDatadamageTick(deserializerState);
ghostCharacterPredictedData.damageDirection = snapshotData.GetCharacterPredictedDatadamageDirection(deserializerState);
ghostCharacterReplicatedData.heroTypeIndex = snapshotData.GetCharacterReplicatedDataheroTypeIndex(deserializerState);
ghostCharacterControllerGroundSupportData.SurfaceNormal = snapshotData.GetCharacterControllerGroundSupportDataSurfaceNormal(deserializerState);
ghostCharacterControllerGroundSupportData.SurfaceVelocity = snapshotData.GetCharacterControllerGroundSupportDataSurfaceVelocity(deserializerState);
ghostCharacterControllerGroundSupportData.SupportedState = snapshotData.GetCharacterControllerGroundSupportDataSupportedState(deserializerState);
ghostCharacterControllerMoveResult.MoveResult = snapshotData.GetCharacterControllerMoveResultMoveResult(deserializerState);
ghostCharacterControllerVelocity.Velocity = snapshotData.GetCharacterControllerVelocityVelocity(deserializerState);
ghostHealthStateData.health = snapshotData.GetHealthStateDatahealth(deserializerState);
ghostInventoryState.activeSlot = snapshotData.GetInventoryStateactiveSlot(deserializerState);
ghostPlayerOwnerPlayerId.Value = snapshotData.GetPlayerOwnerPlayerIdValue(deserializerState);
ghostPlayerControlledState.resetCommandTick = snapshotData.GetPlayerControlledStateresetCommandTick(deserializerState);
ghostPlayerControlledState.resetCommandLookYaw = snapshotData.GetPlayerControlledStateresetCommandLookYaw(deserializerState);
ghostPlayerControlledState.resetCommandLookPitch = snapshotData.GetPlayerControlledStateresetCommandLookPitch(deserializerState);
ghostChild0AbilityAbilityControl.behaviorState = snapshotData.GetChild0AbilityAbilityControlbehaviorState(deserializerState);
ghostChild0AbilityAbilityControl.requestDeactivate = snapshotData.GetChild0AbilityAbilityControlrequestDeactivate(deserializerState);
ghostChild0AbilityMovementInterpolatedState.charLocoState = snapshotData.GetChild0AbilityMovementInterpolatedStatecharLocoState(deserializerState);
ghostChild0AbilityMovementInterpolatedState.charLocoTick = snapshotData.GetChild0AbilityMovementInterpolatedStatecharLocoTick(deserializerState);
ghostChild0AbilityMovementInterpolatedState.crouching = snapshotData.GetChild0AbilityMovementInterpolatedStatecrouching(deserializerState);
ghostChild0AbilityMovementPredictedState.locoState = snapshotData.GetChild0AbilityMovementPredictedStatelocoState(deserializerState);
ghostChild0AbilityMovementPredictedState.locoStartTick = snapshotData.GetChild0AbilityMovementPredictedStatelocoStartTick(deserializerState);
ghostChild0AbilityMovementPredictedState.jumpCount = snapshotData.GetChild0AbilityMovementPredictedStatejumpCount(deserializerState);
ghostChild0AbilityMovementPredictedState.crouching = snapshotData.GetChild0AbilityMovementPredictedStatecrouching(deserializerState);
ghostChild1AbilityAbilityControl.behaviorState = snapshotData.GetChild1AbilityAbilityControlbehaviorState(deserializerState);
ghostChild1AbilityAbilityControl.requestDeactivate = snapshotData.GetChild1AbilityAbilityControlrequestDeactivate(deserializerState);
ghostChild2AbilityAbilityControl.behaviorState = snapshotData.GetChild2AbilityAbilityControlbehaviorState(deserializerState);
ghostChild2AbilityAbilityControl.requestDeactivate = snapshotData.GetChild2AbilityAbilityControlrequestDeactivate(deserializerState);
ghostChild2AbilityDashPredictedState.locoState = snapshotData.GetChild2AbilityDashPredictedStatelocoState(deserializerState);
ghostChild2AbilityDashPredictedState.locoStartTick = snapshotData.GetChild2AbilityDashPredictedStatelocoStartTick(deserializerState);
ghostChild2AbilityDashPredictedState.startVelocity = snapshotData.GetChild2AbilityDashPredictedStatestartVelocity(deserializerState);
ghostChild3AbilityAbilityControl.behaviorState = snapshotData.GetChild3AbilityAbilityControlbehaviorState(deserializerState);
ghostChild3AbilityAbilityControl.requestDeactivate = snapshotData.GetChild3AbilityAbilityControlrequestDeactivate(deserializerState);
ghostChild3AbilityClimbPredictedState.locoState = snapshotData.GetChild3AbilityClimbPredictedStatelocoState(deserializerState);
ghostChild3AbilityClimbPredictedState.SurfaceNormal = snapshotData.GetChild3AbilityClimbPredictedStateSurfaceNormal(deserializerState);
ghostChild3AbilityClimbPredictedState.SurfaceVelocity = snapshotData.GetChild3AbilityClimbPredictedStateSurfaceVelocity(deserializerState);
ghostChild3AbilityClimbPredictedState.SupportedState = snapshotData.GetChild3AbilityClimbPredictedStateSupportedState(deserializerState);
ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value] = ghostChild0AbilityAbilityControl;
ghostAbilityMovementInterpolatedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value] = ghostChild0AbilityMovementInterpolatedState;
ghostAbilityMovementPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][1].Value] = ghostChild0AbilityMovementPredictedState;
ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][2].Value] = ghostChild1AbilityAbilityControl;
ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][3].Value] = ghostChild2AbilityAbilityControl;
ghostAbilityDashPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][3].Value] = ghostChild2AbilityDashPredictedState;
ghostAbilityAbilityControlFromEntity[ghostLinkedEntityGroupArray[entityIndex][4].Value] = ghostChild3AbilityAbilityControl;
ghostAbilityClimbPredictedStateFromEntity[ghostLinkedEntityGroupArray[entityIndex][4].Value] = ghostChild3AbilityClimbPredictedState;
ghostCharacterPredictedDataArray[entityIndex] = ghostCharacterPredictedData;
ghostCharacterReplicatedDataArray[entityIndex] = ghostCharacterReplicatedData;
ghostCharacterControllerGroundSupportDataArray[entityIndex] = ghostCharacterControllerGroundSupportData;
ghostCharacterControllerMoveResultArray[entityIndex] = ghostCharacterControllerMoveResult;
ghostCharacterControllerVelocityArray[entityIndex] = ghostCharacterControllerVelocity;
ghostHealthStateDataArray[entityIndex] = ghostHealthStateData;
ghostInventoryStateArray[entityIndex] = ghostInventoryState;
ghostPlayerOwnerPlayerIdArray[entityIndex] = ghostPlayerOwnerPlayerId;
ghostPlayerControlledStateArray[entityIndex] = ghostPlayerControlledState;
}
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
NativeArray <Entity> entityArray = chunk.GetNativeArray(entityType);
NativeArray <HasReynoldsSeekTargetPos> reynoldsArray = chunk.GetNativeArray(reynoldsType);
NativeArray <FollowWayPointsAction> followWPArray = chunk.GetNativeArray(followWPType);
NativeArray <Translation> transArray = chunk.GetNativeArray(translationType);
BufferAccessor <Action> actionBuffers = chunk.GetBufferAccessor <Action>(actionBufferType);
BufferAccessor <WayPoint> wpBuffers = chunk.GetBufferAccessor <WayPoint>(wayPointBufferType);
for (int i = 0; i < chunk.Count; i++)
{
Entity entity = entityArray[i];
DynamicBuffer <Action> actions = actionBuffers[i];
DynamicBuffer <WayPoint> wayPoints = wpBuffers[i];
HasReynoldsSeekTargetPos seek = reynoldsArray[i];
FollowWayPointsAction data = followWPArray[i];
Translation trans = transArray[i];
if (actions.Length > 0) //if there are actions
{
if (actions[0].id == data.id) //if the current action is the same as the action in the first position
{
if (math.distance(trans.Value, wayPoints[data.curPointNum].value) < tolerance) // if the entity is within tolerance of the waypoint
{
if (data.curPointNum < wayPoints.Length - 1) // if the entity has at least one more waypoint to follow
{
data.curPointNum++; // the index increases by one
seek.targetPos = wayPoints[data.curPointNum].value; // move to the next point
}
else // if there are no more waypoints
//entityCommandBuffer.DestroyEntity(actions[0].dataHolder);//demolish the storage entity
{
Debug.Log("Got to last point");
entityCommandBuffer.AddComponent <RemoveAction>(chunkIndex, entity, new RemoveAction { // add a component that tells the system to remove the action from the queue
id = data.id
});
entityCommandBuffer.RemoveComponent <HasReynoldsSeekTargetPos>(chunkIndex, entity);
entityCommandBuffer.RemoveComponent <FollowWayPointsAction>(chunkIndex, entity);
//remove the current follow waypoints action
}
}
}
else // if there are actions but this action is not the right one
{
Debug.Log("Gotta change!");
int j = 0;
while (j < actions.Length && actions[j].id != data.id) // find the location of the action in the actions queue
{
j++;
}
if (j < actions.Length) // if the action was found in the queue
{
entityCommandBuffer.AddComponent <StoreWayPoints>(chunkIndex, entity, new StoreWayPoints { // store the data
id = data.id,
dataHolder = actions[j].dataHolder,
curPointNum = data.curPointNum
});
}
entityCommandBuffer.AddComponent <ChangeAction>(chunkIndex, entity, new ChangeAction {
}); //signify that the action should be changed
}
}
else // if there are no actions in the action queue
{
Debug.Log("Nothin left!");
entityCommandBuffer.RemoveComponent <HasReynoldsSeekTargetPos>(chunkIndex, entity);
entityCommandBuffer.RemoveComponent <FollowWayPointsAction>(chunkIndex, entity);
entityCommandBuffer.AddComponent <ChangeAction>(chunkIndex, entity, new ChangeAction {
}); //signify that the action should be changed (will remove action)
}
}
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int entityOffset)
{
var chunkTranslations = chunk.GetNativeArray(TranslationType);
var chunkNonUniformScales = chunk.GetNativeArray(NonUniformScaleType);
var chunkScales = chunk.GetNativeArray(ScaleType);
var chunkCompositeScales = chunk.GetNativeArray(CompositeScaleType);
var chunkRotations = chunk.GetNativeArray(RotationType);
var chunkCompositeRotations = chunk.GetNativeArray(CompositeRotationType);
var chunkLocalToParent = chunk.GetNativeArray(LocalToParentType);
var chunkParentScaleInverses = chunk.GetNativeArray(ParentScaleInverseType);
var hasTranslation = chunk.Has(TranslationType);
var hasCompositeRotation = chunk.Has(CompositeRotationType);
var hasRotation = chunk.Has(RotationType);
var hasAnyRotation = hasCompositeRotation || hasRotation;
var hasNonUniformScale = chunk.Has(NonUniformScaleType);
var hasScale = chunk.Has(ScaleType);
var hasCompositeScale = chunk.Has(CompositeScaleType);
var hasAnyScale = hasScale || hasNonUniformScale || hasCompositeScale;
var hasParentScaleInverse = chunk.Has(ParentScaleInverseType);
var count = chunk.Count;
// #todo jump table when burst supports function pointers
if (hasParentScaleInverse)
{
if (!hasAnyRotation)
{
// 00 = invalid (must have at least one)
// 01
if (!hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(parentScaleInverse, scale)
};
}
}
// 10
else if (hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var translation = chunkTranslations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(float4x4.Translate(translation), parentScaleInverse)
};
}
}
// 11
else if (hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
var translation = chunkTranslations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(math.mul(float4x4.Translate(translation), parentScaleInverse),
scale)
};
}
}
}
else if (hasCompositeRotation)
{
// 00
if (!hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var rotation = chunkCompositeRotations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(parentScaleInverse, rotation)
};
}
}
// 01
else if (!hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var rotation = chunkCompositeRotations[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(parentScaleInverse, math.mul(rotation, scale))
};
}
}
// 10
else if (hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var rotation = chunkCompositeRotations[i].Value;
var translation = chunkTranslations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(math.mul(float4x4.Translate(translation), parentScaleInverse),
rotation)
};
}
}
// 11
else if (hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var rotation = chunkCompositeRotations[i].Value;
var translation = chunkTranslations[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(
math.mul(math.mul(float4x4.Translate(translation), parentScaleInverse),
rotation), scale)
};
}
}
}
else // if (hasRotation) -- Only in same WriteGroup if !hasCompositeRotation
{
// 00
if (!hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var rotation = chunkRotations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(parentScaleInverse, new float4x4(rotation, float3.zero))
};
}
}
// 01
else if (!hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var rotation = chunkRotations[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(parentScaleInverse,
math.mul(new float4x4(rotation, float3.zero), scale))
};
}
}
// 10
else if (hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var rotation = chunkRotations[i].Value;
var translation = chunkTranslations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(math.mul(float4x4.Translate(translation), parentScaleInverse),
new float4x4(rotation, new float3(0.0f)))
};
}
}
// 11
else if (hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var parentScaleInverse = chunkParentScaleInverses[i].Value;
var rotation = chunkRotations[i].Value;
var translation = chunkTranslations[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(
math.mul(math.mul(float4x4.Translate(translation), parentScaleInverse),
new float4x4(rotation, new float3(0.0f))), scale)
};
}
}
}
}
else // (!hasParentScaleInverse)
{
if (!hasAnyRotation)
{
// 00 = invalid (must have at least one)
// 01
if (!hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = scale
};
}
}
// 10
else if (hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var translation = chunkTranslations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = float4x4.Translate(translation)
};
}
}
// 11
else if (hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
var translation = chunkTranslations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(float4x4.Translate(translation), scale)
};
}
}
}
else if (hasCompositeRotation)
{
// 00
if (!hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkCompositeRotations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = rotation
};
}
}
// 01
else if (!hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkCompositeRotations[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(rotation, scale)
};
}
}
// 10
else if (hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkCompositeRotations[i].Value;
var translation = chunkTranslations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(float4x4.Translate(translation), rotation)
};
}
}
// 11
else if (hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkCompositeRotations[i].Value;
var translation = chunkTranslations[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(math.mul(float4x4.Translate(translation), rotation), scale)
};
}
}
}
else // if (hasRotation) -- Only in same WriteGroup if !hasCompositeRotation
{
// 00
if (!hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = new float4x4(rotation, float3.zero)
};
}
}
// 01
else if (!hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(new float4x4(rotation, float3.zero), scale)
};
}
}
// 10
else if (hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
var translation = chunkTranslations[i].Value;
chunkLocalToParent[i] = new LocalToParent
{
Value = new float4x4(rotation, translation)
};
}
}
// 11
else if (hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
var translation = chunkTranslations[i].Value;
var scale = hasNonUniformScale
? float4x4.Scale(chunkNonUniformScales[i].Value)
: (hasScale
? float4x4.Scale(new float3(chunkScales[i].Value))
: chunkCompositeScales[i].Value);
chunkLocalToParent[i] = new LocalToParent
{
Value = math.mul(new float4x4(rotation, translation), scale)
};
}
}
}
}
}
public void Execute(ArchetypeChunk chunk, int index, int entityOffset)
{
var chunkRotationPivotTranslations = chunk.GetNativeArray(RotationPivotTranslationTypeHandle);
var chunkRotations = chunk.GetNativeArray(RotationTypeHandle);
var chunkPostRotation = chunk.GetNativeArray(PostRotationTypeHandle);
var chunkRotationPivots = chunk.GetNativeArray(RotationPivotTypeHandle);
var chunkCompositeRotations = chunk.GetNativeArray(CompositeRotationTypeHandle);
var hasRotationPivotTranslation = chunk.Has(RotationPivotTranslationTypeHandle);
var hasRotation = chunk.Has(RotationTypeHandle);
var hasPostRotation = chunk.Has(PostRotationTypeHandle);
var hasRotationPivot = chunk.Has(RotationPivotTypeHandle);
var count = chunk.Count;
var hasAnyRotation = hasRotation || hasPostRotation;
// 000 - Invalid. Must have at least one.
// 001
if (!hasAnyRotation && !hasRotationPivotTranslation && hasRotationPivot)
{
var didChange = chunk.DidChange(RotationPivotTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
// Only pivot? Doesn't do anything.
for (int i = 0; i < count; i++)
{
chunkCompositeRotations[i] = new CompositeRotation {
Value = float4x4.identity
}
}
;
}
// 010
else if (!hasAnyRotation && hasRotationPivotTranslation && !hasRotationPivot)
{
var didChange = chunk.DidChange(RotationPivotTranslationTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var translation = chunkRotationPivotTranslations[i].Value;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = float4x4.Translate(translation)
};
}
}
// 011
else if (!hasAnyRotation && hasRotationPivotTranslation && hasRotationPivot)
{
var didChange = chunk.DidChange(RotationPivotTranslationTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
// Pivot without rotation doesn't affect anything. Only translation.
for (int i = 0; i < count; i++)
{
var translation = chunkRotationPivotTranslations[i].Value;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = float4x4.Translate(translation)
};
}
}
// 100
else if (hasAnyRotation && !hasRotationPivotTranslation && !hasRotationPivot)
{
// 00 - Not valid
// 01
if (!hasPostRotation && hasRotation)
{
var didChange = chunk.DidChange(RotationTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = new float4x4(rotation, float3.zero)
};
}
}
// 10
else if (hasPostRotation && !hasRotation)
{
var didChange = chunk.DidChange(PostRotationTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var rotation = chunkPostRotation[i].Value;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = new float4x4(rotation, float3.zero)
};
}
}
// 11
else if (hasPostRotation && hasRotation)
{
var didChange = chunk.DidChange(PostRotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var rotation = math.mul(chunkRotations[i].Value, chunkPostRotation[i].Value);
chunkCompositeRotations[i] = new CompositeRotation
{
Value = new float4x4(rotation, float3.zero)
};
}
}
}
// 101
else if (hasAnyRotation && !hasRotationPivotTranslation && hasRotationPivot)
{
// 00 - Not valid
// 01
if (!hasPostRotation && hasRotation)
{
var didChange = chunk.DidChange(RotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
var pivot = chunkRotationPivots[i].Value;
var inversePivot = -1.0f * pivot;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = math.mul(new float4x4(rotation, pivot), float4x4.Translate(inversePivot))
};
}
}
// 10
else if (hasPostRotation && !hasRotation)
{
var didChange = chunk.DidChange(PostRotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var rotation = chunkPostRotation[i].Value;
var pivot = chunkRotationPivots[i].Value;
var inversePivot = -1.0f * pivot;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = math.mul(new float4x4(rotation, pivot), float4x4.Translate(inversePivot))
};
}
}
// 11
else if (hasPostRotation && hasRotation)
{
var didChange = chunk.DidChange(PostRotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var rotation = chunkPostRotation[i].Value;
var pivot = chunkRotationPivots[i].Value;
var inversePivot = -1.0f * pivot;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = math.mul(new float4x4(rotation, pivot), float4x4.Translate(inversePivot))
};
}
}
}
// 110
else if (hasAnyRotation && hasRotationPivotTranslation && !hasRotationPivot)
{
// 00 - Not valid
// 01
if (!hasPostRotation && hasRotation)
{
var didChange = chunk.DidChange(RotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTranslationTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var translation = chunkRotationPivotTranslations[i].Value;
var rotation = chunkRotations[i].Value;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = new float4x4(rotation, translation)
};
}
}
// 10
else if (hasPostRotation && !hasRotation)
{
var didChange = chunk.DidChange(PostRotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTranslationTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var translation = chunkRotationPivotTranslations[i].Value;
var rotation = chunkRotations[i].Value;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = new float4x4(rotation, translation)
};
}
}
// 11
else if (hasPostRotation && hasRotation)
{
var didChange = chunk.DidChange(PostRotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTranslationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var translation = chunkRotationPivotTranslations[i].Value;
var rotation = math.mul(chunkRotations[i].Value, chunkPostRotation[i].Value);
chunkCompositeRotations[i] = new CompositeRotation
{
Value = new float4x4(rotation, translation)
};
}
}
}
// 111
else if (hasAnyRotation && hasRotationPivotTranslation && hasRotationPivot)
{
// 00 - Not valid
// 01
if (!hasPostRotation && hasRotation)
{
var didChange = chunk.DidChange(RotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTranslationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var translation = chunkRotationPivotTranslations[i].Value;
var rotation = chunkRotations[i].Value;
var pivot = chunkRotationPivots[i].Value;
var inversePivot = -1.0f * pivot;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = math.mul(float4x4.Translate(translation),
math.mul(new float4x4(rotation, pivot), float4x4.Translate(inversePivot)))
};
}
}
// 10
else if (hasPostRotation && !hasRotation)
{
var didChange = chunk.DidChange(PostRotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTranslationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var translation = chunkRotationPivotTranslations[i].Value;
var rotation = chunkPostRotation[i].Value;
var pivot = chunkRotationPivots[i].Value;
var inversePivot = -1.0f * pivot;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = math.mul(float4x4.Translate(translation),
math.mul(new float4x4(rotation, pivot), float4x4.Translate(inversePivot)))
};
}
}
// 11
else if (hasPostRotation && hasRotation)
{
var didChange = chunk.DidChange(PostRotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTranslationTypeHandle, LastSystemVersion) ||
chunk.DidChange(RotationPivotTypeHandle, LastSystemVersion);
if (!didChange)
{
return;
}
for (int i = 0; i < count; i++)
{
var translation = chunkRotationPivotTranslations[i].Value;
var rotation = math.mul(chunkRotations[i].Value, chunkPostRotation[i].Value);
var pivot = chunkRotationPivots[i].Value;
var inversePivot = -1.0f * pivot;
chunkCompositeRotations[i] = new CompositeRotation
{
Value = math.mul(float4x4.Translate(translation),
math.mul(new float4x4(rotation, pivot), float4x4.Translate(inversePivot)))
};
}
}
}
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
//BufferAccessor<Cell> accessor = this.GridChunks[0].GetBufferAccessor(this.CellTypeRO);
//DynamicBuffer<Cell> grid = accessor[0].Reinterpret<Cell>();
int size = DimX * DimY;
BufferAccessor <Waypoint> Waypoints = chunk.GetBufferAccessor(WaypointChunkBuffer);
NativeArray <PathRequest> PathRequests = chunk.GetNativeArray(PathRequestsChunkComponent);
NativeArray <Translation> Translations = chunk.GetNativeArray(TranslationsChunkComponent);
NativeArray <NavigationCapabilities> NavigationCapabilities = chunk.GetNativeArray(NavigationCapabilitiesChunkComponent);
NativeArray <float> CostSoFar = new NativeArray <float>(size * chunk.Count, Allocator.Temp);
NativeArray <int2> CameFrom = new NativeArray <int2>(size * chunk.Count, Allocator.Temp);
NativeMinHeap OpenSet = new NativeMinHeap((Iterations + 1) * Neighbors.Length * chunk.Count, Allocator.Temp);
for (int i = chunkIndex; i < chunk.Count; i++)
{
NativeSlice <float> costSoFar = CostSoFar.Slice(i * size, size);
NativeSlice <int2> cameFrom = CameFrom.Slice(i * size, size);
int openSetSize = (Iterations + 1) * NeighborCount;
NativeMinHeap openSet = OpenSet.Slice(i * openSetSize, openSetSize);
PathRequest request = PathRequests[i];
// Clear our shared data
//var buffer = costSoFar.GetUnsafePtr();
//UnsafeUtility.MemClear(buffer, (long)costSoFar.Length * UnsafeUtility.SizeOf<float>());
//openSet.Clear();
Translation currentPosition = Translations[i];
NavigationCapabilities capability = NavigationCapabilities[i];
// cache these as they're used a lot
int2 start = currentPosition.Value.xy.FloorToInt();
int2 goal = request.end;
DynamicBuffer <float3> waypoints = Waypoints[i].Reinterpret <float3>();
waypoints.Clear();
// Special case when the start is the same point as the goal
if (start.Equals(goal))
{
// We just set the destination as the goal, but need to get the correct height
int gridIndex = this.GetIndex(goal);
Cell cell = CellArray[gridIndex];
float3 point = new float3(request.Destination.x, request.Destination.y, cell.Height);
waypoints.Add(point);
continue;
}
var stash = new InstanceStash
{
Grid = CellArray,
CameFrom = cameFrom,
CostSoFar = costSoFar,
OpenSet = openSet,
Request = request,
Capability = capability,
CurrentPosition = currentPosition,
Start = start,
Goal = goal,
Waypoints = waypoints,
};
if (this.ProcessPath(ref stash))
{
this.ReconstructPath(stash);
}
}
CostSoFar.Dispose();
CameFrom.Dispose();
OpenSet.Dispose();
}
public void Execute(ArchetypeChunk batchInChunk, int batchIndex)
{
bool changed =
batchInChunk.DidOrderChange(LastSystemVersion) ||
batchInChunk.DidChange(TranslationTypeHandle, LastSystemVersion) ||
batchInChunk.DidChange(NonUniformScaleTypeHandle, LastSystemVersion) ||
batchInChunk.DidChange(ScaleTypeHandle, LastSystemVersion) ||
batchInChunk.DidChange(CompositeScaleTypeHandle, LastSystemVersion) ||
batchInChunk.DidChange(RotationTypeHandle, LastSystemVersion) ||
batchInChunk.DidChange(CompositeRotationTypeHandle, LastSystemVersion);
if (!changed)
{
return;
}
var chunkTranslations = batchInChunk.GetNativeArray(TranslationTypeHandle);
var chunkNonUniformScales = batchInChunk.GetNativeArray(NonUniformScaleTypeHandle);
var chunkScales = batchInChunk.GetNativeArray(ScaleTypeHandle);
var chunkCompositeScales = batchInChunk.GetNativeArray(CompositeScaleTypeHandle);
var chunkRotations = batchInChunk.GetNativeArray(RotationTypeHandle);
var chunkCompositeRotations = batchInChunk.GetNativeArray(CompositeRotationTypeHandle);
var chunkLocalToWorld = batchInChunk.GetNativeArray(LocalToWorldTypeHandle);
var hasTranslation = batchInChunk.Has(TranslationTypeHandle);
var hasCompositeRotation = batchInChunk.Has(CompositeRotationTypeHandle);
var hasRotation = batchInChunk.Has(RotationTypeHandle);
var hasAnyRotation = hasCompositeRotation || hasRotation;
var hasNonUniformScale = batchInChunk.Has(NonUniformScaleTypeHandle);
var hasScale = batchInChunk.Has(ScaleTypeHandle);
var hasCompositeScale = batchInChunk.Has(CompositeScaleTypeHandle);
var hasAnyScale = hasScale || hasNonUniformScale || hasCompositeScale;
var count = batchInChunk.Count;
// #todo jump table when burst supports function pointers
if (!hasAnyRotation)
{
// 00 = invalid (must have at least one)
// 01
if (!hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var scale = hasNonUniformScale ? float4x4.Scale(chunkNonUniformScales[i].Value) : (hasScale ? float4x4.Scale(new float3(chunkScales[i].Value)) : chunkCompositeScales[i].Value);
chunkLocalToWorld[i] = new LocalToWorld
{
Value = scale
};
}
}
// 10
else if (hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var translation = chunkTranslations[i].Value;
chunkLocalToWorld[i] = new LocalToWorld
{
Value = float4x4.Translate(translation)
};
}
}
// 11
else if (hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var scale = hasNonUniformScale ? float4x4.Scale(chunkNonUniformScales[i].Value) : (hasScale ? float4x4.Scale(new float3(chunkScales[i].Value)) : chunkCompositeScales[i].Value);
var translation = chunkTranslations[i].Value;
chunkLocalToWorld[i] = new LocalToWorld
{
Value = math.mul(float4x4.Translate(translation), scale)
};
}
}
}
else if (hasCompositeRotation)
{
// 00
if (!hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkCompositeRotations[i].Value;
chunkLocalToWorld[i] = new LocalToWorld
{
Value = rotation
};
}
}
// 01
else if (!hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkCompositeRotations[i].Value;
var scale = hasNonUniformScale ? float4x4.Scale(chunkNonUniformScales[i].Value) : (hasScale ? float4x4.Scale(new float3(chunkScales[i].Value)) : chunkCompositeScales[i].Value);
chunkLocalToWorld[i] = new LocalToWorld
{
Value = math.mul(rotation, scale)
};
}
}
// 10
else if (hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkCompositeRotations[i].Value;
var translation = chunkTranslations[i].Value;
chunkLocalToWorld[i] = new LocalToWorld
{
Value = math.mul(float4x4.Translate(translation), rotation)
};
}
}
// 11
else if (hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkCompositeRotations[i].Value;
var translation = chunkTranslations[i].Value;
var scale = hasNonUniformScale ? float4x4.Scale(chunkNonUniformScales[i].Value) : (hasScale ? float4x4.Scale(new float3(chunkScales[i].Value)) : chunkCompositeScales[i].Value);
chunkLocalToWorld[i] = new LocalToWorld
{
Value = math.mul(math.mul(float4x4.Translate(translation), rotation), scale)
};
}
}
}
else // if (hasRotation) -- Only in same WriteGroup if !hasCompositeRotation
{
// 00
if (!hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
chunkLocalToWorld[i] = new LocalToWorld
{
Value = new float4x4(rotation, float3.zero)
};
}
}
// 01
else if (!hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
var scale = hasNonUniformScale ? float4x4.Scale(chunkNonUniformScales[i].Value) : (hasScale ? float4x4.Scale(new float3(chunkScales[i].Value)) : chunkCompositeScales[i].Value);
chunkLocalToWorld[i] = new LocalToWorld
{
Value = math.mul(new float4x4(rotation, float3.zero), scale)
};
}
}
// 10
else if (hasTranslation && !hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
var translation = chunkTranslations[i].Value;
chunkLocalToWorld[i] = new LocalToWorld
{
Value = new float4x4(rotation, translation)
};
}
}
// 11
else if (hasTranslation && hasAnyScale)
{
for (int i = 0; i < count; i++)
{
var rotation = chunkRotations[i].Value;
var translation = chunkTranslations[i].Value;
var scale = hasNonUniformScale ? float4x4.Scale(chunkNonUniformScales[i].Value) : (hasScale ? float4x4.Scale(new float3(chunkScales[i].Value)) : chunkCompositeScales[i].Value);
chunkLocalToWorld[i] = new LocalToWorld
{
Value = math.mul(new float4x4(rotation, translation), scale)
};
}
}
}
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex, DynamicComponentTypeHandle *ghostChunkComponentTypesPtr, int ghostChunkComponentTypesLength)
{
if (!predictionState.TryGetValue(chunk, out var state) ||
(*(PredictionBackupState *)state).entityCapacity != chunk.Capacity)
{
return;
}
var ghostComponents = chunk.GetNativeArray(ghostType);
int ghostTypeId = ghostComponents[0].ghostType;
var typeData = GhostTypeCollection[ghostTypeId];
var headerSize = PredictionBackupState.GetHeaderSize();
var entitySize = PredictionBackupState.GetEntitiesSize(chunk.Capacity, out var singleEntitySize);
int baseOffset = typeData.FirstComponent;
Entity *backupEntities = PredictionBackupState.GetEntities(state, headerSize);
var entities = chunk.GetNativeArray(entityType);
var predictedGhostComponents = chunk.GetNativeArray(predictedGhostType);
byte *dataPtr = PredictionBackupState.GetData(state, headerSize, entitySize);
int numBaseComponents = typeData.NumComponents - typeData.NumChildComponents;
for (int comp = 0; comp < numBaseComponents; ++comp)
{
int compIdx = GhostComponentIndex[baseOffset + comp].ComponentIndex;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (compIdx >= ghostChunkComponentTypesLength)
{
throw new System.InvalidOperationException("Component index out of range");
}
#endif
if ((GhostComponentCollection[compIdx].SendMask & requiredSendMask) == 0)
{
continue;
}
var compSize = GhostComponentCollection[compIdx].ComponentSize;
if (chunk.Has(ghostChunkComponentTypesPtr[compIdx]))
{
var compData = (byte *)chunk.GetDynamicComponentDataArrayReinterpret <byte>(ghostChunkComponentTypesPtr[compIdx], compSize).GetUnsafeReadOnlyPtr();
for (int ent = 0; ent < entities.Length; ++ent)
{
// If this entity did not predict anything there was no rollback and no need to debug it
if (!GhostPredictionSystemGroup.ShouldPredict(tick, predictedGhostComponents[ent]))
{
continue;
}
if (entities[ent] == backupEntities[ent])
{
SmoothComponent(compData + compSize * ent, dataPtr + compSize * ent, GhostComponentCollection[compIdx].ComponentType);
}
}
}
dataPtr = PredictionBackupState.GetNextData(dataPtr, compSize, chunk.Capacity);
}
if (typeData.NumChildComponents > 0)
{
var linkedEntityGroupAccessor = chunk.GetBufferAccessor(linkedEntityGroupType);
for (int comp = numBaseComponents; comp < typeData.NumComponents; ++comp)
{
int compIdx = GhostComponentIndex[baseOffset + comp].ComponentIndex;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (compIdx >= ghostChunkComponentTypesLength)
{
throw new System.InvalidOperationException("Component index out of range");
}
#endif
if ((GhostComponentCollection[compIdx].SendMask & requiredSendMask) == 0)
{
continue;
}
var compSize = GhostComponentCollection[compIdx].ComponentSize;
var entityIdx = GhostComponentIndex[baseOffset + comp].EntityIndex;
for (int ent = 0; ent < chunk.Count; ++ent)
{
// If this entity did not predict anything there was no rollback and no need to debug it
if (!GhostPredictionSystemGroup.ShouldPredict(tick, predictedGhostComponents[ent]))
{
continue;
}
if (entities[ent] != backupEntities[ent])
{
continue;
}
var linkedEntityGroup = linkedEntityGroupAccessor[ent];
if (childEntityLookup.TryGetValue(linkedEntityGroup[entityIdx].Value, out var childChunk) &&
childChunk.chunk.Has(ghostChunkComponentTypesPtr[compIdx]))
{
var compData = (byte *)childChunk.chunk.GetDynamicComponentDataArrayReinterpret <byte>(ghostChunkComponentTypesPtr[compIdx], compSize).GetUnsafePtr();
SmoothComponent(compData + compSize * childChunk.index, dataPtr + compSize * ent, GhostComponentCollection[compIdx].ComponentType);
}
}
dataPtr = PredictionBackupState.GetNextData(dataPtr, compSize, chunk.Capacity);
}
}
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
var entities = chunk.GetNativeArray(EntityType);
var translations = chunk.GetNativeArray(TranslationType);
var directions = chunk.GetNativeArray(DirectionType);
var targets = chunk.GetNativeArray(TargetType);
var distanceTargets = chunk.GetNativeArray(DistanceToTargetType);
var areRats = chunk.Has(RatType);
for (int i = 0; i < chunk.Count; ++i)
{
var entity = entities[i];
var translation = translations[i].Value;
var direction = directions[i];
var distance = distanceTargets[i].Value;
if (distance < 1.0f)
{
continue;
}
var index = ((int)translation.z) * BoardSize.y + (int)translation.x;
if (index < 0 || index >= Buffer.Length)
{
continue;
}
var cellMapValue = Buffer[index].Value;
if ((cellMapValue & kHoleFlag) == kHoleFlag)
{
CommandBuffer.AddComponent(chunkIndex, entity, new LbFall());
if (areRats)
{
CommandBuffer.AddComponent(chunkIndex, entity, new LbLifetime()
{
Value = 1.0f
});
}
else
{
CommandBuffer.SetComponent(chunkIndex, entity, new LbLifetime()
{
Value = 1.0f
});
}
CommandBuffer.SetComponent(chunkIndex, entity, new LbMovementSpeed()
{
Value = -2.5f
});
}
else if ((cellMapValue & kHomebaseFlag) == kHomebaseFlag)
{
CommandBuffer.AddComponent(chunkIndex, entity, new LbDestroy());
var player = (cellMapValue >> 9) & 0x3;
var scoreEntity = CommandBuffer.CreateEntity(chunkIndex);
if (areRats)
{
CommandBuffer.AddComponent(chunkIndex, scoreEntity, new LbRatScore()
{
Player = (byte)player
});
}
else
{
CommandBuffer.AddComponent(chunkIndex, scoreEntity, new LbCatScore()
{
Player = (byte)player
});
}
}
else
{
translation.y = 1.0f;
var currentArrow = ArrowDirectionMap[index].Value;
var newDirection = 0x00;
if ((currentArrow & 0x10) == 0x10)
{
newDirection = (byte)(currentArrow & 0x03);
}
else
{
newDirection = direction.Value;
}
var nextDirectionByte = (byte)((cellMapValue >> LbDirection.GetByteShift((byte)newDirection)) & 0x3);
directions[i] = new LbDirection()
{
Value = (byte)nextDirectionByte
};
targets[i] = new LbMovementTarget()
{
From = translation, To = translation + LbDirection.GetDirection((byte)nextDirectionByte)
};
distanceTargets[i] = new LbDistanceToTarget()
{
Value = 0.0f
};
CommandBuffer.SetComponent(chunkIndex, entity, new Rotation()
{
Value = LbDirection.GetRotation((byte)nextDirectionByte)
});
}
}
}
public void Execute(ArchetypeChunk chunk, int orderIndex)
{
data.Execute(chunk, orderIndex);
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
var buffer = FlowMap[BoardEntity];
var entities = chunk.GetNativeArray(EntityType);
var isRats = chunk.Has(RatType);
var byteShift = 0;
var componentType = 0;
if (chunk.Has(DirectionNorthType))
{
byteShift = 6;
componentType = 0;
}
else if (chunk.Has(DirectionSouthType))
{
byteShift = 2;
componentType = 1;
}
else if (chunk.Has(DirectionWestType))
{
byteShift = 0;
componentType = 2;
}
else if (chunk.Has(DirectionEastType))
{
byteShift = 4;
componentType = 3;
}
var chunkTranslation = chunk.GetNativeArray(TranslationType);
for (var i = 0; i < chunk.Count; i++)
{
var entity = entities[i];
var translation = chunkTranslation[i].Value;
var index = ((int)translation.z) * BoardSize.y + (int)translation.x;
var cellMapValue = buffer[index].Value;
if ((cellMapValue & kHoleFlag) == kHoleFlag)
{
RemoveMovement(chunkIndex, entity, componentType);
CommandBuffer.AddComponent(chunkIndex, entity, new LbFall());
if (isRats)
{
CommandBuffer.AddComponent(chunkIndex, entity, new LbLifetime()
{
Value = 1.0f
});
}
else
{
CommandBuffer.SetComponent(chunkIndex, entity, new LbLifetime()
{
Value = 1.0f
});
}
CommandBuffer.SetComponent(chunkIndex, entity, new LbMovementSpeed()
{
Value = -2.5f
});
}
else if ((cellMapValue & kHomebaseFlag) == kHomebaseFlag)
{
CommandBuffer.AddComponent(chunkIndex, entity, new LbDestroy());
var player = (cellMapValue >> 9) & 0x3;
var scoreEntity = CommandBuffer.CreateEntity(chunkIndex);
if (isRats)
{
CommandBuffer.AddComponent(chunkIndex, scoreEntity, new LbRatScore()
{
Player = (byte)player
});
}
else
{
CommandBuffer.AddComponent(chunkIndex, scoreEntity, new LbCatScore()
{
Player = (byte)player
});
}
}
else
{
var nextDir = (cellMapValue >> byteShift) & 0x3;
RemoveMovement(chunkIndex, entity, componentType);
MoveToNextCell(chunkIndex, entity, nextDir);
}
CommandBuffer.RemoveComponent <LbReachCell>(chunkIndex, entity);
}
}
public unsafe Runtime PrepareToExecuteOnEntitiesIn(ref ArchetypeChunk chunk)
{
return(new Runtime()
{
});
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
//DeltaTime dt;
var count = chunk.Count;
var chunkDeltaTime = chunk.Has(etTp) ? chunk.GetNativeArray(dtTp) : default;
var chunkTimeScale = chunk.Has(tsTp) ? chunk.GetNativeArray(tsTp) : default;
var chunkElapsedTime = chunk.Has(etTp) ? chunk.GetNativeArray(etTp) : default;
var chunkFts = chunk.Has(ftsTp) ? chunk.GetNativeArray(ftsTp) : default;
var chunkSc = chunk.Has(scTp) ? chunk.GetNativeArray(scTp) : default;
if (chunkTimeScale != default) //has time scale
{
if (chunkElapsedTime != default) //has ElapsedTime
{
if (chunkDeltaTime != default) //has DeltaTime and ElapsedTime
{
if (chunkFts != default) //has fixed time step
{
if (chunkSc != default) //has step counter
{
for (int i = 0; i < count; i++)
{
var dt = chunkTimeScale[i].Scale(deltaTime);
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(dt);
chunkDeltaTime[i] = dt;
var fst = chunkFts[i] = chunkFts[i].Tick(dt);
chunkSc[i] = chunkSc[i].Tick(fst.AggSteps);
}
}
else//has fixed time step no step counter
{
for (int i = 0; i < count; i++)
{
var dt = chunkTimeScale[i].Scale(deltaTime);
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(dt);
chunkDeltaTime[i] = dt;
chunkFts[i] = chunkFts[i].Tick(dt);
}
}
}
else//no fixed time step
{
for (int i = 0; i < count; i++)
{
var dt = chunkTimeScale[i].Scale(deltaTime);
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(dt);
chunkDeltaTime[i] = dt;
}
}
}
else//has ElapsedTime no DeltaTime
{
if (chunkFts != default)//has fixed time step
{
if (chunkSc != default)//has step counter
{
for (int i = 0; i < count; i++)
{
var dt = chunkTimeScale[i].Scale(deltaTime);
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(dt);
var fst = chunkFts[i] = chunkFts[i].Tick(dt);
chunkSc[i] = chunkSc[i].Tick(fst.AggSteps);
}
}
else//has fixed time step no step counter
{
for (int i = 0; i < count; i++)
{
var dt = chunkTimeScale[i].Scale(deltaTime);
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(dt);
chunkFts[i] = chunkFts[i].Tick(dt);
}
}
}
else//no fixed time step
{
for (int i = 0; i < count; i++)
{
var dt = chunkTimeScale[i].Scale(deltaTime);
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(dt);
}
}
}
}
else//no ElapsedTime
{
//has DeltaTime no ElapsedTime
if (chunkDeltaTime != default)
{
if (chunkFts != default) //has fixed time step
{
if (chunkSc != default) //has step counter
{
for (int i = 0; i < count; i++)
{
var dt = chunkTimeScale[i].Scale(deltaTime);
chunkDeltaTime[i] = chunkTimeScale[i].Scale(deltaTime);
var fst = chunkFts[i] = chunkFts[i].Tick(dt);
chunkSc[i] = chunkSc[i].Tick(fst.AggSteps);
}
}
else//has fixed time step no step counter
{
for (int i = 0; i < count; i++)
{
var dt = chunkTimeScale[i].Scale(deltaTime);
chunkDeltaTime[i] = chunkTimeScale[i].Scale(deltaTime);
chunkFts[i] = chunkFts[i].Tick(dt);
}
}
}
//no fixed time step
else
{
for (int i = 0; i < count; i++)
{
chunkDeltaTime[i] = chunkTimeScale[i].Scale(deltaTime);
}
}
}
else//no DeltaTime no ElapsedTime
{
if (chunkFts != default)//has fixed time step
{
if (chunkSc != default)//has step counter
{
for (int i = 0; i < count; i++)
{
var dt = chunkTimeScale[i].Scale(deltaTime);
var fst = chunkFts[i] = chunkFts[i].Tick(dt);
chunkSc[i] = chunkSc[i].Tick(fst.AggSteps);
}
}
//has fixed time step no step counter
else
{
for (int i = 0; i < count; i++)
{
chunkFts[i] = chunkFts[i].Tick(chunkTimeScale[i].Scale(deltaTime));
}
}
}//no fixed time step
}
//else no DeltaTime no ElapsedTime no fixedtime step no update
}
}
else//no time scale
{
if (chunkElapsedTime != default)//has ElapsedTime
{
if (chunkDeltaTime != default) //has DeltaTime and ElapsedTime
{
if (chunkFts != default) //has fixed time step
{
if (chunkSc != default) //has step counter
{
for (int i = 0; i < count; i++)
{
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(deltaTime);
chunkDeltaTime[i] = deltaTime;
var fst = chunkFts[i] = chunkFts[i].Tick(deltaTime);
chunkSc[i] = chunkSc[i].Tick(fst.AggSteps);
}
}
else//has fixed time step no step counter
{
for (int i = 0; i < count; i++)
{
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(deltaTime);
chunkDeltaTime[i] = deltaTime;
chunkFts[i] = chunkFts[i].Tick(deltaTime);
}
}
}
else//no fixed time step
{
for (int i = 0; i < count; i++)
{
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(deltaTime);
chunkDeltaTime[i] = deltaTime;
}
}
}
else//has ElapsedTime no DeltaTime
{
if (chunkFts != default)//has fixed time step
{
if (chunkSc != default)//has step counter
{
for (int i = 0; i < count; i++)
{
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(deltaTime);
var fst = chunkFts[i] = chunkFts[i].Tick(deltaTime);
chunkSc[i] = chunkSc[i].Tick(fst.AggSteps);
}
}
else//has fixed time step no step counter
{
for (int i = 0; i < count; i++)
{
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(deltaTime);
chunkFts[i] = chunkFts[i].Tick(deltaTime);
}
}
}
//no fixed time step
else
{
for (int i = 0; i < count; i++)
{
chunkElapsedTime[i] = chunkElapsedTime[i].Tick(deltaTime);
}
}
}
}
else//no ElapsedTime
{
//has DeltaTime no ElapsedTime
if (chunkDeltaTime != default)
{
if (chunkFts != default) //has fixed time step
{
if (chunkSc != default) //has step counter
{
for (int i = 0; i < count; i++)
{
chunkDeltaTime[i] = deltaTime;
var fst = chunkFts[i] = chunkFts[i].Tick(deltaTime);
chunkSc[i] = chunkSc[i].Tick(fst.AggSteps);
}
}
else//has fixed time step no step counter
{
for (int i = 0; i < count; i++)
{
chunkDeltaTime[i] = deltaTime;
chunkFts[i] = chunkFts[i].Tick(deltaTime);
}
}
}
//no fixed time step
else
{
for (int i = 0; i < count; i++)
{
chunkDeltaTime[i] = deltaTime;
}
}
}
else//no DeltaTime no ElapsedTime
{
if (chunkFts != default)//has fixed time step
{
if (chunkSc != default)//has step counter
{
for (int i = 0; i < count; i++)
{
var fst = chunkFts[i] = chunkFts[i].Tick(deltaTime);
chunkSc[i] = chunkSc[i].Tick(fst.AggSteps);
}
}
else//has fixed time step no step counter
{
for (int i = 0; i < count; i++)
{
chunkFts[i] = chunkFts[i].Tick(deltaTime);
}
}
}
}
//else no DeltaTime no ElapsedTime no fixedtime step no update
}
}
}
public int CalculateImportance(ArchetypeChunk chunk)
{
return(1);
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
Job.Execute(chunk, chunkIndex, firstEntityIndex, List.GetData(), List.Length);
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
NativeArray <Entity> _entityArray = chunk.GetNativeArray(_entityHandle);
_ecb.Instantiate(chunkIndex, _entityArray[0]);
}
public unsafe void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex, DynamicComponentTypeHandle *ghostChunkComponentTypesPtr, int ghostChunkComponentTypesLength)
{
var entityList = chunk.GetNativeArray(entityType);
var snapshotDataList = chunk.GetNativeArray(snapshotDataType);
var snapshotDataBufferList = chunk.GetBufferAccessor(snapshotDataBufferType);
var snapshotDynamicDataBufferList = chunk.GetBufferAccessor(snapshotDynamicDataBufferType);
var GhostCollection = GhostCollectionFromEntity[GhostCollectionSingleton];
var GhostTypeCollection = GhostTypeCollectionFromEntity[GhostCollectionSingleton];
var ghostTypeComponent = ghostTypeFromEntity[entityList[0]];
int ghostType;
for (ghostType = 0; ghostType < GhostCollection.Length; ++ghostType)
{
if (GhostCollection[ghostType].GhostType == ghostTypeComponent)
{
break;
}
}
if (ghostType >= GhostCollection.Length)
{
throw new InvalidOperationException("Could not find ghost type in the collection");
}
if (ghostType >= GhostTypeCollection.Length)
{
return; // serialization data has not been loaded yet
}
var GhostComponentCollection = GhostComponentCollectionFromEntity[GhostCollectionSingleton];
var GhostComponentIndex = GhostComponentIndexFromEntity[GhostCollectionSingleton];
var spawnList = spawnListFromEntity[spawnListEntity];
var typeData = GhostTypeCollection[ghostType];
var snapshotSize = typeData.SnapshotSize;
int changeMaskUints = GhostCollectionSystem.ChangeMaskArraySizeInUInts(typeData.ChangeMaskBits);
var snapshotBaseOffset = GhostCollectionSystem.SnapshotSizeAligned(4 + changeMaskUints * 4);
var serializerState = new GhostSerializerState
{
GhostFromEntity = ghostFromEntity
};
var buffersToSerialize = new NativeList <BufferDataEntry>(Allocator.Temp);
for (int i = 0; i < entityList.Length; ++i)
{
var entity = entityList[i];
var ghostComponent = ghostFromEntity[entity];
ghostComponent.ghostType = ghostType;
ghostFromEntity[entity] = ghostComponent;
// Set initial snapshot data
// Get the buffers, fill in snapshot size etc
snapshotDataList[i] = new SnapshotData {
SnapshotSize = snapshotSize, LatestIndex = 0
};
var snapshotDataBuffer = snapshotDataBufferList[i];
snapshotDataBuffer.ResizeUninitialized(snapshotSize * GhostSystemConstants.SnapshotHistorySize);
var snapshotPtr = (byte *)snapshotDataBuffer.GetUnsafePtr();
UnsafeUtility.MemClear(snapshotPtr, snapshotSize * GhostSystemConstants.SnapshotHistorySize);
*(uint *)snapshotPtr = spawnTick;
var snapshotOffset = snapshotBaseOffset;
var dynamicSnapshotDataOffset = 0;
//Loop through all the serializable components and copy their data into the snapshot.
//For buffers, we collect what we need to serialize and then we copy the content in a second
//step. This is necessary because we need to resize the dynamic snapshot buffer
int numBaseComponents = typeData.NumComponents - typeData.NumChildComponents;
for (int comp = 0; comp < numBaseComponents; ++comp)
{
int compIdx = GhostComponentIndex[typeData.FirstComponent + comp].ComponentIndex;
int serializerIdx = GhostComponentIndex[typeData.FirstComponent + comp].SerializerIndex;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (compIdx >= ghostChunkComponentTypesLength)
{
throw new InvalidOperationException("Component index out of range");
}
#endif
var componentSnapshotSize = GhostComponentCollection[serializerIdx].ComponentType.IsBuffer
? GhostCollectionSystem.SnapshotSizeAligned(GhostSystemConstants.DynamicBufferComponentSnapshotSize)
: GhostCollectionSystem.SnapshotSizeAligned(GhostComponentCollection[serializerIdx].SnapshotSize);
var compSize = GhostComponentCollection[serializerIdx].ComponentSize;
if (!chunk.Has(ghostChunkComponentTypesPtr[compIdx]))
{
UnsafeUtility.MemClear(snapshotPtr + snapshotOffset, componentSnapshotSize);
}
else if (!GhostComponentCollection[serializerIdx].ComponentType.IsBuffer)
{
var compData = (byte *)chunk.GetDynamicComponentDataArrayReinterpret <byte>(ghostChunkComponentTypesPtr[compIdx], compSize).GetUnsafeReadOnlyPtr();
GhostComponentCollection[serializerIdx].CopyToSnapshot.Ptr.Invoke((IntPtr)UnsafeUtility.AddressOf(ref serializerState), (IntPtr)snapshotPtr, snapshotOffset, snapshotSize, (IntPtr)(compData + i * compSize), compSize, 1);
}
else
{
// Collect the buffer data to serialize by storing pointers, offset and size.
var bufData = chunk.GetUntypedBufferAccessor(ref ghostChunkComponentTypesPtr[compIdx]);
var bufferPointer = (IntPtr)bufData.GetUnsafeReadOnlyPtrAndLength(i, out var bufferLen);
var snapshotData = (uint *)(snapshotPtr + snapshotOffset);
snapshotData[0] = (uint)bufferLen;
snapshotData[1] = (uint)dynamicSnapshotDataOffset;
buffersToSerialize.Add(new BufferDataEntry
{
offset = dynamicSnapshotDataOffset,
len = bufferLen,
serializerIdx = serializerIdx,
bufferData = bufferPointer
});
var maskSize = SnapshotDynamicBuffersHelper.GetDynamicDataChangeMaskSize(GhostComponentCollection[serializerIdx].ChangeMaskBits, bufferLen);
dynamicSnapshotDataOffset += GhostCollectionSystem.SnapshotSizeAligned(maskSize + GhostComponentCollection[serializerIdx].ComponentSize * bufferLen);
}
snapshotOffset += componentSnapshotSize;
}
if (typeData.NumChildComponents > 0)
{
var linkedEntityGroupAccessor = chunk.GetBufferAccessor(linkedEntityGroupType);
for (int comp = numBaseComponents; comp < typeData.NumComponents; ++comp)
{
int compIdx = GhostComponentIndex[typeData.FirstComponent + comp].ComponentIndex;
int serializerIdx = GhostComponentIndex[typeData.FirstComponent + comp].SerializerIndex;
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (compIdx >= ghostChunkComponentTypesLength)
{
throw new System.InvalidOperationException("Component index out of range");
}
#endif
var compSize = GhostComponentCollection[serializerIdx].ComponentSize;
var linkedEntityGroup = linkedEntityGroupAccessor[i];
var childEnt = linkedEntityGroup[GhostComponentIndex[typeData.FirstComponent + comp].EntityIndex].Value;
var componentSnapshotSize = GhostComponentCollection[serializerIdx].ComponentType.IsBuffer
? GhostCollectionSystem.SnapshotSizeAligned(GhostSystemConstants.DynamicBufferComponentSnapshotSize)
: GhostCollectionSystem.SnapshotSizeAligned(GhostComponentCollection[serializerIdx].SnapshotSize);
//We can skip here, becase the memory buffer offset is computed using the start-end entity indices
if (!childEntityLookup.TryGetValue(childEnt, out var childChunk) || !childChunk.chunk.Has(ghostChunkComponentTypesPtr[compIdx]))
{
UnsafeUtility.MemClear(snapshotPtr + snapshotOffset, componentSnapshotSize);
}
else if (!GhostComponentCollection[serializerIdx].ComponentType.IsBuffer)
{
var compData = (byte *)childChunk.chunk.GetDynamicComponentDataArrayReinterpret <byte>(ghostChunkComponentTypesPtr[compIdx], compSize).GetUnsafeReadOnlyPtr();
compData += childChunk.index * compSize;
GhostComponentCollection[serializerIdx].CopyToSnapshot.Ptr.Invoke((System.IntPtr)UnsafeUtility.AddressOf(ref serializerState),
(System.IntPtr)snapshotPtr, snapshotOffset, snapshotSize, (System.IntPtr)compData, compSize, 1);
}
else
{
// Collect the buffer data to serialize by storing pointers, offset and size.
var bufData = childChunk.chunk.GetUntypedBufferAccessor(ref ghostChunkComponentTypesPtr[compIdx]);
var bufferPointer = (IntPtr)bufData.GetUnsafeReadOnlyPtrAndLength(childChunk.index, out var bufferLen);
var snapshotData = (uint *)(snapshotPtr + snapshotOffset);
snapshotData[0] = (uint)bufferLen;
snapshotData[1] = (uint)dynamicSnapshotDataOffset;
buffersToSerialize.Add(new BufferDataEntry
{
offset = dynamicSnapshotDataOffset,
len = bufferLen,
serializerIdx = serializerIdx,
bufferData = bufferPointer
});
var maskSize = SnapshotDynamicBuffersHelper.GetDynamicDataChangeMaskSize(GhostComponentCollection[serializerIdx].ChangeMaskBits, bufferLen);
dynamicSnapshotDataOffset += GhostCollectionSystem.SnapshotSizeAligned(maskSize + GhostComponentCollection[serializerIdx].ComponentSize * bufferLen);
}
snapshotOffset += componentSnapshotSize;
}
}
//Second step (necessary only for buffers): resize the dynamicdata snapshot buffer and copy the buffer contents
if (GhostTypeCollection[ghostType].NumBuffers > 0 && buffersToSerialize.Length > 0)
{
var dynamicDataCapacity = SnapshotDynamicBuffersHelper.CalculateBufferCapacity((uint)dynamicSnapshotDataOffset, out _);
var headerSize = SnapshotDynamicBuffersHelper.GetHeaderSize();
var snapshotDynamicDataBuffer = snapshotDynamicDataBufferList[i];
snapshotDynamicDataBuffer.ResizeUninitialized((int)dynamicDataCapacity);
var snapshotDynamicDataBufferPtr = (byte *)snapshotDynamicDataBuffer.GetUnsafePtr() + headerSize;
((uint *)snapshotDynamicDataBuffer.GetUnsafePtr())[0] = (uint)dynamicSnapshotDataOffset;
for (int buf = 0; buf < buffersToSerialize.Length; ++buf)
{
var entry = buffersToSerialize[buf];
var dynamicDataSize = GhostComponentCollection[entry.serializerIdx].SnapshotSize;
var compSize = GhostComponentCollection[entry.serializerIdx].ComponentSize;
var maskSize = SnapshotDynamicBuffersHelper.GetDynamicDataChangeMaskSize(GhostComponentCollection[entry.serializerIdx].ChangeMaskBits, entry.len);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if ((maskSize + entry.offset + dynamicDataSize * entry.len) > dynamicDataCapacity)
{
throw new System.InvalidOperationException("Overflow writing data to dynamic snapshot memory buffer");
}
#endif
GhostComponentCollection[entry.serializerIdx].CopyToSnapshot.Ptr.Invoke((System.IntPtr)UnsafeUtility.AddressOf(ref serializerState),
(System.IntPtr)snapshotDynamicDataBufferPtr + maskSize, entry.offset, dynamicDataSize,
entry.bufferData, compSize, entry.len);
}
}
// Remove request component
commandBuffer.RemoveComponent <PredictedGhostSpawnRequestComponent>(entity);
// Add to list of predictive spawn component - maybe use a singleton for this so spawn systems can just access it too
spawnList.Add(new PredictedGhostSpawn {
entity = entity, ghostType = ghostType, spawnTick = spawnTick
});
}
}
public void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
{
var lodRequirement = chunk.GetNativeArray(LodRequirement);
var rootLodRequirement = chunk.GetNativeArray(RootLodRequirement);
var meshLods = chunk.GetNativeArray(MeshLODComponent);
var instanceCount = chunk.Count;
for (int i = 0; i < instanceCount; i++)
{
var meshLod = meshLods[i];
var lodGroupEntity = meshLod.Group;
var lodMask = meshLod.LODMask;
var lodGroup = MeshLODGroupComponent[lodGroupEntity];
// Cannot take LocalToWorld from the instances, because they might not all share the same pivot
lodRequirement[i] = new LodRequirement(lodGroup, LocalToWorldLookup[lodGroupEntity], lodMask);
}
var rootLodIndex = -1;
var lastLodRootMask = 0;
var lastLodRootGroupEntity = Entity.Null;
for (int i = 0; i < instanceCount; i++)
{
var meshLod = meshLods[i];
var lodGroupEntity = meshLod.Group;
var lodGroup = MeshLODGroupComponent[lodGroupEntity];
var parentMask = lodGroup.ParentMask;
var parentGroupEntity = lodGroup.ParentGroup;
//@TODO: Bring this optimization back
//var changedRoot = parentGroupEntity != lastLodRootGroupEntity || parentMask != lastLodRootMask || i == 0;
var changedRoot = true;
if (changedRoot)
{
rootLodIndex++;
RootLodRequirement rootLod;
rootLod.InstanceCount = 1;
if (parentGroupEntity == Entity.Null)
{
rootLod.LOD.WorldReferencePosition = new float3(0, 0, 0);
rootLod.LOD.MinDist = 0;
rootLod.LOD.MaxDist = 64000.0f;
}
else
{
var parentLodGroup = MeshLODGroupComponent[parentGroupEntity];
rootLod.LOD = new LodRequirement(parentLodGroup, LocalToWorldLookup[parentGroupEntity], parentMask);
rootLod.InstanceCount = 1;
if (parentLodGroup.ParentGroup != Entity.Null)
{
throw new System.NotImplementedException("Deep HLOD is not supported yet");
}
}
rootLodRequirement[rootLodIndex] = rootLod;
lastLodRootGroupEntity = parentGroupEntity;
lastLodRootMask = parentMask;
}
else
{
var lastRoot = rootLodRequirement[rootLodIndex];
lastRoot.InstanceCount++;
rootLodRequirement[rootLodIndex] = lastRoot;
}
}
/*
* var foundRootInstanceCount = 0;
* for (int i = 0; i < rootLodIndex + 1; i++)
* {
* var lastRoot = rootLodRequirement[i];
* foundRootInstanceCount += lastRoot.InstanceCount;
* }
*
* if (chunk.Count != foundRootInstanceCount)
* {
* throw new System.ArgumentException("Out of bounds");
* }
*/
}
private void snippets()
{
#region component-list-chunk-component
ComponentType[] compTypes =
{
ComponentType.ChunkComponent <ChunkComponentA>(),
ComponentType.ReadOnly <GeneralPurposeComponentA>()
};
Entity entity = EntityManager.CreateEntity(compTypes);
#endregion
#region em-snippet
EntityManager.AddChunkComponentData <ChunkComponentA>(entity);
#endregion
#region desc-chunk-component
EntityQueryDesc ChunksWithoutComponentADesc
= new EntityQueryDesc()
{
None = new ComponentType[] {
ComponentType.ChunkComponent <ChunkComponentA>()
}
};
EntityQuery ChunksWithoutChunkComponentA
= GetEntityQuery(ChunksWithoutComponentADesc);
EntityManager.AddChunkComponentData <ChunkComponentA>(
ChunksWithoutChunkComponentA,
new ChunkComponentA()
{
Value = 4
});
#endregion
#region use-chunk-component
EntityQueryDesc ChunksWithChunkComponentADesc
= new EntityQueryDesc()
{
All = new ComponentType[] {
ComponentType.ChunkComponent <ChunkComponentA>()
}
};
#endregion
#region archetype-chunk-component
EntityArchetype ArchetypeWithChunkComponent
= EntityManager.CreateArchetype(
ComponentType.ChunkComponent(typeof(ChunkComponentA)),
ComponentType.ReadWrite <GeneralPurposeComponentA>());
Entity newEntity
= EntityManager.CreateEntity(ArchetypeWithChunkComponent);
#endregion
{
EntityQuery ChunksWithChunkComponentA = default;
#region read-chunk-component
NativeArray <ArchetypeChunk> chunks
= ChunksWithChunkComponentA.CreateArchetypeChunkArray(
Allocator.TempJob);
foreach (var chunk in chunks)
{
var compValue =
EntityManager.GetChunkComponentData <ChunkComponentA>(chunk);
//..
}
chunks.Dispose();
#endregion
}
#region read-entity-chunk-component
if (EntityManager.HasChunkComponent <ChunkComponentA>(entity))
{
ChunkComponentA chunkComponentValue =
EntityManager.GetChunkComponentData <ChunkComponentA>(entity);
}
#endregion
{
ArchetypeChunk chunk = default;
#region set-chunk-component
EntityManager.SetChunkComponentData <ChunkComponentA>(
chunk, new ChunkComponentA()
{
Value = 7
});
#endregion
}
#region set-entity-chunk-component
var entityChunk = EntityManager.GetChunk(entity);
EntityManager.SetChunkComponentData <ChunkComponentA>(
entityChunk,
new ChunkComponentA()
{
Value = 8
});
#endregion
}
