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