protected override void OnUpdate()
{
var disconnectData = group.GetSharedComponentDataArray <OnDisconnected>();
Debug.LogWarningFormat("Disconnected from SpatialOS with reason: \"{0}\"",
disconnectData[0].ReasonForDisconnect);
}
protected override void OnUpdate()
{
if (flag)
{
return;
}
flag = true;
ComponentGroup planetGroup = GetComponentGroup(typeof(Planet), typeof(PlanetNoise));
ComponentGroup dataGroup = GetComponentGroup(typeof(PlanetSharedData));
ComponentDataArray <Planet> planetArray = planetGroup.GetComponentDataArray <Planet>();
ComponentDataArray <PlanetNoise> noiseArray = planetGroup.GetComponentDataArray <PlanetNoise>();
SharedComponentDataArray <PlanetSharedData> dataArray = dataGroup.GetSharedComponentDataArray <PlanetSharedData>();
GameObject prefab = dataArray[0].nodePrefab;
for (int i = 0; i < planetArray.Length; ++i)
{
Planet planet = planetArray[i];
PlanetNoise noise = noiseArray[i];
HyperDistance r = planet.radius;
for (int n = 0; n < 20; ++n)
{
Entity nodeEntity = EntityManager.Instantiate(prefab);
TerrainNode node = EntityManager.GetComponentData <TerrainNode>(nodeEntity);
node.level = 0;
node.planetData = planet;
node.noiseData = noise;
node.built = 0;
node.divided = 0;
node.hyperDistant = 1;
int idx = n * 3;
node.corner1 = icoVerts[idx];
node.corner2 = icoVerts[idx + 1];
node.corner3 = icoVerts[idx + 2];
EntityManager.SetComponentData(nodeEntity, node);
HyperPosition pos = math.normalize(node.corner1 + node.corner2 + node.corner3) * r;
PrecisePosition prspos = new PrecisePosition {
pos = pos.prs
};
EntityManager.SetComponentData(nodeEntity, prspos);
OctantPosition octpos = new OctantPosition {
pos = pos.oct
};
EntityManager.SetComponentData(nodeEntity, octpos);
}
}
}
protected override void OnUpdate()
{
transformGroup.SetFilter(TransformInternal.ComponentAuthority.Authoritative);
var rateLimitedConfigArray = transformGroup.GetSharedComponentDataArray <RateLimitedSendConfig>();
var transformArray = transformGroup.GetComponentDataArray <TransformInternal.Component>();
var transformToSendArray = transformGroup.GetComponentDataArray <TransformToSend>();
var lastTransformSentArray = transformGroup.GetComponentDataArray <LastTransformSentData>();
var ticksSinceLastUpdateArray = transformGroup.GetComponentDataArray <TicksSinceLastTransformUpdate>();
for (int i = 0; i < transformArray.Length; ++i)
{
var lastTransformSent = lastTransformSentArray[i];
lastTransformSent.TimeSinceLastUpdate += Time.deltaTime;
lastTransformSentArray[i] = lastTransformSent;
if (lastTransformSent.TimeSinceLastUpdate <
1.0f / rateLimitedConfigArray[i].MaxTransformUpdateRateHz)
{
continue;
}
var transform = transformArray[i];
var transformToSend = transformToSendArray[i];
var currentTransform = new TransformInternal.Component
{
Location = (transformToSend.Position - worker.Origin).ToImprobableLocation(),
Rotation = transformToSend.Orientation.ToImprobableQuaternion(),
Velocity = transformToSend.Velocity.ToImprobableVelocity(),
PhysicsTick = transform.PhysicsTick + ticksSinceLastUpdateArray[i].NumberOfTicks,
TicksPerSecond = tickRate.PhysicsTicksPerRealSecond
};
if (!(TransformUtils.HasChanged(currentTransform.Location, transform.Location) ||
TransformUtils.HasChanged(currentTransform.Rotation, transform.Rotation)))
{
continue;
}
lastTransformSent.TimeSinceLastUpdate = 0.0f;
lastTransformSent.Transform = transform;
lastTransformSentArray[i] = lastTransformSent;
transformArray[i] = currentTransform;
ticksSinceLastUpdateArray[i] = new TicksSinceLastTransformUpdate
{
NumberOfTicks = 0
};
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
var job = new SteeringJob()
{
Positions = group.GetComponentDataArray <Position>(),
Movements = group.GetComponentDataArray <MovementData>(),
SharedSteering = group.GetSharedComponentDataArray <SteeringSharedData>()[0],
Steerings = group.GetComponentDataArray <SteeringData>()
};
return(job.Schedule(group.GetComponentDataArray <SteeringData>().Length, 16, inputDeps));
}
protected override void OnUpdate()
{
var disconnectData = group.GetSharedComponentDataArray <OnDisconnected>();
if (disconnectData.Length != 1)
{
worker.LogDispatcher.HandleLog(LogType.Error,
new LogEvent($"{typeof(WorkerEntityTag)} should only be present on a single entity"));
}
OnDisconnected?.Invoke(disconnectData[0].ReasonForDisconnect);
}
private JobHandle ScheduleMembershipDebugJob(JobHandle inputDeps)
{
var handle = inputDeps;
var length = _membershipDebugGroup.CalculateLength();
if (length > 0)
{
handle = new MembershipDebugJob
{
EntityArray = _membershipDebugGroup.GetEntityArray(),
PhysicsObject = _membershipDebugGroup.GetSharedComponentDataArray <PhysicsObject>()[0]
}.Schedule(length, 64, inputDeps);
}
return(handle);
}
public void Initialize(
ComponentGroup group,
UnityEngine.Vector3 [] vertices,
UnityEngine.Vector3 [] normals,
NativeCounter.Concurrent counter
)
{
Particles = group.GetComponentDataArray <Particle>();
Positions = group.GetComponentDataArray <Position>();
Triangles = group.GetComponentDataArray <Triangle>();
Variants = group.GetSharedComponentDataArray <SimpleParticle>();
Vertices = UnsafeUtility.AddressOf(ref vertices[0]);
Normals = UnsafeUtility.AddressOf(ref normals[0]);
Counter = counter;
}
protected override void OnUpdate()
{
var source = group.GetComponentDataArray <CountData>();
var range = group.GetSharedComponentDataArray <RangeData>();
for (int i = 0; i < source.Length; i++)
{
var countData = source[i];
if (range[i].max < countData.count)
{
countData.count = range[i].min;
source[i] = countData;
}
}
}
protected override void OnUpdate()
{
var sharedComponents = m_MissingRenderBounds.GetSharedComponentDataArray <RenderMesh>();
var entities = m_MissingRenderBounds.GetEntityArray();
for (int i = 0; i != sharedComponents.Length; i++)
{
var meshRenderer = sharedComponents[i];
if (meshRenderer.mesh != null)
{
PostUpdateCommands.AddComponent(entities[i], new RenderBounds {
Value = meshRenderer.mesh.bounds
});
}
}
}
protected override void OnUpdate()
{
var sprites = group.GetComponentDataArray <AnimationSpriteData>();
var anims = group.GetSharedComponentDataArray <AnimationData>();
float delta = UnityEngine.Time.deltaTime;
for (int i = 0; i < sprites.Length; i++)
{
AnimationSpriteData sprite = sprites[i];
AnimationData anim = anims[i];
Process(ref sprite, ref anim, delta);
sprites[i] = sprite;
}
}
protected override void OnUpdate()
{
//TODO m_Group.SetFilter(new STNetworkEntityProperty() { IsControllable = true }); //< we only want to process controllable entities
var entityInputs = m_Group.GetComponentDataArray <STDefault_EntityInput>();
var networkProperties = m_Group.GetSharedComponentDataArray <NetworkEntity>();
for (int i = 0; i < entityInputs.Length; i++)
{
var entityInput = entityInputs[i];
entityInput.Direction = new Vector3(Input.GetAxisRaw("Horizontal"), 0, Input.GetAxisRaw("Vertical")).normalized;
entityInput.SpaceKey = new STInputKey(Input.GetButtonDown("Jump"), Input.GetButtonUp("Jump"), Input.GetButton("Jump"));
//entityInput.ShiftKey = new STInputKey(Input.GetButtonDown("Sprint"), Input.GetButtonUp("Sprint"), Input.GetButton("Sprint"));
entityInputs[i] = entityInput;
}
}
protected override void OnUpdate()
{
m_Group.SetFilter(new NetworkEntity()
{
IsLocal = true
});
var networkComponents = m_Group.GetSharedComponentDataArray <NetworkEntity>();
var inputComponents = m_Group.GetComponentDataArray <FreeMovementInputReceiver>();
for (int i = 0; i != networkComponents.Length; i++)
{
var netComponent = networkComponents[i];
var inputComponent = inputComponents[i];
if (netComponent.LocalControlId == 0) //< We only work with the first player for now
{
}
}
}
protected override void OnUpdate()
{
positionGroup.SetFilter(Position.ComponentAuthority.Authoritative);
var rateLimitedConfigArray = positionGroup.GetSharedComponentDataArray <RateLimitedSendConfig>();
var positionArray = positionGroup.GetComponentDataArray <Position.Component>();
var transformArray = positionGroup.GetComponentDataArray <TransformInternal.Component>();
var lastSentPositionArray = positionGroup.GetComponentDataArray <LastPositionSentData>();
for (int i = 0; i < positionArray.Length; ++i)
{
var position = positionArray[i];
var lastPositionSent = lastSentPositionArray[i];
lastPositionSent.TimeSinceLastUpdate += Time.deltaTime;
lastSentPositionArray[i] = lastPositionSent;
if (lastPositionSent.TimeSinceLastUpdate <
1.0f / rateLimitedConfigArray[i].MaxPositionUpdateRateHz)
{
continue;
}
var transform = transformArray[i];
var coords = transform.Location.ToCoordinates();
if (!TransformUtils.HasChanged(coords, position.Coords))
{
continue;
}
position.Coords = coords;
positionArray[i] = position;
lastPositionSent.TimeSinceLastUpdate = 0.0f;
lastPositionSent.Position = position;
lastSentPositionArray[i] = lastPositionSent;
}
}
protected virtual void OnRender(ref int[] sort)
{
var sprites = group.GetComponentDataArray <AnimationSpriteData>();
var pos = group.GetComponentDataArray <PositionData>();
var meshes = group.GetSharedComponentDataArray <SpriteMeshesData>();
cmd.Clear();
cmd.SetViewProjectionMatrices(camera.worldToCameraMatrix, UnityEngine.GL.GetGPUProjectionMatrix(camera.projectionMatrix, false));
//for(int i=0; i<sprites.Length; i++)
for (int indx = 0; indx < sort.Length; indx++)
{
int i = sort[indx];
AnimationSpriteData sprite = sprites[i];
PositionData position = pos[i];
SpriteMeshesData mesh = meshes[i];
cmd.DrawMesh(mesh.Meshes[sprite.spriteIndx], UnityEngine.Matrix4x4.Translate(position.Value), material);
}
}
protected override void OnUpdate()
{
var collisionPositions = _targetsComponentGroup.GetComponentDataArray <Position>();
var collisions = _targetsComponentGroup.GetSharedComponentDataArray <Collision>();
var entities = _targetsComponentGroup.GetEntityArray();
var explosions = new NativeList <Position>(Allocator.Temp);
for (var i = 0; i < _group.Length; i++)
{
var bulletPosition = _group.Positions[i];
var bulletCollision = _group.Collisions[i];
if (CheckBulletCollision(_group.Entites[i], bulletPosition, bulletCollision,
collisionPositions, collisions, entities))
{
explosions.Add(bulletPosition);
}
}
for (var i = 0; i < explosions.Length; i++)
{
CreateExplosion(explosions[i].Value);
}
explosions.Dispose();
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (groupToInit.GetEntityArray().Length == 0)
{
return(inputDeps);
}
var sharedIdxs = new List <SharedComponentIndexToAddComponentData>(20);
EntityManager.GetAllUniqueSharedComponentData(sharedIdxs);
for (int i = 0, length = sharedIdxs.Count; i < length; ++i)
{
var sharedIdx = sharedIdxs[i];
groupToInit.SetFilter(sharedIdx);
if (groupToInit.GetEntityArray().Length == 0)
{
continue;
}
var entities = new NativeArray <Entity>(groupToInit.GetEntityArray().ToArray(), Allocator.TempJob);
var neuralNetwork = neuralNetworkGroup.GetSharedComponentDataArray <NeuralNetworkComponentData>()[sharedIdx.Index];
var inputCount = neuralNetwork.PerceptronPerLayerCount[0];
neuralNetwork.Inputs = new NativeArray <float>(inputCount * entities.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
int perceptronCount = inputCount, connectionCount = 0, previousCount = perceptronCount;
for (int j = 1, length2 = neuralNetwork.PerceptronPerLayerCount.Length; j < length2; ++j)
{
int perceptronPerLayer = neuralNetwork.PerceptronPerLayerCount[j];
connectionCount += previousCount * perceptronPerLayer;
perceptronCount += perceptronPerLayer;
previousCount = perceptronPerLayer;
}
neuralNetwork.ConnectionCountPerNetwork = connectionCount;
neuralNetwork.PerceptronCountPerNetwork = perceptronCount;
neuralNetwork.ResultCountPerNetwork = perceptronCount - inputCount;
neuralNetwork.PerceptronCount = (perceptronCount * entities.Length);
neuralNetwork.Results = new NativeArray <float>((perceptronCount * entities.Length) - (inputCount * entities.Length), Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
neuralNetwork.Connections = new NativeArray <float>(connectionCount * entities.Length, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
var randomNumbers = new NativeList <float>(connectionCount * entities.Length, Allocator.TempJob);
for (int j = 0, count = connectionCount * entities.Length; j < count; ++j)
{
randomNumbers.Add(UnityEngine.Random.Range(-neuralNetwork.WeightRange, neuralNetwork.WeightRange));
}
var job = new InitConnection {
PerceptronPerLayer = neuralNetwork.PerceptronPerLayerCount,
Connections = neuralNetwork.Connections,
RandomNumbers = randomNumbers,
ConnectionPerNetwork = connectionCount
};
var handle = job.ScheduleBatch(perceptronCount * entities.Length, perceptronCount, inputDeps);
JobHandle.ScheduleBatchedJobs();
handle.Complete();
for (int j = 0, entityCount = entities.Length; j < entityCount; ++j)
{
var entity = entities[j];
EntityManager.AddSharedComponentData(entity, neuralNetwork);
EntityManager.AddComponentData(entity, new InitializedComponentData());
EntityManager.RemoveComponent <SharedComponentIndexToAddComponentData>(entity);
EntityManager.RemoveComponent <InitializeNeuralNetworkComponentData>(entity);
}
randomNumbers.Dispose();
entities.Dispose();
}
return(inputDeps);
}
protected override void OnUpdate()
{
interpolationGroup.SetFilter(TransformInternal.ComponentAuthority.NotAuthoritative);
var interpolationConfigArray = interpolationGroup.GetSharedComponentDataArray <InterpolationConfig>();
var bufferedTransformArray = interpolationGroup.GetBufferArray <BufferedTransform>();
var spatialEntityIdArray = interpolationGroup.GetComponentDataArray <SpatialEntityId>();
var transformComponentArray = interpolationGroup.GetComponentDataArray <TransformInternal.Component>();
var lastTransformArray = interpolationGroup.GetComponentDataArray <DeferredUpdateTransform>();
for (int i = 0; i < transformComponentArray.Length; ++i)
{
var config = interpolationConfigArray[i];
var transformBuffer = bufferedTransformArray[i];
var lastTransformApplied = lastTransformArray[i].Transform;
if (transformBuffer.Length >= config.MaxLoadMatchedBufferSize)
{
transformBuffer.Clear();
}
if (transformBuffer.Length == 0)
{
var currentTransformComponent = transformComponentArray[i];
if (currentTransformComponent.PhysicsTick <= lastTransformApplied.PhysicsTick)
{
continue;
}
lastTransformArray[i] = new DeferredUpdateTransform
{
Transform = currentTransformComponent
};
var transformToInterpolateTo = ToBufferedTransform(currentTransformComponent);
uint ticksToFill = math.max((uint)config.TargetBufferSize, 1);
if (ticksToFill > 1)
{
var transformToInterpolateFrom = ToBufferedTransformAtTick(lastTransformApplied,
transformToInterpolateTo.PhysicsTick - ticksToFill + 1);
transformBuffer.Add(transformToInterpolateFrom);
for (uint j = 0; j < ticksToFill - 2; ++j)
{
transformBuffer.Add(InterpolateValues(transformToInterpolateFrom, transformToInterpolateTo,
j + 1));
}
}
transformBuffer.Add(transformToInterpolateTo);
continue;
}
var updates =
updateSystem
.GetEntityComponentUpdatesReceived <TransformInternal.Update>(spatialEntityIdArray[i].EntityId);
for (int j = 0; j < updates.Count; ++j)
{
var update = updates[j].Update;
UpdateLastTransform(ref lastTransformApplied, update);
lastTransformArray[i] = new DeferredUpdateTransform
{
Transform = lastTransformApplied
};
if (!update.PhysicsTick.HasValue)
{
continue;
}
var transformToInterpolateTo = ToBufferedTransform(lastTransformApplied);
var transformToInterpolateFrom = transformBuffer[transformBuffer.Length - 1];
uint lastTickId = transformToInterpolateFrom.PhysicsTick;
// This could go backwards if authority changes quickly between two workers with different loads
if (lastTickId >= transformToInterpolateTo.PhysicsTick)
{
continue;
}
uint ticksToFill = math.max(transformToInterpolateTo.PhysicsTick - lastTickId, 1);
for (uint k = 0; k < ticksToFill - 1; ++k)
{
transformBuffer.Add(InterpolateValues(transformToInterpolateFrom, transformToInterpolateTo,
k + 1));
}
transformBuffer.Add(transformToInterpolateTo);
}
}
}
private JobHandle ScheduleCounting(JobHandle inputDeps)
{
switch (_config.Method)
{
case TestMethod.InstancedByteComponent:
if (_config.InterestingStateCount == 1)
{
return(new CountSpecificInstancedByteStateJob
{
Components = _groupWithInstancedByteComponent.Components,
StateToCheckFor = 0
}.Schedule(_groupWithInstancedByteComponent.Length, 64, inputDeps));
}
else
{
FillStatesToCheckFor();
return(new CountMultipleInstancedByteStatesJob
{
Components = _groupWithInstancedByteComponent.Components,
StatesToCheckFor = _statesToCheckFor
}.Schedule(_groupWithInstancedByteComponent.Length, 64, inputDeps));
}
case TestMethod.AddRemoveInstancedComponent:
return(new CountExistingComponentsJob
{
}.Schedule(_groupWithInstancedBinaryComponent.Length, 64, inputDeps));
case TestMethod.AddRemoveSharedComponent:
return(new CountExistingComponentsJob
{
}.Schedule(_groupWithSharedBinaryComponent.Length, 64, inputDeps));
case TestMethod.SetValueSharedComponentForEachFilter:
var uniques = new List <SharedByteState>();
EntityManager.GetAllUniqueSharedComponentDatas(uniques);
var filter = _byteStateGroup.CreateForEachFilter(uniques);
for (int i = 0; i < filter.Length; i++)
{
if (_config.InterestingStateCount > uniques[i].State)
{
var interestingCount = _byteStateGroup.GetEntityArray(filter, i).Length;
var forEachHandle = new CountExistingComponentsJob
{
}.Schedule(interestingCount, 64, inputDeps);
filter.Dispose();
return(forEachHandle);
}
}
filter.Dispose();
return(inputDeps);
case TestMethod.SetValueSharedComponentSetFilter:
if (_config.InterestingStateCount == 1)
{
var handle = ScheduleCountForFilterWithState(0, inputDeps);
_byteStateGroup.ResetFilter();
return(handle);
}
else
{
var filterHandles = new NativeList <JobHandle>(_config.InterestingStateCount, Allocator.Temp);
for (int i = 0; i < _config.InterestingStateCount; i++)
{
filterHandles.Add(ScheduleCountForFilterWithState(i, inputDeps));
}
var combinedFilterHandles = JobHandle.CombineDependencies(filterHandles);
_byteStateGroup.ResetFilter();
filterHandles.Dispose();
}
return(inputDeps);
case TestMethod.SetValueSharedComponentNoFilter:
var length = _byteStateGroup.CalculateLength();
if (length > 0)
{
if (_config.InterestingStateCount == 1)
{
return(new CountSpecificSharedByteStateJob
{
Components = _byteStateGroup.GetSharedComponentDataArray <SharedByteState>(),
StateToCheckFor = 0
}.Schedule(length, 64, inputDeps));
}
else
{
FillStatesToCheckFor();
return(new CountMultipleSharedByteStatesJob
{
Components = _byteStateGroup.GetSharedComponentDataArray <SharedByteState>(),
StatesToCheckFor = _statesToCheckFor
}.Schedule(length, 64, inputDeps));
}
}
return(inputDeps);
default:
return(inputDeps);
}
}
protected override void OnUpdate()
{
for (int i = meshCreationSets.Count - 1; i >= 0; --i)
{
if (meshCreationSets[i].jobHandle.IsCompleted)
{
meshCreationSets[i].jobHandle.Complete();
if (EntityManager.Exists(meshCreationSets[i].entity))
{
Mesh mesh = new Mesh();
mesh.vertices = meshCreationSets[i].verts.ToArray();
mesh.triangles = meshCreationSets[i].tris.ToArray();
mesh.RecalculateNormals();
HPMeshInstanceRenderer r = EntityManager.GetSharedComponentData <HPMeshInstanceRenderer>(meshCreationSets[i].entity);
r.mesh = mesh;
EntityManager.SetSharedComponentData(meshCreationSets[i].entity, r);
TerrainNode node = EntityManager.GetComponentData <TerrainNode>(meshCreationSets[i].entity);
if (node.level != 0 && EntityManager.Exists(node.parentEntity))
{
TerrainNode parentNode = EntityManager.GetComponentData <TerrainNode>(node.parentEntity);
if (parentNode.divided == 1)
{
++parentNode.childrenBuilt;
if (parentNode.childrenBuilt == 4)
{
HPMeshInstanceRenderer parentR = EntityManager.GetSharedComponentData <HPMeshInstanceRenderer>(node.parentEntity);
parentR.mesh = null;
EntityManager.SetSharedComponentData(node.parentEntity, parentR);
}
EntityManager.SetComponentData(node.parentEntity, parentNode);
}
}
}
meshCreationSets[i].verts.Dispose();
meshCreationSets[i].tris.Dispose();
meshCreationSets.RemoveAt(i);
}
}
ComponentGroup nodeGroup = GetComponentGroup(typeof(TerrainNode), typeof(HPMeshInstanceRenderer), typeof(PrecisePosition), typeof(OctantPosition));
ComponentGroup camGroup = GetComponentGroup(typeof(Flycam), typeof(PrecisePosition), typeof(Rotation), typeof(OctantPosition));
ComponentGroup dataGroup = GetComponentGroup(typeof(PlanetSharedData));
SharedComponentDataArray <PlanetSharedData> planetDataArray = dataGroup.GetSharedComponentDataArray <PlanetSharedData>();
PlanetSharedData[] dataArray = new PlanetSharedData[planetDataArray.Length];
for (int i = 0; i < dataArray.Length; ++i)
{
dataArray[i] = planetDataArray[i];
}
EntityArray entityTempArray = nodeGroup.GetEntityArray();
Entity[] entityArray = new Entity[entityTempArray.Length];
for (int i = 0; i < entityArray.Length; ++i)
{
entityArray[i] = entityTempArray[i];
}
SharedComponentDataArray <HPMeshInstanceRenderer> meshCDArray = nodeGroup.GetSharedComponentDataArray <HPMeshInstanceRenderer>();
HPMeshInstanceRenderer[] meshArray = new HPMeshInstanceRenderer[meshCDArray.Length];
for (int i = 0; i < meshArray.Length; ++i)
{
meshArray[i] = meshCDArray[i];
}
ComponentDataArray <TerrainNode> nodeCDArray = nodeGroup.GetComponentDataArray <TerrainNode>();
TerrainNode[] nodeArray = new TerrainNode[nodeCDArray.Length];
for (int i = 0; i < nodeCDArray.Length; ++i)
{
nodeArray[i] = nodeCDArray[i];
}
ComponentDataArray <PrecisePosition> nodePosArray = nodeGroup.GetComponentDataArray <PrecisePosition>();
PrecisePosition[] posArray = new PrecisePosition[nodePosArray.Length];
for (int i = 0; i < nodePosArray.Length; ++i)
{
posArray[i] = nodePosArray[i];
}
ComponentDataArray <OctantPosition> nodeOctArray = nodeGroup.GetComponentDataArray <OctantPosition>();
OctantPosition[] octArray = new OctantPosition[nodePosArray.Length];
for (int i = 0; i < nodeOctArray.Length; ++i)
{
octArray[i] = nodeOctArray[i];
}
ComponentDataArray <PrecisePosition> camPosArray = camGroup.GetComponentDataArray <PrecisePosition>();
float3 camPos = camPosArray[0].pos;
ComponentDataArray <OctantPosition> camOctArray = camGroup.GetComponentDataArray <OctantPosition>();
int3 camOct = camOctArray[0].pos;
float octantSize = HyperposStaticReferences.OctantSize;
for (int i = 0; i < meshArray.Length; ++i)
{
if (nodeArray[i].built == 1 && nodeArray[i].divided == 0)
{
if (nodeArray[i].level < nodeArray[i].planetData.maxNodeLevels)
{
float3 corner0 = nodeArray[i].corner1;
float3 corner1 = nodeArray[i].corner2;
float3 corner2 = nodeArray[i].corner3;
HyperDistance sphereRadius = nodeArray[i].planetData.radius;
HyperPosition corner0Pos = corner0 * sphereRadius;
HyperPosition corner1Pos = corner1 * sphereRadius;
HyperDistance distToSubdivide = MathUtils.Distance(corner0Pos, corner1Pos)
* (PERCENT_DIST_TO_SUBDIVIDE_AT / 100f);
HyperPosition centerPos = GetNodeCenter(nodeArray[i]);
//if (UnityEngine.Random.Range(0, 20) == 2)
// Debug.Log(MathUtils.ToString(distToSubdivide) + "\n" + MathUtils.ToString(centerPos));
if (InSubdivideDist(camOct, camPos, centerPos.oct, centerPos.prs, distToSubdivide.oct, distToSubdivide.prs))
{
//Debug.Log(MathUtils.ToString(distToSubdivide) + "\n" + MathUtils.ToString(centerPos)
// + "\n" + camOct + " " + camPos);
Subdivide(entityArray[i], nodeArray[i], meshArray[i], dataArray[0],
distToSubdivide.prs, distToSubdivide.oct, centerPos.prs, centerPos.oct);
}
}
if (nodeArray[i].level > 0 && EntityManager.Exists(nodeArray[i].parentEntity))
{
HPMeshInstanceRenderer parentR
= EntityManager.GetSharedComponentData <HPMeshInstanceRenderer>(nodeArray[i].parentEntity);
//float dist = math.distance(camPos, nodeArray[i].parentCenter);
//HyperDistance dist = MathUtils.Distance(camOct, camPos,
// nodeArray[i].parentOctantCenter, nodeArray[i].parentPreciseCenter);
//if (parentR.mesh != null
// && (dist.octantDist < nodeArray[i].parentOctantSubdivideDist
// || (dist.octantDist == nodeArray[i].parentOctantSubdivideDist && dist.preciseDist < nodeArray[i].parentPreciseSubdivideDist)))
if (!InSubdivideDist(camOct, camPos, nodeArray[i].parentOctantCenter, nodeArray[i].parentPreciseCenter,
nodeArray[i].parentOctantSubdivideDist, nodeArray[i].parentPreciseSubdivideDist))
{
EntityManager.DestroyEntity(entityArray[i]);
}
}
}
else if (nodeArray[i].built == 0 && nodeArray[i].divided == 1)
{
float3 corner0 = nodeArray[i].corner1;
float3 corner1 = nodeArray[i].corner2;
float3 corner2 = nodeArray[i].corner3;
HyperDistance sphereRadius = nodeArray[i].planetData.radius;
HyperPosition corner0Pos = corner0 * sphereRadius;
HyperPosition corner1Pos = corner1 * sphereRadius;
HyperDistance distToSubdivide = MathUtils.Distance(corner0Pos, corner1Pos) * (PERCENT_DIST_TO_SUBDIVIDE_AT / 100f);
HyperPosition centerPos = GetNodeCenter(nodeArray[i]);
if (!InSubdivideDist(camOct, camPos, centerPos.oct, centerPos.prs, distToSubdivide.oct, distToSubdivide.prs))
{
nodeArray[i].divided = 0;
nodeArray[i].childrenBuilt = 0;
EntityManager.SetComponentData(entityArray[i], nodeArray[i]);
}
}
else if (nodeArray[i].built == 0 && nodeArray[i].divided == 0)
{
nodeArray[i].built = 1;
Planet planetData = nodeArray[i].planetData;
// rez is the number of vertices on one side of the mesh/triangle
// the part in parentheses is called the "Mersenne Number"
int rez = 2 + ((int)Mathf.Pow(2, planetData.meshSubdivisions) - 1);
// nTris is the number of tris in the mesh
int t = rez - 2;
int nTris = (t * (t + 1)) + (rez - 1);
// nVerts is the number of vertices in the mesh
// it is the formula for the "Triangle Sequence" of numbers
int nVerts = (rez * (rez + 1)) / 2;
NativeArray <Vector3> verts = new NativeArray <Vector3>(nVerts, Allocator.Persistent);
NativeArray <int> tris = new NativeArray <int>(nTris * 3, Allocator.Persistent);
HyperPosition centerPos = GetNodeCenter(nodeArray[i]);
HyperPosition camHyp = new HyperPosition {
prs = camPos, oct = camOct
};
HyperDistance dist = MathUtils.Distance(centerPos, camHyp);
//if (dist > planetData.hyperdistanceThreshold)
//{
// nodeArray[i].hyperDistant = 1;
// if(!EntityManager.HasComponent<HyperdistantMarker>(entityArray[i]))
// EntityManager.AddComponent(entityArray[i], typeof(HyperdistantMarker));
//}
//else
//{
// nodeArray[i].hyperDistant = 0;
// if (EntityManager.HasComponent<HyperdistantMarker>(entityArray[i]))
// EntityManager.RemoveComponent(entityArray[i], typeof(HyperdistantMarker));
//}
MeshBuildJob job = new MeshBuildJob();
job.node = nodeArray[i];
job.corner0 = nodeArray[i].corner3;
job.corner1 = nodeArray[i].corner2;
job.corner2 = nodeArray[i].corner1;
job.rez = rez;
job.nTris = nTris;
job.nVerts = nVerts;
job.verts = verts;
job.tris = tris;
JobHandle handle = job.Schedule();
JobHandle.ScheduleBatchedJobs();
MeshCreationSet mcs = new MeshCreationSet();
mcs.entity = entityArray[i];
mcs.jobHandle = handle;
mcs.verts = verts;
mcs.tris = tris;
meshCreationSets.Add(mcs);
EntityManager.SetComponentData(entityArray[i], nodeArray[i]);
}
}
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
if (!initialized)
{
Initialize();
initialized = true;
}
if (uninitializedPlayfieldGroup.CalculateLength() == 0)
{
return(inputDeps);
}
resultPositions.Clear();
playfieldIndex.Clear();
SharedComponentDataArray <Playfield> playfieldArray = uninitializedPlayfieldGroup.GetSharedComponentDataArray <Playfield>();
EntityArray entityArray = uninitializedPlayfieldGroup.GetEntityArray();
Playfield playfield = entityManager.GetSharedComponentData <Playfield>(entityArray[0]);
for (int i = 0; i < playfieldArray.Length; i++)
{
playfieldIndex.TryAdd(playfieldArray[i].index, i);
}
JobHandle combinedHandle = new JobHandle();
int totalNumCells = 0;
for (int i = 0; i < playfieldArray.Length; i++)
{
int size = playfieldArray[i].width * playfieldArray[i].height;
totalNumCells += size;
JobHandle pHandle = new PlayfieldCellPositionJob {
width = playfieldArray[i].width,
height = playfieldArray[i].height,
playfieldIndex = i,
cellDatas = positions.ToConcurrent(),
}.Schedule(size, 64, inputDeps);
if (i == 0)
{
combinedHandle = pHandle;
}
else
{
combinedHandle = JobHandle.CombineDependencies(combinedHandle, pHandle);
}
}
JobHandle qlHandle = new NativeQueueToNativeListJob <CellData> {
queue = positions,
out_list = resultPositions,
}.Schedule(combinedHandle);
JobHandle pijHandle = new PlayfieldCellCreationJob {
commandBuffer = initBarrier.CreateCommandBuffer().ToConcurrent(),
positions = resultPositions,
playfieldCellArchetype = playfieldCellArchetype,
playfieldArray = playfieldArray,
playfieldIndex = playfieldIndex,
}.Schedule(totalNumCells, 64, qlHandle);
JobHandle pfjHandle = new PlayfieldFinalizeJob {
commandBuffer = finalizeBarrier.CreateCommandBuffer().ToConcurrent(),
playfields = entityArray,
}.Schedule(entityArray.Length, 64, pijHandle);
return(pfjHandle);
}
