public void CanWriteAndRead_ExpectedSum_FromNaturalIntegerRange(int bufferSize) { using (var set = new NodeSet()) { var output = set.Create <KernelBufferOutputNode>(); var input = set.Create <KernelBufferInputNode>(); set.SetBufferSize(output, KernelBufferOutputNode.KernelPorts.Output1, Buffer <long> .SizeRequest(bufferSize)); set.SetBufferSize(output, KernelBufferOutputNode.KernelPorts.Output2, Buffer <long> .SizeRequest(bufferSize)); var aggregateBufferSizes = new Aggregate { SubBuffer1 = Buffer <long> .SizeRequest(bufferSize), SubBuffer2 = Buffer <long> .SizeRequest(bufferSize) }; set.SetBufferSize(output, KernelBufferOutputNode.KernelPorts.Output3, aggregateBufferSizes); set.Connect(output, KernelBufferOutputNode.KernelPorts.Output1, input, KernelBufferInputNode.KernelPorts.Input1); set.Connect(output, KernelBufferOutputNode.KernelPorts.Output2, input, KernelBufferInputNode.KernelPorts.Input2); set.Connect(output, KernelBufferOutputNode.KernelPorts.Output3, input, KernelBufferInputNode.KernelPorts.Input3); var value = set.CreateGraphValue(input, KernelBufferInputNode.KernelPorts.Sum); set.Update(); long n = bufferSize; Assert.AreEqual(4 * n * (n + 1) / 2, set.GetValueBlocking(value)); set.ReleaseGraphValue(value); set.Destroy(input, output); } }
public void TwoNodeFeedbackLoop_Works([Values] NodeSet.RenderExecutionModel model) { using (var set = new NodeSet()) { set.RendererModel = model; var node1 = set.Create <KernelAdderNode>(); var node2 = set.Create <KernelAdderNode>(); GraphValue <int> node1GV = set.CreateGraphValue(node1, KernelAdderNode.KernelPorts.Output); GraphValue <int> node2GV = set.CreateGraphValue(node2, KernelAdderNode.KernelPorts.Output); set.Connect(node1, KernelAdderNode.KernelPorts.Output, node2, KernelAdderNode.KernelPorts.Input); set.Connect(node2, KernelAdderNode.KernelPorts.Output, node1, KernelAdderNode.KernelPorts.Input, NodeSet.ConnectionType.Feedback); // After the first update, we expect GVs 1,2. On the next update, the 2 should be fedback into node1, so we expect 3,4. Next, 5,6... for (int i = 0; i < 10; ++i) { set.Update(); Assert.AreEqual(i * 2 + 1, set.GetValueBlocking(node1GV)); Assert.AreEqual(i * 2 + 2, set.GetValueBlocking(node2GV)); } set.ReleaseGraphValue(node1GV); set.ReleaseGraphValue(node2GV); set.Destroy(node1, node2); } }
public void CannotCreate_FeedbackConnection_AndRegularConnection() { using (var set = new NodeSet()) { var node1 = set.Create <KernelAdderNode>(); var node2 = set.Create <KernelAdderNode>(); set.Connect(node1, KernelAdderNode.KernelPorts.Output, node2, KernelAdderNode.KernelPorts.Input, NodeSet.ConnectionType.Feedback); Assert.Throws <ArgumentException>(() => set.Connect(node1, KernelAdderNode.KernelPorts.Output, node2, KernelAdderNode.KernelPorts.Input)); set.Destroy(node1, node2); } }
public void OutOfBounds_DataBufferRead_ThrowsException() { using (var set = new NodeSet()) { var source = set.Create <GenericOutput <float> >(); set.SendMessage(source, GenericOutput <float> .SimulationPorts.Input, 5.0f); set.SetBufferSize(source, GenericOutput <float> .KernelPorts.Output, Buffer <float> .SizeRequest(10)); var node1 = set.Create <KernelBufferInputReaderNode>(); set.Connect(source, GenericOutput <float> .KernelPorts.Output, node1, KernelBufferInputReaderNode.KernelPorts.Input); set.SetData(node1, KernelBufferInputReaderNode.KernelPorts.ArrayIndexToTest, 15); var value1 = set.CreateGraphValue(node1, KernelBufferInputReaderNode.KernelPorts.Value); var gotException1 = set.CreateGraphValue(node1, KernelBufferInputReaderNode.KernelPorts.GotException); var node2 = set.Create <KernelBufferInputReaderNode>(); set.Connect(source, GenericOutput <float> .KernelPorts.Output, node2, KernelBufferInputReaderNode.KernelPorts.Input); set.SetData(node2, KernelBufferInputReaderNode.KernelPorts.ArrayIndexToTest, -5); var value2 = set.CreateGraphValue(node2, KernelBufferInputReaderNode.KernelPorts.Value); var gotException2 = set.CreateGraphValue(node2, KernelBufferInputReaderNode.KernelPorts.GotException); var node3 = set.Create <KernelBufferInputReaderNode>(); set.Connect(source, GenericOutput <float> .KernelPorts.Output, node3, KernelBufferInputReaderNode.KernelPorts.Input); set.SetData(node3, KernelBufferInputReaderNode.KernelPorts.ArrayIndexToTest, 5); var value3 = set.CreateGraphValue(node3, KernelBufferInputReaderNode.KernelPorts.Value); var gotException3 = set.CreateGraphValue(node3, KernelBufferInputReaderNode.KernelPorts.GotException); set.Update(); Assert.AreEqual(0.0f, set.GetValueBlocking(value1)); Assert.AreEqual(0.0f, set.GetValueBlocking(value2)); Assert.AreEqual(5.0f, set.GetValueBlocking(value3)); Assert.AreEqual(1, set.GetValueBlocking(gotException1)); Assert.AreEqual(1, set.GetValueBlocking(gotException2)); Assert.AreEqual(0, set.GetValueBlocking(gotException3)); set.ReleaseGraphValue(value1); set.ReleaseGraphValue(value2); set.ReleaseGraphValue(value3); set.ReleaseGraphValue(gotException1); set.ReleaseGraphValue(gotException2); set.ReleaseGraphValue(gotException3); set.Destroy(source); set.Destroy(node1); set.Destroy(node2); set.Destroy(node3); } }
public void CanCreate_MultipleFeedbackConnections_BetweenTwoNodes() { using (var set = new NodeSet()) { var node1 = set.Create <NodeWithAllTypesOfPorts>(); var node2 = set.Create <NodeWithAllTypesOfPorts>(); set.Connect(node1, NodeWithAllTypesOfPorts.KernelPorts.OutputScalar, node2, NodeWithAllTypesOfPorts.KernelPorts.InputScalar, NodeSet.ConnectionType.Feedback); set.Connect(node1, NodeWithAllTypesOfPorts.KernelPorts.OutputBuffer, node2, NodeWithAllTypesOfPorts.KernelPorts.InputBuffer, NodeSet.ConnectionType.Feedback); set.Disconnect(node1, NodeWithAllTypesOfPorts.KernelPorts.OutputScalar, node2, NodeWithAllTypesOfPorts.KernelPorts.InputScalar); set.Disconnect(node1, NodeWithAllTypesOfPorts.KernelPorts.OutputBuffer, node2, NodeWithAllTypesOfPorts.KernelPorts.InputBuffer); set.Destroy(node1, node2); } }
protected override RetargetData CreateGraph(Entity entity, NodeSet set, ref RetargetSetup setup) { var srcClip = ClipManager.Instance.GetClipFor(setup.SrcRig, setup.SrcClip); var data = new RetargetData(); data.DeltaTimeNode = set.Create <DeltaTimeNode>(); data.ClipPlayerNode = set.Create <ClipPlayerNode>(); data.RemapperNode = set.Create <RigRemapperNode>(); set.SendMessage(data.ClipPlayerNode, (InputPortID)ClipPlayerNode.SimulationPorts.Speed, 1.0f); // Connect kernel ports set.Connect(data.DeltaTimeNode, (OutputPortID)DeltaTimeNode.KernelPorts.DeltaTime, data.ClipPlayerNode, (InputPortID)ClipPlayerNode.KernelPorts.DeltaTime); set.Connect(data.ClipPlayerNode, (OutputPortID)ClipPlayerNode.KernelPorts.Output, data.RemapperNode, (InputPortID)RigRemapperNode.KernelPorts.Input); // Send messages set.SendMessage(data.ClipPlayerNode, (InputPortID)ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration { Mask = (int)ClipConfigurationMask.LoopTime }); set.SendMessage(data.ClipPlayerNode, (InputPortID)ClipPlayerNode.SimulationPorts.ClipInstance, srcClip); set.SendMessage(data.RemapperNode, (InputPortID)RigRemapperNode.SimulationPorts.SourceRigDefinition, setup.SrcRig); set.SendMessage(data.RemapperNode, (InputPortID)RigRemapperNode.SimulationPorts.DestinationRigDefinition, setup.DstRig); set.SendMessage(data.RemapperNode, (InputPortID)RigRemapperNode.SimulationPorts.RemapTable, setup.RemapTable); data.Output.Buffer = set.CreateGraphValue <Buffer <float> >(data.RemapperNode, (OutputPortID)RigRemapperNode.KernelPorts.Output); data.DebugOutput.Buffer = set.CreateGraphValue <Buffer <float> >(data.ClipPlayerNode, (OutputPortID)ClipPlayerNode.KernelPorts.Output); var debugEntity = RigUtils.InstantiateDebugRigEntity( setup.SrcRig, EntityManager, new BoneRendererProperties { BoneShape = BoneRendererUtils.BoneShape.Line, Color = new float4(0f, 1f, 0f, 0.5f), Size = 1f } ); if (EntityManager.HasComponent <Translation>(entity)) { PostUpdateCommands.AddComponent( debugEntity, EntityManager.GetComponentData <Translation>(entity) ); } PostUpdateCommands.AddComponent(entity, data.Output); PostUpdateCommands.AddComponent(debugEntity, data.DebugOutput); return(data); }
public void ResolvedDataBuffers_GrowStale_AfterOneUpdate() { using (var set = new NodeSet()) { var outputProvider = set.Create <KernelBufferOutputNode>(); var staleNode = set.Create <StaleKernelChecker>(); set.SetBufferSize(outputProvider, KernelBufferOutputNode.KernelPorts.Output1, Buffer <long> .SizeRequest(1)); set.SetBufferSize(staleNode, StaleKernelChecker.KernelPorts.Output, Buffer <long> .SizeRequest(1)); var gotException = set.CreateGraphValue(staleNode, StaleKernelChecker.KernelPorts.ErrorCode); set.Connect(outputProvider, KernelBufferOutputNode.KernelPorts.Output1, staleNode, StaleKernelChecker.KernelPorts.Input); // first frame is OK set.Update(); Assert.AreEqual(0, set.GetValueBlocking(gotException)); // from the second frame and onwards, access to stale buffers should happen for (int i = 0; i < 10; ++i) { set.Update(); Assert.AreEqual(2, set.GetValueBlocking(gotException)); } set.ReleaseGraphValue(gotException); set.Destroy(staleNode, outputProvider); } }
public void FeedbackTraversalOrder_IsCoherent([Values] NodeSet.RenderExecutionModel model) { using (var set = new NodeSet()) { set.RendererModel = model; var node1 = set.Create <KernelAdderNode>(); var node2 = set.Create <KernelAdderNode>(); GraphValue <int> node1GV = set.CreateGraphValue(node1, KernelAdderNode.KernelPorts.Output); GraphValue <int> node2GV = set.CreateGraphValue(node2, KernelAdderNode.KernelPorts.Output); set.Connect(node1, KernelAdderNode.KernelPorts.Output, node2, KernelAdderNode.KernelPorts.Input, NodeSet.ConnectionType.Feedback); for (int i = 0; i < 10; ++i) { set.SetData(node1, KernelAdderNode.KernelPorts.Input, i); set.Update(); Assert.AreEqual(i + 1, set.GetValueBlocking(node1GV)); Assert.AreEqual(i + 1, set.GetValueBlocking(node2GV)); } set.ReleaseGraphValue(node1GV); set.ReleaseGraphValue(node2GV); set.Destroy(node1, node2); } }
protected override ClipLoopPlayerData CreateGraph(Entity entity, NodeSet set, ref ClipLoopPlayerSetup setup) { if (!EntityManager.HasComponent <SharedRigDefinition>(entity)) { throw new System.NullReferenceException("Entity doesn't have required SharedRigDefinition"); } var rigDefinition = EntityManager.GetSharedComponentData <SharedRigDefinition>(entity); var clip = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.Clip); var data = new ClipLoopPlayerData(); data.DeltaTimeNode = set.Create <DeltaTimeNode>(); data.ClipPlayerNode = set.Create <ClipPlayerNode>(); set.SendMessage(data.ClipPlayerNode, (InputPortID)ClipPlayerNode.SimulationPorts.Speed, 1.0f); // Connect kernel ports set.Connect(data.DeltaTimeNode, (OutputPortID)DeltaTimeNode.KernelPorts.DeltaTime, data.ClipPlayerNode, (InputPortID)ClipPlayerNode.KernelPorts.DeltaTime); // Send messages set.SendMessage(data.ClipPlayerNode, (InputPortID)ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration { Mask = (int)ClipConfigurationMask.LoopTime }); set.SendMessage(data.ClipPlayerNode, (InputPortID)ClipPlayerNode.SimulationPorts.ClipInstance, clip); data.Output.Buffer = set.CreateGraphValue <Buffer <float> >(data.ClipPlayerNode, (OutputPortID)ClipPlayerNode.KernelPorts.Output); PostUpdateCommands.AddComponent(entity, data.Output); return(data); }
protected override ConfigurableClipData CreateGraph(Entity entity, NodeSet set, ref ConfigurableClipSetup setup) { if (!EntityManager.HasComponent <SharedRigDefinition>(entity)) { throw new System.NullReferenceException("Entity doesn't have required SharedRigDefinition"); } var rigDefinition = EntityManager.GetSharedComponentData <SharedRigDefinition>(entity); var clip = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.Clip); var data = new ConfigurableClipData(); data.MotionID = setup.MotionID; data.UpdateConfiguration = true; data.ConfigurableClipNode = set.Create <ConfigurableClipNode>(); data.RootMotionNode = set.Create <RootMotionNode>(); set.Connect(data.ConfigurableClipNode, (OutputPortID)ConfigurableClipNode.KernelPorts.Output, data.RootMotionNode, (InputPortID)RootMotionNode.KernelPorts.Input); set.SendMessage(data.ConfigurableClipNode, (InputPortID)ConfigurableClipNode.SimulationPorts.ClipInstance, clip); set.SendMessage(data.RootMotionNode, (InputPortID)RootMotionNode.SimulationPorts.RigDefinition, rigDefinition.Value); set.SetData(data.ConfigurableClipNode, (InputPortID)ConfigurableClipNode.KernelPorts.Time, setup.ClipTime); data.RootXValue = set.CreateGraphValue <RigidTransform>(data.RootMotionNode, (OutputPortID)RootMotionNode.KernelPorts.RootX); data.Output.Buffer = set.CreateGraphValue <Buffer <float> >(data.ConfigurableClipNode, (OutputPortID)ConfigurableClipNode.KernelPorts.Output); PostUpdateCommands.AddComponent(entity, data.Output); return(data); }
public void Touch() { NodeHandle thing = Mixer; m_Set.Disconnect(Mixer, AnimationMixer.KernelPorts.Output, Rotator, DirectionRotator.KernelPorts.Input); m_Set.Connect(Mixer, AnimationMixer.KernelPorts.Output, Rotator, DirectionRotator.KernelPorts.Input); }
protected override TwoClipsAndMixerData CreateGraph(Entity entity, NodeSet set, ref TwoClipsAndMixerSetup setup) { if (!EntityManager.HasComponent <Unity.Animation.SharedRigDefinition>(entity)) { throw new System.NullReferenceException("Entity doesn't have required SharedRigDefinition"); } var rigDefinition = EntityManager.GetSharedComponentData <Unity.Animation.SharedRigDefinition>(entity); var clip1 = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.Clip1); var clip2 = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.Clip2); var data = new TwoClipsAndMixerData(); data.DeltaTimeNode = set.Create <DeltaTimeNode>(); data.Clip1Node = set.Create <ClipPlayerNode>(); data.Clip2Node = set.Create <ClipPlayerNode>(); data.MixerNode = set.Create <MixerNode>(); // Set constant kernel ports set.SendMessage(data.Clip1Node, (InputPortID)ClipPlayerNode.SimulationPorts.Speed, s_Random.NextFloat(0.1f, 1f)); set.SendMessage(data.Clip2Node, (InputPortID)ClipPlayerNode.SimulationPorts.Speed, s_Random.NextFloat(0.1f, 1f)); // Connect kernel ports set.Connect(data.DeltaTimeNode, (OutputPortID)DeltaTimeNode.KernelPorts.DeltaTime, data.Clip1Node, (InputPortID)ClipPlayerNode.KernelPorts.DeltaTime); set.Connect(data.DeltaTimeNode, (OutputPortID)DeltaTimeNode.KernelPorts.DeltaTime, data.Clip2Node, (InputPortID)ClipPlayerNode.KernelPorts.DeltaTime); set.Connect(data.Clip1Node, (OutputPortID)ClipPlayerNode.KernelPorts.Output, data.MixerNode, (InputPortID)MixerNode.KernelPorts.Input0); set.Connect(data.Clip2Node, (OutputPortID)ClipPlayerNode.KernelPorts.Output, data.MixerNode, (InputPortID)MixerNode.KernelPorts.Input1); // Send messages set.SendMessage(data.Clip1Node, (InputPortID)ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration { Mask = (int)ClipConfigurationMask.LoopTime }); set.SendMessage(data.Clip2Node, (InputPortID)ClipPlayerNode.SimulationPorts.Configuration, new ClipConfiguration { Mask = (int)ClipConfigurationMask.LoopTime }); set.SendMessage(data.Clip1Node, (InputPortID)ClipPlayerNode.SimulationPorts.ClipInstance, clip1); set.SendMessage(data.Clip2Node, (InputPortID)ClipPlayerNode.SimulationPorts.ClipInstance, clip2); set.SendMessage(data.MixerNode, (InputPortID)MixerNode.SimulationPorts.RigDefinition, rigDefinition.Value); set.SendMessage(data.MixerNode, (InputPortID)MixerNode.SimulationPorts.Blend, s_Random.NextFloat(0f, 1f)); data.Output.Buffer = set.CreateGraphValue <Buffer <float> >(data.MixerNode, (OutputPortID)MixerNode.KernelPorts.Output); PostUpdateCommands.AddComponent(entity, data.Output); return(data); }
public void NthOrderFeedbackSystem_Works([Values] NodeSet.RenderExecutionModel model, [Values(2, 5, 100)] int numNodes) { using (var set = new NodeSet()) { set.RendererModel = model; var nodes = new List <NodeHandle <KernelSumNode> >(); var nodeGVs = new List <GraphValue <ECSInt> >(); var expected = new List <ECSInt>(); nodes.Add(set.Create <KernelSumNode>()); nodeGVs.Add(set.CreateGraphValue(nodes[0], KernelSumNode.KernelPorts.Output)); expected.Add(1); for (int i = 1; i < numNodes; ++i) { var node = set.Create <KernelSumNode>(); nodeGVs.Add(set.CreateGraphValue(node, KernelSumNode.KernelPorts.Output)); expected.Add(1); nodes.Add(node); set.SetPortArraySize(node, KernelSumNode.KernelPorts.Inputs, 1); set.Connect(nodes[i - 1], KernelSumNode.KernelPorts.Output, node, KernelSumNode.KernelPorts.Inputs, 0); set.SetPortArraySize(nodes[i - 1], KernelSumNode.KernelPorts.Inputs, 2); set.Connect(node, KernelSumNode.KernelPorts.Output, nodes[i - 1], KernelSumNode.KernelPorts.Inputs, 1, NodeSet.ConnectionType.Feedback); } set.SetData(nodes[0], KernelSumNode.KernelPorts.Inputs, 0, 1); for (int i = 0; i < 10; ++i) { set.Update(); for (int j = 0; j < numNodes; ++j) { Assert.AreEqual(expected[j], set.GetValueBlocking(nodeGVs[j])); } expected[0] = expected[1] + 1; for (int j = 1; j < numNodes - 1; ++j) { expected[j] = expected[j - 1] + expected[j + 1]; } expected[numNodes - 1] = expected[numNodes - 2]; } nodeGVs.ForEach(n => set.ReleaseGraphValue(n)); nodes.ForEach(n => set.Destroy(n)); } }
protected override BlendTree2DData CreateGraph(Entity entity, NodeSet set, ref BlendTree2DSetup setup) { if (!EntityManager.HasComponent <SharedRigDefinition>(entity)) { throw new System.NullReferenceException("Entity doesn't have required SharedRigDefinition"); } var rigDefinition = EntityManager.GetSharedComponentData <SharedRigDefinition>(entity); var blendTreeComponent = EntityManager.GetBuffer <BlendTree2DResource>(entity); var blendTreeAsset = BlendTreeBuilder.CreateBlendTree2DFromComponents(blendTreeComponent[setup.BlendTreeIndex], EntityManager, entity); var data = new BlendTree2DData(); var strongHandle = set.Create <BlendTree2DNode>(); data.paramX = rand.NextFloat(-1.0f, 1.0f); data.paramY = rand.NextFloat(-1.0f, 1.0f); data.BlendTree = strongHandle; data.BlendTreeAsset = blendTreeAsset; data.DeltaTimeNode = set.Create <DeltaTimeNode>(); data.TimeCounterNode = set.Create <TimeCounterNode>(); data.TimeLoopNode = set.Create <TimeLoopNode>(); data.FloatRcpSimNode = set.Create <FloatRcpSimNode>(); set.Connect(data.DeltaTimeNode, (OutputPortID)DeltaTimeNode.KernelPorts.DeltaTime, data.TimeCounterNode, (InputPortID)TimeCounterNode.KernelPorts.DeltaTime); set.Connect(data.TimeCounterNode, (OutputPortID)TimeCounterNode.KernelPorts.Time, data.TimeLoopNode, (InputPortID)TimeLoopNode.KernelPorts.InputTime); set.Connect(data.TimeLoopNode, (OutputPortID)TimeLoopNode.KernelPorts.OutputTime, data.BlendTree, (InputPortID)BlendTree2DNode.KernelPorts.NormalizedTime); set.Connect(data.BlendTree, (OutputPortID)BlendTree2DNode.SimulationPorts.Duration, data.FloatRcpSimNode, (InputPortID)FloatRcpSimNode.SimulationPorts.Input); set.Connect(data.FloatRcpSimNode, (OutputPortID)FloatRcpSimNode.SimulationPorts.Output, data.TimeCounterNode, (InputPortID)TimeCounterNode.SimulationPorts.Speed); set.SendMessage(data.TimeLoopNode, (InputPortID)TimeLoopNode.SimulationPorts.Duration, 1.0F); set.SendMessage(data.BlendTree, (InputPortID)BlendTree2DNode.SimulationPorts.RigDefinition, rigDefinition.Value); set.SendMessage(data.BlendTree, (InputPortID)BlendTree2DNode.SimulationPorts.BlendTree, data.BlendTreeAsset); data.Output.Buffer = set.CreateGraphValue(strongHandle, BlendTree2DNode.KernelPorts.Output); PostUpdateCommands.AddComponent(entity, data.Output); return(data); }
public void CanCreate_FeedbackConnection() { using (var set = new NodeSet()) { var node1 = set.Create <KernelAdderNode>(); var node2 = set.Create <KernelAdderNode>(); set.Connect(node1, KernelAdderNode.KernelPorts.Output, node2, KernelAdderNode.KernelPorts.Input, NodeSet.ConnectionType.Feedback); set.Destroy(node1, node2); } }
public TweeningObject(NodeSet set, GameObject prefab, float axisRotation) { GO = Object.Instantiate(prefab); m_Set = set; Vertical = set.Create <PositionAnimator>(); set.SendMessage(Vertical, PositionAnimator.SimulationPorts.Time, axisRotation); set.SendMessage(Vertical, PositionAnimator.SimulationPorts.Movement, Vector3.up); Horizontal = set.Create <PositionAnimator>(); set.SendMessage(Horizontal, PositionAnimator.SimulationPorts.Time, axisRotation); set.SendMessage(Horizontal, PositionAnimator.SimulationPorts.Movement, Vector3.left); Mixer = set.Create <AnimationMixer>(); Rotator = set.Create <DirectionRotator>(); set.SendMessage(Rotator, DirectionRotator.SimulationPorts.Magnitude, axisRotation); set.SendMessage(Rotator, DirectionRotator.SimulationPorts.TransformTarget, GO.transform); m_Set.Connect(Vertical, PositionAnimator.KernelPorts.Output, Mixer, AnimationMixer.KernelPorts.InputA); m_Set.Connect(Horizontal, PositionAnimator.KernelPorts.Output, Mixer, AnimationMixer.KernelPorts.InputB); m_Set.Connect(Mixer, AnimationMixer.KernelPorts.Output, Rotator, DirectionRotator.KernelPorts.Input); }
public static DynamicMixer AddComponents(EntityCommandBuffer cmdBuffer, NodeSet set, Entity entity) { var dynamicMixer = new DynamicMixer { MixerBegin = set.Create <MixerBeginNode>(), MixerEnd = set.Create <MixerEndNode>(), }; cmdBuffer.AddComponent(entity, dynamicMixer); cmdBuffer.AddBuffer <DynamicMixerInput>(entity); set.Connect(dynamicMixer.MixerBegin, MixerBeginNode.KernelPorts.Output, dynamicMixer.MixerEnd, MixerEndNode.KernelPorts.Input); return(dynamicMixer); }
public void TopologyVersionIncreases_OnCreatingConnections() { using (var set = new NodeSet()) { NodeHandle <NodeWithAllTypesOfPorts> a = set.Create <NodeWithAllTypesOfPorts>(), b = set.Create <NodeWithAllTypesOfPorts>(); var version = set.TopologyVersion.Version; set.Connect(a, NodeWithAllTypesOfPorts.SimulationPorts.MessageOut, b, NodeWithAllTypesOfPorts.SimulationPorts.MessageIn); Assert.Greater(set.TopologyVersion.Version, version); set.Destroy(a, b); } }
public void InputDataBuffers_AreReadOnly() { // (read, write) already covered in the other tests. using (var set = new NodeSet()) { var outputProvider = set.Create <KernelBufferOutputNode>(); set.SetBufferSize(outputProvider, KernelBufferOutputNode.KernelPorts.Output1, Buffer <long> .SizeRequest(1)); var nodeThatWritesToInput = set.Create <NodeThatWritesToInputBuffer>(); var gotException = set.CreateGraphValue(nodeThatWritesToInput, NodeThatWritesToInputBuffer.KernelPorts.GotException); set.Connect(outputProvider, KernelBufferOutputNode.KernelPorts.Output1, nodeThatWritesToInput, NodeThatWritesToInputBuffer.KernelPorts.Input); set.Update(); Assert.AreEqual(1, set.GetValueBlocking(gotException)); set.ReleaseGraphValue(gotException); set.Destroy(nodeThatWritesToInput, outputProvider); } }
[Test, Explicit] // Does not work due to issue #331. Do we even want it to work? public void SingleNodeFeedbackLoop_Works([Values] NodeSet.RenderExecutionModel model) { using (var set = new NodeSet()) { set.RendererModel = model; var node = set.Create <KernelAdderNode>(); GraphValue <int> nodeGV = set.CreateGraphValue(node, KernelAdderNode.KernelPorts.Output); set.Connect(node, KernelAdderNode.KernelPorts.Output, node, KernelAdderNode.KernelPorts.Input, NodeSet.ConnectionType.Feedback); for (int i = 0; i < 10; ++i) { set.Update(); Assert.AreEqual(i + 1, set.GetValueBlocking(nodeGV)); } set.ReleaseGraphValue(nodeGV); set.Destroy(node); } }
public void TestGenericType <T>(int testBufferSize, T testValue) where T : struct { using (var set = new NodeSet()) { var output = set.Create <GenericOutput <T> >(); var input = set.Create <GenericInput <T> >(); set.SetBufferSize(output, GenericOutput <T> .KernelPorts.Output, Buffer <T> .SizeRequest(testBufferSize)); set.Connect(output, GenericOutput <T> .KernelPorts.Output, input, GenericInput <T> .KernelPorts.Input); set.SendMessage(output, GenericOutput <T> .SimulationPorts.Input, testValue); var value = set.CreateGraphValue(input, GenericInput <T> .KernelPorts.Output); set.Update(); set.DataGraph.SyncAnyRendering(); Assert.AreEqual(testValue, set.GetValueBlocking(value)); set.ReleaseGraphValue(value); set.Destroy(input, output); } }
void Start() { using (var set = new NodeSet()) { var writer = set.Create <MyWriter>(); var reader = set.Create <MyReader>(); set.Connect(writer, MyWriter.KernelPorts.OutputBuffer, reader, MyReader.KernelPorts.InputBuffer); /* * You'll notice we haven't declared the size of the array anywhere yet. * This is done in the simulation (or externally), by transferring a size request in the SetBufferSize() API * on the node set. */ set.SetBufferSize(writer, MyWriter.KernelPorts.OutputBuffer, Buffer <float> .SizeRequest(50)); set.Update(); /* * Buffer memory is otherwise managed by the node set, so we don't have to worry about cleaning that up. */ set.Destroy(writer, reader); } }
public static void Connect <TType, TBuffer>(this NodeSet set, NodeHandle <ComponentNode> from, NodeHandle <TType> to, DataInput <TType, Buffer <TBuffer> > port, NodeSet.ConnectionType type = NodeSet.ConnectionType.Normal) where TType : NodeDefinition where TBuffer : struct, IBufferElementData { set.Connect(from, ComponentNode.Output <TBuffer>(), to, port, type); }
public static void Connect <TType, TData>(this NodeSet set, NodeHandle <TType> from, DataOutput <TType, TData> port, NodeHandle <ComponentNode> to, NodeSet.ConnectionType type = NodeSet.ConnectionType.Normal) where TType : NodeDefinition where TData : struct, IComponentData { set.Connect(from, port, to, ComponentNode.Input <TData>(), type); }
protected override AnimationControllerData CreateGraph(Entity entity, NodeSet set, ref AnimationControllerSetup setup) { if (!EntityManager.HasComponent <SharedRigDefinition>(entity)) { throw new System.NullReferenceException("Entity doesn't have required SharedRigDefinition"); } var rigDefinition = EntityManager.GetSharedComponentData <SharedRigDefinition>(entity); var walkShortLeftClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.WalkShortLeftClip); var walkLongLeftClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.WalkLongLeftClip); var walkStraightClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.WalkStraightClip); var walkLongRightClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.WalkLongRightClip); var walkShortRightClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.WalkShortRightClip); var jogShortLeftClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.JogShortLeftClip); var jogLongLeftClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.JogLongLeftClip); var jogStraightClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.JogStraightClip); var jogLongRightClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.JogLongRightClip); var jogShortRightClipInstance = ClipManager.Instance.GetClipFor(rigDefinition.Value, setup.JogShortRightClip); var data = new AnimationControllerData(); data.DeltaTimeNode = set.Create <DeltaTimeNode>(); data.TimeCounterNode = set.Create <TimeCounterNode>(); data.MixerWalkNode = set.Create <DirectionMixerNode>(); data.MixerJogNode = set.Create <DirectionMixerNode>(); data.MixerSpeedNode = set.Create <MixerNode>(); data.RootMotionNode = set.Create <RootMotionNode>(); data.Direction = 2.0f; data.Speed = 0.0f; set.Connect(data.DeltaTimeNode, (OutputPortID)DeltaTimeNode.KernelPorts.DeltaTime, data.TimeCounterNode, (InputPortID)TimeCounterNode.KernelPorts.DeltaTime); set.Connect(data.TimeCounterNode, (OutputPortID)TimeCounterNode.KernelPorts.OutputDeltaTime, data.MixerWalkNode, (InputPortID)DirectionMixerNode.KernelPorts.DeltaTime); set.Connect(data.TimeCounterNode, (OutputPortID)TimeCounterNode.KernelPorts.Time, data.MixerWalkNode, (InputPortID)DirectionMixerNode.KernelPorts.Time); set.Connect(data.TimeCounterNode, (OutputPortID)TimeCounterNode.KernelPorts.OutputDeltaTime, data.MixerJogNode, (InputPortID)DirectionMixerNode.KernelPorts.DeltaTime); set.Connect(data.TimeCounterNode, (OutputPortID)TimeCounterNode.KernelPorts.Time, data.MixerJogNode, (InputPortID)DirectionMixerNode.KernelPorts.Time); set.Connect(data.MixerWalkNode, (OutputPortID)DirectionMixerNode.KernelPorts.Output, data.MixerSpeedNode, (InputPortID)MixerNode.KernelPorts.Input0); set.Connect(data.MixerJogNode, (OutputPortID)DirectionMixerNode.KernelPorts.Output, data.MixerSpeedNode, (InputPortID)MixerNode.KernelPorts.Input1); set.Connect(data.MixerSpeedNode, (OutputPortID)MixerNode.KernelPorts.Output, data.RootMotionNode, (InputPortID)RootMotionNode.KernelPorts.Input); set.SendMessage(data.MixerWalkNode, (InputPortID)DirectionMixerNode.SimulationPorts.ClipConfiguration, setup.Configuration); set.SendMessage(data.MixerWalkNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip0, walkShortLeftClipInstance); set.SendMessage(data.MixerWalkNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip1, walkLongLeftClipInstance); set.SendMessage(data.MixerWalkNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip2, walkStraightClipInstance); set.SendMessage(data.MixerWalkNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip3, walkLongRightClipInstance); set.SendMessage(data.MixerWalkNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip4, walkShortRightClipInstance); set.SendMessage(data.MixerJogNode, (InputPortID)DirectionMixerNode.SimulationPorts.ClipConfiguration, setup.Configuration); set.SendMessage(data.MixerJogNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip0, jogShortLeftClipInstance); set.SendMessage(data.MixerJogNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip1, jogLongLeftClipInstance); set.SendMessage(data.MixerJogNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip2, jogStraightClipInstance); set.SendMessage(data.MixerJogNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip3, jogLongRightClipInstance); set.SendMessage(data.MixerJogNode, (InputPortID)DirectionMixerNode.SimulationPorts.Clip4, jogShortRightClipInstance); set.SendMessage(data.MixerSpeedNode, (InputPortID)MixerNode.SimulationPorts.RigDefinition, rigDefinition.Value); set.SendMessage(data.RootMotionNode, (InputPortID)RootMotionNode.SimulationPorts.RigDefinition, rigDefinition.Value); RigidTransform rootX = RigidTransform.identity; if (EntityManager.HasComponent <Translation>(entity)) { rootX.pos = EntityManager.GetComponentData <Translation>(entity).Value; } else { PostUpdateCommands.AddComponent(entity, new Translation()); } if (EntityManager.HasComponent <Rotation>(entity)) { rootX.rot = EntityManager.GetComponentData <Rotation>(entity).Value; } else { PostUpdateCommands.AddComponent(entity, new Rotation { Value = quaternion.identity }); } set.SetData(data.RootMotionNode, (InputPortID)RootMotionNode.KernelPorts.PrevRootX, rootX); data.RootXValue = set.CreateGraphValue <RigidTransform>(data.RootMotionNode, (OutputPortID)RootMotionNode.KernelPorts.RootX); data.Output.Buffer = set.CreateGraphValue <Buffer <float> >(data.RootMotionNode, (OutputPortID)RootMotionNode.KernelPorts.Output); PostUpdateCommands.AddComponent(entity, data.Output); return(data); }
public static void AddInput(NodeSet set, ref DynamicMixer dynamicMixer, DynamicBuffer <DynamicMixerInput> inputs, Entity sourceEntity, NodeHandle sourceNode, OutputPortID sourcePortId) { // Attempt to find unsused input for (int i = 0; i < inputs.Length; i++) { var input = inputs[i]; if (input.SourceEntity == Entity.Null) { // GameDebug.Log("Added input at index:" + i); input.SourceEntity = sourceEntity; input.SourceNode = sourceNode; input.SourcePortId = sourcePortId; inputs[i] = input; set.Connect(sourceNode, sourcePortId, input.AddNode, (InputPortID)MixerAddNode.KernelPorts.Add); return; } } // Create new input // GameDebug.Log("Added input. New input index:" + inputs.Length); var newNode = set.Create <MixerAddNode>(); set.SendMessage(newNode, MixerAddNode.SimulationPorts.RigDefinition, dynamicMixer.Rig); set.Connect(sourceNode, sourcePortId, newNode, (InputPortID)MixerAddNode.KernelPorts.Add); // First node if (inputs.Length == 0) { set.Disconnect(dynamicMixer.MixerBegin, MixerBeginNode.KernelPorts.Output, dynamicMixer.MixerEnd, MixerEndNode.KernelPorts.Input); // Connect begin to add node set.Connect(dynamicMixer.MixerBegin, MixerBeginNode.KernelPorts.Output, newNode, MixerAddNode.KernelPorts.Input); set.Connect(dynamicMixer.MixerBegin, MixerBeginNode.KernelPorts.SumWeight, newNode, MixerAddNode.KernelPorts.SumWeightInput); // Connect Add node to end set.Connect(newNode, MixerAddNode.KernelPorts.Output, dynamicMixer.MixerEnd, MixerEndNode.KernelPorts.Input); set.Connect(newNode, MixerAddNode.KernelPorts.SumWeightOutput, dynamicMixer.MixerEnd, MixerEndNode.KernelPorts.SumWeight); } else { var prevInput = inputs[inputs.Length - 1]; // Disconnect prev from end set.Disconnect(prevInput.AddNode, MixerAddNode.KernelPorts.Output, dynamicMixer.MixerEnd, MixerEndNode.KernelPorts.Input); set.Disconnect(prevInput.AddNode, MixerAddNode.KernelPorts.SumWeightOutput, dynamicMixer.MixerEnd, MixerEndNode.KernelPorts.SumWeight); // Connect prev to new node set.Connect(prevInput.AddNode, MixerAddNode.KernelPorts.Output, newNode, MixerAddNode.KernelPorts.Input); set.Connect(prevInput.AddNode, MixerAddNode.KernelPorts.SumWeightOutput, newNode, MixerAddNode.KernelPorts.SumWeightInput); // Connect new node to end set.Connect(newNode, MixerAddNode.KernelPorts.Output, dynamicMixer.MixerEnd, MixerEndNode.KernelPorts.Input); set.Connect(newNode, MixerAddNode.KernelPorts.SumWeightOutput, dynamicMixer.MixerEnd, MixerEndNode.KernelPorts.SumWeight); } var newInput = new DynamicMixerInput { SourceEntity = sourceEntity, SourceNode = sourceNode, SourcePortId = sourcePortId, AddNode = newNode, }; inputs.Add(newInput); }
public DAGTest(NodeSet set) { m_GC = new List <NodeHandle>(); m_Set = set; Leaves = new NodeHandle <ANode> [5]; Roots = new NodeHandle[5]; RootGVs = new GraphValue <int> [5]; // Part (1) of the graph. Leaves[0] = set.Create <ANode>(); var b1 = set.Create <BNode>(); set.Connect(Leaves[0], ANode.KernelPorts.Output, b1, BNode.KernelPorts.Input); Roots[0] = b1; RootGVs[0] = set.CreateGraphValue(b1, BNode.KernelPorts.Output); // Part (2) of the graph. Leaves[1] = set.Create <ANode>(); var c2 = set.Create <CNode>(); var b2 = set.Create <BNode>(); set.Connect(Leaves[1], ANode.KernelPorts.Output, c2, CNode.KernelPorts.InputA); set.Connect(c2, CNode.KernelPorts.Output, b2, BNode.KernelPorts.Input); Roots[1] = b2; RootGVs[1] = set.CreateGraphValue(b2, BNode.KernelPorts.Output); // Part (4) of the graph. Leaves[3] = set.Create <ANode>(); var c4 = set.Create <CNode>(); var b4 = set.Create <BNode>(); set.Connect(Leaves[3], ANode.KernelPorts.Output, c4, CNode.KernelPorts.InputA); set.Connect(c4, CNode.KernelPorts.Output, b4, BNode.KernelPorts.Input); Roots[3] = b4; RootGVs[3] = set.CreateGraphValue(b4, BNode.KernelPorts.Output); // Part (3) of the graph. Leaves[2] = set.Create <ANode>(); var b3_1 = set.Create <BNode>(); var b3_2 = set.Create <BNode>(); var c3_1 = set.Create <CNode>(); var c3_2 = set.Create <CNode>(); set.Connect(Leaves[2], ANode.KernelPorts.Output, b3_1, BNode.KernelPorts.Input); set.Connect(b3_1, BNode.KernelPorts.Output, b3_2, BNode.KernelPorts.Input); set.Connect(b3_2, BNode.KernelPorts.Output, c2, CNode.KernelPorts.InputB); set.Connect(b3_2, BNode.KernelPorts.Output, c4, CNode.KernelPorts.InputB); set.Connect(c2, CNode.KernelPorts.Output, c3_1, CNode.KernelPorts.InputA); set.Connect(c4, CNode.KernelPorts.Output, c3_1, CNode.KernelPorts.InputB); set.Connect(c3_1, CNode.KernelPorts.Output, c3_2, CNode.KernelPorts.InputA); set.Connect(c3_1, CNode.KernelPorts.Output, c3_2, CNode.KernelPorts.InputB); Roots[2] = c3_2; RootGVs[2] = set.CreateGraphValue(c3_2, CNode.KernelPorts.Output); // Part (5) of the graph. Leaves[4] = set.Create <ANode>(); Roots[4] = Leaves[4]; RootGVs[4] = set.CreateGraphValue(Leaves[4], ANode.KernelPorts.Output); GC(b1, c2, b2, c4, b4, b3_1, b3_2, c3_1, c3_2); }
public void MessageConnectionsMade_CausesConnectionTable_ToBePopulatedCorrectly_AndSubsequentlyRemoved(ConnectionAPI meansOfConnection) { using (var set = new NodeSet()) { NodeHandle <NodeWithAllTypesOfPorts> a = set.Create <NodeWithAllTypesOfPorts>(), b = set.Create <NodeWithAllTypesOfPorts>(); NodeHandle untypedA = a, untypedB = b; Assert.AreEqual(0, set.GetTopologyDatabase().CountEstablishedConnections(), "There are valid connections in a new set with zero connections"); if (meansOfConnection == ConnectionAPI.StronglyTyped) { set.Connect(a, NodeWithAllTypesOfPorts.SimulationPorts.MessageOut, b, NodeWithAllTypesOfPorts.SimulationPorts.MessageIn); } else { set.Connect(a, set.GetDefinition(a).GetPortDescription(a).Outputs[0], b, set.GetDefinition(b).GetPortDescription(b).Inputs[0]); } Assert.AreEqual(1, set.GetTopologyDatabase().CountEstablishedConnections(), "There isn't exactly one valid edge in a new set with one connection"); var madeConnection = new Topology.Connection(); Assert.IsFalse(madeConnection.Valid, "Default constructed connection is valid"); int indexHandleCounter = 0, foundIndexHandle = 0; for (int i = 0; i < set.GetTopologyDatabase().TotalConnections; ++i) { if (set.GetTopologyDatabase()[i].Valid) { madeConnection = set.GetTopologyDatabase()[i]; foundIndexHandle = indexHandleCounter; } indexHandleCounter++; } Assert.IsTrue(madeConnection.Valid, "Could not find the made connection"); Assert.NotZero(foundIndexHandle, "Found connection cannot be the invalid slot"); // check the connection is as it should be Assert.AreEqual((uint)PortDescription.Category.Message, madeConnection.TraversalFlags); Assert.AreEqual(untypedB, madeConnection.Destination.ToPublicHandle()); Assert.AreEqual(untypedA, madeConnection.Source.ToPublicHandle()); Assert.AreEqual(NodeWithAllTypesOfPorts.SimulationPorts.MessageOut.Port, madeConnection.SourceOutputPort); Assert.AreEqual(NodeWithAllTypesOfPorts.SimulationPorts.MessageIn.Port, madeConnection.DestinationInputPort.PortID); Assert.AreEqual(foundIndexHandle, madeConnection.HandleToSelf.Index); if (meansOfConnection == ConnectionAPI.StronglyTyped) { set.Disconnect(a, NodeWithAllTypesOfPorts.SimulationPorts.MessageOut, b, NodeWithAllTypesOfPorts.SimulationPorts.MessageIn); } else { set.Disconnect(a, set.GetDefinition(a).GetPortDescription(a).Outputs[0], b, set.GetDefinition(b).GetPortDescription(b).Inputs[0]); } Assert.AreEqual(0, set.GetTopologyDatabase().CountEstablishedConnections(), "There are valid connections in a new set with zero connections"); set.Destroy(a, b); } }