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);
}
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 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)
{
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 void FillExpression(VFXGraph graph)
{
var allExposedParameter = graph.children.OfType <VFXParameter>().Where(o => o.exposed);
var expressionsList = new List <VFXExpression>();
foreach (var parameter in allExposedParameter)
{
CollectExposedExpression(expressionsList, parameter.outputSlots[0]);
}
mapper = new VFXExpressionMapper();
for (int i = 0; i < expressionsList.Count; ++i)
{
mapper.AddExpression(expressionsList[i], "ImplicitExposedExpression", i);
}
}
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);
}
}