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); } ); }
public void Test_CreateInsertLoopNode([Values] TestingMode mode) { GraphModel.CreateStack(string.Empty, Vector2.zero); GraphModel.CreateLoopStack <ForEachHeaderModel>(Vector2.right * 100); TestPrereqActionPostreq(mode, () => { var loopStack = GetStack(1) as LoopStackModel; var stack = GetStack(0); Assert.That(stack.NodeModels.Count, Is.EqualTo(0)); var portModel = loopStack.InputPort; Assert.That(portModel.Connected, Is.False); return(new CreateInsertLoopNodeAction( loopStack.InputPorts.First(), stack, -1, (LoopStackModel)portModel.NodeModel)); }, () => { var loopStack = GetStack(1) as LoopStackModel; var stack = GetStack(0); Assert.That(stack.NodeModels.Count, Is.EqualTo(1)); var loopNode = stack.NodeModels.First() as ForEachNodeModel; Assert.That(loopNode, Is.Not.Null); Assert.NotNull(loopNode); var portModel = loopNode.OutputPort; Assert.That(portModel.Connected, Is.True); Assert.That(portModel.ConnectionPortModels.Single(), Is.EqualTo(loopStack.InputPort)); }); }
public void TestCreateEdge_CannotConnectForEachNodeToWhileStack() { var stack = GraphModel.CreateStack("", Vector2.zero); var forEach = stack.CreateStackedNode <ForEachNodeModel>(); var whileStack = GraphModel.CreateLoopStack <WhileHeaderModel>(Vector2.zero); var edgeCount = GetEdgeCount(); m_Store.Dispatch(new CreateEdgeAction(whileStack.InputPort, forEach.OutputPort)); Assert.That(GetEdgeCount(), Is.EqualTo(edgeCount)); }
public void InstrumentCooldownNodeModelDoesNotThrow() { var start = GraphModel.CreateEventFunction(typeof(TestStencil.TestArchetype).GetMethod("Start"), Vector2.zero); var cooldown = GraphModel.CreateLoopStack <ForEachHeaderModel>(Vector2.down); var loopNode = cooldown.CreateLoopNode(start, -1); GraphModel.CreateEdge(cooldown.InputPort, loopNode.OutputPort); var result = GraphModel.CreateTranslator().TranslateAndCompile(GraphModel, AssemblyType.None, CompilationOptions.Tracing); Assert.That(result.status, Is.EqualTo(CompilationStatus.Succeeded)); LogAssert.NoUnexpectedReceived(); }
public IEnumerator MovingAStackMovesTheConnectedLoopStack([Values] TestingMode mode) { var stackModel0 = GraphModel.CreateStack(string.Empty, new Vector2(-100, -100)); var loopStack = GraphModel.CreateLoopStack <WhileHeaderModel>(new Vector2(50, 50)); var whileModel = loopStack.CreateLoopNode(stackModel0, 0); GraphModel.CreateEdge(loopStack.InputPort, whileModel.OutputPort); yield return(TestMove(mode, mouseDelta: new Vector2(20, 10), movedNodes: new INodeModel[] { stackModel0 }, expectedMovedDependencies: new INodeModel[] { loopStack } )); }
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 TestRemoveComponent_ForEachContext([Values] CodeGenMode mode) { SetupTestGraph(mode, graphModel => { // query1 - Position var query1 = graphModel.CreateComponentQuery("g1"); query1.AddComponent(graphModel.Stencil, typeof(Translation).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var query1Instance = graphModel.CreateVariableNode(query1, Vector2.zero); // query2 - Scale (will add RenderMesh) var query2 = graphModel.CreateComponentQuery("g2"); query2.AddComponent(graphModel.Stencil, typeof(Scale).GenerateTypeHandle(Stencil), ComponentDefinitionFlags.None); var query2Instance = graphModel.CreateVariableNode(query2, Vector2.zero); // update query 1 var onUpdateEntities = graphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero); graphModel.CreateEdge(onUpdateEntities.InstancePort, query1Instance.OutputPort); // nested update query 2 var forAllStack = GraphModel.CreateLoopStack <ForAllEntitiesStackModel>(Vector2.zero); var forAllNode = forAllStack.CreateLoopNode(onUpdateEntities, 0) as ForAllEntitiesNodeModel; graphModel.CreateEdge(forAllNode.InputPort, query2Instance.OutputPort); graphModel.CreateEdge(forAllStack.InputPort, forAllNode.OutputPort); // Remove Scale component var addComponent = forAllStack.CreateStackedNode <RemoveComponentNodeModel>("remove"); addComponent.ComponentType = typeof(Scale).GenerateTypeHandle(Stencil); var entityInstance = graphModel.CreateVariableNode( forAllStack.FunctionParameterModels.Single( p => p.DataType == typeof(Entity).GenerateTypeHandle(graphModel.Stencil) ), Vector2.zero); graphModel.CreateEdge(addComponent.EntityPort, entityInstance.OutputPort); }, (manager, entityIndex, e) => { // HACK as there is no Single update method as entry point (just the on UpdateEntities right now) var toAdd = entityIndex == 0 ? typeof(Translation) : typeof(Scale); manager.AddComponent(e, toAdd); }, (manager, entityIndex, e) => Assert.That(!manager.HasComponent <Scale>(e))); }
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 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)); } } ); }
void SpawnAllNodeModelsInGraph(VSGraphModel graphModel) { StackModel stack; FunctionModel funcModel; //--Floating Nodes-- //Stack-Derived NodeModels stack = GraphModel.CreateNode <StackModel>("StackModel"); funcModel = GraphModel.CreateNode <FunctionModel>("FunctionModel"); var methodInfo = TypeSystem.GetMethod(typeof(Debug), nameof(Debug.Log), true); GraphModel.CreateEventFunction(methodInfo, Vector2.zero); GraphModel.CreateNode <OnEndEntitiesNodeModel>("OnEndEntitiesNodeModel"); GraphModel.CreateNode <OnEventNodeModel>("OnEventNodeModel"); GraphModel.CreateNode <OnStartEntitiesNodeModel>("OnStartEntitiesNodeModel"); var onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("OnUpdateEntitiesNodeModel"); GraphModel.CreateNode <PostUpdate>("PostUpdate"); GraphModel.CreateNode <PreUpdate>("PreUpdate"); GraphModel.CreateNode <KeyDownEventModel>("KeyDownEventModel"); GraphModel.CreateLoopStack(typeof(ForEachHeaderModel), Vector2.zero); GraphModel.CreateLoopStack(typeof(WhileHeaderModel), Vector2.zero); GraphModel.CreateLoopStack(typeof(ForAllEntitiesStackModel), Vector2.zero); //Constant-typed NodeModels GraphModel.CreateNode <BooleanConstantNodeModel>("BooleanConstantNodeModel"); GraphModel.CreateNode <ColorConstantModel>("ColorConstantModel"); GraphModel.CreateNode <CurveConstantNodeModel>("CurveConstantNodeModel"); GraphModel.CreateNode <DoubleConstantModel>("DoubleConstantModel"); GraphModel.CreateNode <EnumConstantNodeModel>("EnumConstantNodeModel"); GraphModel.CreateNode <FloatConstantModel>("FloatConstantModel"); GraphModel.CreateNode <GetPropertyGroupNodeModel>("GetPropertyGroupNodeModel"); GraphModel.CreateNode <InputConstantModel>("InputConstantModel"); GraphModel.CreateNode <IntConstantModel>("IntConstantModel"); GraphModel.CreateNode <LayerConstantModel>("LayerConstantModel"); GraphModel.CreateNode <LayerMaskConstantModel>("LayerMaskConstantModel"); GraphModel.CreateNode <ObjectConstantModel>("ObjectConstantModel"); GraphModel.CreateNode <QuaternionConstantModel>("QuaternionConstantModel"); GraphModel.CreateNode <StringConstantModel>("StringConstantModel"); GraphModel.CreateNode <TagConstantModel>("TagConstantModel"); GraphModel.CreateNode <TypeConstantModel>("TypeConstantModel"); GraphModel.CreateNode <Vector2ConstantModel>("Vector2ConstantModel"); GraphModel.CreateNode <Vector3ConstantModel>("Vector3ConstantModel"); GraphModel.CreateNode <Vector4ConstantModel>("Vector4ConstantModel"); GraphModel.CreateNode <ConstantSceneAssetNodeModel>("ConstantSceneAssetNodeModel"); GraphModel.CreateNode <Float2ConstantModel>("Float2ConstantModel"); GraphModel.CreateNode <Float3ConstantModel>("Float3ConstantModel"); GraphModel.CreateNode <Float4ConstantModel>("Float4ConstantModel"); //Misc void DefineSystemConstant(SystemConstantNodeModel m) { m.ReturnType = typeof(float).GenerateTypeHandle(Stencil); m.DeclaringType = typeof(Mathf).GenerateTypeHandle(Stencil); m.Identifier = "PI"; } GraphModel.CreateNode <SystemConstantNodeModel>("SystemConstantNodeModel", Vector2.zero, SpawnFlags.Default, DefineSystemConstant); GraphModel.CreateNode <GroupNodeModel>("GroupNodeModel"); GraphModel.CreateNode <GetInputNodeModel>("GetInputNodeModel"); GraphModel.CreateNode <GetOrCreateComponentNodeModel>("GetOrCreateComponentNodeModel"); GraphModel.CreateNode <GetSingletonNodeModel>("GetSingletonNodeModel"); GraphModel.CreateNode <ThisNodeModel>("ThisNodeModel"); VariableDeclarationModel decl = graphModel.CreateGraphVariableDeclaration("MyVariableName", typeof(int).GenerateTypeHandle(graphModel.Stencil), true); GraphModel.CreateVariableNode(decl, Vector2.zero); GraphModel.CreateNode <MacroRefNodeModel>("MacroRefNodeModel"); GraphModel.CreateInlineExpressionNode("2+2", Vector2.zero); GraphModel.CreateBinaryOperatorNode(BinaryOperatorKind.Add, Vector2.zero); GraphModel.CreateUnaryOperatorNode(UnaryOperatorKind.PostIncrement, Vector2.zero); //--Stack-Contained Nodes-- stack.CreateStackedNode <AddComponentNodeModel>(); stack.CreateStackedNode <DestroyEntityNodeModel>(); stack.CreateStackedNode <ForAllEntitiesNodeModel>(); stack.CreateStackedNode <ForEachNodeModel>(); stack.CreateFunctionCallNode(TypeSystem.GetMethod(typeof(Debug), nameof(Debug.Log), true)); stack.CreateFunctionRefCallNode(funcModel); stack.CreateStackedNode <InstantiateNodeModel>(); stack.CreateStackedNode <IfConditionNodeModel>(); stack.CreateStackedNode <LogNodeModel>(); stack.CreateStackedNode <RemoveComponentNodeModel>(); stack.CreateStackedNode <SetComponentNodeModel>(); stack.CreateStackedNode <SetPositionNodeModel>(); stack.CreateStackedNode <SetRotationNodeModel>(); stack.CreateStackedNode <WhileNodeModel>(); stack.CreateStackedNode <SetPropertyGroupNodeModel>(); stack.CreateStackedNode <SetVariableNodeModel>(); funcModel.CreateStackedNode <ReturnNodeModel>(); TypeHandle eventTypeHandle = typeof(UnitTestEvent).GenerateTypeHandle(Stencil); onUpdateModel.CreateStackedNode <SendEventNodeModel>("SendEventNodeModel", 0, SpawnFlags.Default, n => n.EventType = eventTypeHandle); }