556 lines
20 KiB
HLSL
556 lines
20 KiB
HLSL
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
// Buffer format (sizes in bytes):
|
|
//
|
|
// -- START HEADER --
|
|
// PackedExecutionFlagAndNumData (4)
|
|
// For each data:
|
|
// TypeId (4)
|
|
// Attribute Count (4)
|
|
// Element Count (4)
|
|
// For attribute ID 0 to MAX_NUM_ATTR:
|
|
// PackedIdAndStride (4)
|
|
// AttributeElementStartAddress (4)
|
|
// -- END HEADER --
|
|
// For each data:
|
|
// For each present attribute:
|
|
// <Packed element data> (element count * stride)
|
|
|
|
RWByteAddressBuffer {DataInterfaceName}_DataCollectionBuffer;
|
|
|
|
// Multiplier that can be configured on output pins.
|
|
uint {DataInterfaceName}_ElementCountMultiplier;
|
|
|
|
RWStructuredBuffer<uint> {DataInterfaceName}_ElementCountersBuffer;
|
|
uint {DataInterfaceName}_ElementCountersPresent;
|
|
|
|
// #################### HEADER READERS ##########################
|
|
|
|
uint GetNumData_{DataInterfaceName}()
|
|
{
|
|
// We use the most significant bit of NumData to store the KernelExecuted flag.
|
|
return {DataInterfaceName}_DataCollectionBuffer.Load(0) & ~PCG_KERNEL_EXECUTED_FLAG;
|
|
}
|
|
|
|
uint GetNumElements_{DataInterfaceName}(uint InDataIndex)
|
|
{
|
|
const uint ReadAddress =
|
|
PCG_DATA_COLLECTION_HEADER_SIZE_BYTES +
|
|
InDataIndex * PCG_DATA_HEADER_SIZE_BYTES +
|
|
/*TypeId*/4 + /*Attribute Count*/4;
|
|
|
|
return {DataInterfaceName}_DataCollectionBuffer.Load(ReadAddress);
|
|
}
|
|
|
|
int AddToElementCounterInternal_{DataInterfaceName}(uint InDataIndex, uint InElementCount)
|
|
{
|
|
if ({DataInterfaceName}_ElementCountersPresent == 0)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
uint ValueBefore;
|
|
InterlockedAdd({DataInterfaceName}_ElementCountersBuffer[InDataIndex], InElementCount, ValueBefore);
|
|
|
|
return (int)ValueBefore;
|
|
}
|
|
|
|
bool GetThreadData_{DataInterfaceName}(uint InThreadIndex, out uint OutDataIndex, out uint OutElementIndex)
|
|
{
|
|
int ElementIndex = (int)InThreadIndex;
|
|
|
|
const uint NumData = GetNumData_{DataInterfaceName}();
|
|
for (uint DataIndex = 0; DataIndex < NumData; ++DataIndex)
|
|
{
|
|
const int ElemCount = (int)GetNumElements_{DataInterfaceName}(DataIndex);
|
|
|
|
if (ElementIndex < ElemCount)
|
|
{
|
|
OutDataIndex = DataIndex;
|
|
OutElementIndex = (uint)ElementIndex;
|
|
return true;
|
|
}
|
|
|
|
ElementIndex -= ElemCount;
|
|
}
|
|
|
|
OutDataIndex = (uint)-1;
|
|
OutElementIndex = (uint)-1;
|
|
return false;
|
|
}
|
|
|
|
uint GetNumElements_{DataInterfaceName}()
|
|
{
|
|
uint NumElements = 0;
|
|
|
|
const uint NumData = GetNumData_{DataInterfaceName}();
|
|
for (uint DataIndex = 0; DataIndex < NumData; ++DataIndex)
|
|
{
|
|
NumElements += GetNumElements_{DataInterfaceName}(DataIndex);
|
|
}
|
|
|
|
return NumElements;
|
|
}
|
|
|
|
// #################### INTERNAL HELPERS ##########################
|
|
|
|
uint LoadBufferInternal_{DataInterfaceName}(uint Address)
|
|
{
|
|
return {DataInterfaceName}_DataCollectionBuffer.Load(Address);
|
|
}
|
|
|
|
void StoreBufferInternal_{DataInterfaceName}(uint Address, uint Value)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store(Address, Value);
|
|
}
|
|
|
|
uint GetFirstElementAddressInternal_{DataInterfaceName}(uint InDataIndex, int InAttributeId)
|
|
{
|
|
const uint ReadAddress =
|
|
PCG_DATA_COLLECTION_HEADER_SIZE_BYTES +
|
|
InDataIndex * PCG_DATA_HEADER_SIZE_BYTES +
|
|
/*TypeId*/4 + /*Attribute Count*/4 + /*Element Count*/4 +
|
|
InAttributeId * PCG_ATTRIBUTE_HEADER_SIZE_BYTES +
|
|
/*PackedAttributeIdAndStride*/4;
|
|
|
|
return {DataInterfaceName}_DataCollectionBuffer.Load(ReadAddress);
|
|
}
|
|
|
|
uint GetAttributeStrideInternal_{DataInterfaceName}(uint InDataIndex, int InAttributeId)
|
|
{
|
|
const uint ReadAddress =
|
|
PCG_DATA_COLLECTION_HEADER_SIZE_BYTES +
|
|
InDataIndex * PCG_DATA_HEADER_SIZE_BYTES +
|
|
/*TypeId*/4 + /*Attribute Count*/4 + /*Element Count*/4 +
|
|
InAttributeId * PCG_ATTRIBUTE_HEADER_SIZE_BYTES;
|
|
|
|
const uint PackedAttributeIdAndStride = {DataInterfaceName}_DataCollectionBuffer.Load(ReadAddress);
|
|
return PackedAttributeIdAndStride & (0xFFFFFFFF >> 24);
|
|
}
|
|
|
|
uint GetElementAddressInternal_{DataInterfaceName}(uint InDataIndex, uint InElementIndex, int InAttributeId)
|
|
{
|
|
const uint FirstElementAddress = GetFirstElementAddressInternal_{DataInterfaceName}(InDataIndex, InAttributeId);
|
|
const uint AttributeStride = GetAttributeStrideInternal_{DataInterfaceName}(InDataIndex, InAttributeId);
|
|
return InElementIndex * AttributeStride + FirstElementAddress;
|
|
}
|
|
|
|
uint GetDataNumAttributesInternal_{DataInterfaceName}(uint InDataIndex)
|
|
{
|
|
const uint ReadAddress =
|
|
PCG_DATA_COLLECTION_HEADER_SIZE_BYTES +
|
|
InDataIndex * PCG_DATA_HEADER_SIZE_BYTES +
|
|
/*TypeId*/4;
|
|
|
|
return {DataInterfaceName}_DataCollectionBuffer.Load(ReadAddress);
|
|
}
|
|
|
|
void SetAsExecutedInternal_{DataInterfaceName}()
|
|
{
|
|
// We use the most significant bit of NumData to store the KernelExecuted flag
|
|
const uint NumData = GetNumData_{DataInterfaceName}();
|
|
{DataInterfaceName}_DataCollectionBuffer.Store(0, NumData | PCG_KERNEL_EXECUTED_FLAG);
|
|
}
|
|
|
|
// #################### ATTRIBUTE GETTERS ##########################
|
|
|
|
bool GetBool_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
return AttributeAddress > 0 && {DataInterfaceName}_DataCollectionBuffer.Load(AttributeAddress + ElementIndex * 1 * 4) != 0;
|
|
}
|
|
|
|
int GetInt_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
return AttributeAddress > 0 ? asint({DataInterfaceName}_DataCollectionBuffer.Load(AttributeAddress + ElementIndex * 1 * 4)) : 0;
|
|
}
|
|
|
|
int GetUint_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
return AttributeAddress > 0 ? {DataInterfaceName}_DataCollectionBuffer.Load(AttributeAddress + ElementIndex * 1 * 4) : 0;
|
|
}
|
|
|
|
float GetFloat_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
return AttributeAddress > 0 ? asfloat({DataInterfaceName}_DataCollectionBuffer.Load(AttributeAddress + ElementIndex * 1 * 4)) : 0.0f;
|
|
}
|
|
|
|
float2 GetFloat2_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
return AttributeAddress > 0 ? asfloat({DataInterfaceName}_DataCollectionBuffer.Load2(AttributeAddress + ElementIndex * 2 * 4)) : (float2)0;
|
|
}
|
|
|
|
float3 GetFloat3_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
return AttributeAddress > 0 ? asfloat({DataInterfaceName}_DataCollectionBuffer.Load3(AttributeAddress + ElementIndex * 3 * 4)) : (float3)0;
|
|
}
|
|
|
|
float4 GetFloat4_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
return AttributeAddress > 0 ? asfloat({DataInterfaceName}_DataCollectionBuffer.Load4(AttributeAddress + ElementIndex * 4 * 4)) : (float4)0;
|
|
}
|
|
|
|
float3 GetRotator_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
return GetFloat3_{DataInterfaceName}(DataIndex, ElementIndex, AttributeId);
|
|
}
|
|
|
|
float4 GetQuat_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
return GetFloat4_{DataInterfaceName}(DataIndex, ElementIndex, AttributeId);
|
|
}
|
|
|
|
float4x4 GetTransform_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress == 0)
|
|
{
|
|
return (float4x4)0;
|
|
}
|
|
|
|
const uint StartAddress = ElementIndex * 16 * 4 + AttributeAddress;
|
|
|
|
return float4x4(
|
|
asfloat({DataInterfaceName}_DataCollectionBuffer.Load4(StartAddress)),
|
|
asfloat({DataInterfaceName}_DataCollectionBuffer.Load4(StartAddress + 4 * 4)),
|
|
asfloat({DataInterfaceName}_DataCollectionBuffer.Load4(StartAddress + 8 * 4)),
|
|
asfloat({DataInterfaceName}_DataCollectionBuffer.Load4(StartAddress + 12 * 4))
|
|
);
|
|
}
|
|
|
|
int GetStringKey_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
// String keys are represented as ints.
|
|
return GetInt_{DataInterfaceName}(DataIndex, ElementIndex, AttributeId);
|
|
}
|
|
|
|
// TODO: left as uint2 which we locked into for 5.5.0. Future version should change this to int.
|
|
uint2 GetName_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId)
|
|
{
|
|
// Names are represented as ints.
|
|
return uint2((uint)GetInt_{DataInterfaceName}(DataIndex, ElementIndex, AttributeId), 0u);
|
|
}
|
|
|
|
uint GetElementCountMultiplier_{DataInterfaceName}()
|
|
{
|
|
return {DataInterfaceName}_ElementCountMultiplier;
|
|
}
|
|
|
|
// #################### ATTRIBUTE SETTERS ##########################
|
|
|
|
void SetBool_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, bool Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store(AttributeAddress + ElementIndex * 1 * 4, Value ? 1u : 0u);
|
|
}
|
|
}
|
|
|
|
void SetInt_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, int Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store(AttributeAddress + ElementIndex * 1 * 4, asuint(Value));
|
|
}
|
|
}
|
|
|
|
void SetUint_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, uint Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store(AttributeAddress + ElementIndex * 1 * 4, Value);
|
|
}
|
|
}
|
|
|
|
void SetFloat_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, float Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store(AttributeAddress + ElementIndex * 1 * 4, asuint(Value));
|
|
}
|
|
}
|
|
|
|
void SetFloat2_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, float2 Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store2(AttributeAddress + ElementIndex * 2 * 4, asuint(Value));
|
|
}
|
|
}
|
|
|
|
void SetFloat3_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, float3 Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store3(AttributeAddress + ElementIndex * 3 * 4, asuint(Value));
|
|
}
|
|
}
|
|
|
|
void SetFloat4_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, float4 Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store4(AttributeAddress + ElementIndex * 4 * 4, asuint(Value));
|
|
}
|
|
}
|
|
|
|
void SetRotator_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, float3 Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store3(AttributeAddress + ElementIndex * 3 * 4, asuint(Value));
|
|
}
|
|
}
|
|
|
|
void SetQuat_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, float4 Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
{DataInterfaceName}_DataCollectionBuffer.Store4(AttributeAddress + ElementIndex * 4 * 4, asuint(Value));
|
|
}
|
|
}
|
|
|
|
void SetTransform_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, float4x4 Value)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
if (AttributeAddress > 0)
|
|
{
|
|
const uint StartAddress = ElementIndex * 16 * 4 + AttributeAddress;
|
|
{DataInterfaceName}_DataCollectionBuffer.Store4(StartAddress, asuint(Value[0]));
|
|
{DataInterfaceName}_DataCollectionBuffer.Store4(StartAddress + 4 * 4, asuint(Value[1]));
|
|
{DataInterfaceName}_DataCollectionBuffer.Store4(StartAddress + 8 * 4, asuint(Value[2]));
|
|
{DataInterfaceName}_DataCollectionBuffer.Store4(StartAddress + 12 * 4, asuint(Value[3]));
|
|
}
|
|
}
|
|
|
|
void SetStringKey_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, int Value)
|
|
{
|
|
// String keys are represented as ints.
|
|
SetInt_{DataInterfaceName}(DataIndex, ElementIndex, AttributeId, Value);
|
|
}
|
|
|
|
// TODO: Value left as uint2 which we locked into for 5.5.0. Future version should change this to int.
|
|
void SetName_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, uint2 Value)
|
|
{
|
|
// Names are represented as ints.
|
|
SetInt_{DataInterfaceName}(DataIndex, ElementIndex, AttributeId, (int)Value.x);
|
|
}
|
|
|
|
// #################### ATOMICS ##########################
|
|
|
|
// Returns value of attribute before incrementing.
|
|
int AtomicAddInt_{DataInterfaceName}(uint DataIndex, uint ElementIndex, int AttributeId, int ValueToAdd)
|
|
{
|
|
const uint AttributeAddress = GetFirstElementAddressInternal_{DataInterfaceName}(DataIndex, AttributeId);
|
|
|
|
if (AttributeAddress > 0)
|
|
{
|
|
uint OriginalValue;
|
|
{DataInterfaceName}_DataCollectionBuffer.InterlockedAdd(AttributeAddress + ElementIndex * 1 * 4, (uint)ValueToAdd, OriginalValue);
|
|
|
|
return (int)OriginalValue;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// #################### POINT ATTRIBUTE GETTERS ##########################
|
|
|
|
float3 GetPosition_{DataInterfaceName}(uint DataIndex, uint ElementIndex)
|
|
{
|
|
return GetFloat3_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_POSITION_ID);
|
|
}
|
|
|
|
float4 GetRotation_{DataInterfaceName}(uint DataIndex, uint ElementIndex)
|
|
{
|
|
return GetFloat4_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_ROTATION_ID);
|
|
}
|
|
|
|
float3 GetScale_{DataInterfaceName}(uint DataIndex, uint ElementIndex)
|
|
{
|
|
return GetFloat3_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_SCALE_ID);
|
|
}
|
|
|
|
float3 GetBoundsMin_{DataInterfaceName}(uint DataIndex, uint ElementIndex)
|
|
{
|
|
return GetFloat3_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_BOUNDS_MIN_ID);
|
|
}
|
|
|
|
float3 GetBoundsMax_{DataInterfaceName}(uint DataIndex, uint ElementIndex)
|
|
{
|
|
return GetFloat3_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_BOUNDS_MAX_ID);
|
|
}
|
|
|
|
float4 GetColor_{DataInterfaceName}(uint DataIndex, uint ElementIndex)
|
|
{
|
|
return GetFloat4_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_COLOR_ID);
|
|
}
|
|
|
|
float GetDensity_{DataInterfaceName}(uint DataIndex, uint ElementIndex)
|
|
{
|
|
return GetFloat_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_DENSITY_ID);
|
|
}
|
|
|
|
float GetSteepness_{DataInterfaceName}(uint DataIndex, uint ElementIndex)
|
|
{
|
|
return GetFloat_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_STEEPNESS_ID);
|
|
}
|
|
|
|
uint GetSeed_{DataInterfaceName}(uint DataIndex, uint ElementIndex)
|
|
{
|
|
return GetUint_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_SEED_ID);
|
|
}
|
|
|
|
float4x4 GetPointTransform_{DataInterfaceName}(uint InDataIndex, uint InElementIndex)
|
|
{
|
|
const FQuat Rotation = GetRotation_{DataInterfaceName}(InDataIndex, InElementIndex);
|
|
const half3x3 RotationMatrix = QuatToMatrix(Rotation);
|
|
const float3 Position = GetPosition_{DataInterfaceName}(InDataIndex, InElementIndex);
|
|
const float3 Scale = GetScale_{DataInterfaceName}(InDataIndex, InElementIndex);
|
|
|
|
const float3 Axis0 = Scale.x * RotationMatrix[0];
|
|
const float3 Axis1 = Scale.y * RotationMatrix[1];
|
|
const float3 Axis2 = Scale.z * RotationMatrix[2];
|
|
|
|
return float4x4(
|
|
Axis0.x, Axis1.x, Axis2.x, Position.x,
|
|
Axis0.y, Axis1.y, Axis2.y, Position.y,
|
|
Axis0.z, Axis1.z, Axis2.z, Position.z,
|
|
(float3)0.0, 1.0);
|
|
}
|
|
|
|
bool IsPointRemoved_{DataInterfaceName}(uint InDataIndex, uint InElementIndex)
|
|
{
|
|
return GetDensity_{DataInterfaceName}(InDataIndex, InElementIndex) == PCG_INVALID_DENSITY;
|
|
}
|
|
|
|
// #################### POINT ATTRIBUTE SETTERS ##########################
|
|
|
|
void SetPosition_{DataInterfaceName}(uint DataIndex, uint ElementIndex, float3 Position)
|
|
{
|
|
SetFloat3_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_POSITION_ID, Position);
|
|
}
|
|
|
|
void SetRotation_{DataInterfaceName}(uint DataIndex, uint ElementIndex, float4 Rotation)
|
|
{
|
|
SetFloat4_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_ROTATION_ID, Rotation);
|
|
}
|
|
|
|
void SetScale_{DataInterfaceName}(uint DataIndex, uint ElementIndex, float3 Scale)
|
|
{
|
|
SetFloat3_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_SCALE_ID, Scale);
|
|
}
|
|
|
|
void SetBoundsMin_{DataInterfaceName}(uint DataIndex, uint ElementIndex, float3 BoundsMin)
|
|
{
|
|
SetFloat3_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_BOUNDS_MIN_ID, BoundsMin);
|
|
}
|
|
|
|
void SetBoundsMax_{DataInterfaceName}(uint DataIndex, uint ElementIndex, float3 BoundsMax)
|
|
{
|
|
SetFloat3_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_BOUNDS_MAX_ID, BoundsMax);
|
|
}
|
|
|
|
void SetColor_{DataInterfaceName}(uint DataIndex, uint ElementIndex, float4 Color)
|
|
{
|
|
SetFloat4_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_COLOR_ID, Color);
|
|
}
|
|
|
|
void SetDensity_{DataInterfaceName}(uint DataIndex, uint ElementIndex, float Density)
|
|
{
|
|
SetFloat_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_DENSITY_ID, Density);
|
|
}
|
|
|
|
void SetSteepness_{DataInterfaceName}(uint DataIndex, uint ElementIndex, float Steepness)
|
|
{
|
|
SetFloat_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_STEEPNESS_ID, Steepness);
|
|
}
|
|
|
|
void SetSeed_{DataInterfaceName}(uint DataIndex, uint ElementIndex, uint Seed)
|
|
{
|
|
SetUint_{DataInterfaceName}(DataIndex, ElementIndex, PCG_POINT_SEED_ID, Seed);
|
|
}
|
|
|
|
void SetPointTransform_{DataInterfaceName}(uint InDataIndex, uint InElementIndex, float4x4 Transform)
|
|
{
|
|
const float3 Scale = float3(length(Transform._m00_m10_m20), length(Transform._m01_m11_m21), length(Transform._m02_m12_m22));
|
|
SetScale_{DataInterfaceName}(InDataIndex, InElementIndex, Scale);
|
|
|
|
// Assumes Transform axes have the correct handedness. We could do more work to fix this up too if required.
|
|
float3x3 RotationMatix = (float3x3)transpose(Transform);
|
|
// Required unfortunately, QuatFromMatrix expects orthonormalized.
|
|
RotationMatix[0] /= Scale.x;
|
|
RotationMatix[1] /= Scale.y;
|
|
RotationMatix[2] /= Scale.z;
|
|
const FQuat Rotation = QuatFromMatrix(RotationMatix);
|
|
SetRotation_{DataInterfaceName}(InDataIndex, InElementIndex, Rotation);
|
|
|
|
const float3 Position = Transform._m03_m13_m23;
|
|
SetPosition_{DataInterfaceName}(InDataIndex, InElementIndex, Position);
|
|
}
|
|
|
|
void RemovePoint_{DataInterfaceName}(uint InDataIndex, uint InElementIndex)
|
|
{
|
|
SetDensity_{DataInterfaceName}(InDataIndex, InElementIndex, PCG_INVALID_DENSITY);
|
|
}
|
|
|
|
// Initialize a single point with default values.
|
|
void InitializePoint_{DataInterfaceName}(uint InDataIndex, uint InElementIndex)
|
|
{
|
|
SetPosition_{DataInterfaceName}(InDataIndex, InElementIndex, 0.0f);
|
|
SetRotation_{DataInterfaceName}(InDataIndex, InElementIndex, float4(0.0f, 0.0f, 0.0f, 1.0f));
|
|
SetScale_{DataInterfaceName}(InDataIndex, InElementIndex, 1.0f);
|
|
SetBoundsMin_{DataInterfaceName}(InDataIndex, InElementIndex, -50.0f);
|
|
SetBoundsMax_{DataInterfaceName}(InDataIndex, InElementIndex, 50.0f);
|
|
SetColor_{DataInterfaceName}(InDataIndex, InElementIndex, 1.0f);
|
|
SetDensity_{DataInterfaceName}(InDataIndex, InElementIndex, 1.0f);
|
|
SetSeed_{DataInterfaceName}(InDataIndex, InElementIndex, 42);
|
|
SetSteepness_{DataInterfaceName}(InDataIndex, InElementIndex, 1.0f);
|
|
|
|
int NumAttributesRemaining = (int)GetDataNumAttributesInternal_{DataInterfaceName}(InDataIndex);
|
|
|
|
for (int AttributeId = PCG_NUM_RESERVED_ATTRS; AttributeId < PCG_MAX_NUM_ATTRS; ++AttributeId)
|
|
{
|
|
const uint Stride = GetAttributeStrideInternal_{DataInterfaceName}(InDataIndex, AttributeId);
|
|
|
|
if (Stride == 0)
|
|
{
|
|
// No output attribute to write to.
|
|
continue;
|
|
}
|
|
|
|
// We don't bother checking element address is nonzero as we already check Stride above.
|
|
const uint FirstElementAddress = GetFirstElementAddressInternal_{DataInterfaceName}(InDataIndex, AttributeId);
|
|
const uint ElementAddress = InElementIndex * Stride + FirstElementAddress;
|
|
|
|
for (uint Offset = 0; Offset < Stride; Offset += 4)
|
|
{
|
|
// TODO: In future could upload actual default values for attributes rather than 0-initializing.
|
|
StoreBufferInternal_{DataInterfaceName}(ElementAddress + Offset, 0u);
|
|
}
|
|
|
|
if (--NumAttributesRemaining <= 0)
|
|
{
|
|
// Early-out when we've looked at all the possible attributes
|
|
break;
|
|
}
|
|
}
|
|
}
|