public void ProcessExpressionBitwise()
{
int a = 12345;
int b = 2;
var resultA = a << b;
var resultB = a >> b;
var resultC = a | b;
var resultD = a & b;
var resultE = a ^ b;
var resultF = ~a;
var value_a = new VFXValue <uint>((uint)a);
var value_b = new VFXValue <uint>((uint)b);
var expressionA = new VFXExpressionBitwiseLeftShift(value_a, value_b);
var expressionB = new VFXExpressionBitwiseRightShift(value_a, value_b);
var expressionC = new VFXExpressionBitwiseOr(value_a, value_b);
var expressionD = new VFXExpressionBitwiseAnd(value_a, value_b);
var expressionE = new VFXExpressionBitwiseXor(value_a, value_b);
var expressionF = new VFXExpressionBitwiseComplement(value_a);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
var resultExpressionB = context.Compile(expressionB);
var resultExpressionC = context.Compile(expressionC);
var resultExpressionD = context.Compile(expressionD);
var resultExpressionE = context.Compile(expressionE);
var resultExpressionF = context.Compile(expressionF);
Assert.AreEqual((uint)resultA, resultExpressionA.Get <uint>());
Assert.AreEqual((uint)resultB, resultExpressionB.Get <uint>());
Assert.AreEqual((uint)resultC, resultExpressionC.Get <uint>());
Assert.AreEqual((uint)resultD, resultExpressionD.Get <uint>());
Assert.AreEqual((uint)resultE, resultExpressionE.Get <uint>());
Assert.AreEqual((uint)resultF, resultExpressionF.Get <uint>());
}
public void CascadedMulOperator_Mix_Vector2_and_Vector3()
{
var vec2_Two = ScriptableObject.CreateInstance <VFXInlineOperator>();
var vec3_Two = ScriptableObject.CreateInstance <VFXInlineOperator>();
vec2_Two.SetSettingValue("m_Type", (SerializableType)typeof(Vector2));
vec2_Two.inputSlots[0].value = Vector2.one * 2.0f;
vec3_Two.SetSettingValue("m_Type", (SerializableType)typeof(Vector3));
vec3_Two.inputSlots[0].value = Vector3.one * 2.0f;
var mul = ScriptableObject.CreateInstance <Operator.Multiply>();
mul.SetOperandType(0, typeof(Vector2));
mul.inputSlots[0].Link(vec2_Two.outputSlots[0]);
mul.SetOperandType(1, typeof(Vector3));
mul.inputSlots[1].Link(vec3_Two.outputSlots[0]);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var result = context.Compile(mul.outputSlots[0].GetExpression());
var final = result.Get <Vector3>();
Assert.AreEqual(new Vector3(4, 4, 2), final);
}
public void ModuloOperator_With_Unsigned_Integer()
{
var a = 1610612737u;
var b = 805306361u;
var moduloUInt = ScriptableObject.CreateInstance <Operator.Modulo>();
moduloUInt.SetOperandType(typeof(uint));
var moduloFloat = ScriptableObject.CreateInstance <Operator.Modulo>();
moduloFloat.SetOperandType(typeof(float));
var aOperator = ScriptableObject.CreateInstance <VFXInlineOperator>();
aOperator.SetSettingValue("m_Type", (SerializableType)typeof(uint));
var bOperator = ScriptableObject.CreateInstance <VFXInlineOperator>();
bOperator.SetSettingValue("m_Type", (SerializableType)typeof(uint));
aOperator.inputSlots[0].value = a;
bOperator.inputSlots[0].value = b;
moduloUInt.inputSlots[0].Link(aOperator.outputSlots.First());
moduloUInt.inputSlots[1].Link(bOperator.outputSlots.First());
moduloFloat.inputSlots[0].Link(aOperator.outputSlots.First());
moduloFloat.inputSlots[1].Link(bOperator.outputSlots.First());
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultUInt = context.Compile(moduloUInt.outputSlots[0].GetExpression());
var resultFloat = context.Compile(moduloFloat.outputSlots[0].GetExpression());
Assert.AreEqual(a % b, resultUInt.Get <uint>());
Assert.AreEqual(Mathf.Repeat(a, b), resultFloat.Get <float>());
}
public void ProcessOperatorLerp()
{
var a = new Vector3(0.2f, 0.3f, 0.4f);
var b = new Vector3(1.0f, 2.3f, 5.4f);
var c = 0.2f;
var d = 1.5f;
var resultA = Vector3.LerpUnclamped(a, b, c);
var resultB = Vector3.LerpUnclamped(a, b, d);
var value_a = new VFXValue <Vector3>(a);
var value_b = new VFXValue <Vector3>(b);
var value_c = new VFXValue <float>(c);
var value_d = new VFXValue <float>(d);
var expressionA = VFXOperatorUtility.Lerp(value_a, value_b, VFXOperatorUtility.CastFloat(value_c, value_b.valueType));
var expressionB = VFXOperatorUtility.Lerp(value_a, value_b, VFXOperatorUtility.CastFloat(value_d, value_b.valueType));
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
var resultExpressionB = context.Compile(expressionB);
Assert.AreEqual((resultA - resultExpressionA.Get <Vector3>()).magnitude, 0.0f, 0.001f);
Assert.AreEqual((resultB - resultExpressionB.Get <Vector3>()).magnitude, 0.0f, 0.001f);
}
public void ProcessOperatorFit()
{
var value = 0.4f;
var oldRangeMin = 0.2f;
var oldRangeMax = 1.2f;
var newRangeMin = 3.2f;
var newRangeMax = 5.2f;
var percent = (value - oldRangeMin) / (oldRangeMax - oldRangeMin);
var result = Mathf.LerpUnclamped(newRangeMin, newRangeMax, percent);
var value_a = new VFXValue <float>(value);
var value_b = new VFXValue <float>(oldRangeMin);
var value_c = new VFXValue <float>(oldRangeMax);
var value_d = new VFXValue <float>(newRangeMin);
var value_e = new VFXValue <float>(newRangeMax);
var expression = VFXOperatorUtility.Fit(value_a, value_b, value_c, value_d, value_e);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpression = context.Compile(expression);
Assert.AreEqual(result, resultExpression.Get <float>());
}
public void LinkPositionOrVectorAndDirection([ValueSource("usePosition")] bool usePosition)
{
var crossDesc = VFXLibrary.GetOperators().FirstOrDefault(o => o.name.Contains("Cross"));
var positionDesc = VFXLibrary.GetParameters().FirstOrDefault(o => o.name.Contains("Position"));
var vectorDesc = VFXLibrary.GetParameters().FirstOrDefault(o => o.name == "Vector");
var directionDesc = VFXLibrary.GetParameters().FirstOrDefault(o => o.name.Contains("Direction"));
var cross = m_ViewController.AddVFXOperator(new Vector2(1, 1), crossDesc);
var position = m_ViewController.AddVFXParameter(new Vector2(2, 2), positionDesc);
var vector = m_ViewController.AddVFXParameter(new Vector2(3, 3), vectorDesc);
var direction = m_ViewController.AddVFXParameter(new Vector2(4, 4), directionDesc);
(cross as IVFXOperatorUniform).SetOperandType(typeof(Vector3));
m_ViewController.ApplyChanges();
Func <IVFXSlotContainer, VFXNodeController> fnFindController = delegate(IVFXSlotContainer slotContainer)
{
var allController = m_ViewController.allChildren.OfType <VFXNodeController>();
return(allController.FirstOrDefault(o => o.slotContainer == slotContainer));
};
var controllerCross = fnFindController(cross);
var vA = new Vector3(2, 3, 4);
position.outputSlots[0].value = new Position()
{
position = vA
};
vector.outputSlots[0].value = new Vector()
{
vector = vA
};
var vB = new Vector3(5, 6, 7);
direction.outputSlots[0].value = new DirectionType()
{
direction = vB
};
var edgeControllerAppend_A = new VFXDataEdgeController(controllerCross.inputPorts.Where(o => o.portType == typeof(Vector3)).First(), fnFindController(usePosition ? position : vector).outputPorts.First());
m_ViewController.AddElement(edgeControllerAppend_A);
(cross as IVFXOperatorUniform).SetOperandType(typeof(Vector3));
m_ViewController.ApplyChanges();
var edgeControllerAppend_B = new VFXDataEdgeController(controllerCross.inputPorts.Where(o => o.portType == typeof(Vector3)).Last(), fnFindController(direction).outputPorts.First());
m_ViewController.AddElement(edgeControllerAppend_B);
(cross as IVFXOperatorUniform).SetOperandType(typeof(Vector3));
m_ViewController.ApplyChanges();
m_ViewController.ForceReload();
Assert.AreEqual(1, cross.inputSlots[0].LinkedSlots.Count());
Assert.AreEqual(1, cross.inputSlots[1].LinkedSlots.Count());
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation | VFXExpressionContextOption.ConstantFolding);
var currentA = context.Compile(cross.inputSlots[0].GetExpression()).Get <Vector3>();
var currentB = context.Compile(cross.inputSlots[1].GetExpression()).Get <Vector3>();
var result = context.Compile(cross.outputSlots[0].GetExpression()).Get <Vector3>();
Assert.AreEqual((double)vA.x, (double)currentA.x, 0.001f);
Assert.AreEqual((double)vA.y, (double)currentA.y, 0.001f);
Assert.AreEqual((double)vA.z, (double)currentA.z, 0.001f);
Assert.AreEqual((double)vB.normalized.x, (double)currentB.x, 0.001f);
Assert.AreEqual((double)vB.normalized.y, (double)currentB.y, 0.001f);
Assert.AreEqual((double)vB.normalized.z, (double)currentB.z, 0.001f);
var expectedResult = Vector3.Cross(vA, vB.normalized);
Assert.AreEqual((double)expectedResult.x, (double)result.x, 0.001f);
Assert.AreEqual((double)expectedResult.y, (double)result.y, 0.001f);
Assert.AreEqual((double)expectedResult.z, (double)result.z, 0.001f);
}
public void CascadedAddOperator_Adding_And_Removing_Several_Links()
{
var one = ScriptableObject.CreateInstance <VFXInlineOperator>();
var add = ScriptableObject.CreateInstance <Operator.Add>();
one.SetSettingValue("m_Type", (SerializableType)typeof(float));
one.inputSlots[0].value = 1.0f;
var count = 8.0f;
for (int i = 0; i < (int)count; i++)
{
add.AddOperand();
}
for (int i = 0; i < (int)count; i++)
{
var inputSlots = add.inputSlots.ToArray();
var emptySlot = inputSlots.First(s => !s.HasLink());
emptySlot.Link(one.outputSlots.First());
}
var finalExpr = add.outputSlots.First().GetExpression();
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var result = context.Compile(finalExpr);
var eight = result.Get <float>();
Assert.AreEqual(count, eight);
//< Process some remove
var removeCount = 4.0f;
for (int i = 0; i < (int)removeCount; ++i)
{
var linkedSlots = add.inputSlots.Where(o => o.HasLink());
VFXSlot removeSlot = null;
if (i % 2 == 0)
{
removeSlot = linkedSlots.First();
}
else
{
removeSlot = linkedSlots.Last();
}
//Check expected link count
var linkCount = add.inputSlots.Where(o => o.HasLink()).Count();
Assert.AreEqual((int)count - i, linkCount);
var index = add.inputSlots.IndexOf(removeSlot);
add.RemoveOperand(index);
//Check expected link count
linkCount = add.inputSlots.Where(o => o.HasLink()).Count();
Assert.AreEqual((int)count - i - 1, linkCount);
//Check if all input slot are still with a default value
foreach (var slot in add.inputSlots.Where(o => o.HasLink()))
{
Assert.AreEqual(0.0f, slot.value);
}
//Check computed result
finalExpr = add.outputSlots.First().GetExpression();
result = context.Compile(finalExpr);
var res = result.Get <float>();
Assert.AreEqual(count - (float)i - 1.0f, res);
}
}
