protected override void OnUpdate()
{
Entities.ForEach((Entity entity, ref GUIComponent guiComp) => {
if (guiComp.id == uiState)
{
return;
}
var guiPreset = EntityManager.GetSharedComponentData <GUIPresetComponent>(Utility.SystemEntity);
guiPreset.preset.GUIUpdate(guiComp.id);
switch (guiComp.id)
{
case IdUtility.GUIId.Title:
GameStart.Stop();
if (false == EntityManager.HasComponent <FadeInComponent>(Utility.SystemEntity))
{
EntityManager.AddComponentData(Utility.SystemEntity, new FadeInComponent()
{
time = 0.0f
});
}
EntityManager.AddComponentData(EntityManager.CreateEntity(), new SubSceneLoadComponent {
id = IdUtility.GUIId.Title,
delay = 0.0f
});
break;
case IdUtility.GUIId.InGame:
GameStart.Play();
GameOver.Play();
if (false == EntityManager.HasComponent <FadeOutComponent>(Utility.SystemEntity))
{
EntityManager.AddComponentData(Utility.SystemEntity, new FadeOutComponent()
{
time = 0.5f
});
}
EntityManager.AddComponentData(EntityManager.CreateEntity(), new SubSceneUnLoadComponent {
id = IdUtility.GUIId.Title,
delay = 0.0f
});
EntityManager.AddComponentData(EntityManager.CreateEntity(), new SubSceneUnLoadComponent {
id = IdUtility.GUIId.Result,
delay = 0.0f
});
EntityManager.AddComponentData(EntityManager.CreateEntity(), new SubSceneLoadComponent {
id = IdUtility.GUIId.InGame,
delay = 0.0f
});
break;
case IdUtility.GUIId.Over:
GameStart.Stop();
if (false == EntityManager.HasComponent <FadeInComponent>(Utility.SystemEntity))
{
EntityManager.AddComponentData(Utility.SystemEntity, new FadeInComponent()
{
time = 2.0f
});
}
EntityManager.AddComponentData(EntityManager.CreateEntity(), new SubSceneUnLoadComponent {
id = IdUtility.GUIId.InGame,
delay = 2.0f
});
EntityManager.AddComponentData(EntityManager.CreateEntity(), new SubSceneLoadComponent {
id = IdUtility.GUIId.Result,
delay = 1.0f
});
break;
case IdUtility.GUIId.Result:
break;
}
uiState = guiComp.id;
EntityManager.RemoveComponent <GUIComponent>(entity);
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new State());
dstManager.AddBuffer <AbilityUIElement>(entity);
dstManager.AddBuffer <PresentationElement>(entity);
}
void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new ModifyContactJacobians {
type = ModificationType
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new RotationEulerXYZ());
}
public void Instantiate_HasGetComponent_VisibleFromInsideForEach()
{
EntityManager.AddComponentData(EntityManager.CreateEntity(), new EcsTestData(5));
Entities
.WithStructuralChanges()
.ForEach((Entity e, ref EcsTestData testData) =>
{
Assert.AreEqual(5, testData.value);
Assert.IsFalse(EntityManager.HasComponent <EcsTestData2>(e));
Entity newe1 = EntityManager.Instantiate(e);
EntityManager.AddComponentData(e, new EcsTestData2()
{
value0 = 1, value1 = 3
});
{
EcsTestData2 ed2 = EntityManager.GetComponentData <EcsTestData2>(e);
Assert.AreEqual(3, ed2.value1);
Assert.AreEqual(1, ed2.value0);
}
Entity deferred = EntityManager.CreateEntity();
EntityManager.AddComponentData(deferred, testData);
{
var ed = EntityManager.GetComponentData <EcsTestData>(deferred);
Assert.AreEqual(testData.value, ed.value);
}
Entity newe2 = EntityManager.Instantiate(e);
Assert.IsFalse(EntityManager.HasComponent <EcsTestData2>(newe1));
{
EcsTestData ed = EntityManager.GetComponentData <EcsTestData>(newe1);
Assert.AreEqual(5, ed.value);
}
Assert.IsTrue(EntityManager.HasComponent <EcsTestData2>(e));
{
EcsTestData2 ed2 = EntityManager.GetComponentData <EcsTestData2>(newe2);
Assert.AreEqual(3, ed2.value1);
Assert.AreEqual(1, ed2.value0);
}
Assert.IsTrue(EntityManager.HasComponent <EcsTestData>(newe1));
EntityManager.RemoveComponent <EcsTestData>(newe1);
Assert.IsFalse(EntityManager.HasComponent <EcsTestData>(newe1));
}).Run();
using (var allEntities = EntityManager.GetAllEntities())
Assert.AreEqual(4, allEntities.Length);
using (var group = new ExtractTestDataFromEntityManager <EcsTestData>(EntityManager))
{
Assert.AreEqual(3, group.Values.Length);
Assert.AreEqual(5, group.Values[0].value); // e
Assert.AreEqual(5, group.Values[1].value); // deferred
Assert.AreEqual(5, group.Values[2].value); // newe2
}
using (var group = new ExtractTestDataFromEntityManager <EcsTestData2>(EntityManager))
{
Assert.AreEqual(2, group.Values.Length); // (e && newe2)
Assert.AreEqual(3, group.Values[0].value1);
Assert.AreEqual(1, group.Values[0].value0);
Assert.AreEqual(3, group.Values[1].value1);
Assert.AreEqual(1, group.Values[1].value0);
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new TurretBehaviour());
}
public static void CreateCharacterComponent(EntityManager entityManager, Entity e, Vector3 position,
Quaternion rotation)
{
entityManager.SetComponentData(e, new Translation {
Value = position
});
entityManager.SetComponentData(e, new Rotation {
Value = rotation
});
entityManager.AddComponentData(e, new Character());
entityManager.AddComponentData(e, new ReplicatedEntityData
{
Id = -1,
PredictingPlayerId = -1
});
entityManager.AddComponentData(e, new DespawnPredictedState()
{
IsDespawn = false,
Tick = 0
});
entityManager.AddComponentData(e, new TransformPredictedState
{
Position = position,
Rotation = rotation
});
entityManager.AddComponentData(e, new VelocityPredictedState
{
MotionType = MotionType.Kinematic,
Linear = float3.zero,
Angular = float3.zero
});
entityManager.AddComponentData(e, new CharacterInterpolatedState
{
Position = position,
Rotation = rotation
});
entityManager.AddComponentData(e, UserCommand.DefaultCommand);
entityManager.AddComponentData(e, new CharacterMoveSetting
{
Gravity = PhysicsStep.Default.Gravity,
SkinWidth = 0.02f,
Velocity = 9.0f,
MaxVelocity = 30.0f,
RotationVelocity = 22.5f,
JumpUpwardsVelocity = 4.0f,
MaxSlope = 60.0f,
MaxIterations = 5,
CharacterMass = 1.0f,
ContactTolerance = 0.1f,
AffectsPhysicsBodies = 1
});
entityManager.AddComponentData(e, new CharacterMovePredictedState
{
UnsupportedVelocity = float3.zero
});
entityManager.AddComponentData(e, new TriggerSetting
{
Distance = 1.0f,
IsMotionLess = true
// Distance = 3f
});
entityManager.AddComponentData(e, new TriggerPredictedState
{
TriggeredEntity = Entity.Null,
PreTriggeredEntity = Entity.Null,
IsAllowTrigger = true
});
//entityManager.AddComponentData(e, new SlotSetting()
//{
// Pos = new float3(0f,0.1f,0.8f)
//});
//entityManager.AddComponentData(e, new SlotPredictedState()
//{
// FilledIn = Entity.Null
//});
entityManager.AddComponentData(e, new ThrowSetting
{
Velocity = 17.0f,
DelayTick = 10
});
entityManager.AddComponentData(e, new ThrowPredictState
{
IsThrowed = false,
CurTick = 0
});
entityManager.AddComponentData(e, new RushSetting
{
Velocity = 28.0f,
DurationTick = 6,
CooldownTick = 30
});
entityManager.AddComponentData(e, new RushPredictState
{
CurCooldownTick = 0
});
entityManager.AddComponentData(e, new SlicePredictedState()
{
IsSlicing = false
});
entityManager.AddComponentData(e, new WashSetting());
entityManager.AddComponentData(e, new WashPredictedState()
{
IsWashing = false
});
entityManager.AddComponentData(e, new ServeSetting());
}
void Instantiate(int count)
{
var planetOwnership = new List <int>
{
1, 1,
2, 2
};
for (var i = 0; i < count; ++i)
{
var sphereRadius = UnityEngine.Random.Range(5.0f, 20.0f);
var safe = false;
float3 pos;
int attempts = 0;
do
{
if (++attempts >= 500)
{
Debug.Log("Couldn't find a good planet placement. Settling for the planets we already have");
return;
}
var randomValue = (Vector3)UnityEngine.Random.insideUnitSphere;
randomValue.y = 0;
pos = (randomValue * radius) + new Vector3(transform.position.x, transform.position.z);
var collisions = Physics.OverlapSphere(pos, sphereRadius);
if (!collisions.Any())
{
safe = true;
}
} while (!safe);
var randomRotation = UnityEngine.Random.insideUnitSphere;
var go = GameObject.Instantiate(_planetPrefab, pos, quaternion.identity);
var planetEntity = go.GetComponent <GameObjectEntity>().Entity;
var meshGo = go.GetComponentsInChildren <Transform>().First(c => c.gameObject != go).gameObject;
var collider = go.GetComponent <SphereCollider>();
var meshEntity = meshGo.GetComponent <GameObjectEntity>().Entity;
collider.radius = sphereRadius;
meshGo.transform.localScale = new Vector3(sphereRadius * 2.0f, sphereRadius * 2.0f, sphereRadius * 2.0f);
var planetData = new PlanetData
{
TeamOwnership = 0,
Radius = sphereRadius,
Position = pos
};
var rotationData = new RotationData
{
RotationSpeed = randomRotation
};
if (planetOwnership.Any())
{
planetData.TeamOwnership = planetOwnership.First();
planetOwnership.Remove(planetData.TeamOwnership);
}
else
{
planetData.Occupants = UnityEngine.Random.Range(1, 100);
}
entities[planetEntity] = go;
SetColor(planetEntity, planetData.TeamOwnership);
_entityManager.AddComponentData(planetEntity, planetData);
_entityManager.AddComponentData(meshEntity, rotationData);
}
}
public override void AddGraphSetupComponent(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var walkShortLeftClip = WalkShortLeftClip.ToDenseClip();
var walkLongLeftClip = WalkLongLeftClip.ToDenseClip();
var walkStraightClip = WalkStraightClip.ToDenseClip();
var walkLongRightClip = WalkLongRightClip.ToDenseClip();
var walkShortRightClip = WalkShortRightClip.ToDenseClip();
var jogShortLeftClip = JogShortLeftClip.ToDenseClip();
var jogLongLeftClip = JogLongLeftClip.ToDenseClip();
var jogStraightClip = JogStraightClip.ToDenseClip();
var jogLongRightClip = JogLongRightClip.ToDenseClip();
var jogShortRightClip = JogShortRightClip.ToDenseClip();
var clipConfiguration = new ClipConfiguration();
clipConfiguration.Mask = ClipConfigurationMask.LoopTime | ClipConfigurationMask.CycleRootMotion | ClipConfigurationMask.DeltaRootMotion;
clipConfiguration.Mask |= LoopValues ? ClipConfigurationMask.LoopValues : 0;
clipConfiguration.Mask |= BankPivot ? ClipConfigurationMask.BankPivot : 0;
clipConfiguration.MotionID = m_MotionId;
var graphSetup = new AnimationControllerSetup
{
WalkShortLeftClip = walkShortLeftClip,
WalkLongLeftClip = walkLongLeftClip,
WalkStraightClip = walkStraightClip,
WalkLongRightClip = walkLongRightClip,
WalkShortRightClip = walkShortRightClip,
JogShortLeftClip = jogShortLeftClip,
JogLongLeftClip = jogLongLeftClip,
JogStraightClip = jogStraightClip,
JogLongRightClip = jogLongRightClip,
JogShortRightClip = jogShortRightClip,
};
if (Bake)
{
var rigDefinition = dstManager.GetComponentData <Rig>(entity);
graphSetup.WalkShortLeftClip = UberClipNode.Bake(rigDefinition.Value, walkShortLeftClip, clipConfiguration, SampleRate);
graphSetup.WalkLongLeftClip = UberClipNode.Bake(rigDefinition.Value, walkLongLeftClip, clipConfiguration, SampleRate);
graphSetup.WalkStraightClip = UberClipNode.Bake(rigDefinition.Value, walkStraightClip, clipConfiguration, SampleRate);
graphSetup.WalkLongRightClip = UberClipNode.Bake(rigDefinition.Value, walkLongRightClip, clipConfiguration, SampleRate);
graphSetup.WalkShortRightClip = UberClipNode.Bake(rigDefinition.Value, walkShortRightClip, clipConfiguration, SampleRate);
graphSetup.JogShortLeftClip = UberClipNode.Bake(rigDefinition.Value, jogShortLeftClip, clipConfiguration, SampleRate);
graphSetup.JogLongLeftClip = UberClipNode.Bake(rigDefinition.Value, jogLongLeftClip, clipConfiguration, SampleRate);
graphSetup.JogStraightClip = UberClipNode.Bake(rigDefinition.Value, jogStraightClip, clipConfiguration, SampleRate);
graphSetup.JogLongRightClip = UberClipNode.Bake(rigDefinition.Value, jogLongRightClip, clipConfiguration, SampleRate);
graphSetup.JogShortRightClip = UberClipNode.Bake(rigDefinition.Value, jogShortRightClip, clipConfiguration, SampleRate);
clipConfiguration.Mask = ClipConfigurationMask.NormalizedTime | ClipConfigurationMask.LoopTime | ClipConfigurationMask.RootMotionFromVelocity;
clipConfiguration.MotionID = 0;
}
else
{
clipConfiguration.Mask |= ClipConfigurationMask.NormalizedTime;
}
graphSetup.Configuration = clipConfiguration;
dstManager.AddComponentData(entity, graphSetup);
dstManager.AddComponent <ProcessDefaultAnimationGraph.AnimatedRootMotion>(entity);
dstManager.AddComponent <DeltaTime>(entity);
}
protected virtual void SetEntityComponentsData(Entity entity, EntityManager manager)
{
var translation = this.transform.position;
manager.SetComponentData(entity, new Translation()
{
Value = new float3(
translation.x + UnityEngine.Random.Range(-spawnRandRange, spawnRandRange),
translation.y + UnityEngine.Random.Range(-spawnRandRange, spawnRandRange),
0f
)
});
manager.SetComponentData(entity, new VelocityAbsoluteComponentData()
{
value = velocity
});
manager.SetComponentData(entity, new Scale()
{
Value = 1f
});
manager.SetComponentData(entity, new RenderScaleComponentdata()
{
value = new float2(flipHorisontalScale ? -1 : 1, 1)
});
manager.SetComponentData(entity, DataToComponentData.ToComponentData(scaleByPosSettings));
manager.SetComponentData(entity, new FactionComponentData()
{
value = faction
});
manager.SetComponentData(entity, new LinearMovementComponentData()
{
doMoving = true
});
manager.SetComponentData(entity, new HealthComponentData()
{
value = health
});
manager.SetComponentData(entity, new DestroyWithHealthComponentData()
{
delay = 1f
});
manager.SetComponentData(entity, new SpriteTintComponentData()
{
color = tint
});
manager.SetComponentData(entity, DataToComponentData.ToComponentData(ZbyYSettings));
manager.SetComponentData(entity, new SpriteRendererComponentData()
{
usePivot = true,
pivot = new Vector2(0.5f, 0)
});
manager.SetComponentData(entity, new FlibHorisontalByMoveDirTagComponentData()
{
defaultFlipped = flipHorisontalScale
});
manager.SetComponentData(entity, new FlibHorisontalByTargetTagComponentData()
{
defaultFlipped = flipHorisontalScale
});
if (updateAnimationStatesBuTriggers)
{
manager.AddComponent <AnimatorStateLastTriggeredAnimationComponentData>(entity);
}
CastSpritesShadowComponentData shd;
if (!useLocalDefauldShadowSetting && shadowSettings != null)
{
shd = DataToComponentData.ToComponentData(shadowSettings);
}
else
{
shd = shadowData;
}
shd.disableCastShadow = !castSpriteShadows;
manager.SetComponentData(entity, shd);
if (shiftShadows)
{
manager.AddComponentData(entity, new ShiftCastShadowsTagComponentData()
{
positionUnitsOffsetDefaultValue = shd.positionUnitsOffset
});
}
manager.SetComponentData(entity, new AudioClipComponentData()
{
audioSourcePoolId = squadId,
randRangeId = randClipId,
maxClipId = actionSoundMaxClipId,
clipId = actionSoundClipId
});
manager.SetComponentData(entity, new DeathAudioClipComponentData()
{
audio = new AudioClipComponentData()
{
audioSourcePoolId = squadId,
randRangeId = deathRandClipId,
maxClipId = deathSoundMaxClipId,
clipId = deathSoundClipId
}
});
}
private void AddAnimations(EntityManager EntityManager)
{
int chestIndex = 0;
int headIndex = 1;
int hipsIndex = 2;
int leftLegBegin = 3;
int rightLegBegin = 6;
int leftArmBegin = 9;
int rightArmBegin = 13;
float armSwingLength = 3 / 32f;
float swingSpeed = 0.9f;
for (int i = 0; i < bones.Length; i++)
{
var bone = bones[i];
var position = EntityManager.GetComponentData <Bone>(bone).position;
// head bob
if (i == headIndex)
{
EntityManager.AddComponentData(bone, new PositionLerper
{
createdTime = UnityEngine.Time.time,
lifeTime = 0.9f,
positionBegin = position - new float3(0, 1 / 32f, 0f),
positionEnd = position + new float3(0, 1 / 32f, 0f),
loop = 1
});
}
// left arm animation
if (i >= leftArmBegin && i <= leftArmBegin + 3)
{
EntityManager.AddComponentData(bone, new PositionLerper
{
createdTime = UnityEngine.Time.time,
lifeTime = swingSpeed,
positionBegin = position - new float3(0, 0, armSwingLength + (i - leftArmBegin) * armSwingLength),
positionEnd = position + new float3(0, 0, armSwingLength + (i - leftArmBegin) * armSwingLength),
loop = 1
});
}
// right arm animation
if (i >= rightArmBegin && i <= rightArmBegin + 3)
{
EntityManager.AddComponentData(bone, new PositionLerper
{
createdTime = UnityEngine.Time.time,
lifeTime = swingSpeed,
positionEnd = position - new float3(0, 0, armSwingLength + (i - rightArmBegin) * armSwingLength),
positionBegin = position + new float3(0, 0, armSwingLength + (i - rightArmBegin) * armSwingLength),
loop = 1
});
}
// right leg animation
if (i >= rightLegBegin && i <= rightLegBegin + 2)
{
EntityManager.AddComponentData(bone, new PositionLerper
{
createdTime = UnityEngine.Time.time,
lifeTime = swingSpeed,
positionBegin = position - new float3(0, 0, armSwingLength / 4f + (i - rightLegBegin) * armSwingLength),
positionEnd = position + new float3(0, 0, armSwingLength / 4f + (i - rightLegBegin) * armSwingLength),
loop = 1
});
}
if (i >= leftLegBegin && i <= leftLegBegin + 2)
{
EntityManager.AddComponentData(bone, new PositionLerper
{
createdTime = UnityEngine.Time.time,
lifeTime = swingSpeed,
positionEnd = position - new float3(0, 0, armSwingLength / 4f + (i - leftLegBegin) * armSwingLength),
positionBegin = position + new float3(0, 0, armSwingLength / 4f + (i - leftLegBegin) * armSwingLength),
loop = 1
});
}
}
}
protected override void OnUpdate()
{
_entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
var _ecb = m_BeginSimulationBufferSystem.CreateCommandBuffer();
if (Time.ElapsedTime > 2 && _JobIsDone == false)
{
if (Time.ElapsedTime < 5)
{
_fullBodyEntity = EntityManager.Instantiate(PrefabConvert._FullBody);
EntityManager.AddComponent <MoveStats>(_fullBodyEntity);
var _pouet = EntityManager.GetChunk(_fullBodyEntity);
_herosArchetype = _pouet.Archetype;
//_entityManager.DestroyEntity(_fullBodyEntity);
for (int i = -75; i < 75; i++)
{
for (int j = -75; j < 75; j++)
{
var e = EntityManager.Instantiate(PrefabConvert._DalleGrize);
EntityManager.SetComponentData <Translation>(e, new Translation {
Value = new float3(i, 3, j)
});
EntityManager.AddComponentData <CustomColor>(e, new CustomColor());
EntityManager.SetComponentData <CustomColor>(e, new CustomColor {
Value = new float4 {
x = 0.01179f, y = 0.5f, z = 0.1044553f, w = 0f
}
});
}
}
_JobIsDone = true;
}
}
if (Time.ElapsedTime > 2)
{
if (_heroesQuery.CalculateEntityCount() < 2)
{
var _pouet = EntityManager.Instantiate(_fullBodyEntity);
EntityManager.SetComponentData(_pouet, new LocalToWorld
{
Value = new float4x4(rotation: quaternion.identity, translation: new float3(1, 5, 3))
});
EntityManager.SetComponentData(_pouet, new Translation {
Value = new float3(0, 5, 0)
});
}
}
CollisionFilter _filter = new CollisionFilter()
{
BelongsTo = (uint)9 << 8,
CollidesWith = (uint)17 << 10,
GroupIndex = 7
};
BoxGeometry _boxGeometry = new BoxGeometry()
{
Center = float3.zero, Size = new float3(10000, 10, 10000), Orientation = quaternion.identity
};
BlobAssetReference <Collider> _boxCollider = Unity.Physics.BoxCollider.Create(_boxGeometry, _filter);
this.Dependency = Entities.
ForEach((ref PhysicsCollider _physicsCollider, in Entity _entity, in PlaneLayer _planeLayer) =>
{
_physicsCollider.Value = _boxCollider;
}).Schedule(this.Dependency);
protected override void OnUpdate()
{
var destroySubScenes = new NativeList <Entity>(Allocator.Temp);
var sceneDataFromEntity = GetComponentDataFromEntity <SceneSectionData>();
bool SceneSectionRequiresSynchronousLoading(Entity entity) =>
(EntityManager.GetComponentData <RequestSceneLoaded>(entity).LoadFlags & SceneLoadFlags.BlockOnStreamIn) != 0;
// Sections > 0 need the external references from sections 0 and will wait for it to be loaded.
// So we have to ensure sections 0 are loaded first, otherwise there's a risk of starving loading streams.
var priorityList = new NativeList <Entity>(Allocator.Temp);
using (var entities = m_PendingStreamRequests.ToEntityArray(Allocator.TempJob))
{
var priorities = new NativeArray <int>(entities.Length, Allocator.Temp);
for (int i = 0; i < entities.Length; ++i)
{
var entity = entities[i];
if (SceneSectionRequiresSynchronousLoading(entity))
{
priorities[i] = 0;
var operation = CreateAsyncLoadSceneOperation(m_SynchronousSceneLoadWorld.EntityManager, entity, true);
var result = UpdateLoadOperation(operation, m_SynchronousSceneLoadWorld, entity);
if (result == UpdateLoadOperationResult.Error)
{
m_SynchronousSceneLoadWorld.Dispose();
m_SynchronousSceneLoadWorld = new World("LoadingWorld (synchronous)");
}
Assert.AreNotEqual(UpdateLoadOperationResult.Aborted, result);
}
else if (sceneDataFromEntity[entity].SubSectionIndex == 0)
{
priorities[i] = 1;
}
else
{
priorities[i] = 2;
}
}
for (int priority = 1; priority <= 2; ++priority)
{
for (int i = 0; i < entities.Length; ++i)
{
if (priorityList.Length == LoadScenesPerFrame)
{
break;
}
if (priorities[i] == priority)
{
priorityList.Add(entities[i]);
}
}
}
}
var priorityArray = priorityList.AsArray();
foreach (var entity in priorityArray)
{
var streamIndex = CreateAsyncLoadScene(entity, false);
if (streamIndex != -1)
{
var streamingState = new StreamingState {
ActiveStreamIndex = streamIndex, Status = StreamingStatus.NotYetProcessed
};
EntityManager.AddComponentData(entity, streamingState);
}
}
Entities.With(m_UnloadStreamRequests).ForEach((Entity entity) =>
{
destroySubScenes.Add(entity);
});
foreach (var destroyScene in destroySubScenes.AsArray())
{
UnloadSectionImmediate(destroyScene);
}
if (ProcessActiveStreams())
{
EditorUpdateUtility.EditModeQueuePlayerLoopUpdate();
}
// Process unloading bundles
SceneBundleHandle.ProcessUnloadingBundles();
}
public void Convert(Entity entity, EntityManager manager, GameObjectConversionSystem conversionSystem)
{
manager.AddComponentData(entity, new FollowPathData());
manager.AddBuffer <PathBufferElement>(entity);
}
void LoadAssetBundles(NativeArray <ResolvedAssetID> assets)
{
LiveLinkMsg.LogInfo("--- Begin Load asset bundles");
var patchAssetBundles = new List <AssetBundle>();
var patchAssetBundlesPath = new List <string>();
var newAssetBundles = new List <Hash128>();
var assetBundleToValidate = new List <Hash128>();
foreach (var asset in assets)
{
var assetGUID = asset.GUID;
var targetHash = asset.TargetHash;
var assetBundleCachePath = GetCachePath(targetHash);
//if we already loaded an asset bundle and we just need a refresh
var oldAssetBundle = _GlobalAssetObjectResolver.GetAssetBundle(assetGUID);
if (oldAssetBundle != null)
{
if (oldAssetBundle.isStreamedSceneAssetBundle)
{
LiveLinkMsg.LogInfo($"Unloading scene bundle: {assetGUID}");
var sceneSystem = World.GetExistingSystem <SceneSystem>();
if (sceneSystem != null)
{
sceneSystem.ReloadScenesWithHash(assetGUID, targetHash);
}
_GlobalAssetObjectResolver.UnloadAsset(assetGUID);
continue;
}
else
{
LiveLinkMsg.LogInfo($"patching asset bundle: {assetGUID}");
patchAssetBundles.Add(oldAssetBundle);
patchAssetBundlesPath.Add(assetBundleCachePath);
_GlobalAssetObjectResolver.UpdateTargetHash(assetGUID, targetHash);
newAssetBundles.Add(assetGUID);
}
}
else
{
LiveLinkMsg.LogInfo($"Loaded asset bundle: {assetGUID}");
var loadedAssetBundle = AssetBundle.LoadFromFile(assetBundleCachePath);
_GlobalAssetObjectResolver.AddAsset(assetGUID, targetHash, null, loadedAssetBundle);
newAssetBundles.Add(assetGUID);
}
assetBundleToValidate.Add(assetGUID);
//@TODO: Keep a hashtable of guid -> entity?
Entities.ForEach((Entity entity, ref ResourceGUID guid) =>
{
if (guid.Guid == assetGUID)
{
EntityManager.AddComponentData(entity, new ResourceLoaded());
}
});
}
AssetBundleUtility.PatchAssetBundles(patchAssetBundles.ToArray(), patchAssetBundlesPath.ToArray());
foreach (var assetGUID in newAssetBundles)
{
var assetBundle = _GlobalAssetObjectResolver.GetAssetBundle(assetGUID);
if (assetBundle == null)
{
Debug.LogError($"Could not load requested asset bundle.'");
return;
}
if (!assetBundle.isStreamedSceneAssetBundle)
{
var loadedManifest = assetBundle.LoadAsset <AssetObjectManifest>(assetGUID.ToString());
if (loadedManifest == null)
{
Debug.LogError($"Loaded {assetGUID} failed to load ObjectManifest");
return;
}
_GlobalAssetObjectResolver.UpdateObjectManifest(assetGUID, loadedManifest);
}
}
foreach (var assetGUID in assetBundleToValidate)
{
_GlobalAssetObjectResolver.Validate(assetGUID);
}
LiveLinkMsg.LogInfo("--- End Load asset bundles");
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem) =>
dstManager.AddComponentData(entity, new LifeTime {
Value = Value
});
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new LookAtEntityPlane {
Value = conversionSystem.GetPrimaryEntity(Target)
});
}
protected override void OnCreateManager( )
{
base.OnCreateManager( );
// Test octrees
// Many octrees, to ray pair
// Where each octree has one ray entity target.
// Results return, weather collision with an instance occured.
// Toggle manually only one example systems at the time
if (!(ExampleSelector.selector == Selector.IsRayCollidingSystem_Octrees2Ray))
{
return; // Early exit
}
Debug.Log("Start Test Is Ray Colliding Octree System");
// Create new octree
// See arguments details (names) of _CreateNewOctree and coresponding octree readme file.
EntityCommandBuffer ecb = barrier.CreateCommandBuffer();
// Many octrees, to single, or many rays
// Where each octree has one ray entity target.
// ***** Example Ray Components For Collision Checks ***** //
// Test ray entity
// for each octree
Entity rayEntity = EntityManager.CreateEntity();
EntityManager.AddComponentData(rayEntity, new IsActiveTag());
EntityManager.AddComponentData(rayEntity, new RayData());
EntityManager.AddComponentData(rayEntity, new RayMaxDistanceData()
{
f = 100f
});
// ***** Initialize Octree ***** //
int i_octreesCount = ExampleSelector.i_generateInstanceInOctreeCount; // Example of x octrees instances. // 1000
for (int i_octreeEntityIndex = 0; i_octreeEntityIndex < i_octreesCount; i_octreeEntityIndex++)
{
ecb = barrier.CreateCommandBuffer();
Entity newOctreeEntity = EntityManager.CreateEntity( );
AddNewOctreeSystem._CreateNewOctree(ecb, newOctreeEntity, 8, float3.zero - new float3(1, 1, 1) * 0.5f, 1, 1.01f, 1);
EntityManager.AddComponent(newOctreeEntity, typeof(IsRayCollidingTag));
EntityManager.AddComponentData(newOctreeEntity, new IsCollidingData()); // Check bounds collision with octree and return colliding instances.
EntityManager.AddBuffer <CollisionInstancesBufferElement> (newOctreeEntity);
// Assign target ray entity, to octree entity
Entity octreeEntity = newOctreeEntity;
// Check bounds collision with octree and return colliding instances.
EntityManager.AddComponentData(octreeEntity, new RayEntityPair4CollisionData()
{
ray2CheckEntity = rayEntity
});
// ***** Example Components To Add / Remove Instance ***** //
// Example of adding and removing some instanceses, hence entity blocks.
// Add
int i_instances2AddCount = 100;
NativeArray <Entity> a_instanceEntities = Common._CreateInstencesArray(EntityManager, i_instances2AddCount);
// Request to add n instances.
// User is responsible to ensure, that instances IDs are unique in the octrtree.
EntityManager.AddBuffer <AddInstanceBufferElement> (octreeEntity); // Once system executed and instances were added, buffer will be deleted.
BufferFromEntity <AddInstanceBufferElement> addInstanceBufferElement = GetBufferFromEntity <AddInstanceBufferElement> ();
Common._RequesAddInstances(ecb, octreeEntity, addInstanceBufferElement, ref a_instanceEntities, i_instances2AddCount);
// Remove
EntityManager.AddBuffer <RemoveInstanceBufferElement> (octreeEntity); // Once system executed and instances were removed, component will be deleted.
BufferFromEntity <RemoveInstanceBufferElement> removeInstanceBufferElement = GetBufferFromEntity <RemoveInstanceBufferElement> ();
// Request to remove some instances
// Se inside method, for details
int i_instances2RemoveCount = ExampleSelector.i_deleteInstanceInOctreeCount; // Example of x octrees instances / entities to delete. // 53
Common._RequestRemoveInstances(ecb, octreeEntity, removeInstanceBufferElement, ref a_instanceEntities, i_instances2RemoveCount);
// Ensure example array is disposed.
a_instanceEntities.Dispose();
} // for
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
//Create a separate entity to hold the waypoint buffer
Entity holder = dstManager.CreateEntity();
//dstManager.SetName(holder, "Waypoint Holder");
DynamicBuffer <WayPoint> tempBuff = dstManager.AddBuffer <WayPoint>(holder);
foreach (float3 location in positions1) //Add the waypoints
{
tempBuff.Add(new WayPoint {
value = location
});
}
dstManager.AddComponentData <FollowWayPointsStorage>(holder, new FollowWayPointsStorage {
id = 11,
curPointNum = 0
}); // add the FollowWayPointsAction to the crowd agent
DynamicBuffer <Action> dynamicBuffer = dstManager.AddBuffer <Action>(entity); // add a buffer to the entity
//wpBuffer.Add(new WayPoint {point = float3.zero} );
for (int i = 0; i < priorites.Length; i++)
{
int curPriority = priorites[i];
//int curMessage = messages[i];
float curTime = times[i];
//find out where the new element should be added
int pos = 0;
//Debug.Log(i + " try, Length is: " + dynamicBuffer.Length);
while (pos < dynamicBuffer.Length && curPriority <= dynamicBuffer[pos].priority)
{
if (curPriority == dynamicBuffer[pos].priority) // if the current priorities are the same
//compare the times
{
if (curTime >= dynamicBuffer[pos].timeCreated) // if the current elements time is greater than the other element's time, this element should go later
{
pos++;
}
else
{
break;
}
}
else if (curPriority < dynamicBuffer[pos].priority) // if this elements priority is smaller than the other element's priority, this element should go later
{
pos++;
}
else
{
break;
}
}
//add the element at that location
dynamicBuffer.Insert(
pos,
new Action {
id = i,
priority = priorites[i],
type = ActionType.Follow_WayPoints,
timeCreated = times[i],
dataHolder = holder,
}); // the Values (in the buffer) are the values in the array
}
dstManager.AddComponentData <FollowWayPointsAction>(entity, new FollowWayPointsAction {
id = 11,
curPointNum = 2
}); // add the FollowWayPointsAction to the crowd agent
dstManager.AddComponentData <StoreWayPoints>(entity, new StoreWayPoints {
id = 11,
dataHolder = holder,
curPointNum = 2
}); // add the FollowWayPointsAction to the crowd agent
tempBuff = dstManager.AddBuffer <WayPoint>(entity);
foreach (float3 location in positions1) //Add the waypoints
{
tempBuff.Add(new WayPoint {
value = location
});
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new DoodleId {
Guid = Guid.Empty
});
}
void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new VerifyBodyPairsIteratorData());
}
void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new MousePick());
}
public void Convert(GameObject gameObject, Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new GhostTypeIndex {
Value = gameObject.name == "GhostTypeIndex1Test" ? 1 : 0
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new ShipStateComponentData());
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, ProjectileData);
}
public override void OnAddComponent(AddComponentOp op)
{
if (!IsValidEntityId(op.EntityId, "AddComponentOp", out var entity))
{
return;
}
var data = Generated.Improbable.Gdk.Tests.ExhaustiveSingular.Serialization.Deserialize(op.Data.SchemaData.Value.GetFields(), World);
data.DirtyBit = false;
entityManager.AddComponentData(entity, data);
entityManager.AddComponentData(entity, new NotAuthoritative <Generated.Improbable.Gdk.Tests.ExhaustiveSingular.Component>());
var update = new Generated.Improbable.Gdk.Tests.ExhaustiveSingular.Update
{
Field1 = data.Field1,
Field2 = data.Field2,
Field3 = data.Field3,
Field4 = data.Field4,
Field5 = data.Field5,
Field6 = data.Field6,
Field7 = data.Field7,
Field8 = data.Field8,
Field9 = data.Field9,
Field10 = data.Field10,
Field11 = data.Field11,
Field12 = data.Field12,
Field13 = data.Field13,
Field14 = data.Field14,
Field15 = data.Field15,
Field16 = data.Field16,
Field17 = data.Field17,
};
var updates = new List <Generated.Improbable.Gdk.Tests.ExhaustiveSingular.Update>
{
update
};
var updatesComponent = new Generated.Improbable.Gdk.Tests.ExhaustiveSingular.ReceivedUpdates
{
handle = ReferenceTypeProviders.UpdatesProvider.Allocate(World)
};
ReferenceTypeProviders.UpdatesProvider.Set(updatesComponent.handle, updates);
entityManager.AddComponentData(entity, updatesComponent);
if (entityManager.HasComponent <ComponentRemoved <Generated.Improbable.Gdk.Tests.ExhaustiveSingular.Component> >(entity))
{
entityManager.RemoveComponent <ComponentRemoved <Generated.Improbable.Gdk.Tests.ExhaustiveSingular.Component> >(entity);
}
else if (!entityManager.HasComponent <ComponentAdded <Generated.Improbable.Gdk.Tests.ExhaustiveSingular.Component> >(entity))
{
entityManager.AddComponentData(entity, new ComponentAdded <Generated.Improbable.Gdk.Tests.ExhaustiveSingular.Component>());
}
else
{
LogDispatcher.HandleLog(LogType.Error, new LogEvent(ReceivedDuplicateComponentAdded)
.WithField(LoggingUtils.LoggerName, LoggerName)
.WithField(LoggingUtils.EntityId, op.EntityId.Id)
.WithField("Component", "Generated.Improbable.Gdk.Tests.ExhaustiveSingular")
);
}
}
public void Convert(GameObject gameObject, Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new GhostValueSerializer {
});
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new Drift {
speed = speed_, angle = angle_
});
}
public override void OnAddComponent(AddComponentOp op)
{
var entity = TryGetEntityFromEntityId(op.EntityId);
Profiler.BeginSample("ExhaustiveRepeated");
var data = Improbable.Gdk.Tests.ExhaustiveRepeated.Serialization.Deserialize(op.Data.SchemaData.Value.GetFields(), World);
data.DirtyBit = false;
entityManager.AddComponentData(entity, data);
entityManager.AddComponent(entity, ComponentType.Create <NotAuthoritative <Improbable.Gdk.Tests.ExhaustiveRepeated.Component> >());
var update = new Improbable.Gdk.Tests.ExhaustiveRepeated.Update
{
Field1 = data.Field1,
Field2 = data.Field2,
Field3 = data.Field3,
Field4 = data.Field4,
Field5 = data.Field5,
Field6 = data.Field6,
Field7 = data.Field7,
Field8 = data.Field8,
Field9 = data.Field9,
Field10 = data.Field10,
Field11 = data.Field11,
Field12 = data.Field12,
Field13 = data.Field13,
Field14 = data.Field14,
Field15 = data.Field15,
Field16 = data.Field16,
Field17 = data.Field17,
};
var updates = new List <Improbable.Gdk.Tests.ExhaustiveRepeated.Update>
{
update
};
var updatesComponent = new Improbable.Gdk.Tests.ExhaustiveRepeated.ReceivedUpdates
{
handle = ReferenceTypeProviders.UpdatesProvider.Allocate(World)
};
ReferenceTypeProviders.UpdatesProvider.Set(updatesComponent.handle, updates);
entityManager.AddComponentData(entity, updatesComponent);
if (entityManager.HasComponent <ComponentRemoved <Improbable.Gdk.Tests.ExhaustiveRepeated.Component> >(entity))
{
entityManager.RemoveComponent <ComponentRemoved <Improbable.Gdk.Tests.ExhaustiveRepeated.Component> >(entity);
}
else if (!entityManager.HasComponent <ComponentAdded <Improbable.Gdk.Tests.ExhaustiveRepeated.Component> >(entity))
{
entityManager.AddComponent(entity, ComponentType.Create <ComponentAdded <Improbable.Gdk.Tests.ExhaustiveRepeated.Component> >());
}
else
{
LogDispatcher.HandleLog(LogType.Error, new LogEvent(ReceivedDuplicateComponentAdded)
.WithField(LoggingUtils.LoggerName, LoggerName)
.WithField(LoggingUtils.EntityId, op.EntityId.Id)
.WithField("Component", "Improbable.Gdk.Tests.ExhaustiveRepeated")
);
}
Profiler.EndSample();
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
dstManager.AddComponentData(entity, new Missile {
});
}
