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);
}
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);
}
sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
{
return(VFXValue.Constant(UnityEngine.Random.value));
}
sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
{
var matrix = constParents[0].Get <Matrix4x4>();
return(VFXValue.Constant(matrix.transpose));
}
public VFXExpressionMatrixToVector4s() : this(new VFXExpression[] { VFXValue <Matrix4x4> .Default, VFXValue.Constant <int>(0) } // TODO row index should not be an expression!
)
{
}
protected override VFXExpression Evaluate(VFXExpression[] constParents)
{
var graphicsBuffer = constParents[0].Get <GraphicsBuffer>();
return(VFXValue.Constant <uint>(graphicsBuffer != null ? (uint)graphicsBuffer.stride : 0u));
}
static public VFXExpression RadToDeg(VFXExpression radians)
{
return(radians * CastFloat(VFXValue.Constant(180.0f / Mathf.PI), radians.valueType));
}
protected override IEnumerable <VFXNamedExpression> CollectGPUExpressions(IEnumerable <VFXNamedExpression> slotExpressions)
{
foreach (var exp in base.CollectGPUExpressions(slotExpressions))
{
yield return(exp);
}
yield return(slotExpressions.First(o => o.name == "smoothness"));
uint diffusionProfileHash;
switch (materialType)
{
case MaterialType.Standard:
case MaterialType.SimpleLit:
yield return(slotExpressions.First(o => o.name == "metallic"));
break;
case MaterialType.SpecularColor:
yield return(slotExpressions.First(o => o.name == "specularColor"));
break;
case MaterialType.Translucent:
case MaterialType.SimpleLitTranslucent:
yield return(slotExpressions.First(o => o.name == "thickness"));
#if VFX_HAS_HDRP
diffusionProfileHash = (diffusionProfileAsset?.profile != null) ? diffusionProfileAsset.profile.hash : 0;
#else
diffusionProfileHash = 0;
#endif
yield return(new VFXNamedExpression(VFXValue.Constant(diffusionProfileHash), "diffusionProfileHash"));
break;
default: break;
}
if (allowTextures)
{
if (useBaseColorMap != BaseColorMapMode.None)
{
yield return(slotExpressions.First(o => o.name == "baseColorMap"));
}
if (useMaskMap)
{
yield return(slotExpressions.First(o => o.name == "maskMap"));
}
if (useNormalMap)
{
yield return(slotExpressions.First(o => o.name == "normalMap"));
yield return(slotExpressions.First(o => o.name == "normalScale"));
}
if (useEmissiveMap)
{
yield return(slotExpressions.First(o => o.name == "emissiveMap"));
yield return(slotExpressions.First(o => o.name == "emissiveScale"));
}
}
if ((colorMode & ColorMode.BaseColor) == 0)
{
yield return(slotExpressions.First(o => o.name == "baseColor"));
}
if (((colorMode & ColorMode.Emissive) == 0) && useEmissive)
{
yield return(slotExpressions.First(o => o.name == "emissiveColor"));
}
}
sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
{
var tex = constParents[0].Get <Texture>();
return(VFXValue.Constant <uint>(tex ? (uint)tex.height : 0u));
}
sealed protected override VFXExpression Evaluate(VFXExpression[] reducedParents)
{
return(VFXValue.Constant((uint)reducedParents[0].Get <float>()));
}
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);
}
public VFXExpressionBranch()
: this(VFXValue.Constant(true), VFXValue.Constant(0.0f), VFXValue.Constant(0.0f))
{
}
public VFXExpressionCondition()
: this(VFXCondition.Equal, VFXValue.Constant(0.0f), VFXValue.Constant(0.0f))
{
}
sealed protected override VFXExpression Evaluate(VFXExpression[] constParents)
{
return(VFXValue.Constant <Texture2D>(null));
}
static public VFXExpression FixedRandom(uint hash, VFXSeedMode mode)
{
return(FixedRandom(VFXValue.Constant <uint>(hash), mode));
}
public static VFXExpression operator&(VFXExpression a, uint b)
{
return(new VFXExpressionBitwiseAnd(a, VFXValue.Constant(b)));
}
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);
}
}
public static VFXExpression operator>>(VFXExpression a, int shift)
{
return(new VFXExpressionBitwiseRightShift(a, VFXValue.Constant((uint)shift)));
}
static public VFXExpression DegToRad(VFXExpression degrees)
{
return(degrees * CastFloat(VFXValue.Constant(Mathf.PI / 180.0f), degrees.valueType));
}
protected virtual IEnumerable <VFXNamedExpression> CollectGPUExpressions(IEnumerable <VFXNamedExpression> slotExpressions)
{
if (exposeAlphaThreshold)
{
yield return(slotExpressions.First(o => o.name == "alphaThreshold"));
}
if (colorMapping == ColorMappingMode.GradientMapped)
{
yield return(slotExpressions.First(o => o.name == "gradient"));
}
if (hasSoftParticles)
{
var softParticleFade = slotExpressions.First(o => o.name == "softParticleFadeDistance");
var invSoftParticleFade = (VFXValue.Constant(1.0f) / softParticleFade.exp);
yield return(new VFXNamedExpression(invSoftParticleFade, "invSoftParticlesFadeDistance"));
}
if (supportsUV && uvMode != UVMode.Default)
{
VFXNamedExpression flipBookSizeExp;
switch (uvMode)
{
case UVMode.Flipbook:
case UVMode.FlipbookBlend:
case UVMode.FlipbookMotionBlend:
if (flipbookLayout == FlipbookLayout.Texture2D)
{
flipBookSizeExp = slotExpressions.First(o => o.name == "flipBookSize");
yield return(flipBookSizeExp);
yield return(new VFXNamedExpression(VFXValue.Constant(Vector2.one) / flipBookSizeExp.exp, "invFlipBookSize"));
}
else if (flipbookLayout == FlipbookLayout.Texture2DArray)
{
VFXNamedExpression mainTextureExp;
try
{
mainTextureExp = slotExpressions.First(o => (o.name == "mainTexture") | (o.name == "baseColorMap") | (o.name == "distortionBlurMap") | (o.name == "normalMap"));
}
catch (InvalidOperationException)
{
throw new NotImplementedException("Trying to fetch an inexistent slot Main Texture or Base Color Map or Distortion Blur Map or Normal Map. ");
}
yield return(new VFXNamedExpression(new VFXExpressionCastUintToFloat(new VFXExpressionTextureDepth(mainTextureExp.exp)), "flipBookSize"));
}
if (uvMode == UVMode.FlipbookMotionBlend)
{
yield return(slotExpressions.First(o => o.name == "motionVectorMap"));
yield return(slotExpressions.First(o => o.name == "motionVectorScale"));
}
break;
case UVMode.ScaleAndBias:
yield return(slotExpressions.First(o => o.name == "uvScale"));
yield return(slotExpressions.First(o => o.name == "uvBias"));
break;
default: throw new NotImplementedException("Unimplemented UVMode: " + uvMode);
}
}
if (hasExposure && useExposureWeight)
{
yield return(slotExpressions.First(o => o.name == "exposureWeight"));
}
}
static public VFXExpression FixedRandom(uint hash, bool perElement)
{
return(FixedRandom(VFXValue.Constant <uint>(hash), perElement));
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
if (!m_Output)
{
throw new NullReferenceException("Unexpected call of GetExpressionMapper with a null output");
}
if (features == Features.None)
{
throw new InvalidOperationException("This additional update context has no feature set");
}
if (target == VFXDeviceTarget.GPU)
{
var expressionMapper = m_Output.GetExpressionMapper(target);
var exp = GetExpressionsFromSlots(m_Output);
if (HasFeature(Features.LOD))
{
var lodExp = exp.FirstOrDefault(e => e.name == VFXMultiMeshHelper.lodName);
var ratioExp = lodExp.exp * VFXValue.Constant(new Vector4(0.01f, 0.01f, 0.01f, 0.01f));
expressionMapper.AddExpression(ratioExp, VFXMultiMeshHelper.lodName, -1);
}
if (HasFeature(Features.LOD) || HasFeature(Features.FrustumCulling))
{
var radiusScaleExp = exp.FirstOrDefault(e => e.name == "radiusScale").exp;
if (radiusScaleExp == null) // Not found, assume it's 1
{
radiusScaleExp = VFXValue.Constant(1.0f);
}
expressionMapper.AddExpression(radiusScaleExp, "radiusScale", -1);
}
if (HasFeature(Features.MotionVector))
{
var currentFrameIndex = expressionMapper.FromNameAndId("currentFrameIndex", -1);
if (currentFrameIndex == null)
{
Debug.LogError("CurrentFrameIndex isn't reachable in encapsulatedOutput for motionVector");
}
}
//Since it's a compute shader without renderer associated, these entries aren't automatically sent
expressionMapper.AddExpression(VFXBuiltInExpression.LocalToWorld, "unity_ObjectToWorld", -1);
expressionMapper.AddExpression(VFXBuiltInExpression.WorldToLocal, "unity_WorldToObject", -1);
if (m_Output.HasCustomSortingCriterion())
{
var sortKeyExp = m_Output.inputSlots.First(s => s.name == "sortKey").GetExpression();
expressionMapper.AddExpression(sortKeyExp, "sortKey", -1);
}
return(expressionMapper);
}
else
{
return(new VFXExpressionMapper());
}
}