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);
}
}