void GetValue(ChangeMode mode)
        {
            EmptySystem.Update();
            var entityArray = EmptySystem.GetComponentGroup(typeof(EcsTestData)).GetEntityArray();

            if (mode == ChangeMode.ComponentDataArray)
            {
                var array = EmptySystem.GetComponentGroup(typeof(EcsTestData)).GetComponentDataArray <EcsTestData>();
                for (int i = 0; i != array.Length; i++)
                {
                    var val = array[i];
                }
            }
            else if (mode == ChangeMode.SetComponentData)
            {
                for (int i = 0; i != entityArray.Length; i++)
                {
                    m_Manager.GetComponentData <EcsTestData>(entityArray[i]);
                }
            }
            else if (mode == ChangeMode.SetComponentDataFromEntity)
            {
                for (int i = 0; i != entityArray.Length; i++)
                {
                    m_Manager.GetComponentData <EcsTestData>(entityArray[i]);
                }
            }
            else if (mode == ChangeMode.ComponentGroupArray)
            {
                foreach (var e in EmptySystem.GetEntities <GroupRO>())
                {
                    ;
                }
            }
        }
        public void EmptyTransformAccessArrayWorks()
        {
            var group = EmptySystem.GetComponentGroup(typeof(Transform), typeof(TransformAccessArrayTestTag));
            var ta    = group.GetTransformAccessArray();

            Assert.AreEqual(0, ta.length);
        }
        public void BarrierPlaybackExceptionIsolation()
        {
            var barrier = World.GetOrCreateManager <EndFrameBarrier>();

            var buf1 = barrier.CreateCommandBuffer();
            var buf2 = barrier.CreateCommandBuffer();

            var e1 = buf1.CreateEntity();

            buf1.AddComponent(e1, new EcsTestData());
            buf1.AddComponent(e1, new EcsTestData());

            var e2 = buf2.CreateEntity();

            buf2.AddComponent(e2, new EcsTestData());
            buf2.AddComponent(e2, new EcsTestData());

            // We exp both command buffers to execute, and an exception thrown afterwards
            // Essentially we want isolation of two systems that might fail independently.
            Assert.Throws <ArgumentException>(() => { barrier.Update(); });
            Assert.AreEqual(2, EmptySystem.GetComponentGroup(typeof(EcsTestData)).CalculateLength());

            // On second run, we expect all buffers to be removed...
            // So no more exceptions thrown.
            barrier.Update();

            Assert.AreEqual(2, EmptySystem.GetComponentGroup(typeof(EcsTestData)).CalculateLength());
        }
        public void JobProcessWithFilteredComponentGroup()
        {
            var archetype = m_Manager.CreateArchetype(typeof(EcsTestData), typeof(EcsTestSharedComp));

            var entityInGroupA = m_Manager.CreateEntity(archetype);
            var entityInGroupB = m_Manager.CreateEntity(archetype);

            m_Manager.SetComponentData <EcsTestData>(entityInGroupA, new EcsTestData {
                value = 5
            });
            m_Manager.SetComponentData <EcsTestData>(entityInGroupB, new EcsTestData {
                value = 5
            });
            m_Manager.SetSharedComponentData <EcsTestSharedComp>(entityInGroupA, new EcsTestSharedComp {
                value = 1
            });
            m_Manager.SetSharedComponentData <EcsTestSharedComp>(entityInGroupB, new EcsTestSharedComp {
                value = 2
            });

            var group = EmptySystem.GetComponentGroup(typeof(EcsTestData), typeof(EcsTestSharedComp));

            group.SetFilter(new EcsTestSharedComp {
                value = 1
            });

            var processJob = new ProcessFilteredData();

            processJob.ScheduleGroup(group).Complete();

            Assert.AreEqual(10, m_Manager.GetComponentData <EcsTestData>(entityInGroupA).value);
            Assert.AreEqual(5, m_Manager.GetComponentData <EcsTestData>(entityInGroupB).value);
        }
#pragma warning restore 649

        unsafe void SetValue(int index, int value, ChangeMode mode)
        {
            EmptySystem.Update();
            var entityArray = EmptySystem.GetComponentGroup(typeof(EcsTestData)).GetEntityArray();
            var entity      = entityArray[index];

            if (mode == ChangeMode.ComponentDataArray)
            {
                var array = EmptySystem.GetComponentGroup(typeof(EcsTestData)).GetComponentDataArray <EcsTestData>();
                array[index] = new EcsTestData(value);
            }
            else if (mode == ChangeMode.SetComponentData)
            {
                m_Manager.SetComponentData(entity, new EcsTestData(value));
            }
            else if (mode == ChangeMode.SetComponentDataFromEntity)
            {
                //@TODO: Chaining correctness... Definately not implemented right now...
                var array = EmptySystem.GetComponentDataFromEntity <EcsTestData>(false);
                array[entity] = new EcsTestData(value);
            }
            else if (mode == ChangeMode.ComponentGroupArray)
            {
                *(EmptySystem.GetEntities <GroupRW>()[index].Data) = new EcsTestData(value);
            }
        }
        // The atomic safety handle of TransformAccessArrays are not invalidated when injection changes, the array represents the transforms when you got it
        public void AddAndUseOldTransformAccessArrayDoesNotUpdateContent()
        {
            var go = new GameObject();

            go.AddComponent <TransformAccessArrayTestTagComponent>();
            // Execute in edit mode is not enabled so this has to be called manually right now
            go.GetComponent <GameObjectEntity>().OnEnable();
            var group = EmptySystem.GetComponentGroup(typeof(Transform), typeof(TransformAccessArrayTestTag));
            var ta    = group.GetTransformAccessArray();

            Assert.AreEqual(1, ta.length);

            var go2 = new GameObject();

            go2.AddComponent <TransformAccessArrayTestTagComponent>();
            // Execute in edit mode is not enabled so this has to be called manually right now
            go2.GetComponent <GameObjectEntity>().OnEnable();
            Assert.AreEqual(1, ta.length);

            // Execute in edit mode is not enabled so this has to be called manually right now
            go.GetComponent <GameObjectEntity>().OnDisable();
            go2.GetComponent <GameObjectEntity>().OnDisable();
            Object.DestroyImmediate(go);
            Object.DestroyImmediate(go2);
        }
 public void RequireSingletonWorks()
 {
     EmptySystem.RequireSingletonForUpdate<EcsTestData>();
     EmptySystem.GetComponentGroup(typeof(EcsTestData2));
     
     m_Manager.CreateEntity(typeof(EcsTestData2));
     Assert.IsFalse(EmptySystem.ShouldRunSystem());
     m_Manager.CreateEntity(typeof(EcsTestData));
     Assert.IsTrue(EmptySystem.ShouldRunSystem());
 }
Exemplo n.º 8
0
        public void StructuralChangeAfterSchedulingNoDependenciesJobThrows()
        {
            var archetype = m_Manager.CreateArchetype(typeof(EcsTestData));
            var entity    = m_Manager.CreateEntity(archetype);
            var group     = EmptySystem.GetComponentGroup(typeof(EcsTestData));
            var handle    = new NoDependenciesJob().Schedule(group);

            Assert.Throws <InvalidOperationException>(() => m_Manager.DestroyEntity(entity));
            handle.Complete();
        }
        public void JobProcessComponentWithEntityGroupCorrect()
        {
            ComponentType[] expectedTypes = { ComponentType.ReadOnly <EcsTestData>(), ComponentType.Create <EcsTestData2>(), ComponentType.Create <EcsTestData3>() };

            new Process3Entity().Run(EmptySystem);
            var group = EmptySystem.GetComponentGroup(expectedTypes);

            Assert.AreEqual(1, EmptySystem.ComponentGroups.Length);
            Assert.IsTrue(EmptySystem.ComponentGroups[0].CompareComponents(expectedTypes));
            Assert.AreEqual(group, EmptySystem.ComponentGroups[0]);
        }
        public void SingleItemTransformAccessArrayWorks()
        {
            var go = new GameObject();

            go.AddComponent <TransformAccessArrayTestTagProxy>();
            var group = EmptySystem.GetComponentGroup(typeof(Transform), typeof(TransformAccessArrayTestTag));
            var ta    = group.GetTransformAccessArray();

            Assert.AreEqual(1, ta.length);

            Object.DestroyImmediate(go);
        }
Exemplo n.º 11
0
        void CheckFilter(NativeArray <int> indexList)
        {
            var group = EmptySystem.GetComponentGroup(typeof(EcsTestData));

            group.SetFilter(indexList);

            var array = group.GetComponentDataArray <EcsTestData>();

            for (int i = 0; i != indexList.Length; i++)
            {
                Assert.AreEqual(indexList[i], array[i].value);
            }
        }
Exemplo n.º 12
0
	    public void ReadOnlyDynamicBufferImpl(bool readOnlyType)
	    {
	        var original = m_Manager.CreateEntity(typeof(EcsIntElement));
	        var buffer = m_Manager.GetBuffer<EcsIntElement>(original);
	        buffer.Add(5);

	        var group = EmptySystem.GetComponentGroup(new EntityArchetypeQuery {All = new ComponentType[] {typeof(EcsIntElement)}});
	        var job = new ReadOnlyJob
            {
                Int = EmptySystem.GetArchetypeChunkBufferType<EcsIntElement>(readOnlyType)
            };
        
            job.Schedule(group).Complete();
	    }
Exemplo n.º 13
0
        public void GetComponentGroupWithDuplicates()
        {
            // Currently duplicates will create two seperate groups doing the same thing...
            ComponentType[] dup_1 = { typeof(EcsTestData2) };
            ComponentType[] dup_2 = { typeof(EcsTestData2), typeof(EcsTestData2) };

            var dup1_system = EmptySystem.GetComponentGroup(dup_1);
            var dup2_system = EmptySystem.GetComponentGroup(dup_2);

            Assert.AreEqual(dup1_system, EmptySystem.GetComponentGroup(dup_1));
            Assert.AreEqual(dup2_system, EmptySystem.GetComponentGroup(dup_2));

            Assert.AreEqual(2, EmptySystem.ComponentGroups.Length);
        }
Exemplo n.º 14
0
	    public void ReadWriteDynamicBuffer()
	    {
	        var original = m_Manager.CreateEntity(typeof(EcsIntElement));
	        var buffer = m_Manager.GetBuffer<EcsIntElement>(original);
	        buffer.Add(5);

	        var group = EmptySystem.GetComponentGroup(new EntityArchetypeQuery {All = new ComponentType[] {typeof(EcsIntElement)}});
	        var job = new WriteJob
	        {
	            //@TODO: Throw exception when read only flag is not accurately passed to job for buffers...
	            Int = EmptySystem.GetArchetypeChunkBufferType<EcsIntElement>()
	        };
        
	        job.Schedule(group).Complete();
	    }
        public void GetComponentGroupRespectsRWAccessInequality()
        {
            var query1 = new EntityArchetypeQuery {
                All = new [] { ComponentType.ReadOnly <EcsTestData>(), ComponentType.ReadWrite <EcsTestData2>() }
            };
            var query2 = new EntityArchetypeQuery {
                All = new [] { ComponentType.ReadOnly <EcsTestData>(), ComponentType.ReadOnly <EcsTestData2>() }
            };

            var group1 = EmptySystem.GetComponentGroup(query1);
            var group2 = EmptySystem.GetComponentGroup(query2);

            Assert.AreNotEqual(group1, group2);
            Assert.AreEqual(2, EmptySystem.ComponentGroups.Length);
        }
Exemplo n.º 16
0
        public void GetComponentGroup()
        {
            ComponentType[] ro_rw = { ComponentType.ReadOnly <EcsTestData>(), typeof(EcsTestData2) };
            ComponentType[] rw_rw = { typeof(EcsTestData), typeof(EcsTestData2) };
            ComponentType[] rw    = { typeof(EcsTestData) };

            var ro_rw0_system = EmptySystem.GetComponentGroup(ro_rw);
            var rw_rw_system  = EmptySystem.GetComponentGroup(rw_rw);
            var rw_system     = EmptySystem.GetComponentGroup(rw);

            Assert.AreEqual(ro_rw0_system, EmptySystem.GetComponentGroup(ro_rw));
            Assert.AreEqual(rw_rw_system, EmptySystem.GetComponentGroup(rw_rw));
            Assert.AreEqual(rw_system, EmptySystem.GetComponentGroup(rw));

            Assert.AreEqual(3, EmptySystem.ComponentGroups.Length);
        }
        // The atomic safety handle of TransformAccessArrays are not invalidated when injection changes, the array represents the transforms when you got it
        public void AddAndUseOldTransformAccessArrayDoesNotUpdateContent()
        {
            var go = new GameObject();

            go.AddComponent <TransformAccessArrayTestTagProxy>();
            var group = EmptySystem.GetComponentGroup(typeof(Transform), typeof(TransformAccessArrayTestTag));
            var ta    = group.GetTransformAccessArray();

            Assert.AreEqual(1, ta.length);

            var go2 = new GameObject();

            go2.AddComponent <TransformAccessArrayTestTagProxy>();
            Assert.AreEqual(1, ta.length);

            Object.DestroyImmediate(go);
            Object.DestroyImmediate(go2);
        }
        public void GetComponentGroupComponentTypeArchetypeQueryEquality()
        {
            var query1 = new ComponentType[] { typeof(EcsTestData) };
            var query2 = new EntityArchetypeQuery {
                All = new ComponentType[] { typeof(EcsTestData) }
            };
            var query3 = new EntityArchetypeQuery {
                All = new [] { ComponentType.ReadWrite <EcsTestData>() }
            };

            var group1 = EmptySystem.GetComponentGroup(query1);
            var group2 = EmptySystem.GetComponentGroup(query2);
            var group3 = EmptySystem.GetComponentGroup(query3);

            Assert.AreEqual(group1, group2);
            Assert.AreEqual(group2, group3);
            Assert.AreEqual(1, EmptySystem.ComponentGroups.Length);
        }
Exemplo n.º 19
0
        public void GetComponentGroupArchetypeQuery()
        {
            var query1 = new ComponentType[] { typeof(EcsTestData) };
            var query2 = new EntityArchetypeQuery {
                All = new ComponentType[] { typeof(EcsTestData) }
            };
            var query3 = new EntityArchetypeQuery {
                All = new ComponentType[] { typeof(EcsTestData), typeof(EcsTestData2) }
            };

            var group1 = EmptySystem.GetComponentGroup(query1);
            var group2 = EmptySystem.GetComponentGroup(query2);
            var group3 = EmptySystem.GetComponentGroup(query3);

            Assert.AreEqual(group1, EmptySystem.GetComponentGroup(query1));
            Assert.AreEqual(group2, EmptySystem.GetComponentGroup(query2));
            Assert.AreEqual(group3, EmptySystem.GetComponentGroup(query3));

            Assert.AreEqual(3, EmptySystem.ComponentGroups.Length);
        }
Exemplo n.º 20
0
        public void DestroyAndGetNewTransformAccessArrayUpdatesContent()
        {
            var go = new GameObject();

            go.AddComponent <TransformAccessArrayTestTagComponent>();
            var go2 = new GameObject();

            go2.AddComponent <TransformAccessArrayTestTagComponent>();

            var group = EmptySystem.GetComponentGroup(typeof(Transform), typeof(TransformAccessArrayTestTag));
            var ta    = group.GetTransformAccessArray();

            Assert.AreEqual(2, ta.length);

            Object.DestroyImmediate(go);

            ta = group.GetTransformAccessArray();
            Assert.AreEqual(1, ta.length);

            Object.DestroyImmediate(go2);
        }
        public void JobProcessComponentGroupCorrectNativeArrayOfComponentTypes()
        {
            ComponentType[] initialTypes = { typeof(EcsTestData), typeof(EcsTestData2) };

            var archetype = m_Manager.CreateArchetype(initialTypes);
            var entity    = m_Manager.CreateEntity(archetype);

            new Process2().Run(EmptySystem);
            var componentTypes = m_Manager.GetComponentTypes(entity);

            Assert.IsTrue(componentTypes[0] == initialTypes[0]);
            Assert.IsTrue(componentTypes[1] == initialTypes[1]);

            componentTypes[0] = ComponentType.ReadOnly(componentTypes[0].TypeIndex);

            var group = EmptySystem.GetComponentGroup(componentTypes);

            Assert.AreEqual(1, EmptySystem.ComponentGroups.Length);
            Assert.IsTrue(EmptySystem.ComponentGroups[0].CompareComponents(componentTypes));
            Assert.AreEqual(group, EmptySystem.ComponentGroups[0]);

            componentTypes.Dispose();
        }
        public void GetComponentGroupOrderIndependent()
        {
            var query1 = new ComponentType[] { typeof(EcsTestData), typeof(EcsTestData2) };
            var query2 = new ComponentType[] { typeof(EcsTestData2), typeof(EcsTestData) };

            var group1 = EmptySystem.GetComponentGroup(query1);
            var group2 = EmptySystem.GetComponentGroup(query2);

            Assert.AreEqual(group1, group2);
            Assert.AreEqual(1, EmptySystem.ComponentGroups.Length);

            var query3 = new EntityArchetypeQuery {
                All = new ComponentType[] { typeof(EcsTestData2), typeof(EcsTestData3) }
            };
            var query4 = new EntityArchetypeQuery {
                All = new ComponentType[] { typeof(EcsTestData3), typeof(EcsTestData2) }
            };

            var group3 = EmptySystem.GetComponentGroup(query3);
            var group4 = EmptySystem.GetComponentGroup(query4);

            Assert.AreEqual(group3, group4);
            Assert.AreEqual(2, EmptySystem.ComponentGroups.Length);
        }
Exemplo n.º 23
0
 public void GetComponentGroupWithEntityThrows()
 {
     ComponentType[] e = { typeof(Entity), typeof(EcsTestData) };
     EmptySystem.GetComponentGroup(e);
     Assert.Throws <ArgumentException>(() => EmptySystem.GetComponentGroup(e));
 }