public void ProcessOperatorDot()
{
var a = new Vector2(0.2f, 0.3f);
var b = new Vector2(1.0f, 2.3f);
var c = new Vector3(0.2f, 0.3f, 0.4f);
var d = new Vector3(1.0f, 2.3f, 5.4f);
var e = new Vector4(0.2f, 0.3f, 0.4f, 4.0f);
var f = new Vector4(1.0f, 2.3f, 5.4f, 0.6f);
var resultA = Vector2.Dot(a, b);
var resultB = Vector3.Dot(c, d);
var resultC = Vector4.Dot(e, f);
var value_a = new VFXValue <Vector2>(a);
var value_b = new VFXValue <Vector2>(b);
var value_c = new VFXValue <Vector3>(c);
var value_d = new VFXValue <Vector3>(d);
var value_e = new VFXValue <Vector4>(e);
var value_f = new VFXValue <Vector4>(f);
var expressionA = VFXOperatorUtility.Dot(value_a, value_b);
var expressionB = VFXOperatorUtility.Dot(value_c, value_d);
var expressionC = VFXOperatorUtility.Dot(value_e, value_f);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
var resultExpressionB = context.Compile(expressionB);
var resultExpressionC = context.Compile(expressionC);
Assert.AreEqual(resultA, resultExpressionA.Get <float>(), 0.0001f);
Assert.AreEqual(resultB, resultExpressionB.Get <float>(), 0.0001f);
Assert.AreEqual(resultC, resultExpressionC.Get <float>(), 0.0001f);
}
public void ProcessExpressionRGBtoHSV()
{
var rgb = new Vector3(0.5f, 0.2f, 0.8f);
float h, s, v;
Color color = new Color(rgb.x, rgb.y, rgb.z, 1.0f);
Color.RGBToHSV(color, out h, out s, out v);
var hsv = new Vector3(h, s, v);
Color rgbResult = Color.HSVToRGB(hsv.x, hsv.y, hsv.z, true);
var rgbAgain = new Vector3(rgbResult.r, rgbResult.g, rgbResult.b);
var value_rgb = new VFXValue <Vector3>(rgb);
var value_hsv = new VFXValue <Vector3>(hsv);
var absExpressionA = new VFXExpressionRGBtoHSV(value_rgb);
var absExpressionB = new VFXExpressionHSVtoRGB(value_hsv);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var expressionA = context.Compile(absExpressionA);
var expressionB = context.Compile(absExpressionB);
Assert.AreEqual(hsv, expressionA.Get <Vector3>());
Assert.AreEqual(rgb, expressionB.Get <Vector3>());
Assert.AreEqual(rgb, rgbAgain);
}
public void ProcessExpressionTRSToMatrix()
{
var t = new Vector3(0.2f, 0.3f, 0.4f);
var r = new Vector3(0.5f, 0.6f, 0.7f);
var s = new Vector3(0.8f, 0.9f, 1.0f);
var q = Quaternion.Euler(r);
Matrix4x4 result = new Matrix4x4();
result.SetTRS(t, q, s);
var value_t = new VFXValue <Vector3>(t);
var value_r = new VFXValue <Vector3>(r);
var value_s = new VFXValue <Vector3>(s);
var expressionA = new VFXExpressionTRSToMatrix(new VFXExpression[] { value_t, value_r, value_s });
var expressionB = new VFXExpressionExtractPositionFromMatrix(expressionA);
var expressionC = new VFXExpressionExtractAnglesFromMatrix(expressionA);
var expressionD = new VFXExpressionExtractScaleFromMatrix(expressionA);
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);
Assert.AreEqual(result, resultExpressionA.Get <Matrix4x4>());
Assert.AreEqual((t - resultExpressionB.Get <Vector3>()).magnitude, 0.0f, 0.01f);
Assert.AreEqual((r - resultExpressionC.Get <Vector3>()).magnitude, 0.0f, 0.01f);
Assert.AreEqual((s - resultExpressionD.Get <Vector3>()).magnitude, 0.0f, 0.01f);
}
public void ProcessOperatorSphericalToRectangular()
{
var theta = 0.2f;
var phi = 0.4f;
var distance = 0.5f;
var rectangular = new Vector3(Mathf.Cos(phi) * Mathf.Cos(theta), Mathf.Sin(phi), Mathf.Cos(phi) * Mathf.Sin(theta));
rectangular *= distance;
var value_theta = new VFXValue <float>(theta);
var value_phi = new VFXValue <float>(phi);
var value_distance = new VFXValue <float>(distance);
var expressionA = VFXOperatorUtility.SphericalToRectangular(value_distance, value_theta, value_phi);
var expressionB = VFXOperatorUtility.RectangularToSpherical(expressionA);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
var resultExpressionB0 = context.Compile(expressionB[0]);
var resultExpressionB1 = context.Compile(expressionB[1]);
var resultExpressionB2 = context.Compile(expressionB[2]);
Assert.AreEqual(rectangular, resultExpressionA.Get <Vector3>());
Assert.AreEqual(distance, resultExpressionB0.Get <float>(), 0.001f);
Assert.AreEqual(theta, resultExpressionB1.Get <float>(), 0.001f);
Assert.AreEqual(phi, resultExpressionB2.Get <float>(), 0.001f);
}
public void ProcessExpressionBasic()
{
//Reference some float math operation
var a = new Vector2(0.75f, 0.5f);
var b = new Vector3(1.3f, 0.2f, 0.7f);
var c = 0.8f;
var d = 0.1f;
var refResultA = new Vector3(a.x + b.x, a.y + b.y, b.z);
var refResultB = new Vector3(Mathf.Sin(refResultA.x), Mathf.Sin(refResultA.y), Mathf.Sin(refResultA.z));
var refResultC = refResultB * c;
var refResultD = new Vector3(d, d, d) - refResultC;
//Using expression system
var value_a = new VFXValue <Vector2>(a);
var value_b = new VFXValue <Vector3>(b);
var value_c = new VFXValue <float>(c);
var value_d = new VFXValue <float>(d);
var addExpression = VFXOperatorUtility.CastFloat(value_a, value_b.valueType) + value_b;
var sinExpression = new VFXExpressionSin(addExpression);
var mulExpression = (sinExpression * VFXOperatorUtility.CastFloat(value_c, sinExpression.valueType));
var subtractExpression = VFXOperatorUtility.CastFloat(value_d, mulExpression.valueType) - mulExpression;
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultA = context.Compile(addExpression);
var resultB = context.Compile(sinExpression);
var resultC = context.Compile(mulExpression);
var resultD = context.Compile(subtractExpression);
Assert.AreEqual(refResultA, resultA.Get <Vector3>());
Assert.AreEqual(refResultB, resultB.Get <Vector3>());
Assert.AreEqual(refResultC, resultC.Get <Vector3>());
Assert.AreEqual(refResultD, resultD.Get <Vector3>());
}
public void ProcessOperatorSaturate()
{
var a = -1.5f;
var b = 0.2f;
var c = 1.3f;
var resultA = Mathf.Clamp(a, 0.0f, 1.0f);
var resultB = Mathf.Clamp(b, 0.0f, 1.0f);
var resultC = Mathf.Clamp(c, 0.0f, 1.0f);
var value_a = new VFXValue <float>(a);
var value_b = new VFXValue <float>(b);
var value_c = new VFXValue <float>(c);
var expressionA = VFXOperatorUtility.Saturate(value_a);
var expressionB = VFXOperatorUtility.Saturate(value_b);
var expressionC = VFXOperatorUtility.Saturate(value_c);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
var resultExpressionB = context.Compile(expressionB);
var resultExpressionC = context.Compile(expressionC);
Assert.AreEqual(resultA, resultExpressionA.Get <float>());
Assert.AreEqual(resultB, resultExpressionB.Get <float>());
Assert.AreEqual(resultC, resultExpressionC.Get <float>());
}
public void SpaceConversion_Sphere_Unexpected_Linking_MasterSlot()
{
var sphere_A = ScriptableObject.CreateInstance <VFXInlineOperator>();
var sphere_B = ScriptableObject.CreateInstance <VFXInlineOperator>();
sphere_A.SetSettingValue("m_Type", (SerializableType)typeof(Sphere));
sphere_B.SetSettingValue("m_Type", (SerializableType)typeof(Sphere));
sphere_A.inputSlots[0].space = VFXCoordinateSpace.World;
sphere_B.inputSlots[0].space = VFXCoordinateSpace.Local;
Assert.AreEqual(VFXCoordinateSpace.World, sphere_A.outputSlots[0].space);
Assert.AreEqual(VFXCoordinateSpace.Local, sphere_B.outputSlots[0].space);
sphere_B.inputSlots[0][1].Link(sphere_A.outputSlots[0][1]); //link radius to other radius
Assert.AreEqual(VFXCoordinateSpace.Local, sphere_B.outputSlots[0].space);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultCenter = context.Compile(sphere_B.outputSlots[0][0].GetExpression());
var resultRadius = context.Compile(sphere_B.outputSlots[0][1].GetExpression());
var allExprCenter = CollectParentExpression(resultCenter).ToArray();
var allExprRadius = CollectParentExpression(resultRadius).ToArray();
Assert.IsFalse(allExprCenter.Any(o => o.operation == VFXExpressionOperation.LocalToWorld || o.operation == VFXExpressionOperation.WorldToLocal));
Assert.IsFalse(allExprRadius.Any(o => o.operation == VFXExpressionOperation.LocalToWorld || o.operation == VFXExpressionOperation.WorldToLocal));
}
public void ProcessExpressionLogical()
{
bool a = true;
bool b = false;
var resultA = a && b;
var resultB = a || b;
var resultC = !a;
var resultD = !b;
var value_a = new VFXValue <bool>((bool)a);
var value_b = new VFXValue <bool>((bool)b);
var expressionA = new VFXExpressionLogicalAnd(value_a, value_b);
var expressionB = new VFXExpressionLogicalOr(value_a, value_b);
var expressionC = new VFXExpressionLogicalNot(value_a);
var expressionD = new VFXExpressionLogicalNot(value_b);
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);
Assert.AreEqual((bool)resultA, resultExpressionA.Get <bool>());
Assert.AreEqual((bool)resultB, resultExpressionB.Get <bool>());
Assert.AreEqual((bool)resultC, resultExpressionC.Get <bool>());
Assert.AreEqual((bool)resultD, resultExpressionD.Get <bool>());
}
public void ProcessExpressionSign()
{
var a = -1.5f;
var b = 0.0f;
var c = 0.2f;
var resultA = Mathf.Sign(a);
var resultB = Mathf.Sign(b);
var resultC = Mathf.Sign(c);
var value_a = new VFXValue <float>(a);
var value_b = new VFXValue <float>(b);
var value_c = new VFXValue <float>(c);
var absExpressionA = new VFXExpressionSign(value_a);
var absExpressionB = new VFXExpressionSign(value_b);
var absExpressionC = new VFXExpressionSign(value_c);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var expressionA = context.Compile(absExpressionA);
var expressionB = context.Compile(absExpressionB);
var expressionC = context.Compile(absExpressionC);
Assert.AreEqual(resultA, expressionA.Get <float>());
Assert.AreEqual(resultB, expressionB.Get <float>());
Assert.AreEqual(resultC, expressionC.Get <float>());
}
public void BranchOperator_With_Sphere()
{
var branch = ScriptableObject.CreateInstance <Operator.Branch>();
branch.SetOperandType(typeof(Sphere));
var sphereA = new Sphere()
{
center = new Vector3(1.0f, 2.0f, 3.0f), radius = 4.0f
};
var sphereB = new Sphere()
{
center = new Vector3(1.0f, 2.0f, 3.0f), radius = 4.0f
};
branch.inputSlots[0].value = false;
branch.inputSlots[1].value = sphereA;
branch.inputSlots[2].value = sphereB;
Func <Sphere, Sphere, bool> fnCompareSphere = delegate(Sphere aS, Sphere bS)
{
if (aS.center.x != bS.center.x)
{
return(false);
}
if (aS.center.y != bS.center.y)
{
return(false);
}
if (aS.center.z != bS.center.z)
{
return(false);
}
if (aS.radius != bS.radius)
{
return(false);
}
return(true);
};
Func <VFXSlot, Sphere> fnSlotToSphere = delegate(VFXSlot slot)
{
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var center = context.Compile(slot[0].GetExpression());
var radius = context.Compile(slot[1].GetExpression());
return(new Sphere()
{
center = center.Get <Vector3>(),
radius = radius.Get <float>()
});
};
Assert.IsTrue(fnCompareSphere(fnSlotToSphere(branch.outputSlots[0]), sphereB));
branch.inputSlots[0].value = true;
Assert.IsTrue(fnCompareSphere(fnSlotToSphere(branch.outputSlots[0]), sphereA));
}
public void BranchOperator_With_Transform()
{
var branch = ScriptableObject.CreateInstance <Operator.Branch>();
branch.SetOperandType(typeof(Transform));
var transformA = new Transform()
{
position = Vector3.one * 3.0f, angles = Vector3.zero, scale = Vector3.one
};
var transformB = new Transform()
{
position = Vector3.one * 4.0f, angles = Vector3.zero, scale = Vector3.one
};
branch.inputSlots[0].value = false;
branch.inputSlots[1].value = transformA;
branch.inputSlots[2].value = transformB;
Func <Transform, Transform, bool> fnCompareTransform = delegate(Transform aS, Transform bS)
{
//Only compare position => didn't modify something else above
if (aS.position.x != bS.position.x)
{
return(false);
}
if (aS.position.y != bS.position.y)
{
return(false);
}
if (aS.position.z != bS.position.z)
{
return(false);
}
return(true);
};
Func <VFXSlot, Transform> fnSlotToTransform = delegate(VFXSlot slot)
{
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var position = context.Compile(slot[0].GetExpression());
var angles = context.Compile(slot[1].GetExpression());
var scale = context.Compile(slot[2].GetExpression());
return(new Transform()
{
position = position.Get <Vector3>(),
angles = angles.Get <Vector3>(),
scale = scale.Get <Vector3>(),
});
};
Assert.IsTrue(fnCompareTransform(fnSlotToTransform(branch.outputSlots[0]), transformB));
branch.inputSlots[0].value = true;
Assert.IsTrue(fnCompareTransform(fnSlotToTransform(branch.outputSlots[0]), transformA));
}
public void AddOperator_MixingVector_And_Direction()
{
var add = ScriptableObject.CreateInstance <Operator.Add>();
add.SetOperandType(0, typeof(Vector));
add.SetOperandType(1, typeof(DirectionType));
var a = new Vector3(1, 2, 3);
var b = new Vector3(6, 5, 4);
add.inputSlots[0].value = new Vector()
{
vector = a
};
add.inputSlots[1].value = new DirectionType()
{
direction = b
};
Assert.AreEqual(typeof(Vector), add.outputSlots[0].property.type);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultVector3Expression = context.Compile(add.outputSlots[0].GetExpression());
var r = resultVector3Expression.Get <Vector3>();
var e = a + b.normalized;
Assert.AreEqual(e.x, r.x);
Assert.AreEqual(e.y, r.y);
Assert.AreEqual(e.z, r.z);
}
public void AppendOperator_With_Direction()
{
var append = ScriptableObject.CreateInstance <Operator.AppendVector>();
append.SetOperandType(0, typeof(DirectionType));
append.SetOperandType(1, typeof(float));
append.inputSlots[0].value = new DirectionType()
{
direction = new Vector3(1.0f, 1.0f, 0)
};
append.inputSlots[1].value = 3.0f;
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var outputValue = context.Compile(append.outputSlots[0].GetExpression());
var expressionValue = outputValue.Get <Vector4>();
//Direction expects a normalize
var expectedValue = new Vector4(1.0f / Mathf.Sqrt(2), 1.0f / Mathf.Sqrt(2), 0.0f, 3.0f);
Assert.AreEqual(expectedValue.x, expressionValue.x, 1e-5f);
Assert.AreEqual(expectedValue.y, expressionValue.y, 1e-5f);
Assert.AreEqual(expectedValue.z, expressionValue.z, 1e-5f);
Assert.AreEqual(expectedValue.w, expressionValue.w, 1e-5f);
}
public void SpaceUniformisation_Between_World_And_Local()
{
var add = ScriptableObject.CreateInstance <Add>();
add.SetOperandType(0, typeof(Position));
add.SetOperandType(1, typeof(Position));
Assert.AreEqual(add.outputSlots[0].property.type, typeof(Position));
Assert.AreEqual(add.outputSlots[0].space, VFXCoordinateSpace.Local);
add.inputSlots[0].space = VFXCoordinateSpace.World;
Assert.AreEqual(add.inputSlots[0].space, VFXCoordinateSpace.World);
Assert.AreEqual(add.inputSlots[1].space, VFXCoordinateSpace.Local);
Assert.AreEqual(add.outputSlots[0].space, VFXCoordinateSpace.World);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var result = context.Compile(add.outputSlots[0].GetExpression());
var allExpr = CollectParentExpression(result).ToArray();
Assert.IsTrue(allExpr.Count(o =>
{
return(o.operation == VFXExpressionOperation.LocalToWorld);
}) == 1);
}
public void OuputExpression_From_Slot_Mesh_Should_Be_Invalid_Constant_Propagation()
{
var source = ScriptableObject.CreateInstance <VFXInlineOperator>();
source.SetSettingValue("m_Type", (SerializableType)typeof(Mesh));
var meshCount = ScriptableObject.CreateInstance <Operator.MeshVertexCount>();
meshCount.inputSlots[0].Link(source.outputSlots[0]);
var add = ScriptableObject.CreateInstance <Operator.Add>();
add.SetOperandType(0, typeof(uint));
add.SetOperandType(1, typeof(uint));
add.inputSlots[1].value = 8u;
var expressionOutputBefore = add.outputSlots[0].GetExpression();
var contextBefore = new VFXExpression.Context(VFXExpressionContextOption.ConstantFolding); //Used by runtime
var reducedBeforeLink = contextBefore.Compile(expressionOutputBefore);
bool success = add.inputSlots[0].Link(meshCount.outputSlots[0]);
Assert.IsTrue(success);
var expressionOutputAfter = add.outputSlots[0].GetExpression();
var contextAfter = new VFXExpression.Context(VFXExpressionContextOption.ConstantFolding); //Used by runtime
var reducedAfterLink = contextAfter.Compile(expressionOutputAfter);
var contextAfterCPUEvaluation = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation | VFXExpressionContextOption.ConstantFolding); //Used by GUI
var reducedAfterLinkCPUEvaluation = contextAfterCPUEvaluation.Compile(expressionOutputAfter);
Assert.IsAssignableFrom(typeof(VFXValue <uint>), reducedBeforeLink);
Assert.IsAssignableFrom(typeof(VFXExpressionAdd), reducedAfterLink);
Assert.IsAssignableFrom(typeof(VFXValue <uint>), reducedAfterLinkCPUEvaluation);
}
public void ProcessOperatorDegToRad()
{
var a = -1.5f;
var b = a * Mathf.Deg2Rad;
var value_a = new VFXValue <float>(a);
var expressionA = VFXOperatorUtility.DegToRad(value_a);
var expressionB = VFXOperatorUtility.RadToDeg(expressionA);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
var resultExpressionB = context.Compile(expressionB);
Assert.AreEqual(b, resultExpressionA.Get <float>());
Assert.AreEqual(a, resultExpressionB.Get <float>());
}
public void ProcessOperatorCeil([ValueSource("ProcessOperatorCeil_Values")] float inValue)
{
var value = new VFXValue <float>(inValue);
var expression = VFXOperatorUtility.Ceil(value);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expression);
Assert.AreEqual(Mathf.Ceil(inValue), resultExpressionA.Get <float>(), 0.001f);
}
public void ProcessExpressionSafeNormalize([ValueSource("s_ProcessExpressionSafeNormalizeValues")] Vector2 input)
{
var valueInput = new VFXValue <Vector2>(input);
var expression = VFXOperatorUtility.SafeNormalize(valueInput);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpression = context.Compile(expression);
var expectedResult = input.normalized;
Assert.AreEqual(expectedResult, resultExpression.Get <Vector2>());
}
public void ProcessOperatorSphereVolume()
{
var a = 1.5f;
var value_a = new VFXValue <float>(a);
var expressionA = VFXOperatorUtility.SphereVolume(value_a);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
Assert.AreEqual(14.137167f, resultExpressionA.Get <float>(), 0.001f);
}
public void ProcessOperatorNegate()
{
var a = -1.5f;
var b = 0.2f;
var resultA = -a;
var resultB = -b;
var value_a = new VFXValue <float>(a);
var value_b = new VFXValue <float>(b);
var expressionA = VFXOperatorUtility.Negate(value_a);
var expressionB = VFXOperatorUtility.Negate(value_b);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
var resultExpressionB = context.Compile(expressionB);
Assert.AreEqual(resultA, resultExpressionA.Get <float>());
Assert.AreEqual(resultB, resultExpressionB.Get <float>());
}
public void ProcessOperatorCircleCircumference()
{
var a = 1.5f;
var value_a = new VFXValue <float>(a);
var expressionA = VFXOperatorUtility.CircleCircumference(value_a);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
Assert.AreEqual(a * 2.0f * Mathf.PI, resultExpressionA.Get <float>(), 0.001f);
}
public void ProcessOperatorAbsInt([ValueSource("ProcessOperatorAbsInt_a")] int a)
{
var r = Mathf.Abs(a);
var value_a = new VFXValue <int>(a);
var expression = new VFXExpressionAbs(value_a);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpression = context.Compile(expression);
Assert.AreEqual(r, resultExpression.Get <int>());
}
public void ProcessOperatorSign([ValueSource("ProcessOperatorAbs_a")] float a)
{
var r = Mathf.Sign(a);
var value_a = new VFXValue <float>(a);
var expression = new VFXExpressionSign(value_a);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpression = context.Compile(expression);
Assert.AreEqual(r, resultExpression.Get <float>());
}
public void ProcessOperatorDistance()
{
var a = new Vector3(0.2f, 0.3f, 0.4f);
var b = new Vector3(1.0f, 2.3f, 5.4f);
var resultA = Vector3.Distance(a, b);
var resultB = Vector3.Dot(a - b, a - b);
var value_a = new VFXValue <Vector3>(a);
var value_b = new VFXValue <Vector3>(b);
var expressionA = VFXOperatorUtility.Distance(value_a, value_b);
var expressionB = VFXOperatorUtility.SqrDistance(value_a, value_b);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
var resultExpressionB = context.Compile(expressionB);
Assert.AreEqual(resultA, resultExpressionA.Get <float>());
Assert.AreEqual(resultB, resultExpressionB.Get <float>());
}
public void ProcessOperatorBoxVolume()
{
var a = new Vector3(1.5f, 2.5f, 3.5f);
var value_a = new VFXValue <Vector3>(a);
var expressionA = VFXOperatorUtility.BoxVolume(value_a);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
Assert.AreEqual(a.x * a.y * a.z, resultExpressionA.Get <float>(), 0.001f);
}
public void OuputExpression_From_Slot_Mesh_Should_Be_Invalid_Constant()
{
var source = ScriptableObject.CreateInstance <VFXInlineOperator>();
source.SetSettingValue("m_Type", (SerializableType)typeof(Mesh));
var expressionOutput = source.outputSlots[0].GetExpression();
var context = new VFXExpression.Context(VFXExpressionContextOption.ConstantFolding);
var reduced = context.Compile(expressionOutput);
Assert.IsTrue(expressionOutput.Is(VFXExpression.Flags.InvalidConstant));
}
public void ProcessExpressionBranch()
{
var branch0 = VFXValue.Constant(Vector3.right);
var branch1 = VFXValue.Constant(Vector3.up);
var test0 = new VFXExpressionBranch(VFXValue.Constant(true), branch0, branch1);
var test1 = new VFXExpressionBranch(VFXValue.Constant(false), branch0, branch1);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultA = context.Compile(test0);
var resultB = context.Compile(test1);
Assert.AreEqual(Vector3.right, resultA.Get <Vector3>());
Assert.AreEqual(Vector3.up, resultB.Get <Vector3>());
// Test static branching
context = new VFXExpression.Context(VFXExpressionContextOption.Reduction);
var resultC = context.Compile(test0);
Assert.AreEqual(branch0, resultC);
}
public void ProcessExpressionMatrixToVector4s()
{
var matValue = VFXValue.Constant(Matrix4x4.identity);
var axisValue = VFXValue.Constant <int>(0);
var xValue = new VFXExpressionMatrixToVector4s(matValue, axisValue);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var reduced = context.Compile(xValue);
Assert.AreEqual(new Vector4(1, 0, 0, 0), reduced.Get <Vector4>());
}
public void Round_Expression([ValueSource("k_RoundExpression_TestCase_Names")] string testCaseName)
{
var testCase = k_RoundExpression_TestCase.First(o => o.name == testCaseName);
var valueConstant = new VFXValue <float>(testCase.x);
var round = new VFXExpressionRound(valueConstant);
var context = new VFXExpression.Context(VFXExpressionContextOption.ConstantFolding);
var resultCompiled = context.Compile(round);
Assert.IsTrue(resultCompiled is VFXValue);
Assert.AreEqual(testCase.r, (resultCompiled as VFXValue).Get <float>());
}
public void ProcessExpressionMinMax()
{
var a = -1.5f;
var b = 0.2f;
var resultA = Mathf.Min(a, b);
var resultB = Mathf.Max(a, b);
var value_a = new VFXValue <float>(a);
var value_b = new VFXValue <float>(b);
var expressionA = new VFXExpressionMin(value_a, value_b);
var expressionB = new VFXExpressionMax(value_a, value_b);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var resultExpressionA = context.Compile(expressionA);
var resultExpressionB = context.Compile(expressionB);
Assert.AreEqual(resultA, resultExpressionA.Get <float>());
Assert.AreEqual(resultB, resultExpressionB.Get <float>());
Assert.Greater(resultExpressionB.Get <float>(), resultExpressionA.Get <float>());
}
