public void TestInstantiateAtActivated(bool isActivated)
{
GraphBuilder.VariableHandle handle = default;
SetupTestGraphDefinitionMultipleFrames((b, _) =>
{
handle = b.BindVariableToDataIndex("TestEntity");
var onUpdate = b.AddNode(new OnUpdate());
var enabled = b.AddNode(new ConstantBool {
Value = true
});
var instantiateAt = b.AddNode(new InstantiateAt());
var constantActivatedValue = b.AddNode(new ConstantBool {
Value = isActivated
});
b.BindVariableToInput(handle, instantiateAt.Prefab);
b.CreateEdge(enabled.ValuePort, onUpdate.Enabled);
b.CreateEdge(onUpdate.Output, instantiateAt.Input);
b.CreateEdge(constantActivatedValue.ValuePort, instantiateAt.Activate);
},
(manager, entity, index) =>
{
var instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(handle.DataIndex, entity);
},
(manager, entity, index) =>
{
var e = manager.GetAllEntities().Last();
Assert.AreEqual(manager.GetEnabled(e), isActivated);
});
}
public void UpdateLogVariable()
{
GraphBuilder.VariableHandle varIndex = default;
SetupTestGraphDefinitionMultipleFrames((b, inputs) =>
{
var constBool = b.AddNode(new ConstantBool {
Value = true
});
varIndex = b.BindVariableToDataIndex("a");
var onUpdate = b.AddNode(new OnUpdate());
var log = AddLogNode(b);
b.CreateEdge(constBool.ValuePort, onUpdate.Enabled);
b.CreateEdge(onUpdate.Output, log.Input);
b.BindVariableToInput(varIndex, log.Messages.SelectPort(0));
}, (manager, entity, index) =>
{
LogAssert.NoUnexpectedReceived();
GraphInstance instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(varIndex.DataIndex, 42);
}, (manager, entity, index) =>
{
LogAssert.Expect(LogType.Log, "42");
});
}
static GraphBuilder.VariableHandle CreateGraphReferenceEntityVariable(GraphBuilder b, List <ValueInput> inputs, Entity referencedEntity)
{
var bindingId = nameof(GraphReference.Target).ToBidingId();
GraphBuilder.VariableHandle entityVariableDataIndex = b.DeclareObjectReferenceVariable(bindingId);
inputs.Add(new ValueInput {
Value = referencedEntity, Index = entityVariableDataIndex.DataIndex
});
return(entityVariableDataIndex);
}
public void TestSetComponent()
{
GraphBuilder.VariableHandle varIndex = default;
int initialValue = 42;
int newValue = 55;
SetupTestGraphDefinitionMultipleFrames((b, _) =>
{
var componentTypeRef = new TypeReference {
TypeHash = TypeHash.CalculateStableTypeHash(typeof(TestComponent))
};
var onUpdate = b.AddNode(new OnUpdate());
var enabled = b.AddNode(new ConstantBool {
Value = true
});
var setComponent = b.AddNode(new SetComponent {
Type = componentTypeRef, ComponentData = new InputDataMultiPort {
DataCount = 2
}
});
b.CreateEdge(enabled.ValuePort, onUpdate.Enabled);
varIndex = b.BindVariableToDataIndex("a");
b.BindVariableToInput(varIndex, setComponent.ComponentData.SelectPort(0));
b.CreateEdge(onUpdate.Output, setComponent.Set);
b.AddReferencedComponent(componentTypeRef);
}
, (manager, entity, index) =>
{
// don't add the component yet, next frame we can test that "set component" doesn't do anything if no component is attached
}, (manager, entity, index) =>
{
LogAssert.NoUnexpectedReceived();
Assert.That(manager.HasComponent <TestComponent>(entity), Is.False); // Set component shouldn't add a component
manager.AddComponentData(entity, new TestComponent {
Int = initialValue, Float = 12.7f
});
GraphInstance instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(varIndex.DataIndex, newValue);
}, (manager, entity, index) =>
{
var componentData = manager.GetComponentData <TestComponent>(entity);
Assert.That(componentData.Int, Is.EqualTo(newValue));
});
}
public void SystemTestingWorks()
{
GraphBuilder.VariableHandle varIndex = default;
SetupTestGraphDefinitionMultipleFrames(b =>
{
var update = b.AddUpdate();
var log = b.AddLog();
varIndex = b.BindVariableToDataIndex("a");
b.BindVariableToInput(varIndex, log.Messages.SelectPort(0));
b.CreateEdge(update.Output, log.Input);
}, (manager, entity, index) =>
{
GraphInstance instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(varIndex.DataIndex, 42);
LogAssert.NoUnexpectedReceived();
}, (manager, entity, index) =>
{
LogAssert.Expect(LogType.Log, "42");
});
}
public void TestInstantiateAtNonUniformScale(bool hasComponent)
{
GraphBuilder.VariableHandle handle = default;
var scale = new float3(1f, 2f, 4f);
SetupTestGraphDefinitionMultipleFrames((b, _) =>
{
handle = b.BindVariableToDataIndex("TestEntity");
var onUpdate = b.AddNode(new OnUpdate());
var enabled = b.AddNode(new ConstantBool {
Value = true
});
var instantiateAt = b.AddNode(new InstantiateAt());
var scaleValue = b.AddNode(new ConstantFloat3 {
Value = scale
});
b.BindVariableToInput(handle, instantiateAt.Prefab);
b.CreateEdge(enabled.ValuePort, onUpdate.Enabled);
b.CreateEdge(onUpdate.Output, instantiateAt.Input);
b.CreateEdge(scaleValue.ValuePort, instantiateAt.Scale);
},
(manager, entity, index) =>
{
var instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(handle.DataIndex, entity);
if (hasComponent)
{
manager.AddComponent <Scale>(entity);
manager.AddComponent <NonUniformScale>(entity);
}
},
(manager, entity, index) =>
{
var e = manager.GetAllEntities().Last();
Assert.IsTrue(manager.GetComponentData <NonUniformScale>(e).Value.Equals(scale));
Assert.IsFalse(manager.HasComponent <Scale>(e));
});
}
public void TestSetRotationEulerAngles()
{
GraphBuilder.VariableHandle handle = default;
var setValue = new float3(-30f, 0f, 0f);
SetupTestGraphDefinitionMultipleFrames((b, _) =>
{
handle = b.BindVariableToDataIndex("TestEntity");
var onUpdate = b.AddNode(new OnUpdate());
var enabled = b.AddNode(new ConstantBool {
Value = true
});
var setRotation = b.AddNode(new SetRotation {
});
var quatFromEuler = b.AddNode(new RotationEuler());
var constantRotationValue = b.AddNode(new ConstantFloat3()
{
Value = setValue
});
b.BindVariableToInput(handle, setRotation.GameObject);
b.CreateEdge(enabled.ValuePort, onUpdate.Enabled);
b.CreateEdge(onUpdate.Output, setRotation.Input);
b.CreateEdge(constantRotationValue.ValuePort, quatFromEuler.Euler);
b.CreateEdge(quatFromEuler.Value, setRotation.Value);
}
, (manager, entity, index) =>
{
GraphInstance instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(handle.DataIndex, entity);
Assert.That(!manager.HasComponent <Rotation>(entity));
}, (manager, entity, index) =>
{
Rotation rotation = manager.GetComponentData <Rotation>(entity);
var q = rotation.Value;
Assert.That(q, Is.EqualTo(quaternion.Euler(math.radians(setValue))));
LogAssert.NoUnexpectedReceived();
});
}
public void TestInstantiateAtRotation(bool hasComponent)
{
GraphBuilder.VariableHandle handle = default;
var rotation = new quaternion(1f, 2f, 3f, 4f);
SetupTestGraphDefinitionMultipleFrames((b, _) =>
{
handle = b.BindVariableToDataIndex("TestEntity");
var onUpdate = b.AddNode(new OnUpdate());
var enabled = b.AddNode(new ConstantBool {
Value = true
});
var instantiateAt = b.AddNode(new InstantiateAt());
var constantPositionValue = b.AddNode(new ConstantQuaternion {
Value = rotation
});
b.BindVariableToInput(handle, instantiateAt.Prefab);
b.CreateEdge(enabled.ValuePort, onUpdate.Enabled);
b.CreateEdge(onUpdate.Output, instantiateAt.Input);
b.CreateEdge(constantPositionValue.ValuePort, instantiateAt.Rotation);
},
(manager, entity, index) =>
{
var instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(handle.DataIndex, entity);
if (hasComponent)
{
manager.AddComponent <Rotation>(entity);
}
},
(manager, entity, index) =>
{
var e = manager.GetAllEntities().Last();
Assert.IsTrue(manager.GetComponentData <Rotation>(e).Value.Equals(rotation));
});
}
public void TestSetRotationVector3()
{
GraphBuilder.VariableHandle handle = default;
var setValue = new quaternion(0.258819f, 0f, 0f, 0.9659258f);
SetupTestGraphDefinitionMultipleFrames((b, _) =>
{
handle = b.BindVariableToDataIndex("TestEntity");
var onUpdate = b.AddNode(new OnUpdate());
var enabled = b.AddNode(new ConstantBool {
Value = true
});
var setRotation = b.AddNode(new SetRotation {
});
var constantRotationValue = b.AddNode(new ConstantQuaternion()
{
Value = setValue
});
b.BindVariableToInput(handle, setRotation.GameObject);
b.CreateEdge(enabled.ValuePort, onUpdate.Enabled);
b.CreateEdge(onUpdate.Output, setRotation.Input);
b.CreateEdge(constantRotationValue.ValuePort, setRotation.Value);
}
, (manager, entity, index) =>
{
GraphInstance instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(handle.DataIndex, entity);
Assert.That(!manager.HasComponent <Rotation>(entity));
}, (manager, entity, index) =>
{
Rotation rotation = manager.GetComponentData <Rotation>(entity);
Quaternion q = rotation.Value;
Assert.That(q == setValue);
LogAssert.NoUnexpectedReceived();
});
}
public void TestSetScaleFloat()
{
GraphBuilder.VariableHandle handle = default;
float setValue = 42.42f;
SetupTestGraphDefinitionMultipleFrames((b, _) =>
{
handle = b.BindVariableToDataIndex("TestEntity");
var onUpdate = b.AddNode(new OnUpdate());
var enabled = b.AddNode(new ConstantBool {
Value = true
});
var setScale = b.AddNode(new SetScale {
});
var constantRotationValue = b.AddNode(new ConstantFloat()
{
Value = setValue
});
b.BindVariableToInput(handle, setScale.GameObject);
b.CreateEdge(enabled.ValuePort, onUpdate.Enabled);
b.CreateEdge(onUpdate.Output, setScale.Input);
b.CreateEdge(constantRotationValue.ValuePort, setScale.Value);
}
, (manager, entity, index) =>
{
GraphInstance instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(handle.DataIndex, entity);
Assert.That(!manager.HasComponent <NonUniformScale>(entity));
}, (manager, entity, index) =>
{
NonUniformScale scale = manager.GetComponentData <NonUniformScale>(entity);
Assert.That(scale.Value.Equals(setValue));
LogAssert.NoUnexpectedReceived();
});
}
public void TestGetRotation()
{
GraphBuilder.VariableHandle handle = default;
SetupTestGraphDefinitionMultipleFrames((b, _) =>
{
handle = b.BindVariableToDataIndex("TestEntity");
var onUpdate = b.AddNode(new OnUpdate());
var enabled = b.AddNode(new ConstantBool {
Value = true
});
var getRotation = b.AddNode(new GetRotation {
});
var log = b.AddNode(new Log()
{
Messages = new InputDataMultiPort {
DataCount = 1
}
});
b.BindVariableToInput(handle, getRotation.GameObject);
b.CreateEdge(enabled.ValuePort, onUpdate.Enabled);
b.CreateEdge(onUpdate.Output, log.Input);
b.CreateEdge(getRotation.Value, log.Messages.SelectPort(0));
}, (manager, entity, index) =>
{
GraphInstance instance = GetGraphInstance(entity);
instance.WriteValueToDataSlot(handle.DataIndex, entity);
manager.AddComponentData(entity, new Rotation {
Value = Quaternion.Euler(30, 0, 0)
});
}, (manager, entity, index) =>
{
LogAssert.Expect(LogType.Log, "quaternion(0.258819f, 0f, 0f, 0.9659258f)");
});
}
public void TestSendEventToSelf()
{
GraphBuilder.VariableHandle varAIndex = default, varBIndex = default;
static GraphReference CreateGraphReferenceFromGrapohAndEntity(GraphBuilder b, GraphDefinition nestedDef, GraphBuilder.VariableHandle entityVariableDataIndex)
{
var graphReference = new GraphReference();
graphReference.Inputs.SetCount(nestedDef.InputTriggers.Count);
graphReference.Outputs.SetCount(nestedDef.OutputTriggers.Count);
graphReference.DataInputs.SetCount(nestedDef.InputDatas.Count);
graphReference.DataOutputs.SetCount(nestedDef.OutputDatas.Count);
graphReference = b.AddNode(graphReference);
b.BindVariableToInput(entityVariableDataIndex, graphReference.Target);
return(graphReference);
}
