public void OneGroupIterationSystem_SharedAndRegularComponents([Values(CodeGenMode.NoJobs)] CodeGenMode mode)
{
SetupTestGraph(mode, g =>
{
var query = GraphModel.CreateComponentQuery("query");
var positionType = typeof(Translation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None);
var renderType = typeof(RenderMesh).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, renderType, ComponentDefinitionFlags.Shared);
var queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
var onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
var posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero);
var renderComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == renderType), Vector2.zero);
var logTranslation = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0);
var logRenderMesh = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 1);
GraphModel.CreateEdge(logTranslation.GetParameterPorts().First(), posComponent.OutputPort);
GraphModel.CreateEdge(logRenderMesh.GetParameterPorts().First(), renderComponent.OutputPort);
},
(manager, entityIndex, e) =>
{
manager.AddComponentData(e, new Translation {
Value = { x = entityIndex }
});
manager.AddSharedComponentData(e, new RenderMesh());
},
(manager, entityIndex, e) => Assert.Pass());
}
public void OneGroupIterationSystem([Values] CodeGenMode mode)
{
SetupTestGraph(mode, g =>
{
ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1");
TypeHandle positionType = typeof(Translation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None);
IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
SetPropertyGroupNodeModel set = onUpdateModel.CreateStackedNode <SetPropertyGroupNodeModel>("set");
var member = new TypeMember(TypeHandle.Float, new List <string> {
nameof(Translation.Value), nameof(Translation.Value.x)
});
set.AddMember(member);
IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
((FloatConstantModel)set.InputConstantsById[member.GetId()]).value = 2f;
},
(manager, entityIndex, e) => manager.AddComponentData(e, new Translation {
Value = { x = entityIndex }
}),
(manager, entityIndex, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f)));
}
public void SendEventTest([Values] CodeGenMode mode)
{
SetupTestGraphMultipleFrames(mode, g =>
{
ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1");
TypeHandle positionType = typeof(Translation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None);
IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
TypeHandle eventTypeHandle = typeof(UnitTestEvent).GenerateTypeHandle(Stencil);
SendEventNodeModel set = onUpdateModel.CreateStackedNode <SendEventNodeModel>("set", 0, SpawnFlags.Default, n => n.EventType = eventTypeHandle);
TypeHandle entityType = typeof(Entity).GenerateTypeHandle(Stencil);
IVariableModel entityVar = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == entityType), Vector2.zero);
GraphModel.CreateEdge(set.EntityPort, entityVar.OutputPort);
var firstFieldInput = set.FieldInputs.First();
((FloatConstantModel)set.InputConstantsById[firstFieldInput.UniqueId]).value = 2f;
},
// Add translation to even entities
EachEntity((manager, i, e) =>
{
manager.AddComponent(e, typeof(Translation));
manager.World.CreateSystem <InitializationSystemGroup>();
}),
(manager, entities) =>
{
EventSystem <UnitTestEvent> eventSystem = manager.World.GetExistingSystem <EventSystem <UnitTestEvent> >();
Assert.That(eventSystem, Is.Not.Null);
eventSystem.Update();
},
// OnUpdate should have added a buffer and one event
EachEntity((manager, i, e) =>
{
DynamicBuffer <UnitTestEvent> buffer = default;
Assert.DoesNotThrow(() => buffer = manager.GetBuffer <UnitTestEvent>(e));
Assert.That(buffer.IsCreated, Is.True);
Assert.That(buffer.Length, Is.EqualTo(1));
Assert.That(buffer[0].i, Is.EqualTo(2f));
})
);
}
public void NestedIterationSystem_DifferentGroups_DifferentComponents([Values] CodeGenMode mode)
{
SetupTestGraph(mode, g =>
{
TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil);
TypeHandle rotationType = typeof(Rotation).GenerateTypeHandle(Stencil);
// query1 - Position
ComponentQueryDeclarationModel query1 = GraphModel.CreateComponentQuery("g1");
query1.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
IVariableModel query1Instance = GraphModel.CreateVariableNode(query1, Vector2.zero);
// query2 - Rotation too
ComponentQueryDeclarationModel query2 = GraphModel.CreateComponentQuery("g2");
query2.AddComponent(Stencil, rotationType, ComponentDefinitionFlags.None);
IVariableModel query2Instance = GraphModel.CreateVariableNode(query2, Vector2.zero);
// update query 1
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, query1Instance.OutputPort);
// nested update query 2
var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero);
var forAllNode = forAllStack.CreateLoopNode(onUpdateModel, 0) as ForAllEntitiesNodeModel;
Assert.That(forAllNode, Is.Not.Null);
GraphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort);
GraphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort);
// set query1.translation = ...
SetPropertyGroupNodeModel set = forAllStack.CreateStackedNode <SetPropertyGroupNodeModel>("set");
var member = new TypeMember(TypeHandle.Float, new List <string> {
nameof(Translation.Value), nameof(Translation.Value.x)
});
set.AddMember(member);
IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == translationType), Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
((FloatConstantModel)set.InputConstantsById[member.GetId()]).value = 2f;
},
(manager, entityIndex, e) =>
{
manager.AddComponentData(e, new Translation {
Value = { x = entityIndex }
});
manager.AddComponentData(e, new Rotation());
},
(manager, entityIndex, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f)));
}
public void AddComponentToQuery([Values] TestingMode mode)
{
var query = GraphModel.CreateComponentQuery("query");
var rotationType = typeof(Rotation).GenerateTypeHandle(Stencil);
TestPrereqActionPostreq(mode, () =>
{
Assert.That(GraphModel.VariableDeclarations.Count, Is.EqualTo(1));
Assert.That(query.Components.Count(), Is.EqualTo(0));
return new AddComponentToQueryAction(query, rotationType, ComponentDefinitionFlags.None);
}, () =>
{
Assert.That(query.Components.Count(), Is.EqualTo(1));
Assert.That(query.Components.Single().Component.TypeHandle, Is.EqualTo(rotationType));
});
}
public void MultipleOnUpdateEntities([Values] CodeGenMode mode)
{
SetupTestGraph(mode, graph =>
{
var translationType = typeof(Translation).GenerateTypeHandle(Stencil);
var query = GraphModel.CreateComponentQuery("g1");
query.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
var queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
CreateUpdateAndLogEntity(graph, queryInstance);
CreateUpdateAndLogEntity(graph, queryInstance);
},
(manager, index, entity) => manager.AddComponentData(entity, new Translation()),
(manager, index, entity) => Assert.Pass()
);
}
public void OneGroupIterationSystem_LocalVariable([Values] CodeGenMode mode)
{
SetupTestGraph(mode, g =>
{
ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1");
TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
var localDeclaration = onUpdateModel.CreateFunctionVariableDeclaration("local", TypeHandle.Float);
var local = GraphModel.CreateVariableNode(localDeclaration, Vector2.zero);
var log = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0);
GraphModel.CreateEdge(log.GetParameterPorts().First(), local.OutputPort);
},
(manager, entityIndex, e) => {},
(manager, entityIndex, e) => Assert.Pass());
}
public void NestedIterationSystem_DifferentGroups_NestedLocalVariable([Values] CodeGenMode mode)
{
SetupTestGraphMultipleFrames(mode, g =>
{
TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil);
TypeHandle rotationType = typeof(Rotation).GenerateTypeHandle(Stencil);
// query1 - Position
ComponentQueryDeclarationModel query1 = GraphModel.CreateComponentQuery("g1");
query1.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
IVariableModel query1Instance = GraphModel.CreateVariableNode(query1, Vector2.zero);
// query2 - Rotation too
ComponentQueryDeclarationModel query2 = GraphModel.CreateComponentQuery("g2");
query2.AddComponent(Stencil, rotationType, ComponentDefinitionFlags.None);
IVariableModel query2Instance = GraphModel.CreateVariableNode(query2, Vector2.zero);
// update query 1
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, query1Instance.OutputPort);
// nested update query 2
var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero);
var forAllNode = forAllStack.CreateLoopNode(onUpdateModel, 0) as ForAllEntitiesNodeModel;
Assert.That(forAllNode, Is.Not.Null);
GraphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort);
GraphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort);
var decl = forAllStack.CreateFunctionVariableDeclaration("x", TypeHandle.Int);
// set query1.translation = ...
SetVariableNodeModel set = forAllStack.CreateStackedNode <SetVariableNodeModel>("set");
IVariableModel posComponent = GraphModel.CreateVariableNode(decl, Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
});
}
public void OneGroupIterationSystem_ReadOnly([Values] CodeGenMode mode)
{
SetupTestGraph(mode, g =>
{
ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1");
TypeHandle translationType = typeof(Translation).GenerateTypeHandle(Stencil);
TypeHandle rotationType = typeof(Rotation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
query.AddComponent(Stencil, rotationType, ComponentDefinitionFlags.None);
IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
var log = onUpdateModel.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0);
IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == translationType), Vector2.zero);
GraphModel.CreateEdge(log.GetParameterPorts().First(), posComponent.OutputPort);
},
(manager, entityIndex, e) => manager.AddComponents(e,
new ComponentTypes(ComponentType.ReadWrite <Translation>(), ComponentType.ReadWrite <Rotation>())),
(manager, entityIndex, e) => Assert.Pass());
}
public void OnEventTest([Values] CodeGenMode mode)
{
SetupTestGraphMultipleFrames(mode, g =>
{
ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1");
TypeHandle positionType = typeof(Translation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None);
IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
TypeHandle eventTypeHandle = typeof(UnitTestEvent).GenerateTypeHandle(Stencil);
OnEventNodeModel onUpdateModel = GraphModel.CreateNode <OnEventNodeModel>("update", Vector2.zero, SpawnFlags.Default, n => n.EventTypeHandle = eventTypeHandle);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
SetPropertyGroupNodeModel set = onUpdateModel.CreateStackedNode <SetPropertyGroupNodeModel>("set", 0);
var member = new TypeMember(TypeHandle.Float, new List <string> {
nameof(Translation.Value), nameof(Translation.Value.x)
});
set.AddMember(member);
IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
((FloatConstantModel)set.InputConstantsById[member.GetId()]).value = 2f;
},
// Add translation to even entities
EachEntity((manager, i, e) =>
{
if (e.Index % 2 == 0)
{
manager.AddComponent(e, typeof(Translation));
}
}),
// Send event on these
EachEntity(del: (manager, i, e) =>
{
if (e.Index % 2 == 0)
{
Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(0f));
}
else
{
Assert.IsFalse(manager.HasComponent <Translation>(e));
}
// Add event on all entities
manager.AddBuffer <UnitTestEvent>(e).Add(new UnitTestEvent());
}),
// Event handler should set t.x to 2
EachEntity((manager, i, e) =>
{
if (e.Index % 2 == 0)
{
Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f));
}
}),
// Reset translation
EachEntity((manager, i, e) =>
{
if (e.Index % 2 == 0)
{
var t = manager.GetComponentData <Translation>(e);
t.Value.x = 0;
manager.SetComponentData(e, t);
}
}),
// As we send events manually, the event system is not running and won't cleanup events.
// Event handler should set t.x to 2 again
EachEntity((manager, i, e) =>
{
if (e.Index % 2 == 0)
{
Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f));
}
})
);
}
public void NestedIteration_DifferentGroups_DifferentEntitiesAccess([Values] CodeGenMode mode)
{
SetupTestGraph(mode, graph =>
{
var translationType = typeof(Translation).GenerateTypeHandle(Stencil);
var scaleType = typeof(Scale).GenerateTypeHandle(Stencil);
// query1 - Position
var query1 = GraphModel.CreateComponentQuery("g1");
query1.AddComponent(Stencil, translationType, ComponentDefinitionFlags.None);
var query1Instance = GraphModel.CreateVariableNode(query1, Vector2.zero);
// query2 - Scale
var query2 = GraphModel.CreateComponentQuery("g2");
query2.AddComponent(Stencil, scaleType, ComponentDefinitionFlags.None);
var query2Instance = GraphModel.CreateVariableNode(query2, Vector2.zero);
// update query 1
var update = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(update.InstancePort, query1Instance.OutputPort);
// nested update query 2
var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero);
var forAllNode = forAllStack.CreateLoopNode(update, 0) as ForAllEntitiesNodeModel;
Assert.That(forAllNode, Is.Not.Null);
GraphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort);
GraphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort);
// entity from query 1
var entity1 = graph.CreateVariableNode(
update.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graph.Stencil)),
Vector2.zero);
// entity from query 2
var entity2 = graph.CreateVariableNode(
forAllStack.FunctionParameterModels.Single(
p => p.DataType == typeof(Entity).GenerateTypeHandle(graph.Stencil)),
Vector2.zero);
// set a new Translation to entities of query1
var setTranslation = forAllStack.CreateStackedNode <SetComponentNodeModel>("set translation");
setTranslation.ComponentType = typeof(Translation).GenerateTypeHandle(graph.Stencil);
setTranslation.DefineNode();
((FloatConstantModel)setTranslation.InputConstantsById["z"]).value = 10f;
graph.CreateEdge(setTranslation.EntityPort, entity1.OutputPort);
// set a new Scale to entities of query2
var setScale = forAllStack.CreateStackedNode <SetComponentNodeModel>("set scale");
setScale.ComponentType = typeof(Scale).GenerateTypeHandle(graph.Stencil);
setScale.DefineNode();
((FloatConstantModel)setScale.InputConstantsById["Value"]).value = 30f;
graph.CreateEdge(setScale.EntityPort, entity2.OutputPort);
},
(manager, index, entity) =>
{
if (index % 2 == 0)
{
manager.AddComponentData(entity, new Translation());
}
else
{
manager.AddComponentData(entity, new Scale());
}
},
(manager, index, entity) =>
{
if (manager.HasComponent <Translation>(entity))
{
Assert.That(manager.GetComponentData <Translation>(entity).Value.z, Is.EqualTo(10f));
}
if (manager.HasComponent <Scale>(entity))
{
Assert.That(manager.GetComponentData <Scale>(entity).Value, Is.EqualTo(30f));
}
}
);
}
