Half2 Vertex Conversion

2024-12-09 20:21 UTC gpt-4o Open in ChatGPT ↗

My mesh (as a graphicsbuffer) has half2 vertices. so the stride is 4.

ensure this compute shader does all the conversion to/from float properly

#pragma kernel UpdatePositions #pragma kernel Spawn

#define VERTEX_32BIT_STRIDE 3 // float3 position

#include ”../ShaderLibrary/RemapUtils.hlsl” #include ”../ShaderLibrary/SamplingUtils.hlsl” #include ”../ShaderLibrary/SpawnUtils.hlsl”

float DT; float Step; float Multiplier; float3 Bounds_Min; float3 Bounds_Max;

//uint Slice; //uint Range;

int _VertexBufferStride; int _VertexBufferPosAttributeOffset; RWByteAddressBuffer _VertexBuffer;

Texture2D Vel_Tex; SamplerState samplerVel_Tex;

int res2D;

float3 GetPos3D(uint i) { return asfloat(_VertexBuffer.Load3(i * _VertexBufferStride + _VertexBufferPosAttributeOffset)); }

min16float2 GetPos2D(uint i) { return min16float2( asfloat(_VertexBuffer.Load2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset))); }

void SetPos3D(uint i, float3 position) { // Buffer index is accessed by byte offset, so 4 for each 32bit value (float,int,uint…). _VertexBuffer.Store3( i * _VertexBufferStride, asuint( position ) ); }

void SetPos2D(uint i, half2 position) { // Buffer index is accessed by byte offset, so 4 for each 32bit value (float,int,uint…). _VertexBuffer.Store2( i * _VertexBufferStride, asuint( position ) ); }

float3 Random_Position3D(const uint id) { float2 pos = RandomPointInRectangle(id, Bounds_Min.xz, Bounds_Max.xz) ; return float3(pos.x, 0, pos.y); }

half2 Random_Position2D(const uint id) { float2 pos = RandomPointInRectangle(id, Bounds_Min.xz, Bounds_Max.xz) ; return half2(pos.xy); }

[numthreads(32, 32, 1)] void UpdatePositions (uint2 id : SV_DispatchThreadID) { uint ID = id.x + res2D * id.y;

half2 raw2 = GetPos2D(ID);

// float3 raw = GetPos3D(ID);

float2 rm = remap(Bounds_Min.xz, Bounds_Max.xz, 0, 1, float2(raw2.x, raw2.y));

float2 newPos = rm + Multiplier * Integrate_RK4(Vel_Tex, samplerVel_Tex, rm, Step) * DT;

float2 rm2 = remap(0,1,Bounds_Min.xz, Bounds_Max.xz, newPos.xy);

half2 result = half2((half)rm2.x, (half)rm2.y);

SetPos2D(ID, result);

}

[numthreads(32,32,1)] void Spawn (uint2 id : SV_DispatchThreadID) { uint ID = id.x + res2D * id.y;

//SetPos3D(ID,  Random_Position3D(ID));
SetPos2D(ID,  Random_Position2D(ID));

}

Here’s a review and minor adjustments to your compute shader to ensure it handles the conversion between float and half properly, especially given that your vertex buffer contains half2 vertices, and the stride is 4 bytes:

Key Considerations:

half2 Handling:
Ensure the correct alignment when accessing and storing half2 data. The stride and offsets must be carefully aligned with the buffer layout.
Conversion Functions:
Proper use of asfloat, asuint, and ashalf for type conversions to/from the buffer format.
Memory Alignment:
Ensure all memory accesses conform to the stride of 4 bytes per half2.
Precise half Arithmetic:
Use min16float2 or half2 consistently when dealing with half precision variables.

Updated Code Snippet:

Here are the adjustments to your compute shader to improve clarity and precision:

float3 GetPos3D(uint i)
{
    return asfloat(_VertexBuffer.Load3(i * _VertexBufferStride + _VertexBufferPosAttributeOffset));
}

half2 GetPos2D(uint i)
{
    return ashalf(asfloat(_VertexBuffer.Load2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset)));
}

void SetPos3D(uint i, float3 position)
{
    _VertexBuffer.Store3(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, asuint(position));
}

void SetPos2D(uint i, half2 position)
{
    // Convert half2 to uint for storage
    uint packed = asuint(asfloat(position));
    _VertexBuffer.Store2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, packed);
}

float3 Random_Position3D(const uint id)
{
    float2 pos = RandomPointInRectangle(id, Bounds_Min.xz, Bounds_Max.xz);
    return float3(pos.x, 0, pos.y);
}

half2 Random_Position2D(const uint id)
{
    float2 pos = RandomPointInRectangle(id, Bounds_Min.xz, Bounds_Max.xz);
    return half2((half)pos.x, (half)pos.y);
}

[numthreads(32, 32, 1)]
void UpdatePositions(uint2 id : SV_DispatchThreadID)
{
    uint ID = id.x + res2D * id.y;

    half2 raw2 = GetPos2D(ID);

    // Remap position to 0-1 range
    float2 rm = remap(Bounds_Min.xz, Bounds_Max.xz, 0.0, 1.0, float2(raw2));

    // Compute new position using RK4 integration
    float2 newPos = rm + Multiplier * Integrate_RK4(Vel_Tex, samplerVel_Tex, rm, Step) * DT;

    // Remap back to world bounds
    float2 rm2 = remap(0.0, 1.0, Bounds_Min.xz, Bounds_Max.xz, newPos);

    // Store result back as half precision
    half2 result = half2((half)rm2.x, (half)rm2.y);
    SetPos2D(ID, result);
}

[numthreads(32, 32, 1)]
void Spawn(uint2 id : SV_DispatchThreadID)
{
    uint ID = id.x + res2D * id.y;

    // Set a random position in the buffer
    SetPos2D(ID, Random_Position2D(ID));
}

Changes and Improvements:

Consistent Use of half2:
Replaced min16float2 with half2 for clarity and consistency.
Precision Conversion:
Ensured explicit conversion from float to half and vice versa using (half) casts.
Remap Utility:
Used consistent remapping for positions to/from 0-1 space and world space.
Buffer Access Offsets:
Ensured offsets consider _VertexBufferStride and _VertexBufferPosAttributeOffset.
Type Safety:
Avoided mixing asfloat and ashalf directly to ensure intermediate variables maintain clarity.

Testing Advice:

Validate Data Alignment:
Check if _VertexBufferStride and _VertexBufferPosAttributeOffset are correctly set for the data layout.
Debug Outputs:
Use a debug shader or buffer readback to confirm values are stored and retrieved accurately.
Performance Profiling:
Ensure performance is acceptable with half arithmetic, as precision can slightly impact speed on certain hardware.

You’re absolutely correct—ashalf is not a valid function in HLSL. To handle half precision, we need to rely on type casting and proper usage of HLSL’s intrinsic types like half and half2. Here’s an updated version of your shader with corrections:

Updated Shader Code:

float3 GetPos3D(uint i)
{
    return asfloat(_VertexBuffer.Load3(i * _VertexBufferStride + _VertexBufferPosAttributeOffset));
}

half2 GetPos2D(uint i)
{
    // Load data as float2 and cast to half2 for precision
    float2 loadedData = asfloat(_VertexBuffer.Load2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset));
    return half2((half)loadedData.x, (half)loadedData.y);
}

void SetPos3D(uint i, float3 position)
{
    _VertexBuffer.Store3(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, asuint(position));
}

void SetPos2D(uint i, half2 position)
{
    // Convert half2 to float2 before storing
    float2 converted = float2(position.x, position.y);
    _VertexBuffer.Store2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, asuint(converted));
}

float3 Random_Position3D(const uint id)
{
    float2 pos = RandomPointInRectangle(id, Bounds_Min.xz, Bounds_Max.xz);
    return float3(pos.x, 0, pos.y);
}

half2 Random_Position2D(const uint id)
{
    float2 pos = RandomPointInRectangle(id, Bounds_Min.xz, Bounds_Max.xz);
    return half2((half)pos.x, (half)pos.y);
}

[numthreads(32, 32, 1)]
void UpdatePositions(uint2 id : SV_DispatchThreadID)
{
    uint ID = id.x + res2D * id.y;

    half2 raw2 = GetPos2D(ID);

    // Remap position to 0-1 range
    float2 rm = remap(Bounds_Min.xz, Bounds_Max.xz, 0.0, 1.0, float2(raw2));

    // Compute new position using RK4 integration
    float2 newPos = rm + Multiplier * Integrate_RK4(Vel_Tex, samplerVel_Tex, rm, Step) * DT;

    // Remap back to world bounds
    float2 rm2 = remap(0.0, 1.0, Bounds_Min.xz, Bounds_Max.xz, newPos);

    // Store result back as half precision
    half2 result = half2((half)rm2.x, (half)rm2.y);
    SetPos2D(ID, result);
}

[numthreads(32, 32, 1)]
void Spawn(uint2 id : SV_DispatchThreadID)
{
    uint ID = id.x + res2D * id.y;

    // Set a random position in the buffer
    SetPos2D(ID, Random_Position2D(ID));
}

Explanation of Fixes:

ashalf Removal: Replaced all references to ashalf with explicit casting to half. For example:
```
half2((half)loadedData.x, (half)loadedData.y);
```
Storing half2 Data: Since half is not directly supported by RWByteAddressBuffer, the half2 values are converted to float2 before storing:
```
float2 converted = float2(position.x, position.y);
```

Loading half2 Data: Data is loaded as float2 and converted to half2:

float2 loadedData = asfloat(_VertexBuffer.Load2(...));
return half2((half)loadedData.x, (half)loadedData.y);

Consistency: All operations on half-precision data now use half2 explicitly, with casting where necessary.
Alignment: The stride and offset calculations remain consistent with your data layout.

Testing Recommendations:

Buffer Alignment:
Ensure the buffer layout aligns with _VertexBufferStride and _VertexBufferPosAttributeOffset to prevent data corruption.
Debugging Precision:
If you encounter issues with precision, temporarily store and retrieve positions as float2 to isolate the problem.
Hardware Validation:
Test the shader on target hardware to ensure half operations behave as expected, particularly for mobile GPUs or other hardware with limited floating-point precision.

This approach ensures correctness while maintaining the required half precision for your shader operations.