protected override sealed VFXExpression[] BuildExpression(VFXExpression[] inputExpression)
{
if (GetNbOutputSlots() == 0)
{
return new VFXExpression[] { }
}
;
var outputSlot = GetOutputSlot(0);
var slots = outputSlot.GetVFXValueTypeSlots();
var buffer = inputExpression[0];
var index = inputExpression[1];
var count = new VFXExpressionBufferCount(buffer);
index = VFXOperatorUtility.ApplyAddressingMode(index, count, mode);
var stride = new VFXExpressionBufferStride(buffer);
var expressions = new List <VFXExpression>();
foreach (var slot in slots)
{
var path = ComputeSlotPath(slot);
var current = new VFXExpressionSampleBuffer(m_Type, slot.valueType, path, buffer, index, stride, count);
expressions.Add(current);
}
return(expressions.ToArray());
}
}
private VFXExpression BuildRandomUIntPerParticle(VFXExpression max, int id)
{
//TODO : Add support of proper integer random
var rand = VFXOperatorUtility.BuildRandom(VFXSeedMode.PerParticle, false, new RandId(this, id));
VFXExpression r = new VFXExpressionCastFloatToUint(rand * new VFXExpressionCastUintToFloat(max));
r = VFXOperatorUtility.ApplyAddressingMode(r, max, VFXOperatorUtility.SequentialAddressingMode.Clamp);
return(r);
}
public static IEnumerable <VFXExpression> SampleEdgeAttribute(VFXExpression source, VFXExpression index, VFXExpression x, VFXOperatorUtility.SequentialAddressingMode mode, IEnumerable <VertexAttribute> vertexAttributes)
{
bool skinnedMesh = source.valueType == UnityEngine.VFX.VFXValueType.SkinnedMeshRenderer;
var mesh = !skinnedMesh ? source : new VFXExpressionMeshFromSkinnedMeshRenderer(source);
var meshIndexCount = new VFXExpressionMeshIndexCount(mesh);
index = VFXOperatorUtility.ApplyAddressingMode(index, meshIndexCount, mode);
return(SampleEdgeAttribute(source, index, x, vertexAttributes));
}
protected override sealed VFXExpression[] BuildExpression(VFXExpression[] inputExpression)
{
var mesh = inputExpression[0].valueType == VFXValueType.Mesh ? inputExpression[0] : new VFXExpressionMeshFromSkinnedMeshRenderer(inputExpression[0]);
var indexFormat = new VFXExpressionMeshIndexFormat(mesh);
var indexCount = new VFXExpressionMeshIndexCount(mesh);
var index = VFXOperatorUtility.ApplyAddressingMode(inputExpression[1], indexCount, VFXOperatorUtility.SequentialAddressingMode.Wrap);
var sampledIndex = new VFXExpressionSampleIndex(mesh, index, indexFormat);
return(new[] { sampledIndex });
}
public static IEnumerable <VFXExpression> SampleTriangleAttribute(VFXExpression source, VFXExpression triangleIndex, VFXExpression coord, VFXOperatorUtility.SequentialAddressingMode mode, SurfaceCoordinates coordMode, IEnumerable <VertexAttribute> vertexAttributes)
{
bool skinnedMesh = source.valueType == UnityEngine.VFX.VFXValueType.SkinnedMeshRenderer;
var mesh = !skinnedMesh ? source : new VFXExpressionMeshFromSkinnedMeshRenderer(source);
var UintThree = VFXOperatorUtility.ThreeExpression[UnityEngine.VFX.VFXValueType.Uint32];
var meshIndexCount = new VFXExpressionMeshIndexCount(mesh);
var triangleCount = meshIndexCount / UintThree;
triangleIndex = VFXOperatorUtility.ApplyAddressingMode(triangleIndex, triangleCount, mode);
return(SampleTriangleAttribute(source, triangleIndex, coord, coordMode, vertexAttributes));
}
protected override sealed VFXExpression[] BuildExpression(VFXExpression[] inputExpression)
{
VFXExpression height = new VFXExpressionTextureHeight(inputExpression[1]);
VFXExpression width = new VFXExpressionTextureWidth(inputExpression[1]);
VFXExpression u_index = VFXOperatorUtility.ApplyAddressingMode(inputExpression[2], new VFXExpressionMin(height * width, inputExpression[0]), mode);
VFXExpression y = u_index / width;
VFXExpression x = u_index - (y * width);
Type outputType = GetOperandType();
var type = typeof(VFXExpressionSampleAttributeMap <>).MakeGenericType(outputType);
var outputExpr = Activator.CreateInstance(type, new object[] { inputExpression[1], x, y });
return(new[] { (VFXExpression)outputExpr });
}
public void CheckExpectedSequence_ApplyAddressingMode([ValueSource("ApplyAddressingModeTestCase_ValueSource")] ApplyAddressingModeTestCase addressingMode)
{
var computedSequence = new uint[addressingMode.expectedSequence.Length];
for (uint index = 0u; index < computedSequence.Length; ++index)
{
var indexExpr = VFXValue.Constant(index);
var countExpr = VFXValue.Constant(addressingMode.count);
var computed = VFXOperatorUtility.ApplyAddressingMode(indexExpr, countExpr, addressingMode.mode);
var context = new VFXExpression.Context(VFXExpressionContextOption.CPUEvaluation);
var result = context.Compile(computed);
computedSequence[index] = result.Get <uint>();
}
for (uint index = 0u; index < computedSequence.Length; ++index)
{
Assert.AreEqual(addressingMode.expectedSequence[index], computedSequence[index]);
}
}
protected override sealed VFXExpression[] BuildExpression(VFXExpression[] inputExpression)
{
var mesh = inputExpression[0];
var meshVertexStride = new VFXExpressionMeshVertexStride(mesh);
var meshVertexCount = new VFXExpressionMeshVertexCount(mesh);
var vertexIndex = VFXOperatorUtility.ApplyAddressingMode(inputExpression[1], meshVertexCount, mode);
var outputExpressions = new List <VFXExpression>();
foreach (var vertexAttribute in GetOutputVertexAttributes())
{
var meshChannelOffset = new VFXExpressionMeshChannelOffset(mesh, VFXValue.Constant <uint>((uint)GetActualVertexAttribute(vertexAttribute)));
var outputType = GetOutputType(vertexAttribute);
VFXExpression sampled = null;
if (vertexAttribute == VertexAttributeFlag.Color)
{
sampled = new VFXExpressionSampleMeshColor(mesh, vertexIndex, meshChannelOffset, meshVertexStride);
}
else if (outputType == typeof(float))
{
sampled = new VFXExpressionSampleMeshFloat(mesh, vertexIndex, meshChannelOffset, meshVertexStride);
}
else if (outputType == typeof(Vector2))
{
sampled = new VFXExpressionSampleMeshFloat2(mesh, vertexIndex, meshChannelOffset, meshVertexStride);
}
else if (outputType == typeof(Vector3))
{
sampled = new VFXExpressionSampleMeshFloat3(mesh, vertexIndex, meshChannelOffset, meshVertexStride);
}
else
{
sampled = new VFXExpressionSampleMeshFloat4(mesh, vertexIndex, meshChannelOffset, meshVertexStride);
}
outputExpressions.Add(sampled);
}
return(outputExpressions.ToArray());
}
protected override sealed VFXExpression[] BuildExpression(VFXExpression[] inputExpression)
{
VFXExpression[] expressions = new VFXExpression[asset.surfaces.Length + 1];
expressions[0] = VFXValue.Constant((uint)asset.PointCount);
for (int i = 0; i < asset.surfaces.Length; i++)
{
var surfaceExpr = VFXValue.Constant(asset.surfaces[i]);
VFXExpression height = new VFXExpressionTextureHeight(surfaceExpr);
VFXExpression width = new VFXExpressionTextureWidth(surfaceExpr);
VFXExpression u_index = VFXOperatorUtility.ApplyAddressingMode(inputExpression[0], new VFXExpressionMin(height * width, expressions[0]), mode);
VFXExpression y = u_index / width;
VFXExpression x = u_index - (y * width);
Type outputType = GetOutputType(asset.surfaces[i]);
var type = typeof(VFXExpressionSampleAttributeMap <>).MakeGenericType(outputType);
var outputExpr = Activator.CreateInstance(type, new object[] { surfaceExpr, x, y });
expressions[i + 1] = (VFXExpression)outputExpr;
}
return(expressions);
}
