public static string TypeToCode(VFXValueType type)
{
switch (type)
{
case VFXValueType.Float: return("float");
case VFXValueType.Float2: return("float2");
case VFXValueType.Float3: return("float3");
case VFXValueType.Float4: return("float4");
case VFXValueType.Int32: return("int");
case VFXValueType.Uint32: return("uint");
case VFXValueType.Texture2D: return("Texture2D");
case VFXValueType.Texture2DArray: return("Texture2DArray");
case VFXValueType.Texture3D: return("Texture3D");
case VFXValueType.TextureCube: return("TextureCube");
case VFXValueType.TextureCubeArray: return("TextureCubeArray");
case VFXValueType.Matrix4x4: return("float4x4");
case VFXValueType.Boolean: return("bool");
}
throw new NotImplementedException(type.ToString());
}
public static bool IsFloatValueType(VFXValueType valueType)
{
return(valueType == VFXValueType.Float ||
valueType == VFXValueType.Float2 ||
valueType == VFXValueType.Float3 ||
valueType == VFXValueType.Float4);
}
public static string GetValueString(VFXValueType type, object value)
{
var format = "";
switch (type)
{
case VFXValueType.Boolean:
case VFXValueType.Int32:
case VFXValueType.Uint32:
case VFXValueType.Float:
format = "({0}){1}";
break;
case VFXValueType.Float2:
case VFXValueType.Float3:
case VFXValueType.Float4:
case VFXValueType.Matrix4x4:
format = "{0}{1}";
break;
default: throw new Exception("GetValueString missing type: " + type);
}
// special cases of ToString
switch (type)
{
case VFXValueType.Boolean:
value = value.ToString().ToLower();
break;
case VFXValueType.Float:
value = ((float)value).ToString("G9", CultureInfo.InvariantCulture);
break;
case VFXValueType.Float2:
value = $"({((Vector2)value).x.ToString("G9", CultureInfo.InvariantCulture)}, {((Vector2)value).y.ToString("G9", CultureInfo.InvariantCulture)})";
break;
case VFXValueType.Float3:
value = $"({((Vector3)value).x.ToString("G9", CultureInfo.InvariantCulture)}, {((Vector3)value).y.ToString("G9", CultureInfo.InvariantCulture)}, {((Vector3)value).z.ToString("G9", CultureInfo.InvariantCulture)})";
break;
case VFXValueType.Float4:
value = $"({((Vector4)value).x.ToString("G9", CultureInfo.InvariantCulture)}, {((Vector4)value).y.ToString("G9", CultureInfo.InvariantCulture)}, {((Vector4)value).z.ToString("G9", CultureInfo.InvariantCulture)}, {((Vector4)value).w.ToString("G9", CultureInfo.InvariantCulture)})";
break;
case VFXValueType.Matrix4x4:
{
var matrix = ((Matrix4x4)value).transpose;
value = "(";
for (int i = 0; i < 16; ++i)
{
value += string.Format(CultureInfo.InvariantCulture, i == 15 ? "{0}" : "{0},", matrix[i].ToString("G9", CultureInfo.InvariantCulture));
}
value += ")";
}
break;
}
return(string.Format(CultureInfo.InvariantCulture, format, VFXExpression.TypeToCode(type), value));
}
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));
}
internal static void DataTypeLabel(Rect r, string Label, VFXValueType type, GUIStyle style)
{
Color backup = GUI.color;
GUI.color = valueTypeColors[type];
GUI.Label(r, Label, style);
GUI.color = backup;
}
internal static void DataTypeLabel(string Label, VFXValueType type, GUIStyle style, params GUILayoutOption[] options)
{
Color backup = GUI.color;
GUI.color = valueTypeColors[type];
GUILayout.Label(Label, style, options);
GUI.color = backup;
}
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 VFXExpression CastFloat(VFXExpression from, VFXValueType toValueType, float defaultValue = 0.0f)
{
if (!VFXExpressionNumericOperation.IsFloatValueType(from.valueType) || !VFXExpressionNumericOperation.IsFloatValueType(toValueType))
{
throw new ArgumentException(string.Format("Invalid CastFloat : {0} to {1}", from, toValueType));
}
if (from.valueType == toValueType)
{
return(from);
}
var fromValueType = from.valueType;
var fromValueTypeSize = VFXExpression.TypeToSize(fromValueType);
var toValueTypeSize = VFXExpression.TypeToSize(toValueType);
var inputComponent = new VFXExpression[fromValueTypeSize];
var outputComponent = new VFXExpression[toValueTypeSize];
if (inputComponent.Length == 1)
{
inputComponent[0] = from;
}
else
{
for (int iChannel = 0; iChannel < fromValueTypeSize; ++iChannel)
{
inputComponent[iChannel] = from[iChannel];
}
}
for (int iChannel = 0; iChannel < toValueTypeSize; ++iChannel)
{
if (iChannel < fromValueTypeSize)
{
outputComponent[iChannel] = inputComponent[iChannel];
}
else if (fromValueTypeSize == 1)
{
//Manage same logic behavior for float => floatN in HLSL
outputComponent[iChannel] = inputComponent[0];
}
else
{
outputComponent[iChannel] = VFXValue.Constant(defaultValue);
}
}
if (toValueTypeSize == 1)
{
return(outputComponent[0]);
}
var combine = new VFXExpressionCombine(outputComponent);
return(combine);
}
public void WriteDeclaration(VFXValueType type, string variableName)
{
if (!VFXExpression.IsTypeValidOnGPU(type))
{
throw new ArgumentException(string.Format("Invalid GPU Type: {0}", type));
}
WriteFormat("{0} {1};\n", VFXExpression.TypeToCode(type), variableName);
}
sealed protected override string GetBinaryOperationCode(string x, string y, VFXValueType type)
{
if (!IsUIntValueType(type))
{
throw new InvalidOperationException("Invalid VFXExpressionBinaryUIntOperation");
}
return(GetBinaryOperationCode(x, y));
}
public void WriteDeclaration(VFXValueType type, string variableName, string semantic)
{
if (!VFXExpression.IsTypeValidOnGPU(type))
{
throw new ArgumentException(string.Format("Invalid GPU Type: {0}", type));
}
WriteFormat("VFX_OPTIONAL_INTERPOLATION {0} {1} : {2};\n", VFXExpression.TypeToCode(type), variableName, semantic);
}
private static string GetCompatTypeString(VFXValueType valueType)
{
if (!VFXExpression.IsUniform(valueType))
{
throw new InvalidOperationException("Trying to fetch an attribute of type: " + valueType);
}
return(VFXExpression.TypeToCode(valueType));
}
sealed protected override string GetUnaryOperationCode(string x, VFXValueType type)
{
if (!IsUIntValueType(type))
{
throw new InvalidOperationException("VFXExpressionUnaryUIntOperation : Unexpected type");
}
return(GetUnaryOperationCode(x));
}
public void WriteVariable(VFXValueType type, string variableName, string value)
{
if (!VFXExpression.IsTypeValidOnGPU(type))
{
throw new ArgumentException(string.Format("Invalid GPU Type: {0}", type));
}
WriteFormat("{0} ", VFXExpression.TypeToCode(type));
WriteAssignement(type, variableName, value);
}
public static bool IsTypeConstantFoldable(VFXValueType type)
{
switch (type)
{
//Mesh API can modify the vertex count & layout.
//Thus, all mesh related expression should never been constant folded while generating code.
case VFXValueType.Mesh:
return(false);
}
return(true);
}
public static bool IsTexture(VFXValueType type)
{
switch (type)
{
case VFXValueType.Texture2D:
case VFXValueType.Texture2DArray:
case VFXValueType.Texture3D:
case VFXValueType.TextureCube:
case VFXValueType.TextureCubeArray:
return(true);
}
return(false);
}
static private VFXExpression BaseToConstant(Base _base, VFXValueType type)
{
switch (_base)
{
case Base.Base2: return(TwoExpression[type]);
case Base.Base10: return(TenExpression[type]);
case Base.BaseE: return(E_NapierConstantExpression[type]);
default:
throw new NotImplementedException();
}
}
public VFXExpressionCondition(VFXValueType type, VFXCondition cond, VFXExpression left, VFXExpression right) : base(VFXExpression.Flags.None, new VFXExpression[] { left, right })
{
if (type != left.valueType || type != right.valueType)
{
throw new InvalidOperationException(string.Format("Unexpected value type in condition expression : {0}/{1} (expected {2})", left.valueType, right.valueType, type));
}
if (type != VFXValueType.Float && type != VFXValueType.Uint32 && type != VFXValueType.Int32)
{
throw new NotImplementedException("This type is not handled by condition expression: " + type);
}
condition = cond;
this.type = type;
}
public static bool IsUniform(VFXValueType type)
{
switch (type)
{
case VFXValueType.Float:
case VFXValueType.Float2:
case VFXValueType.Float3:
case VFXValueType.Float4:
case VFXValueType.Int32:
case VFXValueType.Uint32:
case VFXValueType.Matrix4x4:
case VFXValueType.Boolean:
return(true);
}
return(false);
}
public static VFXValueType GetMatchingScalar(VFXValueType type)
{
if (IsFloatValueType(type))
{
return(VFXValueType.Float);
}
if (IsUIntValueType(type))
{
return(VFXValueType.Uint32);
}
if (IsIntValueType(type))
{
return(VFXValueType.Int32);
}
return(VFXValueType.None);
}
private static string GetFunctionParameterType(VFXValueType type)
{
switch (type)
{
case VFXValueType.Texture2D: return("VFXSampler2D");
case VFXValueType.Texture2DArray: return("VFXSampler2DArray");
case VFXValueType.Texture3D: return("VFXSampler3D");
case VFXValueType.TextureCube: return("VFXSamplerCube");
case VFXValueType.TextureCubeArray: return("VFXSamplerCubeArray");
default:
return(VFXExpression.TypeToCode(type));
}
}
public static bool IsTypeConstantFoldable(VFXValueType type)
{
switch (type)
{
//Mesh API can modify the vertex count & layout.
//Thus, all mesh related expression should never been constant folded while generating code.
// The same goes for textures
case VFXValueType.Texture2D:
case VFXValueType.Texture2DArray:
case VFXValueType.Texture3D:
case VFXValueType.TextureCube:
case VFXValueType.TextureCubeArray:
case VFXValueType.CameraBuffer:
case VFXValueType.Mesh:
return(false);
}
return(true);
}
static private VFXValue GetValueFromType(VFXValueType type)
{
switch (type)
{
case VFXValueType.Boolean: return(VFXValue.Constant <bool>());
case VFXValueType.Uint32: return(VFXValue.Constant <uint>());
case VFXValueType.Int32: return(VFXValue.Constant <int>());
case VFXValueType.Float: return(VFXValue.Constant <float>());
case VFXValueType.Float2: return(VFXValue.Constant <Vector2>());
case VFXValueType.Float3: return(VFXValue.Constant <Vector3>());
case VFXValueType.Float4: return(VFXValue.Constant <Vector4>());
default: throw new InvalidOperationException(string.Format("Unexpected attribute type: {0}", type));
}
}
public static Type TypeToType(VFXValueType type)
{
switch (type)
{
case VFXValueType.Float: return(typeof(float));
case VFXValueType.Float2: return(typeof(Vector2));
case VFXValueType.Float3: return(typeof(Vector3));
case VFXValueType.Float4: return(typeof(Vector4));
case VFXValueType.Int32: return(typeof(int));
case VFXValueType.Uint32: return(typeof(uint));
case VFXValueType.Texture2D: return(typeof(Texture));
case VFXValueType.Texture2DArray: return(typeof(Texture));
case VFXValueType.Texture3D: return(typeof(Texture));
case VFXValueType.TextureCube: return(typeof(Texture));
case VFXValueType.TextureCubeArray: return(typeof(Texture));
case VFXValueType.CameraBuffer: return(typeof(CameraBuffer));
case VFXValueType.Matrix4x4: return(typeof(Matrix4x4));
case VFXValueType.Mesh: return(typeof(Mesh));
case VFXValueType.Curve: return(typeof(AnimationCurve));
case VFXValueType.ColorGradient: return(typeof(Gradient));
case VFXValueType.Boolean: return(typeof(bool));
}
throw new NotImplementedException(type.ToString());
}
public static string TypeToCode(VFXValueType type)
{
switch (type)
{
case VFXValueType.Float: return("float");
case VFXValueType.Float2: return("float2");
case VFXValueType.Float3: return("float3");
case VFXValueType.Float4: return("float4");
case VFXValueType.Int32: return("int");
case VFXValueType.Uint32: return("uint");
case VFXValueType.Texture2D: return("Texture2D");
case VFXValueType.Texture2DArray: return("Texture2DArray");
case VFXValueType.Texture3D: return("Texture3D");
case VFXValueType.TextureCube: return("TextureCube");
case VFXValueType.TextureCubeArray: return("TextureCubeArray");
case VFXValueType.CameraBuffer: return("CameraBuffer");
case VFXValueType.Matrix4x4: return("float4x4");
case VFXValueType.Mesh:
case VFXValueType.SkinnedMeshRenderer:
case VFXValueType.Buffer: return("ByteAddressBuffer");
case VFXValueType.Boolean: return("bool");
}
throw new NotImplementedException(type.ToString());
}
public static bool IsTypeValidOnGPU(VFXValueType type)
{
switch (type)
{
case VFXValueType.Float:
case VFXValueType.Float2:
case VFXValueType.Float3:
case VFXValueType.Float4:
case VFXValueType.Int32:
case VFXValueType.Uint32:
case VFXValueType.Texture2D:
case VFXValueType.Texture2DArray:
case VFXValueType.Texture3D:
case VFXValueType.TextureCube:
case VFXValueType.TextureCubeArray:
case VFXValueType.Matrix4x4:
case VFXValueType.Boolean:
return(true);
}
return(false);
}
// As certain type of uniforms are not handled in material, we need to use floats instead
public static string TypeToUniformCode(VFXValueType type)
{
switch (type)
{
case VFXValueType.Float: return("float");
case VFXValueType.Float2: return("float2");
case VFXValueType.Float3: return("float3");
case VFXValueType.Float4: return("float4");
case VFXValueType.Int32: return("float");
case VFXValueType.Uint32: return("float");
case VFXValueType.Matrix4x4: return("float4x4");
case VFXValueType.Boolean: return("float");
}
throw new NotImplementedException(type.ToString());
}
public void WriteAssignement(VFXValueType type, string variableName, string value)
{
var format = value == "0" ? "{1} = ({0}){2};" : "{1} = {2};";
WriteFormat(format, VFXExpression.TypeToCode(type), variableName, value);
}
sealed protected override string GetBinaryOperationCode(string left, string right, VFXValueType type)
{
return(string.Format("{0} - {1}", left, right));
}
public VFXAttribute(string name, VFXValueType type, VFXVariadic variadic = VFXVariadic.False, SpaceableType space = SpaceableType.None)
: this(name, GetValueFromType(type), variadic, space)
{
}
