895 lines
29 KiB
C#
895 lines
29 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Runtime.CompilerServices;
|
|
using UnityEngine;
|
|
using UnityEngine.VFX;
|
|
|
|
namespace UnityEditor.VFX
|
|
{
|
|
class VFXExpressionCos : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionCos() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionCos(VFXExpression parent) : base(parent, VFXExpressionOperation.Cos)
|
|
{
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("cos({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Cos(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionSin : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionSin() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionSin(VFXExpression parent) : base(parent, VFXExpressionOperation.Sin)
|
|
{
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("sin({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Sin(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionTan : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionTan() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionTan(VFXExpression parent) : base(parent, VFXExpressionOperation.Tan)
|
|
{
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("tan({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Tan(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionACos : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionACos() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionACos(VFXExpression parent) : base(parent, VFXExpressionOperation.ACos)
|
|
{
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("acos({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Acos(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionASin : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionASin() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionASin(VFXExpression parent) : base(parent, VFXExpressionOperation.ASin)
|
|
{
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("asin({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Asin(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionATan : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionATan() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionATan(VFXExpression parent) : base(parent, VFXExpressionOperation.ATan)
|
|
{
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("atan({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Atan(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionLog2 : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionLog2() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionLog2(VFXExpression parent) : base(parent, VFXExpressionOperation.Log2)
|
|
{
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("log2({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Log(input, 2.0f);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionAbs : VFXExpressionUnaryNumericOperation
|
|
{
|
|
public VFXExpressionAbs() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionAbs(VFXExpression parent) : base(parent, VFXExpressionOperation.Abs)
|
|
{
|
|
if (parent.valueType == VFXValueType.Uint32)
|
|
throw new NotImplementedException("Unexpected type for VFXExpressionAbs");
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x, VFXValueType type)
|
|
{
|
|
if (type == VFXValueType.Uint32)
|
|
throw new NotImplementedException("Unexpected type for VFXExpressionAbs");
|
|
return string.Format("abs({0})", x);
|
|
}
|
|
|
|
protected override uint ProcessUnaryOperation(uint input)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
protected override int ProcessUnaryOperation(int input)
|
|
{
|
|
return Mathf.Abs(input);
|
|
}
|
|
|
|
protected override bool ProcessUnaryOperation(bool input)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Abs(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionSign : VFXExpressionUnaryNumericOperation
|
|
{
|
|
public VFXExpressionSign() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionSign(VFXExpression parent) : base(parent, VFXExpressionOperation.Sign)
|
|
{
|
|
if (parent.valueType == VFXValueType.Uint32)
|
|
throw new NotImplementedException("Unexpected type for VFXExpressionSign");
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x, VFXValueType type)
|
|
{
|
|
if (type == VFXValueType.Uint32)
|
|
throw new NotImplementedException("Unexpected type for VFXExpressionSign");
|
|
return string.Format("sign({0})", x);
|
|
}
|
|
|
|
protected override uint ProcessUnaryOperation(uint input)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
protected override int ProcessUnaryOperation(int input)
|
|
{
|
|
return (input > 0 ? 1 : 0) - (input < 0 ? 1 : 0);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return (input > 0.0f ? 1.0f : 0.0f) - (input < 0.0f ? 1.0f : 0.0f);
|
|
}
|
|
|
|
protected override bool ProcessUnaryOperation(bool input)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
class VFXExpressionSaturate : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionSaturate() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionSaturate(VFXExpression parent) : base(parent, VFXExpressionOperation.Saturate)
|
|
{
|
|
if (!IsFloatValueType(parent.valueType))
|
|
throw new InvalidOperationException("Unexpected VFXExpressionSaturate type with parent " + parent.valueType);
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("saturate({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Clamp01(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionCeil : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionCeil() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionCeil(VFXExpression parent) : base(parent, VFXExpressionOperation.Ceil)
|
|
{
|
|
if (!IsFloatValueType(parent.valueType))
|
|
throw new InvalidOperationException("Unexpected VFXExpressionCeil type with parent " + parent.valueType);
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("ceil({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Ceil(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionRound : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionRound() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionRound(VFXExpression parent) : base(parent, VFXExpressionOperation.Round)
|
|
{
|
|
if (!IsFloatValueType(parent.valueType))
|
|
throw new InvalidOperationException("Unexpected VFXExpressionRound type with parent " + parent.valueType);
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("round({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Round(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionFrac : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionFrac() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionFrac(VFXExpression parent) : base(parent, VFXExpressionOperation.Frac)
|
|
{
|
|
if (!IsFloatValueType(parent.valueType))
|
|
throw new InvalidOperationException("Unexpected VFXExpressionFrac type with parent " + parent.valueType);
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("frac({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Repeat(input, 1.0f);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionFloor : VFXExpressionUnaryFloatOperation
|
|
{
|
|
public VFXExpressionFloor() : this(VFXValue<float>.Default) {}
|
|
|
|
public VFXExpressionFloor(VFXExpression parent) : base(parent, VFXExpressionOperation.Floor)
|
|
{
|
|
if (!IsFloatValueType(parent.valueType))
|
|
throw new InvalidOperationException("Unexpected VFXExpressionFloor type with parent " + parent.valueType);
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("floor({0})", x);
|
|
}
|
|
|
|
sealed protected override float ProcessUnaryOperation(float input)
|
|
{
|
|
return Mathf.Floor(input);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionAdd : VFXExpressionBinaryNumericOperation
|
|
{
|
|
public VFXExpressionAdd() : this(VFXValue<float>.Default, VFXValue<float>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionAdd(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.Add)
|
|
{
|
|
}
|
|
|
|
protected override VFXExpression Reduce(VFXExpression[] reducedParents)
|
|
{
|
|
var zero = VFXOperatorUtility.ZeroExpression[reducedParents[0].valueType];
|
|
if (zero.Equals(reducedParents[0]))
|
|
return reducedParents[1];
|
|
if (zero.Equals(reducedParents[1]))
|
|
return reducedParents[0];
|
|
|
|
return base.Reduce(reducedParents);
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right, VFXValueType type)
|
|
{
|
|
return string.Format("{0} + {1}", left, right);
|
|
}
|
|
|
|
sealed protected override float ProcessBinaryOperation(float left, float right)
|
|
{
|
|
return left + right;
|
|
}
|
|
|
|
sealed protected override int ProcessBinaryOperation(int left, int right)
|
|
{
|
|
return left + right;
|
|
}
|
|
|
|
sealed protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left + right;
|
|
}
|
|
|
|
protected override bool ProcessBinaryOperation(bool left, bool right)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
}
|
|
|
|
class VFXExpressionMul : VFXExpressionBinaryNumericOperation
|
|
{
|
|
public VFXExpressionMul() : this(VFXValue<float>.Default, VFXValue<float>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionMul(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.Mul)
|
|
{
|
|
}
|
|
|
|
protected override VFXExpression Reduce(VFXExpression[] reducedParents)
|
|
{
|
|
var zero = VFXOperatorUtility.ZeroExpression[reducedParents[0].valueType];
|
|
if (zero.Equals(reducedParents[0]) || zero.Equals(reducedParents[1]))
|
|
return zero;
|
|
|
|
var one = VFXOperatorUtility.OneExpression[reducedParents[0].valueType];
|
|
if (one.Equals(reducedParents[0]))
|
|
return reducedParents[1];
|
|
if (one.Equals(reducedParents[1]))
|
|
return reducedParents[0];
|
|
|
|
return base.Reduce(reducedParents);
|
|
}
|
|
|
|
sealed protected override float ProcessBinaryOperation(float left, float right)
|
|
{
|
|
return left * right;
|
|
}
|
|
|
|
sealed protected override int ProcessBinaryOperation(int left, int right)
|
|
{
|
|
return left * right;
|
|
}
|
|
|
|
sealed protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left * right;
|
|
}
|
|
|
|
protected override bool ProcessBinaryOperation(bool left, bool right)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right, VFXValueType type)
|
|
{
|
|
return string.Format("{0} * {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionDivide : VFXExpressionBinaryNumericOperation
|
|
{
|
|
public VFXExpressionDivide() : this(VFXValue<float>.Default, VFXValue<float>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionDivide(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.Divide)
|
|
{
|
|
}
|
|
|
|
protected override VFXExpression Reduce(VFXExpression[] reducedParents)
|
|
{
|
|
var zero = VFXOperatorUtility.ZeroExpression[reducedParents[0].valueType];
|
|
if (zero.Equals(reducedParents[0]))
|
|
return zero;
|
|
|
|
var one = VFXOperatorUtility.OneExpression[reducedParents[0].valueType];
|
|
if (one.Equals(reducedParents[1]))
|
|
return reducedParents[0];
|
|
|
|
return base.Reduce(reducedParents);
|
|
}
|
|
|
|
sealed protected override float ProcessBinaryOperation(float left, float right)
|
|
{
|
|
return left / right;
|
|
}
|
|
|
|
sealed protected override int ProcessBinaryOperation(int left, int right)
|
|
{
|
|
if (right == 0)
|
|
return 0;
|
|
|
|
return left / right;
|
|
}
|
|
|
|
sealed protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
if (right == 0u)
|
|
return 0u;
|
|
|
|
return left / right;
|
|
}
|
|
|
|
protected override bool ProcessBinaryOperation(bool left, bool right)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right, VFXValueType type)
|
|
{
|
|
return string.Format("{0} / {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionSubtract : VFXExpressionBinaryNumericOperation
|
|
{
|
|
public VFXExpressionSubtract() : this(VFXValue<float>.Default, VFXValue<float>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionSubtract(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.Subtract)
|
|
{
|
|
}
|
|
|
|
protected override VFXExpression Reduce(VFXExpression[] reducedParents)
|
|
{
|
|
var zero = VFXOperatorUtility.ZeroExpression[reducedParents[0].valueType];
|
|
if (zero.Equals(reducedParents[1]))
|
|
return reducedParents[0];
|
|
|
|
return base.Reduce(reducedParents);
|
|
}
|
|
|
|
sealed protected override float ProcessBinaryOperation(float left, float right)
|
|
{
|
|
return left - right;
|
|
}
|
|
|
|
sealed protected override int ProcessBinaryOperation(int left, int right)
|
|
{
|
|
return left - right;
|
|
}
|
|
|
|
sealed protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left - right;
|
|
}
|
|
|
|
protected override bool ProcessBinaryOperation(bool left, bool right)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right, VFXValueType type)
|
|
{
|
|
return string.Format("{0} - {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionMin : VFXExpressionBinaryNumericOperation
|
|
{
|
|
public VFXExpressionMin() : this(VFXValue<float>.Default, VFXValue<float>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionMin(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.Min)
|
|
{
|
|
}
|
|
|
|
sealed protected override float ProcessBinaryOperation(float left, float right)
|
|
{
|
|
return Mathf.Min(left, right);
|
|
}
|
|
|
|
protected override int ProcessBinaryOperation(int left, int right)
|
|
{
|
|
return Mathf.Min(left, right);
|
|
}
|
|
|
|
protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left < right ? left : right;
|
|
}
|
|
|
|
protected override bool ProcessBinaryOperation(bool left, bool right)
|
|
{
|
|
return left ? right : left;
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right, VFXValueType type)
|
|
{
|
|
if (type == VFXValueType.Uint32)
|
|
return string.Format("{0} < {1} ? {0} : {1}", left, right);
|
|
return string.Format("min({0}, {1})", left, right);
|
|
}
|
|
|
|
protected override VFXExpression Reduce(VFXExpression[] reducedParents)
|
|
{
|
|
VFXExpression inputSaturateExpression = null;
|
|
if (VFXExpressionMax.CanBeReducedToSaturate(this, reducedParents, out inputSaturateExpression))
|
|
{
|
|
return new VFXExpressionSaturate(inputSaturateExpression);
|
|
}
|
|
return base.Reduce(reducedParents);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionMax : VFXExpressionBinaryNumericOperation
|
|
{
|
|
public VFXExpressionMax() : this(VFXValue<float>.Default, VFXValue<float>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionMax(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.Max)
|
|
{
|
|
}
|
|
|
|
sealed protected override float ProcessBinaryOperation(float left, float right)
|
|
{
|
|
return Mathf.Max(left, right);
|
|
}
|
|
|
|
protected override int ProcessBinaryOperation(int left, int right)
|
|
{
|
|
return Mathf.Max(left, right);
|
|
}
|
|
|
|
protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left > right ? left : right;
|
|
}
|
|
|
|
protected override bool ProcessBinaryOperation(bool left, bool right)
|
|
{
|
|
return left ? left : right;
|
|
}
|
|
|
|
protected override string GetBinaryOperationCode(string left, string right, VFXValueType type)
|
|
{
|
|
if (type == VFXValueType.Uint32)
|
|
return string.Format("{0} > {1} ? {0} : {1}", left, right);
|
|
return string.Format("max({0}, {1})", left, right);
|
|
}
|
|
|
|
static public bool CanBeReducedToSaturate(VFXExpression current, VFXExpression[] reducedParents, out VFXExpression inputValueRef)
|
|
{
|
|
inputValueRef = null;
|
|
var valueType = current.valueType;
|
|
if (reducedParents.Length != 2 || !VFXExpression.IsFloatValueType(valueType))
|
|
return false;
|
|
|
|
var one = VFXOperatorUtility.OneExpression[valueType];
|
|
var zero = VFXOperatorUtility.ZeroExpression[valueType];
|
|
|
|
Type searchInnerFunctionType = null;
|
|
VFXExpression searchInnerValueFirstLevel = null;
|
|
VFXExpression searchInnerValueSecondLevel = null;
|
|
|
|
if (current is VFXExpressionMax)
|
|
{
|
|
searchInnerFunctionType = typeof(VFXExpressionMin);
|
|
searchInnerValueFirstLevel = zero;
|
|
searchInnerValueSecondLevel = one;
|
|
}
|
|
else if (current is VFXExpressionMin)
|
|
{
|
|
searchInnerFunctionType = typeof(VFXExpressionMax);
|
|
searchInnerValueFirstLevel = one;
|
|
searchInnerValueSecondLevel = zero;
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var minReferenceExpected = reducedParents.FirstOrDefault(o => o.GetType() == searchInnerFunctionType);
|
|
var firstValueExpected = reducedParents.FirstOrDefault(o => o == searchInnerValueFirstLevel);
|
|
if (minReferenceExpected != null && firstValueExpected != null)
|
|
{
|
|
var indexOf = Array.IndexOf(minReferenceExpected.parents, searchInnerValueSecondLevel);
|
|
if (indexOf != -1)
|
|
{
|
|
var otherIndexOf = (indexOf + 1) % 2;
|
|
inputValueRef = minReferenceExpected.parents[otherIndexOf];
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected override VFXExpression Reduce(VFXExpression[] reducedParents)
|
|
{
|
|
VFXExpression inputSaturateExpression = null;
|
|
if (CanBeReducedToSaturate(this, reducedParents, out inputSaturateExpression))
|
|
{
|
|
return new VFXExpressionSaturate(inputSaturateExpression);
|
|
}
|
|
return base.Reduce(reducedParents);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionPow : VFXExpressionBinaryFloatOperation
|
|
{
|
|
public VFXExpressionPow() : this(VFXValue<float>.Default, VFXValue<float>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionPow(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.Pow)
|
|
{
|
|
}
|
|
|
|
sealed protected override float ProcessBinaryOperation(float left, float right)
|
|
{
|
|
return Mathf.Pow(left, right);
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right)
|
|
{
|
|
return string.Format("pow({0}, {1})", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionATan2 : VFXExpressionBinaryFloatOperation
|
|
{
|
|
public VFXExpressionATan2() : this(VFXValue<float>.Default, VFXValue<float>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionATan2(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.ATan2)
|
|
{
|
|
}
|
|
|
|
sealed protected override float ProcessBinaryOperation(float left, float right)
|
|
{
|
|
return Mathf.Atan2(left, right);
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right)
|
|
{
|
|
return string.Format("atan2({0}, {1})", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionBitwiseLeftShift : VFXExpressionBinaryUIntOperation
|
|
{
|
|
public VFXExpressionBitwiseLeftShift()
|
|
: this(VFXValue<uint>.Default, VFXValue<uint>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionBitwiseLeftShift(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.BitwiseLeftShift)
|
|
{
|
|
}
|
|
|
|
sealed protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left << (int)right;
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right)
|
|
{
|
|
return string.Format("{0} << {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionBitwiseRightShift : VFXExpressionBinaryUIntOperation
|
|
{
|
|
public VFXExpressionBitwiseRightShift() : this(VFXValue<uint>.Default, VFXValue<uint>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionBitwiseRightShift(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.BitwiseRightShift)
|
|
{
|
|
}
|
|
|
|
sealed protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left >> (int)right;
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right)
|
|
{
|
|
return string.Format("{0} >> {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionBitwiseOr : VFXExpressionBinaryUIntOperation
|
|
{
|
|
public VFXExpressionBitwiseOr() : this(VFXValue<uint>.Default, VFXValue<uint>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionBitwiseOr(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.BitwiseOr)
|
|
{
|
|
}
|
|
|
|
sealed protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left | right;
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right)
|
|
{
|
|
return string.Format("{0} | {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionBitwiseAnd : VFXExpressionBinaryUIntOperation
|
|
{
|
|
public VFXExpressionBitwiseAnd() : this(VFXValue<uint>.Default, VFXValue<uint>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionBitwiseAnd(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.BitwiseAnd)
|
|
{
|
|
}
|
|
|
|
sealed protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left & right;
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right)
|
|
{
|
|
return string.Format("{0} & {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionBitwiseXor : VFXExpressionBinaryUIntOperation
|
|
{
|
|
public VFXExpressionBitwiseXor() : this(VFXValue<uint>.Default, VFXValue<uint>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionBitwiseXor(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.BitwiseXor)
|
|
{
|
|
}
|
|
|
|
sealed protected override uint ProcessBinaryOperation(uint left, uint right)
|
|
{
|
|
return left ^ right;
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right)
|
|
{
|
|
return string.Format("{0} ^ {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionBitwiseComplement : VFXExpressionUnaryUIntOperation
|
|
{
|
|
public VFXExpressionBitwiseComplement() : this(VFXValue<uint>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionBitwiseComplement(VFXExpression parent) : base(parent, VFXExpressionOperation.BitwiseComplement)
|
|
{
|
|
}
|
|
|
|
sealed protected override uint ProcessUnaryOperation(uint input)
|
|
{
|
|
return ~input;
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("~{0}", x);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionLogicalAnd : VFXExpressionBinaryBoolOperation
|
|
{
|
|
public VFXExpressionLogicalAnd() : this(VFXValue<bool>.Default, VFXValue<bool>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionLogicalAnd(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.LogicalAnd)
|
|
{
|
|
}
|
|
|
|
sealed protected override bool ProcessBinaryOperation(bool left, bool right)
|
|
{
|
|
return left && right;
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right)
|
|
{
|
|
return string.Format("{0} && {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionLogicalOr : VFXExpressionBinaryBoolOperation
|
|
{
|
|
public VFXExpressionLogicalOr() : this(VFXValue<bool>.Default, VFXValue<bool>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionLogicalOr(VFXExpression parentLeft, VFXExpression parentRight) : base(parentLeft, parentRight, VFXExpressionOperation.LogicalOr)
|
|
{
|
|
}
|
|
|
|
sealed protected override bool ProcessBinaryOperation(bool left, bool right)
|
|
{
|
|
return left || right;
|
|
}
|
|
|
|
sealed protected override string GetBinaryOperationCode(string left, string right)
|
|
{
|
|
return string.Format("{0} || {1}", left, right);
|
|
}
|
|
}
|
|
|
|
class VFXExpressionLogicalNot : VFXExpressionUnaryBoolOperation
|
|
{
|
|
public VFXExpressionLogicalNot() : this(VFXValue<bool>.Default)
|
|
{
|
|
}
|
|
|
|
public VFXExpressionLogicalNot(VFXExpression parent) : base(parent, VFXExpressionOperation.LogicalNot)
|
|
{
|
|
}
|
|
|
|
sealed protected override bool ProcessUnaryOperation(bool input)
|
|
{
|
|
return !input;
|
|
}
|
|
|
|
sealed protected override string GetUnaryOperationCode(string x)
|
|
{
|
|
return string.Format("!{0}", x);
|
|
}
|
|
}
|
|
}
|