public VFXExpression GetReduced(VFXExpression exp, VFXDeviceTarget target)
{
VFXExpression reduced;
var expressionToReduced = target == VFXDeviceTarget.GPU ? m_GPUExpressionsToReduced : m_CPUExpressionsToReduced;
expressionToReduced.TryGetValue(exp, out reduced);
return(reduced);
}
private void CompileExpressionContext(IEnumerable <VFXContext> contexts,
VFXExpressionContextOption options,
VFXDeviceTarget target,
VFXExpression.Flags forbiddenFlags = VFXExpression.Flags.None)
{
var expressionContext = new VFXExpression.Context(options, m_GlobalEventAttributes);
var contextsToExpressions = target == VFXDeviceTarget.GPU ? m_ContextsToGPUExpressions : m_ContextsToCPUExpressions;
var expressionsToReduced = target == VFXDeviceTarget.GPU ? m_GPUExpressionsToReduced : m_CPUExpressionsToReduced;
foreach (var context in contexts)
{
var mapper = context.GetExpressionMapper(target);
if (mapper != null)
{
foreach (var exp in mapper.expressions)
{
expressionContext.RegisterExpression(exp);
}
contextsToExpressions.Add(context, mapper);
}
}
expressionContext.Compile();
foreach (var exp in expressionContext.RegisteredExpressions)
{
var reduced = expressionContext.GetReduced(exp);
if (expressionsToReduced.ContainsKey(exp))
{
if (reduced != expressionsToReduced[exp])
{
throw new InvalidOperationException("Unexpected diverging expression reduction");
}
continue;
}
expressionsToReduced.Add(exp, reduced);
}
var allReduced = expressionContext.BuildAllReduced();
if (forbiddenFlags != VFXExpression.Flags.None)
{
var check = allReduced.Any(e => e.IsAny(forbiddenFlags));
if (check)
{
//TODO: Provide an error in GUI when feedback is possible
throw new InvalidOperationException("Invalid expression usage while compiling");
}
}
m_Expressions.UnionWith(allReduced);
foreach (var exp in expressionsToReduced.Values)
{
AddExpressionDataRecursively(m_ExpressionsData, exp);
}
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
if (target == VFXDeviceTarget.CPU)
{
return(VFXExpressionMapper.FromContext(this));
}
return(null);
}
public virtual VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
if (target == VFXDeviceTarget.GPU)
{
return(VFXExpressionMapper.FromContext(this));
}
return(null);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
if (target == VFXDeviceTarget.GPU)
{
var gpuMapper = VFXExpressionMapper.FromBlocks(activeChildrenWithImplicit);
gpuMapper.AddExpressions(CollectGPUExpressions(GetExpressionsFromSlots(this)), -1);
return(gpuMapper);
}
return(new VFXExpressionMapper());
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
var mapper = base.GetExpressionMapper(target);
if (target == VFXDeviceTarget.GPU && skipZeroDeltaUpdate)
{
mapper.AddExpression(VFXBuiltInExpression.DeltaTime, "deltaTime", -1);
}
return(mapper);
}
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);
return(expressionMapper);
}
else
{
return(new VFXExpressionMapper());
}
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
if (target == VFXDeviceTarget.CPU)
{
var mapper = VFXExpressionMapper.FromBlocks(activeFlattenedChildrenWithImplicit);
var mapperFromContext = new VFXExpressionMapper();
mapperFromContext.AddExpressionsFromSlotContainer(this, -1);
if (loopDuration != LoopMode.Infinite)
{
var expression = mapperFromContext.FromNameAndId("LoopDuration", -1);
if (loopDuration == LoopMode.Random)
{
expression = RandomFromVector2(expression);
}
mapper.AddExpression(expression, "LoopDuration", -1);
}
if (loopCount != LoopMode.Infinite)
{
var expression = mapperFromContext.FromNameAndId("LoopCount", -1);
if (loopCount == LoopMode.Random)
{
expression = new VFXExpressionCastFloatToInt(RandomFromVector2(expression));
}
mapper.AddExpression(expression, "LoopCount", -1);
}
if (delayBeforeLoop != DelayMode.None)
{
var expression = mapperFromContext.FromNameAndId("DelayBeforeLoop", -1);
if (delayBeforeLoop == DelayMode.Random)
{
expression = RandomFromVector2(expression);
}
mapper.AddExpression(expression, "DelayBeforeLoop", -1);
}
if (delayAfterLoop != DelayMode.None)
{
var expression = mapperFromContext.FromNameAndId("DelayAfterLoop", -1);
if (delayAfterLoop == DelayMode.Random)
{
expression = RandomFromVector2(expression);
}
mapper.AddExpression(expression, "DelayAfterLoop", -1);
}
return(mapper);
}
return(null);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
var localSpace = ((VFXDataParticle)GetData()).space == VFXCoordinateSpace.Local;
if (localSpace && target == VFXDeviceTarget.GPU) // Needs to add locaToWorld matrix
{
var gpuMapper = new VFXExpressionMapper();
gpuMapper.AddExpression(VFXBuiltInExpression.LocalToWorld, "localToWorld", -1);
return(gpuMapper);
}
return(null); // cpu
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
// GPU
if (target == VFXDeviceTarget.GPU)
{
return(VFXExpressionMapper.FromBlocks(activeChildrenWithImplicit));
}
// CPU
var cpuMapper = new VFXExpressionMapper();
cpuMapper.AddExpressionFromSlotContainer(this, -1);
return(cpuMapper);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
if (target == VFXDeviceTarget.GPU)
{
var gpuMapper = VFXExpressionMapper.FromBlocks(activeFlattenedChildrenWithImplicit);
gpuMapper.AddExpressions(CollectGPUExpressions(GetExpressionsFromSlots(this)), -1);
if (generateMotionVector)
{
gpuMapper.AddExpression(VFXBuiltInExpression.FrameIndex, "currentFrameIndex", -1);
}
return(gpuMapper);
}
return(new VFXExpressionMapper());
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
var mapper = base.GetExpressionMapper(target);
if (target == VFXDeviceTarget.GPU && skipZeroDeltaUpdate)
{
mapper.AddExpression(VFXBuiltInExpression.DeltaTime, "deltaTime", -1);
}
var dataParticle = GetData() as VFXDataParticle;
if (target == VFXDeviceTarget.GPU && dataParticle && dataParticle.NeedsComputeBounds() && space == VFXCoordinateSpace.World)
{
mapper.AddExpression(VFXBuiltInExpression.WorldToLocal, "worldToLocal", -1);
}
return(mapper);
}
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);
return(mapper);
}
default:
return(null);
}
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
var mapper = base.GetExpressionMapper(target);
var shaderGraph = GetOrRefreshShaderGraphObject();
switch (target)
{
case VFXDeviceTarget.CPU:
{
}
break;
case VFXDeviceTarget.GPU:
if (shaderGraph != null)
{
foreach (var tex in shaderGraph.textureInfos)
{
switch (tex.dimension)
{
default:
case TextureDimension.Tex2D:
mapper.AddExpression(new VFXTexture2DValue(tex.instanceID, VFXValue.Mode.Variable), tex.name, -1);
break;
case TextureDimension.Tex3D:
mapper.AddExpression(new VFXTexture3DValue(tex.instanceID, VFXValue.Mode.Variable), tex.name, -1);
break;
case TextureDimension.Cube:
mapper.AddExpression(new VFXTextureCubeValue(tex.instanceID, VFXValue.Mode.Variable), tex.name, -1);
break;
case TextureDimension.Tex2DArray:
mapper.AddExpression(new VFXTexture2DArrayValue(tex.instanceID, VFXValue.Mode.Variable), tex.name, -1);
break;
case TextureDimension.CubeArray:
mapper.AddExpression(new VFXTextureCubeArrayValue(tex.instanceID, VFXValue.Mode.Variable), tex.name, -1);
break;
}
}
}
break;
}
return(mapper);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
var mapper = base.GetExpressionMapper(target);
switch (target)
{
case VFXDeviceTarget.CPU:
break;
case VFXDeviceTarget.GPU:
RefreshShaderGraphObject();
if (shaderGraph != null)
{
foreach (var tex in shaderGraph.textureInfos.Where(t => t.texture != null).OrderBy(t => t.name))
{
switch (tex.texture.dimension)
{
case TextureDimension.Tex2D:
mapper.AddExpression(new VFXTexture2DValue(tex.texture.GetInstanceID(), VFXValue.Mode.Variable), tex.name, -1);
break;
case TextureDimension.Tex3D:
mapper.AddExpression(new VFXTexture3DValue(tex.texture.GetInstanceID(), VFXValue.Mode.Variable), tex.name, -1);
break;
case TextureDimension.Cube:
mapper.AddExpression(new VFXTextureCubeValue(tex.texture.GetInstanceID(), VFXValue.Mode.Variable), tex.name, -1);
break;
case TextureDimension.Tex2DArray:
mapper.AddExpression(new VFXTexture2DArrayValue(tex.texture.GetInstanceID(), VFXValue.Mode.Variable), tex.name, -1);
break;
case TextureDimension.CubeArray:
mapper.AddExpression(new VFXTextureCubeArrayValue(tex.texture.GetInstanceID(), VFXValue.Mode.Variable), tex.name, -1);
break;
}
}
}
break;
}
return(mapper);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
// GPU
if (target == VFXDeviceTarget.GPU)
{
var gpuMapper = VFXExpressionMapper.FromBlocks(activeFlattenedChildrenWithImplicit);
if (ownedType == VFXDataType.ParticleStrip)
{
gpuMapper.AddExpressionsFromSlot(inputSlots[1], -1); // strip index
}
return(gpuMapper);
}
// CPU
var cpuMapper = new VFXExpressionMapper();
cpuMapper.AddExpressionsFromSlot(inputSlots[0], -1); // bounds
return(cpuMapper);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
var mapper = base.GetExpressionMapper(target);
switch (target)
{
case VFXDeviceTarget.CPU:
{
mapper.AddExpression(inputSlots.First(s => s.name == "mesh").GetExpression(), "mesh", -1);
mapper.AddExpression(inputSlots.First(s => s.name == "subMeshMask").GetExpression(), "subMeshMask", -1);
break;
}
default:
{
break;
}
}
return(mapper);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
var mapper = base.GetExpressionMapper(target);
switch (target)
{
case VFXDeviceTarget.CPU:
{
foreach (var name in VFXMultiMeshHelper.GetCPUExpressionNames(MeshCount))
{
mapper.AddExpression(inputSlots.First(s => s.name == name).GetExpression(), name, -1);
}
break;
}
default:
break;
}
return(mapper);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
var particleData = GetData() as VFXDataParticle;
bool isRecordedBounds = particleData && particleData.boundsSettingMode == BoundsSettingMode.Recorded;
// GPU
if (target == VFXDeviceTarget.GPU)
{
var gpuMapper = VFXExpressionMapper.FromBlocks(activeFlattenedChildrenWithImplicit);
if (ownedType == VFXDataType.ParticleStrip && !hasGPUSpawner)
{
gpuMapper.AddExpressionsFromSlot(inputSlots[(isRecordedBounds ? 2 : 1)], -1); // strip index
}
return(gpuMapper);
}
// CPU
var cpuMapper = new VFXExpressionMapper();
if (particleData)
{
switch (particleData.boundsSettingMode)
{
case BoundsSettingMode.Manual:
cpuMapper.AddExpressionsFromSlot(inputSlots[0], -1); // bounds
break;
case BoundsSettingMode.Recorded:
cpuMapper.AddExpressionsFromSlot(inputSlots[0], -1); // bounds
cpuMapper.AddExpressionsFromSlot(inputSlots[1], -1); //bounds padding
break;
case BoundsSettingMode.Automatic:
cpuMapper.AddExpressionsFromSlot(inputSlots[0], -1); //bounds padding
break;
}
}
return(cpuMapper);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
var localSpace = ((VFXDataParticle)GetData()).space == VFXCoordinateSpace.Local;
if (localSpace && target == VFXDeviceTarget.GPU) // Needs to add locaToWorld matrix
{
var gpuMapper = new VFXExpressionMapper();
if (IsPerCamera(sortCriterion))
{
gpuMapper.AddExpression(VFXBuiltInExpression.LocalToWorld, "unity_ObjectToWorld", -1);
gpuMapper.AddExpression(VFXBuiltInExpression.WorldToLocal, "unity_WorldToObject", -1);
}
if (sortCriterion == SortCriteria.Custom)
{
var sortKeyExp = customSortingSlot.GetExpression();
gpuMapper.AddExpression(sortKeyExp, "sortKey", -1);
}
return(gpuMapper);
}
return(null); // cpu
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
if (!m_encapsulatedOutput)
{
throw new NullReferenceException("Unexpected call of GetExpressionMapper with a null m_encapsulatedOutput");
}
var expressionMapper = m_encapsulatedOutput.GetExpressionMapper(target);
if (target == VFXDeviceTarget.GPU)
{
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);
}
return(expressionMapper);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
return(target == VFXDeviceTarget.CPU ? mapper : null);
}
private void CompileExpressionContext(IEnumerable <VFXContext> contexts, VFXExpressionContextOption options, VFXDeviceTarget target)
{
HashSet <VFXExpression> expressions = new HashSet <VFXExpression>();
var expressionContext = new VFXExpression.Context(options);
var contextsToExpressions = target == VFXDeviceTarget.GPU ? m_ContextsToGPUExpressions : m_ContextsToCPUExpressions;
var expressionsToReduced = target == VFXDeviceTarget.GPU ? m_GPUExpressionsToReduced : m_CPUExpressionsToReduced;
contextsToExpressions.Clear();
expressionsToReduced.Clear();
foreach (var context in contexts)
{
var mapper = context.GetExpressionMapper(target);
if (mapper != null)
{
foreach (var exp in mapper.expressions)
{
expressionContext.RegisterExpression(exp);
}
expressions.UnionWith(mapper.expressions);
contextsToExpressions.Add(context, mapper);
}
}
expressionContext.Compile();
foreach (var exp in expressionContext.RegisteredExpressions)
{
expressionsToReduced.Add(exp, expressionContext.GetReduced(exp));
}
m_Expressions.UnionWith(expressionContext.BuildAllReduced());
foreach (var exp in expressionsToReduced.Values)
{
AddExpressionDataRecursively(m_ExpressionsData, exp);
}
}
private VFXExpressionMapper BuildMapper(VFXContext context, Dictionary <VFXContext, VFXExpressionMapper> dictionnary, VFXDeviceTarget target)
{
VFXExpression.Flags check = target == VFXDeviceTarget.GPU ? VFXExpression.Flags.InvalidOnGPU | VFXExpression.Flags.PerElement : VFXExpression.Flags.InvalidOnCPU;
VFXExpressionMapper outMapper = new VFXExpressionMapper();
VFXExpressionMapper inMapper;
dictionnary.TryGetValue(context, out inMapper);
if (inMapper != null)
{
foreach (var exp in inMapper.expressions)
{
var reduced = GetReduced(exp, target);
if (reduced.Is(check))
{
throw new InvalidOperationException(string.Format("The expression {0} is not valid as it have the invalid flag: {1}", reduced, check));
}
var mappedDataList = inMapper.GetData(exp);
foreach (var mappedData in mappedDataList)
{
outMapper.AddExpression(reduced, mappedData);
}
}
}
return(outMapper);
}
private void CompileExpressionContext(IEnumerable <VFXContext> contexts,
VFXExpressionContextOption options,
VFXDeviceTarget target,
VFXExpression.Flags forbiddenFlags = VFXExpression.Flags.None)
{
var expressionContext = new VFXExpression.Context(options, m_GlobalEventAttributes);
var contextsToExpressions = target == VFXDeviceTarget.GPU ? m_ContextsToGPUExpressions : m_ContextsToCPUExpressions;
var expressionsToReduced = target == VFXDeviceTarget.GPU ? m_GPUExpressionsToReduced : m_CPUExpressionsToReduced;
foreach (var context in contexts)
{
var mapper = context.GetExpressionMapper(target);
if (mapper != null)
{
foreach (var exp in mapper.expressions)
{
expressionContext.RegisterExpression(exp);
}
contextsToExpressions.Add(context, mapper);
}
}
expressionContext.Compile();
foreach (var exp in expressionContext.RegisteredExpressions)
{
var reduced = expressionContext.GetReduced(exp);
if (expressionsToReduced.ContainsKey(exp))
{
if (reduced != expressionsToReduced[exp])
{
throw new InvalidOperationException("Unexpected diverging expression reduction");
}
continue;
}
expressionsToReduced.Add(exp, reduced);
}
var allReduced = expressionContext.BuildAllReduced();
m_Expressions.UnionWith(allReduced);
foreach (var exp in expressionsToReduced.Values)
{
AddExpressionDataRecursively(m_ExpressionsData, exp);
}
var graphicsBufferUsageType = m_GraphicsBufferUsageType
.Concat(expressionContext.GraphicsBufferUsageType)
.GroupBy(o => o.Key).ToArray();
m_GraphicsBufferUsageType.Clear();
foreach (var expression in graphicsBufferUsageType)
{
var types = expression.Select(o => o.Value);
if (types.Count() != 1)
{
throw new InvalidOperationException("Diverging type usage for GraphicsBuffer : " + types.Select(o => o.ToString()).Aggregate((a, b) => a + b));
}
m_GraphicsBufferUsageType.Add(expression.Key, types.First());
}
}
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 override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
PatchInputExpressions();
return(null);
}
public override VFXExpressionMapper GetExpressionMapper(VFXDeviceTarget target)
{
return(null);
}
