sealed protected override void ConvertExpressionsFromLink(VFXSlot fromSlot) { if (fromSlot.property.type == typeof(TSphere)) { var destSlots = GetVFXValueTypeSlots(); var fromSlots = fromSlot.GetVFXValueTypeSlots(); var sourceRadius = fromSlots.FirstOrDefault(o => o.name == nameof(TSphere.radius)).GetExpression(); var sourceScale = fromSlots.FirstOrDefault(o => o.name == nameof(TSphere.transform.scale)).GetExpression(); var computedRadius = sourceRadius * VFXOperatorUtility.Max3(sourceScale); UpdateLinkedInExpression(destSlots.FirstOrDefault(o => o.name == nameof(Sphere.radius)), computedRadius, null); var sourcePosition = fromSlots.FirstOrDefault(o => o.name == nameof(TSphere.transform.position)); UpdateLinkedInExpression(destSlots.FirstOrDefault(o => o.name == nameof(Sphere.center)), sourcePosition.GetExpression(), sourcePosition); } else { throw new InvalidOperationException("Unexpected manual conversion from slot type : " + fromSlot.property.type); } }
static private VFXExpression ApplyAddressingMode(VFXExpression index, VFXExpression count, SequentialAddressingMode mode) { VFXExpression r = null; if (mode == SequentialAddressingMode.Wrap) { r = VFXOperatorUtility.Modulo(index, count); } else if (mode == SequentialAddressingMode.Clamp) { r = VFXOperatorUtility.Clamp(index, ZeroExpression[VFXValueType.Uint32], count, false); } else if (mode == SequentialAddressingMode.Mirror) { var direction = VFXOperatorUtility.Modulo(index / count, VFXOperatorUtility.TwoExpression[VFXValueType.Uint32]); var modulo = VFXOperatorUtility.Modulo(index, count); r = VFXOperatorUtility.Lerp(modulo, count - modulo, direction); } return(r); }
sealed protected override VFXExpression ConvertExpression(VFXExpression expression, VFXSlot sourceSlot) { if (sourceSlot != null) { if (sourceSlot.GetType() == typeof(VFXSlotDirection)) { return(expression); //avoid multiple normalization } if (sourceSlot.property.attributes != null && sourceSlot.property.attributes.OfType <NormalizeAttribute>().Any()) { return(expression); //avoid multiple normalization from Normalize attribute (rarely used for output slot) } } if (expression.valueType == VFXValueType.Float4) { expression = VFXOperatorUtility.CastFloat(expression, VFXValueType.Float3); } return(ApplyPatchExpression(expression)); }
public static VFXExpression ApplyToExpressionGraph(VFXPropertyAttribute[] attributes, VFXExpression exp) { if (attributes != null) { foreach (VFXPropertyAttribute attribute in attributes) { switch (attribute.m_Type) { case Type.kRange: exp = VFXOperatorUtility.Clamp(exp, VFXValue.Constant(attribute.m_Min), VFXValue.Constant(attribute.m_Max)); break; case Type.kMin: exp = new VFXExpressionMax(exp, VFXOperatorUtility.CastFloat(VFXValue.Constant(attribute.m_Min), exp.valueType)); break; case Type.kNormalize: exp = VFXOperatorUtility.Normalize(exp); break; case Type.kTooltip: case Type.kAngle: case Type.kColor: case Type.kRegex: case Type.kDelayed: case Type.kBitField: break; default: throw new NotImplementedException(); } } } return(exp); }
static public VFXExpression SequentialCircle(VFXExpression center, VFXExpression radius, VFXExpression normal, VFXExpression up, VFXExpression index, VFXExpression count, SequentialAddressingMode mode) { VFXExpression countForAddressing = count; if (mode == SequentialAddressingMode.Clamp || mode == SequentialAddressingMode.Mirror) { //Explicitly close the circle loop, if `index` equals to `count`, adds an extra step. countForAddressing = count + OneExpression[VFXValueType.Uint32]; } VFXExpression dt = ApplyAddressingMode(index, countForAddressing, mode); dt = new VFXExpressionCastUintToFloat(dt); dt = dt / new VFXExpressionCastUintToFloat(count); var cos = new VFXExpressionCos(dt * VFXOperatorUtility.TauExpression[VFXValueType.Float]) as VFXExpression; var sin = new VFXExpressionSin(dt * VFXOperatorUtility.TauExpression[VFXValueType.Float]) as VFXExpression; var left = VFXOperatorUtility.Normalize(VFXOperatorUtility.Cross(normal, up)); radius = new VFXExpressionCombine(radius, radius, radius); sin = new VFXExpressionCombine(sin, sin, sin); cos = new VFXExpressionCombine(cos, cos, cos); return(center + (cos * up + sin * left) * radius); }
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target) { var meshData = (VFXDataMesh)GetData(); switch (target) { case VFXDeviceTarget.GPU: { var mapper = new VFXExpressionMapper(); for (int i = 2; i < GetNbInputSlots(); ++i) { VFXExpression exp = GetInputSlot(i).GetExpression(); VFXProperty prop = GetInputSlot(i).property; // As there's not shader generation here, we need expressions that can be evaluated on CPU if (exp.IsAny(VFXExpression.Flags.NotCompilableOnCPU)) { throw new InvalidOperationException(string.Format("Expression for slot {0} must be evaluable on CPU: {1}", prop.name, exp)); } // needs to convert to srgb as color are linear in vfx graph // This should not be performed for colors with the attribute [HDR] and be performed for vector4 with the attribute [Gamma] // But property attributes cannot seem to be accessible from C# :( if (prop.type == typeof(Color)) { exp = VFXOperatorUtility.LinearToGamma(exp); } mapper.AddExpression(exp, prop.name, -1); } return(mapper); } case VFXDeviceTarget.CPU: { var mapper = new VFXExpressionMapper(); mapper.AddExpression(GetInputSlot(0).GetExpression(), "mesh", -1); mapper.AddExpression(GetInputSlot(1).GetExpression(), "transform", -1); mapper.AddExpression(GetInputSlot(2).GetExpression(), "subMeshMask", -1); // TODO Remove this once material are serialized // Add material properties if (shader != null) { var mat = meshData.GetOrCreateMaterial(); for (int i = 0; i < ShaderUtil.GetPropertyCount(shader); ++i) { if (ShaderUtil.IsShaderPropertyHidden(shader, i)) { var name = ShaderUtil.GetPropertyName(shader, i); var nameId = Shader.PropertyToID(name); if (!mat.HasProperty(nameId)) { continue; } VFXExpression expr = null; switch (ShaderUtil.GetPropertyType(shader, i)) { case ShaderUtil.ShaderPropertyType.Float: expr = VFXValue.Constant <float>(mat.GetFloat(nameId)); break; default: break; } if (expr != null) { mapper.AddExpression(expr, name, -1); } } } } return(mapper); } default: return(null); } }
static VFXExpression RandomFromVector2(VFXExpression input) { return(VFXOperatorUtility.Lerp(input.x, input.y, new VFXExpressionRandom())); }
public static VFXExpression ApplyToExpressionGraph(VFXPropertyAttribute[] attributes, VFXExpression exp) { if (attributes != null) { foreach (VFXPropertyAttribute attribute in attributes) { switch (attribute.m_Type) { case Type.kRange: switch (exp.valueType) { case VFXValueType.Int32: exp = VFXOperatorUtility.Clamp(exp, VFXValue.Constant((int)attribute.m_Min), VFXValue.Constant((int)attribute.m_Max), false); break; case VFXValueType.Uint32: exp = VFXOperatorUtility.Clamp(exp, VFXValue.Constant((uint)attribute.m_Min), VFXValue.Constant((uint)attribute.m_Max), false); break; case VFXValueType.Float: case VFXValueType.Float2: case VFXValueType.Float3: case VFXValueType.Float4: exp = VFXOperatorUtility.Clamp(exp, VFXValue.Constant(attribute.m_Min), VFXValue.Constant(attribute.m_Max)); break; default: throw new NotImplementedException(string.Format("Cannot use RangeAttribute on value of type: {0}", exp.valueType)); } break; case Type.kMin: switch (exp.valueType) { case VFXValueType.Int32: exp = new VFXExpressionMax(exp, VFXValue.Constant((int)attribute.m_Min)); break; case VFXValueType.Uint32: exp = new VFXExpressionMax(exp, VFXValue.Constant((uint)attribute.m_Min)); break; case VFXValueType.Float: case VFXValueType.Float2: case VFXValueType.Float3: case VFXValueType.Float4: exp = new VFXExpressionMax(exp, VFXOperatorUtility.CastFloat(VFXValue.Constant(attribute.m_Min), exp.valueType)); break; default: throw new NotImplementedException(string.Format("Cannot use MinAttribute on value of type: {0}", exp.valueType)); } break; case Type.kNormalize: exp = VFXOperatorUtility.Normalize(exp); break; case Type.kTooltip: case Type.kAngle: case Type.kColor: case Type.kRegex: case Type.kDelayed: case Type.kBitField: break; default: throw new NotImplementedException(); } } } return(exp); }
static VFXExpression RandomFromVector2(VFXExpression input, RandId randId) { return(VFXOperatorUtility.Lerp(input.x, input.y, new VFXExpressionRandom(false, randId))); }
protected override VFXExpression ApplyPatchExpression(VFXExpression expression) { return(VFXOperatorUtility.Normalize(expression)); }
public VFXExpression ApplyToExpressionGraph(VFXExpression exp) { if (m_GraphAttributes == null) { return(exp); } foreach (PropertyAttribute attribute in m_GraphAttributes) { if (attribute is RangeAttribute) { var rangeAttribute = (RangeAttribute)attribute; switch (exp.valueType) { case VFXValueType.Int32: exp = VFXOperatorUtility.Clamp(exp, VFXValue.Constant((int)rangeAttribute.min), VFXValue.Constant((int)rangeAttribute.max), false); break; case VFXValueType.Uint32: exp = VFXOperatorUtility.Clamp(exp, VFXValue.Constant((uint)rangeAttribute.min), VFXValue.Constant((uint)rangeAttribute.max), false); break; case VFXValueType.Float: case VFXValueType.Float2: case VFXValueType.Float3: case VFXValueType.Float4: exp = VFXOperatorUtility.Clamp(exp, VFXValue.Constant(rangeAttribute.min), VFXValue.Constant(rangeAttribute.max)); break; default: throw new NotImplementedException(string.Format("Cannot use RangeAttribute on value of type: {0}", exp.valueType)); } } else if (attribute is MinAttribute) { var minAttribute = (MinAttribute)attribute; switch (exp.valueType) { case VFXValueType.Int32: exp = new VFXExpressionMax(exp, VFXValue.Constant((int)minAttribute.min)); break; case VFXValueType.Uint32: exp = new VFXExpressionMax(exp, VFXValue.Constant((uint)minAttribute.min)); break; case VFXValueType.Float: case VFXValueType.Float2: case VFXValueType.Float3: case VFXValueType.Float4: exp = new VFXExpressionMax(exp, VFXOperatorUtility.CastFloat(VFXValue.Constant(minAttribute.min), exp.valueType)); break; default: throw new NotImplementedException(string.Format("Cannot use MinAttribute on value of type: {0}", exp.valueType)); } } else if (attribute is NormalizeAttribute) { exp = VFXOperatorUtility.Normalize(exp); } else if (attribute is EnumAttribute) { var enumAttribute = (EnumAttribute)attribute; exp = new VFXExpressionMin(exp, VFXValue.Constant((uint)enumAttribute.values.Length - 1)); } else { throw new NotImplementedException("Unrecognized expression attribute: " + attribute); } } return(exp); }
//Convert automatically input expression with diverging floatN size to floatMax protected override IEnumerable <VFXExpression> ApplyPatchInputExpression(IEnumerable <VFXExpression> inputExpression) { return(VFXOperatorUtility.UpcastAllFloatN(inputExpression, m_FallbackValue)); }