void PrepareGraph(VSGraphModel graphModel) { var entityTypeHandle = typeof(Entity).GenerateTypeHandle(graphModel.Stencil); // Component creation var scale = typeof(Scale).GenerateTypeHandle(Stencil); var group = graphModel.CreateComponentQuery("g"); group.AddComponent(graphModel.Stencil, scale, ComponentDefinitionFlags.None); // On update var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero); m_OnUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(m_OnUpdateEntities.InstancePort, groupInstance.OutputPort); m_CreateEntityModel = m_OnUpdateEntities.CreateStackedNode <CreateEntityNodeModel>("instantiate"); // Variable containing the new entity m_OnUpdateEntities.CreateFunctionVariableDeclaration("newEntity", entityTypeHandle); m_NewEntityVariable = graphModel.CreateVariableNode( m_OnUpdateEntities.FunctionParameterModels.Single(p => p.DataType == entityTypeHandle), Vector2.zero); m_FloatConstantNode = (FloatConstantModel)graphModel.CreateConstantNode("float", TypeHandle.Float, Vector2.zero); m_FloatConstantNode.value = 10f; graphModel.CreateEdge(m_CreateEntityModel.InstancePort, m_NewEntityVariable.OutputPort); }
static State CreateVariableNodes(State previousState, CreateVariableNodesAction action) { if (action.VariablesToCreate.Count > 0) { if (action.ConnectAfterCreation != null) { // Delete previous connections if (action.EdgeModelsToDelete.Any()) { ((VSGraphModel)previousState.CurrentGraphModel).DeleteEdges(action.EdgeModelsToDelete); } } foreach (Tuple <IVariableDeclarationModel, Vector2> tuple in action.VariablesToCreate) { VSGraphModel vsGraphModel = ((VSGraphModel)previousState.CurrentGraphModel); IVariableModel newVariable = vsGraphModel.CreateVariableNode(tuple.Item1, tuple.Item2); if (action.ConnectAfterCreation != null) { var newEdge = ((VSGraphModel)previousState.CurrentGraphModel).CreateEdge(action.ConnectAfterCreation, newVariable.OutputPort); if (action.AutoAlign) { vsGraphModel.LastChanges.ModelsToAutoAlign.Add(newEdge); } } } } return(previousState); }
[Test] // TODO: fix jobs public void OnExitWorks([Values(CodeGenMode.NoJobs)] CodeGenMode mode) { SetupTestGraphMultipleFrames(mode, graphModel => { var group = graphModel.CreateComponentQuery("g"); var positionType = typeof(Translation).GenerateTypeHandle(Stencil); group.AddComponent(graphModel.Stencil, positionType, ComponentDefinitionFlags.None); group.AddComponent(graphModel.Stencil, typeof(Rotation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero); var update = graphModel.CreateNode <OnEndEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(update.InstancePort, groupInstance.OutputPort); var log = update.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0); IVariableModel entityVariable = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == typeof(Entity).GenerateTypeHandle(Stencil)), Vector2.zero); GraphModel.CreateEdge(log.GetParameterPorts().First(), entityVariable.OutputPort); }, EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Rotation))), EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Translation))), EachEntity((manager, i, e) => { LogAssert.NoUnexpectedReceived(); LogAssert.Expect(LogType.Log, $"Entity({i}:1)"); manager.RemoveComponent <Rotation>(e); }), EachEntity((manager, i, e) => {}) ); }
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 SendEventNestedTest([Values] CodeGenMode mode) { SetupTestGraphMultipleFrames(mode, graphModel => { // group1 - Position var group1 = graphModel.CreateComponentQuery("g1"); group1.AddComponent(graphModel.Stencil, typeof(Translation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var group1Instance = graphModel.CreateVariableNode(group1, Vector2.zero); // group2 - Scale (will add RenderMesh) var group2 = graphModel.CreateComponentQuery("g2"); group2.AddComponent(graphModel.Stencil, typeof(Scale).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var group2Instance = graphModel.CreateVariableNode(group2, Vector2.zero); // update group 1 var onUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(onUpdateEntities.InstancePort, group1Instance.OutputPort); // nested update group 2 var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero); var forAllNode = forAllStack.CreateLoopNode(onUpdateEntities, 0) as ForAllEntitiesNodeModel; graphModel.CreateEdge(forAllNode.InputPort, group2Instance.OutputPort); graphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort); TypeHandle eventTypeHandle = typeof(UnitTestEvent).GenerateTypeHandle(Stencil); SendEventNodeModel set = forAllStack.CreateStackedNode <SendEventNodeModel>("set", 0, SpawnFlags.Default, n => n.EventType = eventTypeHandle); TypeHandle entityType = typeof(Entity).GenerateTypeHandle(Stencil); IVariableModel entityVar = GraphModel.CreateVariableNode(forAllStack.FunctionParameterModels.Single(p => p.DataType == entityType), Vector2.zero); var firstFieldInput = set.EntityPort; GraphModel.CreateEdge(firstFieldInput, entityVar.OutputPort); } ); }
[Test] // TODO: fix jobs public void OnEnterWorks([Values(CodeGenMode.NoJobs)] CodeGenMode mode) { SetupTestGraphMultipleFrames(mode, graphModel => { var group = graphModel.CreateComponentQuery("g"); var positionType = typeof(Translation).GenerateTypeHandle(Stencil); group.AddComponent(graphModel.Stencil, positionType, ComponentDefinitionFlags.None); group.AddComponent(graphModel.Stencil, typeof(Rotation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var groupInstance = graphModel.CreateVariableNode(group, Vector2.zero); var update = graphModel.CreateNode <OnStartEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(update.InstancePort, groupInstance.OutputPort); var set = update.CreateStackedNode <SetPositionNodeModel>("set", 0, SpawnFlags.Default, n => n.Mode = SetPositionNodeModel.TranslationMode.Float3); set.Add = true; // increment so we can detect multiple runs if they happen ((Float3ConstantModel)set.InputConstantsById["Value"]).value = new Vector3(1f, 0.0f, 0.0f); IVariableModel posComponent = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero); GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort); }, EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Rotation))), EachEntity((manager, i, e) => { manager.AddComponent(e, typeof(Translation)); // will make the entity enter the query Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(0)); }), EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))), // translate ran once EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))) // not twice ); }
VisualElement SetupConstantEditor(IVariableModel criterionValue) { EnableInClassList("constant", true); VisualElement propertyField = this.CreateEditorForNodeModel((IConstantNodeModel)criterionValue, _ => Store.Dispatch(new RefreshUIAction(UpdateFlags.RequestCompilation))); propertyField.name = "criterionRowValue"; return(propertyField); }
public void Test_RemoveSetPropertyMemberKeepsEdges([Values] TestingMode mode) { // test that removing a SetProperty member doesn't break the edge with it's Instance // i.e. here: check that removing Position keeps the link with Transform // |_TestFunction_____| // (Transform)---+-o Set Property | // | o Position | VariableDeclarationModel trDecl = GraphModel.CreateGraphVariableDeclaration("tr", typeof(Transform).GenerateTypeHandle(Stencil), true); IVariableModel trVar = GraphModel.CreateVariableNode(trDecl, Vector2.left); FunctionModel method = GraphModel.CreateFunction("TestFunction", Vector2.zero); SetPropertyGroupNodeModel setters = method.CreateSetPropertyGroupNode(0); GraphModel.CreateEdge(setters.InstancePort, trVar.OutputPort); PropertyInfo propertyToAdd = typeof(Transform).GetProperty("position"); var newMember = new TypeMember { Path = new List <string> { propertyToAdd?.Name }, Type = propertyToAdd.GetUnderlyingType().GenerateTypeHandle(Stencil) }; setters.AddMember(newMember); TestPrereqActionPostreq(mode, () => { RefreshReference(ref method); RefreshReference(ref setters); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(setters.InputsByDisplayOrder.Count, Is.EqualTo(2)); Assert.That(setters.Members.Count, Is.EqualTo(1)); return(new EditPropertyGroupNodeAction( EditPropertyGroupNodeAction.EditType.Remove, setters, newMember)); }, () => { RefreshReference(ref method); RefreshReference(ref setters); Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(GetStackedNode(0, 0), Is.TypeOf <SetPropertyGroupNodeModel>()); Assert.That(setters.InputsByDisplayOrder.Count, Is.EqualTo(1)); Assert.That(setters.Members.Count, Is.EqualTo(0)); }); }
public void TestExcludedComponentQuery_RootContext([Values] CodeGenMode mode) { var defaultValue = new quaternion(0, 0, 0, 0); var modifiedValue = new quaternion(1, 1, 1, 1); SetupTestGraph(mode, CreateGraphNodes, AddComponentsToEntities, ValidateSubtractive); void CreateGraphNodes(VSGraphModel graphModel) { var scaleType = typeof(Scale).GenerateTypeHandle(Stencil); var rotationType = typeof(Rotation).GenerateTypeHandle(Stencil); var group = graphModel.CreateComponentQuery("g"); group.AddComponent(graphModel.Stencil, scaleType, ComponentDefinitionFlags.Subtract); group.AddComponent(graphModel.Stencil, rotationType, ComponentDefinitionFlags.None); IVariableModel groupInstance = graphModel.CreateVariableNode(group, Vector2.zero); OnUpdateEntitiesNodeModel onOnEntitiesNodeModel = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("loop", Vector2.zero); graphModel.CreateEdge(onOnEntitiesNodeModel.InstancePort, groupInstance.OutputPort); SetComponentNodeModel setRotationNode = graphModel.CreateNode <SetComponentNodeModel>("SetComponent", Vector2.zero); setRotationNode.ComponentType = typeof(Rotation).GenerateTypeHandle(Stencil); onOnEntitiesNodeModel.AddStackedNode(setRotationNode, -1); setRotationNode.DefineNode(); var entityVarDeclaration = onOnEntitiesNodeModel.FunctionParameterModels.Single(p => p.DataType == typeof(Entity).GenerateTypeHandle(graphModel.Stencil)); var entityInstance = graphModel.CreateVariableNode(entityVarDeclaration, Vector2.zero); var float4ConstantNode = (Float4ConstantModel)graphModel.CreateConstantNode("float4", typeof(float4).GenerateTypeHandle(graphModel.Stencil), Vector2.zero); float4ConstantNode.value = modifiedValue.value; graphModel.CreateEdge(setRotationNode.EntityPort, entityInstance.OutputPort); graphModel.CreateEdge(setRotationNode.InputsById[nameof(Rotation.Value)], float4ConstantNode.OutputPort); } void AddComponentsToEntities(EntityManager manager, int entityIndex, Entity e) { manager.AddComponent(e, typeof(Rotation)); if (entityIndex % 2 == 1) { manager.AddComponent(e, typeof(Scale)); } } void ValidateSubtractive(EntityManager manager, int entityIndex, Entity e) { var expectedValue = manager.HasComponent <Scale>(e) ? defaultValue : modifiedValue; Assert.That(manager.GetComponentData <Rotation>(e).Value, Is.EqualTo(expectedValue)); } }
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 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)); }) ); }
static State CreateVariableNodes(State previousState, CreateVariableNodesAction action) { if (action.VariablesToCreate.Count > 0) { if (action.ConnectAfterCreation != null) { // Delete previous connections if (action.EdgeModelsToDelete.Any()) { ((VSGraphModel)previousState.CurrentGraphModel).DeleteEdges(action.EdgeModelsToDelete); } } bool needToGroup = action.GroupModel != null; List <INodeModel> nodesToGroup = needToGroup ? new List <INodeModel>(action.VariablesToCreate.Count) : null; foreach (Tuple <IVariableDeclarationModel, Vector2> tuple in action.VariablesToCreate) { VSGraphModel vsGraphModel = ((VSGraphModel)previousState.CurrentGraphModel); IVariableModel newVariable = vsGraphModel.CreateVariableNode(tuple.Item1, tuple.Item2); if (action.ConnectAfterCreation != null) { var newEdge = ((VSGraphModel)previousState.CurrentGraphModel).CreateEdge(action.ConnectAfterCreation, newVariable.OutputPort); if (action.AutoAlign) { vsGraphModel.LastChanges.ModelsToAutoAlign.Add(newEdge); } } if (needToGroup) { nodesToGroup.Add(newVariable); } } if (needToGroup) { GroupNodeModel.Ungroup(nodesToGroup); ((GroupNodeModel)action.GroupModel).AddNodes(nodesToGroup); } } return(previousState); }
static void CreateUpdateAndLogEntity(VSGraphModel graphModel, IVariableModel variable) { // update entities var update = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(update.InstancePort, variable.OutputPort); // Create entity from update var entity = graphModel.CreateVariableNode( update.FunctionParameterModels.Single( p => p.DataType == typeof(Entity).GenerateTypeHandle(graphModel.Stencil)), Vector2.zero); // Log the entity var log = update.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0); graphModel.CreateEdge(log.GetParameterPorts().First(), entity.OutputPort); }
public void Test_DisconnectSetPropertyKeepsPortType([Values] TestingMode mode) { VariableDeclarationModel trDecl = GraphModel.CreateGraphVariableDeclaration("tr", typeof(Transform).GenerateTypeHandle(Stencil), true); IVariableModel trVar = GraphModel.CreateVariableNode(trDecl, Vector2.left); FunctionModel method = GraphModel.CreateFunction("TestFunction", Vector2.zero); SetPropertyGroupNodeModel setters = method.CreateSetPropertyGroupNode(0); GraphModel.CreateEdge(setters.InstancePort, trVar.OutputPort); setters.AddMember( new TypeMember { Path = new List <string> { "position" }, Type = Stencil.GenerateTypeHandle(typeof(Vector3)) } ); IConstantNodeModel constToken = GraphModel.CreateConstantNode("v3", typeof(Vector3).GenerateTypeHandle(Stencil), Vector2.left * 200); IEdgeModel edge = GraphModel.CreateEdge(setters.GetPortsForMembers().First(), constToken.OutputPort); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(2)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(setters.GetPortsForMembers().First().DataType.Resolve(Stencil), Is.EqualTo(typeof(Vector3))); return(new DeleteElementsAction(edge)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(3)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(GetStackedNode(0, 0), Is.TypeOf <SetPropertyGroupNodeModel>()); Assert.That(setters.GetPortsForMembers().First().DataType.Resolve(Stencil), Is.EqualTo(typeof(Vector3))); }); }
public void Test_DisconnectSetPropertyInstanceSetsRightPortType(TestingMode mode, int inputIndex, Type expectedPortType) { VariableDeclarationModel goDecl = GraphModel.CreateGraphVariableDeclaration("go", typeof(GameObject).GenerateTypeHandle(Stencil), true); IVariableModel goVar = GraphModel.CreateVariableNode(goDecl, Vector2.left); FunctionModel method = GraphModel.CreateFunction("TestFunction", Vector2.zero); SetPropertyGroupNodeModel setters = method.CreateSetPropertyGroupNode(0); IEdgeModel edge = GraphModel.CreateEdge(setters.InstancePort, goVar.OutputPort); PropertyInfo propertyInfo = typeof(Transform).GetProperty("position"); var newMember = new TypeMember { Path = new List <string> { propertyInfo?.Name }, Type = typeof(Transform).GenerateTypeHandle(Stencil) }; setters.AddMember(newMember); TestPrereqActionPostreq(mode, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(1)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(setters.GetPortsForMembers().First().DataType, Is.EqualTo(typeof(Transform).GenerateTypeHandle(Stencil))); return(new DeleteElementsAction(edge)); }, () => { Assert.That(GetNodeCount(), Is.EqualTo(2)); Assert.That(GetEdgeCount(), Is.EqualTo(0)); Assert.That(method.NodeModels.Count(), Is.EqualTo(1)); Assert.That(GetStackedNode(0, 0), Is.TypeOf <SetPropertyGroupNodeModel>()); Assert.That(setters.InstancePort.DataType, Is.EqualTo(TypeHandle.Unknown)); Assert.That(setters.GetPortsForMembers().First().DataType, Is.EqualTo(typeof(Transform).GenerateTypeHandle(Stencil))); }); }
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()); }
[Test] // TODO: fix jobs public void OnEnterAndExitWorks([Values(CodeGenMode.NoJobs)] CodeGenMode mode) { SetupTestGraphMultipleFrames(mode, graphModel => { var query = graphModel.CreateComponentQuery("g"); var positionType = typeof(Translation).GenerateTypeHandle(Stencil); query.AddComponent(graphModel.Stencil, positionType, ComponentDefinitionFlags.None); query.AddComponent(graphModel.Stencil, typeof(Rotation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var queryInstance = graphModel.CreateVariableNode(query, Vector2.zero); var update = graphModel.CreateNode <OnStartEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(update.InstancePort, queryInstance.OutputPort); var set = update.CreateStackedNode <SetPositionNodeModel>("set", 0, SpawnFlags.Default, n => n.Mode = SetPositionNodeModel.TranslationMode.Float3); set.Add = true; // increment so we can detect multiple runs if they happen ((Float3ConstantModel)set.InputConstantsById["Value"]).value = new Vector3(1f, 0.0f, 0.0f); IVariableModel posComponent = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero); GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort); var log = update.CreateFunctionCallNode(typeof(Debug).GetMethod("Log", new[] { typeof(object) }), 0); IVariableModel entityVariable = GraphModel.CreateVariableNode(update.FunctionParameterModels.Single(p => p.DataType == typeof(Entity).GenerateTypeHandle(Stencil)), Vector2.zero); GraphModel.CreateEdge(log.GetParameterPorts().First(), entityVariable.OutputPort); }, EachEntity((manager, i, e) => manager.AddComponent(e, typeof(Rotation))), EachEntity((manager, i, e) => { manager.AddComponent(e, typeof(Translation)); // will make the entity enter the query Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(0)); }), EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))), // translate ran once EachEntity((manager, i, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(1))), // not twice EachEntity((manager, i, e) => { LogAssert.Expect(LogType.Log, $"Entity({i}:1)"); manager.RemoveComponent <Rotation>(e); }), EachEntity((manager, i, e) => {}) ); }
// create a function bool IsIntEven(int i) // if ((i % 2) == 0) { return true; } else { return false; } // the goal is to have 2 different return nodes depending on a parameter FunctionModel CreateIsIntEvenFunction() { // define function FunctionModel method = GraphModel.CreateFunction("IsIntEven", Vector2.zero); method.ReturnType = typeof(bool).GenerateTypeHandle(GraphModel.Stencil); VariableDeclarationModel paramI = method.CreateAndRegisterFunctionParameterDeclaration("i", typeof(int).GenerateTypeHandle(GraphModel.Stencil)); // add if/then/else structure IfConditionNodeModel if0 = CreateIfThenElseStacks(method, out var then0, out var else0); // if (i % 2 == 0) var binOpNode = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Modulo, Vector2.zero); IVariableModel varI = GraphModel.CreateVariableNode(paramI, Vector2.left); var const2 = CreateConstantIntNode(2); GraphModel.CreateEdge(binOpNode.InputPortA, varI.OutputPort); GraphModel.CreateEdge(binOpNode.InputPortB, const2.OutputPort); var equalNode = GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Equals, Vector2.zero); var const0 = CreateConstantIntNode(0); GraphModel.CreateEdge(equalNode.InputPortA, binOpNode.OutputPort); GraphModel.CreateEdge(equalNode.InputPortB, const0.OutputPort); GraphModel.CreateEdge(if0.IfPort, equalNode.OutputPort); // then return true var returnTrue = then0.CreateStackedNode <ReturnNodeModel>("return true"); var constTrue = CreateConstantBoolNode(true); GraphModel.CreateEdge(returnTrue.InputPort, constTrue.OutputPort); // else return false var returnFalse = else0.CreateStackedNode <ReturnNodeModel>("return false"); var constFalse = CreateConstantBoolNode(false); GraphModel.CreateEdge(returnFalse.InputPort, constFalse.OutputPort); return(method); }
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 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 AddVariable(IVariableModel variable) { TfVariables.Add(variable); }
static bool HandleVariable(GraphBuilder builder, out INode node, out PortMapper portToOffsetMapping, out uint?preAllocatedDataIndex, IVariableModel variableModel) { if (variableModel.DeclarationModel.IsInputOrOutputTrigger()) { preAllocatedDataIndex = null; portToOffsetMapping = new PortMapper(); if (variableModel.DeclarationModel.Modifiers == ModifierFlags.ReadOnly) // Input { var trigger = builder.DeclareInputTrigger(variableModel.DeclarationModel.VariableName); node = MapPort(portToOffsetMapping, variableModel.OutputPort, ref trigger.Output.Port, trigger); } else { var trigger = builder.DeclareOutputTrigger(variableModel.DeclarationModel.VariableName); node = MapPort(portToOffsetMapping, variableModel.OutputPort, ref trigger.Input.Port, trigger); } return(true); } var valueType = variableModel.DeclarationModel.DataType.ToValueType(); var type = GraphBuilder.GetVariableType(variableModel.DeclarationModel); switch (type) { case GraphBuilder.VariableType.ObjectReference: switch (valueType) { case ValueType.Entity: preAllocatedDataIndex = builder.GetVariableDataIndex(variableModel.DeclarationModel).DataIndex; portToOffsetMapping = new PortMapper(); var cf = new ConstantEntity(); node = MapPort(portToOffsetMapping, variableModel.OutputPort, ref cf.ValuePort.Port, cf); return(true); } break; case GraphBuilder.VariableType.Variable: // Data throw new NotImplementedException(); case GraphBuilder.VariableType.InputOutput: // Just create an edge later node = default; portToOffsetMapping = null; preAllocatedDataIndex = null; return(false); default: throw new ArgumentOutOfRangeException("Variable type not supported: " + type); } throw new ArgumentOutOfRangeException(valueType.ToString()); }
public static IEnumerable <SyntaxNode> BuildVariable(this RoslynTranslator translator, IVariableModel v, IPortModel portModel) { if (v is IConstantNodeModel constantNodeModel) { if (constantNodeModel.ObjectValue != null) { if (constantNodeModel is IStringWrapperConstantModel) { yield return(translator.Constant(constantNodeModel.ObjectValue.ToString(), translator.Stencil)); } else { yield return(translator.Constant(constantNodeModel.ObjectValue, translator.Stencil)); } } yield break; } if (translator.InMacro.Count > 0 && v.DeclarationModel.VariableType == VariableType.GraphVariable && v.DeclarationModel.Modifiers == ModifierFlags.ReadOnly) { MacroRefNodeModel oldValue = translator.InMacro.Pop(); var syntaxNodes = translator.BuildPort(oldValue.InputsById[v.DeclarationModel.VariableName]); translator.InMacro.Push(oldValue); foreach (var syntaxNode in syntaxNodes) { yield return(syntaxNode); } yield break; } switch (v.DeclarationModel.VariableType) { case VariableType.FunctionVariable: case VariableType.GraphVariable: case VariableType.ComponentQueryField: yield return(RoslynBuilder.LocalVariableReference(v.DeclarationModel.Name)); break; case VariableType.FunctionParameter: yield return(RoslynBuilder.ArgumentReference(v.DeclarationModel.Name)); break; // case VariableType.Literal: // case VariableType.InlineExpression: default: throw new ArgumentOutOfRangeException(); } }
public static GraphElement CreateToken(this INodeBuilder builder, Store store, IVariableModel model) { var isExposed = model.DeclarationModel?.IsExposed; Texture2D icon = (isExposed != null && isExposed.Value) ? VisualScriptingIconUtility.LoadIconRequired("GraphView/Nodes/BlackboardFieldExposed.png") : null; GetTokenPorts(store, model, out var input, out var output, Orientation.Horizontal); var token = new Token(model, store, input, output, builder.GraphView, icon); if (model.DeclarationModel != null && model.DeclarationModel is LoopVariableDeclarationModel loopVariableDeclarationModel) { VseUtility.AddTokenIcon(token, loopVariableDeclarationModel.TitleComponentIcon); } return(token); }
static bool HandleVariable(GraphBuilder builder, out INode node, out Dictionary <string, uint> portToOffsetMapping, out uint?preAllocatedDataIndex, IVariableModel variableModel) { if (variableModel.DeclarationModel.IsInputOrOutputTrigger()) { preAllocatedDataIndex = null; portToOffsetMapping = new Dictionary <string, uint>(); if (variableModel.DeclarationModel.Modifiers == ModifierFlags.ReadOnly) // Input { var trigger = builder.DeclareInputTrigger(variableModel.DeclarationModel.VariableName); node = MapPort(portToOffsetMapping, variableModel.OutputPort.UniqueId, ref trigger.Output.Port, trigger); } else { var trigger = builder.DeclareOutputTrigger(variableModel.DeclarationModel.VariableName); node = MapPort(portToOffsetMapping, variableModel.OutputPort.UniqueId, ref trigger.Input.Port, trigger); } return(true); } var valueType = variableModel.DeclarationModel.DataType.TypeHandleToValueType(); Assert.AreEqual(VariableType.GraphVariable, variableModel.DeclarationModel.VariableType); var type = GraphBuilder.GetVariableType(variableModel.DeclarationModel); switch (type) { case GraphBuilder.VariableType.ObjectReference: switch (valueType) { case ValueType.Entity: preAllocatedDataIndex = builder.GetVariableDataIndex(variableModel.DeclarationModel).DataIndex; portToOffsetMapping = new Dictionary <string, uint>(); var cf = new ConstantEntity(); node = MapPort(portToOffsetMapping, variableModel.OutputPort.UniqueId, ref cf.ValuePort.Port, cf); return(true); } break; case GraphBuilder.VariableType.Variable: // Data // Just create an edge later node = default; portToOffsetMapping = null; preAllocatedDataIndex = null; return(false); case GraphBuilder.VariableType.InputOutput: Assert.IsFalse(variableModel.DeclarationModel.IsDataOutput()); // TODO check legit portToOffsetMapping = new Dictionary <string, uint>(); preAllocatedDataIndex = null; var inputData = builder.DeclareInputData(variableModel.DeclarationModel.VariableName, variableModel.DeclarationModel.DataType.TypeHandleToValueType()); node = MapPort(portToOffsetMapping, variableModel.OutputPort.UniqueId, ref inputData.Output.Port, inputData); return(true); default: throw new ArgumentOutOfRangeException("Variable type not supported: " + type); } throw new ArgumentOutOfRangeException(valueType.ToString()); }
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 static IGraphElement CreateToken(this ElementBuilder elementBuilder, IStore store, IVariableModel model) { var isExposed = model.DeclarationModel?.IsExposed; Texture2D icon = (isExposed != null && isExposed.Value) ? GraphViewStaticBridge.LoadIconRequired("GraphView/Nodes/BlackboardFieldExposed.png") : null; var ui = new Token(); ui.Setup(model, store, elementBuilder.GraphView, icon); return(ui); }
public static IEnumerable <SyntaxNode> BuildVariable(this RoslynEcsTranslator translator, IVariableModel v, IPortModel portModel) { if (v is IConstantNodeModel model) { if (model.ObjectValue != null) { yield return(translator.Constant(model.ObjectValue, translator.Stencil, model.Type)); } yield break; } if (translator.InMacro.Count > 0 && v.DeclarationModel.VariableType == VariableType.GraphVariable && v.DeclarationModel.Modifiers == ModifierFlags.ReadOnly) { MacroRefNodeModel oldValue = translator.InMacro.Pop(); var syntaxNodes = translator.BuildPort(oldValue.InputsById[v.DeclarationModel.VariableName]); translator.InMacro.Push(oldValue); foreach (var syntaxNode in syntaxNodes) { yield return(syntaxNode); } yield break; } switch (v.DeclarationModel.VariableType) { case VariableType.GraphVariable: yield return(translator.context.GetSingletonVariable(v.DeclarationModel)); break; case VariableType.FunctionVariable: case VariableType.ComponentGroupField: yield return(RoslynBuilder.LocalVariableReference(v.DeclarationModel.VariableName)); break; case VariableType.FunctionParameter: var variableDeclarationModel = v.DeclarationModel; if (variableDeclarationModel.VariableIsAGeneratedEcsComponent(out var groupDeclaration)) { var relevantContext = translator.FindContext(groupDeclaration); translator.context.RecordComponentAccess(relevantContext, v.DeclarationModel.DataType, translator.IsRecordingComponentAccesses); yield return(RoslynBuilder.ArgumentReference(translator.context.GetComponentVariableName(groupDeclaration, variableDeclarationModel.DataType))); } else { yield return(RoslynBuilder.ArgumentReference(v.DeclarationModel.VariableName)); } break; default: throw new ArgumentOutOfRangeException(); } }
public static IEnumerable <SyntaxNode> BuildVariable(this RoslynTranslator translator, IVariableModel v, IPortModel portModel) { if (v is IConstantNodeModel constantNodeModel) { if (constantNodeModel.ObjectValue != null) { if (constantNodeModel is IStringWrapperConstantModel) { yield return(translator.Constant(constantNodeModel.ObjectValue.ToString(), translator.Stencil)); } else { yield return(translator.Constant(constantNodeModel.ObjectValue, translator.Stencil)); } } yield break; } switch (v.DeclarationModel.VariableType) { case VariableType.GraphVariable: case VariableType.ComponentQueryField: yield return(RoslynBuilder.LocalVariableReference(v.DeclarationModel.Name)); break; // case VariableType.Literal: // case VariableType.InlineExpression: default: throw new ArgumentOutOfRangeException(); } }