Half2 to Float Conversion

2024-12-09 20:24 UTC o1 Open in ChatGPT ↗

You

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));

}

ChatGPT

Below is a more robust version of your compute shader that properly handles conversion between half-precision floats (half2) stored in a single 32-bit value (4 bytes) and full-precision floats (float2) in HLSL. The key points are:

1. Byte Addressing:
   Since you are using a RWByteAddressBuffer and each vertex position is stored as a half2 (2 x 16-bit floats), that totals 4 bytes per vertex. Make sure that _VertexBufferStride and _VertexBufferPosAttributeOffset are in bytes, not elements.

2. Loading/Storing Half Precision:
   The RWByteAddressBuffer.Load2() and Store2() instructions read/write two 32-bit values (8 bytes total), which is too large for a single half2 (which fits in just one 32-bit word). Instead, use Load() and Store() for a single 32-bit value.

3. Packing and Unpacking Half2:
   You cannot directly store or load half2 as a native type in a ByteAddressBuffer. You must pack/unpack the two half values into a single uint (32-bit) before storage/retrieval.

   • Use f32tof16() to convert a float to a 16-bit half representation (stored in a uint16).
   • Use f16tof32() to convert a 16-bit half representation back to a float.

4. Ensuring Proper Conversion:
   When retrieving positions, read the 32-bit packed value, extract each 16-bit half, then convert them to float. When setting positions, convert floats to half, pack them into a single uint, and write to the buffer.

Revised Shader Code:

#pragma kernel UpdatePositions
#pragma kernel Spawn

#define VERTEX_32BIT_STRIDE 3 // For reference if needed, but here we have half2 = 4 bytes

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

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

int _VertexBufferStride;              // in bytes
int _VertexBufferPosAttributeOffset;  // in bytes
RWByteAddressBuffer _VertexBuffer;

Texture2D<float2> Vel_Tex;
SamplerState samplerVel_Tex;

int res2D;

float2 RemapTo01(float2 val, float2 minv, float2 maxv)
{
    return (val - minv) / (maxv - minv);
}

float2 RemapFrom01(float2 val, float2 minv, float2 maxv)
{
    return val * (maxv - minv) + minv;
}

// Helper functions to handle half2 <-> float2 storage
min16float2 GetPos2D(uint i)
{
    // We have one half2 (4 bytes) per vertex, so use Load() which returns a single uint (32 bits)
    uint packed = _VertexBuffer.Load(i * _VertexBufferStride + _VertexBufferPosAttributeOffset);

    // Extract half floats
    uint16 h0 = (uint16)(packed & 0xFFFF);
    uint16 h1 = (uint16)((packed >> 16) & 0xFFFF);

    float x = f16tof32(h0);
    float y = f16tof32(h1);

    return min16float2(x, y);
}

void SetPos2D(uint i, half2 position)
{
    // Convert half2 to two half floats (uint16)
    uint16 h0 = f32tof16((float)position.x);
    uint16 h1 = f32tof16((float)position.y);

    // Pack into a single uint
    uint packed = (uint)h0 | ((uint)h1 << 16);

    _VertexBuffer.Store(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, packed);
}

// If needed, for a 3D position stored as float3 (12 bytes), you'd use Load3/Store3.
// But for half2, we do not need these 3D helpers. They are provided here for reference.
//float3 GetPos3D(uint i)
//{
//    return asfloat(_VertexBuffer.Load3(i * _VertexBufferStride + _VertexBufferPosAttributeOffset));
//}
//
//void SetPos3D(uint i, float3 position)
//{
//    _VertexBuffer.Store3(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, 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;

    // Load current position (in domain Bounds_Min.xz - Bounds_Max.xz)
    half2 currentPos_half = GetPos2D(ID);
    float2 currentPos = (float2)currentPos_half;

    // Remap from [Bounds_Min.xz, Bounds_Max.xz] to [0,1]
    float2 rm = RemapTo01(currentPos, Bounds_Min.xz, Bounds_Max.xz);

    // Integrate velocity field
    float2 vel = Integrate_RK4(Vel_Tex, samplerVel_Tex, rm, Step);
    float2 newPos_01 = rm + vel * Multiplier * DT; // Move in normalized [0,1] space

    // Remap back to world space
    float2 newPos = RemapFrom01(newPos_01, Bounds_Min.xz, Bounds_Max.xz);

    // Store new position as half2
    SetPos2D(ID, half2(newPos));
}

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

    // Initialize positions
    //SetPos3D(ID, Random_Position3D(ID));
    SetPos2D(ID, Random_Position2D(ID));
}

Key Changes:

• Switched to _VertexBuffer.Load() and _VertexBuffer.Store() for half2 since we only need one 32-bit value per vertex.
• Explicitly packed and unpacked half2 data using f32tof16() and f16tof32().
• Ensured all remapping and conversions are done in float2, with final storage as half2.

This ensures correct and precise handling of half2 vertex data in the compute shader.

You

uint16 doesnt exist in hlsl

ChatGPT

HLSL (particularly older versions or common DirectX HLSL) does not define a uint16 type. Instead, you must store and manipulate half-precision floats using 32-bit integers (uint) and carefully pack/unpack the 16-bit halves using bitwise operations.

Here’s how you can pack and unpack two half floats (from and to float2 or half2) using only uint:

Converting float2 to a single uint:

1. Convert each float component to a half using f32tof16().
   f32tof16(floatVal) returns a uint whose lower 16 bits contain the half-float representation, and the upper 16 bits are zero.

2. Pack two half floats into a single uint by shifting and OR-ing:

   float2 pos = ...; // your float2 position
   uint halfX = f32tof16(pos.x);
   uint halfY = f32tof16(pos.y);
   
   uint packed = (halfX & 0xFFFF) | ((halfY & 0xFFFF) << 16);

Converting a single uint back to float2:

1. Extract the two halves by masking and shifting:

   uint packed = ...; // your packed uint
   uint halfX = packed & 0xFFFF;
   uint halfY = (packed >> 16) & 0xFFFF;

2. Convert them back to full floats:

   float x = f16tof32(halfX);
   float y = f16tof32(halfY);
   
   float2 pos = float2(x, y);

Full Example in Your Shader:

// Fetch half2 position from RWByteAddressBuffer
float2 GetPos2D(uint i)
{
    uint packed = _VertexBuffer.Load(i * _VertexBufferStride + _VertexBufferPosAttributeOffset);
    uint halfX = packed & 0xFFFF;
    uint halfY = (packed >> 16) & 0xFFFF;

    float x = f16tof32(halfX);
    float y = f16tof32(halfY);

    return float2(x, y);
}

// Store half2 position into RWByteAddressBuffer
void SetPos2D(uint i, float2 position)
{
    uint halfX = f32tof16(position.x);
    uint halfY = f32tof16(position.y);

    uint packed = (halfX & 0xFFFF) | ((halfY & 0xFFFF) << 16);

    _VertexBuffer.Store(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, packed);
}

This approach ensures no uint16 type is needed. You simply work with uint and use bitwise operations to handle the packing and unpacking of half-precision floats.

You

create function for 3d half precision vertices, and a robust way to choose between 3d half, 3d float and 2d half

ChatGPT

Below is an example of how you can implement and organize helper functions to handle multiple vertex formats: half-precision 2D, half-precision 3D, and full-precision 3D. The key points are:

• Use a format indicator (e.g., _FormatType) to choose which functions to call.
• For half-precision storage, use f32tof16() and f16tof32() and pack/unpack the data into uint values using bitwise operations.
• For 2D half: 1 uint (4 bytes)
• For 3D half: 2 uint (8 bytes total), with 3 halves packed plus 16 bits of padding.
• For 3D float: 3 uint (12 bytes), using Load3() and Store3() directly.

HLSL Example:

// Format types (can be set from C# code or a shader param)
#define FORMAT_2D_HALF  0
#define FORMAT_3D_FLOAT 1
#define FORMAT_3D_HALF  2

// Chosen format
int _FormatType;

int _VertexBufferStride;              // in bytes
int _VertexBufferPosAttributeOffset;  // in bytes
RWByteAddressBuffer _VertexBuffer;

//-------------------------
// 2D Half-Precision (half2)
//-------------------------
// Each vertex: half2 = 2 * 16 bits = 32 bits = 1 uint
float2 GetPos2D_Half(uint i)
{
    uint packed = _VertexBuffer.Load(i * _VertexBufferStride + _VertexBufferPosAttributeOffset);
    uint halfX = packed & 0xFFFF;
    uint halfY = (packed >> 16) & 0xFFFF;

    float x = f16tof32(halfX);
    float y = f16tof32(halfY);
    return float2(x, y);
}

void SetPos2D_Half(uint i, float2 position)
{
    uint halfX = f32tof16(position.x);
    uint halfY = f32tof16(position.y);
    uint packed = (halfX & 0xFFFF) | ((halfY & 0xFFFF) << 16);

    _VertexBuffer.Store(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, packed);
}

//-------------------------
// 3D Half-Precision (half3)
//-------------------------
// Each vertex: half3 = 3 * 16 bits = 48 bits. To align to 32-bit boundaries,
// store as 8 bytes = 2 uints with the last 16 bits as padding.
// Layout: [hX,hY] in first uint, [hZ,padding] in second uint.
// total = 8 bytes per vertex.
float3 GetPos3D_Half(uint i)
{
    uint2 packed = _VertexBuffer.Load2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset);

    uint halfX = packed.x & 0xFFFF;
    uint halfY = (packed.x >> 16) & 0xFFFF;
    uint halfZ = packed.y & 0xFFFF;  // upper 16 bits of packed.y are unused/padding

    float x = f16tof32(halfX);
    float y = f16tof32(halfY);
    float z = f16tof32(halfZ);
    return float3(x, y, z);
}

void SetPos3D_Half(uint i, float3 position)
{
    uint halfX = f32tof16(position.x);
    uint halfY = f32tof16(position.y);
    uint halfZ = f32tof16(position.z);

    uint packed1 = (halfX & 0xFFFF) | ((halfY & 0xFFFF) << 16);
    uint packed2 = (halfZ & 0xFFFF); // upper 16 bits are padding

    _VertexBuffer.Store2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, uint2(packed1, packed2));
}

//-------------------------
// 3D Full-Precision (float3)
//-------------------------
// Each vertex: float3 = 3 * 32 bits = 12 bytes = 3 uint
float3 GetPos3D_Float(uint i)
{
    return asfloat(_VertexBuffer.Load3(i * _VertexBufferStride + _VertexBufferPosAttributeOffset));
}

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

//-------------------------
// Generic Get/Set Functions
//-------------------------
float2 GetPosition2D(uint i)
{
    if (_FormatType == FORMAT_2D_HALF)
    {
        return GetPos2D_Half(i);
    }
    // If you need to handle other formats that store just 2D, add them here
    return float2(0,0); // default fallback
}

void SetPosition2D(uint i, float2 pos)
{
    if (_FormatType == FORMAT_2D_HALF)
    {
        SetPos2D_Half(i, pos);
    }
    // Add other formats if required
}

float3 GetPosition3D(uint i)
{
    if (_FormatType == FORMAT_3D_FLOAT)
    {
        return GetPos3D_Float(i);
    }
    else if (_FormatType == FORMAT_3D_HALF)
    {
        return GetPos3D_Half(i);
    }
    else
    {
        // If the data is actually 2D half stored, we could return with a zero Y or Z.
        // For now, just fallback:
        float2 xy = GetPos2D_Half(i);
        return float3(xy.x, 0.0, xy.y);
    }
}

void SetPosition3D(uint i, float3 pos)
{
    if (_FormatType == FORMAT_3D_FLOAT)
    {
        SetPos3D_Float(i, pos);
    }
    else if (_FormatType == FORMAT_3D_HALF)
    {
        SetPos3D_Half(i, pos);
    }
    else
    {
        // If the format is 2D half but you're trying to set 3D, you could store just XY
        SetPos2D_Half(i, pos.xz);
    }
}

// Example usage within a compute shader kernel
[numthreads(32, 32, 1)]
void UpdatePositions(uint2 id : SV_DispatchThreadID)
{
    uint ID = id.x + res2D * id.y;

    if (_FormatType == FORMAT_2D_HALF)
    {
        float2 pos = GetPosition2D(ID);
        // Modify pos...
        SetPosition2D(ID, pos);
    }
    else
    {
        float3 pos = GetPosition3D(ID);
        // Modify pos...
        SetPosition3D(ID, pos);
    }
}

[numthreads(32, 32, 1)]
void Spawn(uint2 id : SV_DispatchThreadID)
{
    uint ID = id.x + res2D * id.y;
    if (_FormatType == FORMAT_2D_HALF)
    {
        float2 randomPos = /* ... generate random pos ... */;
        SetPosition2D(ID, randomPos);
    }
    else if (_FormatType == FORMAT_3D_HALF || _FormatType == FORMAT_3D_FLOAT)
    {
        float3 randomPos = /* ... generate random pos ... */;
        SetPosition3D(ID, randomPos);
    }
}

Summary:

• 2D Half: Uses f32tof16 to pack into one 32-bit uint.
• 3D Half: Packs three half floats into two uints (8 bytes). The last 16 bits are unused padding.
• 3D Float: Uses Load3() and Store3() directly for float3.

This modular approach allows you to easily switch formats by setting _FormatType and using the corresponding Get/Set functions.

You

Also add 2d full precision in the same manner

ChatGPT

Below is an updated version that includes a 2D full-precision (float2) format, along with the previously demonstrated half and full precision formats for both 2D and 3D. The approach is consistent across all formats, providing a clear and modular way to handle each.

Supported Formats:

• FORMAT_2D_HALF: half2 (4 bytes per vertex)
• FORMAT_2D_FLOAT: float2 (8 bytes per vertex)
• FORMAT_3D_HALF: half3 (8 bytes per vertex, with padding)
• FORMAT_3D_FLOAT: float3 (12 bytes per vertex)

Code Example:

// Format type defines
#define FORMAT_2D_HALF   0
#define FORMAT_2D_FLOAT  1
#define FORMAT_3D_HALF   2
#define FORMAT_3D_FLOAT  3

// Selected format
int _FormatType;

int _VertexBufferStride;              // in bytes
int _VertexBufferPosAttributeOffset;  // in bytes
RWByteAddressBuffer _VertexBuffer;

//-------------------------
// 2D Half-Precision (half2)
// Layout: 2 * 16 bits = 32 bits total = 4 bytes
//-------------------------
float2 GetPos2D_Half(uint i)
{
    uint packed = _VertexBuffer.Load(i * _VertexBufferStride + _VertexBufferPosAttributeOffset);
    uint halfX = packed & 0xFFFF;
    uint halfY = (packed >> 16) & 0xFFFF;

    float x = f16tof32(halfX);
    float y = f16tof32(halfY);
    return float2(x, y);
}

void SetPos2D_Half(uint i, float2 position)
{
    uint halfX = f32tof16(position.x);
    uint halfY = f32tof16(position.y);
    uint packed = (halfX & 0xFFFF) | ((halfY & 0xFFFF) << 16);

    _VertexBuffer.Store(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, packed);
}

//-------------------------
// 2D Full-Precision (float2)
// Layout: 2 * 32 bits = 64 bits total = 8 bytes
//-------------------------
float2 GetPos2D_Float(uint i)
{
    uint2 data = _VertexBuffer.Load2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset);
    return asfloat(data);
}

void SetPos2D_Float(uint i, float2 position)
{
    uint2 data = asuint(position);
    _VertexBuffer.Store2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, data);
}

//-------------------------
// 3D Half-Precision (half3)
// Layout: half3 = 3 * 16 bits = 48 bits. We store 8 bytes = 64 bits:
//   packed as [hX,hY] in first uint, and [hZ, padding] in second uint.
//-------------------------
float3 GetPos3D_Half(uint i)
{
    uint2 packed = _VertexBuffer.Load2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset);

    uint halfX = packed.x & 0xFFFF;
    uint halfY = (packed.x >> 16) & 0xFFFF;
    uint halfZ = packed.y & 0xFFFF; // upper 16 bits unused

    float x = f16tof32(halfX);
    float y = f16tof32(halfY);
    float z = f16tof32(halfZ);
    return float3(x, y, z);
}

void SetPos3D_Half(uint i, float3 position)
{
    uint halfX = f32tof16(position.x);
    uint halfY = f32tof16(position.y);
    uint halfZ = f32tof16(position.z);

    uint packed1 = (halfX & 0xFFFF) | ((halfY & 0xFFFF) << 16);
    uint packed2 = (halfZ & 0xFFFF); // upper bits padding

    _VertexBuffer.Store2(i * _VertexBufferStride + _VertexBufferPosAttributeOffset, uint2(packed1, packed2));
}

//-------------------------
// 3D Full-Precision (float3)
// Layout: 3 * 32 bits = 96 bits = 12 bytes
//-------------------------
float3 GetPos3D_Float(uint i)
{
    return asfloat(_VertexBuffer.Load3(i * _VertexBufferStride + _VertexBufferPosAttributeOffset));
}

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

//-------------------------
// Generic Get/Set Functions
//-------------------------
float2 GetPosition2D(uint i)
{
    if (_FormatType == FORMAT_2D_HALF)
    {
        return GetPos2D_Half(i);
    }
    else if (_FormatType == FORMAT_2D_FLOAT)
    {
        return GetPos2D_Float(i);
    }

    // If the data is 3D, we can fallback by ignoring Y or Z.
    if (_FormatType == FORMAT_3D_HALF)
    {
        float3 pos3 = GetPos3D_Half(i);
        return float2(pos3.x, pos3.z);
    }
    else if (_FormatType == FORMAT_3D_FLOAT)
    {
        float3 pos3 = GetPos3D_Float(i);
        return float2(pos3.x, pos3.z);
    }

    return float2(0,0);
}

void SetPosition2D(uint i, float2 pos)
{
    if (_FormatType == FORMAT_2D_HALF)
    {
        SetPos2D_Half(i, pos);
    }
    else if (_FormatType == FORMAT_2D_FLOAT)
    {
        SetPos2D_Float(i, pos);
    }
    else if (_FormatType == FORMAT_3D_HALF)
    {
        // If the underlying format is 3D half, store XY and 0 for Z
        SetPos3D_Half(i, float3(pos.x, 0.0f, pos.y));
    }
    else if (_FormatType == FORMAT_3D_FLOAT)
    {
        SetPos3D_Float(i, float3(pos.x, 0.0f, pos.y));
    }
}

float3 GetPosition3D(uint i)
{
    if (_FormatType == FORMAT_3D_FLOAT)
    {
        return GetPos3D_Float(i);
    }
    else if (_FormatType == FORMAT_3D_HALF)
    {
        return GetPos3D_Half(i);
    }
    else if (_FormatType == FORMAT_2D_HALF)
    {
        float2 pos2 = GetPos2D_Half(i);
        return float3(pos2.x, 0.0, pos2.y);
    }
    else if (_FormatType == FORMAT_2D_FLOAT)
    {
        float2 pos2 = GetPos2D_Float(i);
        return float3(pos2.x, 0.0, pos2.y);
    }
    return float3(0,0,0);
}

void SetPosition3D(uint i, float3 pos)
{
    if (_FormatType == FORMAT_3D_FLOAT)
    {
        SetPos3D_Float(i, pos);
    }
    else if (_FormatType == FORMAT_3D_HALF)
    {
        SetPos3D_Half(i, pos);
    }
    else if (_FormatType == FORMAT_2D_HALF)
    {
        // If underlying is 2D half, just store XZ
        SetPos2D_Half(i, float2(pos.x, pos.z));
    }
    else if (_FormatType == FORMAT_2D_FLOAT)
    {
        // If underlying is 2D float, just store XZ
        SetPos2D_Float(i, float2(pos.x, pos.z));
    }
}

// Example usage within kernels:

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

    // For example, if working in 2D space:
    float2 pos = GetPosition2D(ID);
    // ... Perform modifications on pos ...
    SetPosition2D(ID, pos);

    // For 3D:
    // float3 pos3 = GetPosition3D(ID);
    // ... modifications ...
    // SetPosition3D(ID, pos3);
}

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

    if (_FormatType == FORMAT_2D_HALF || _FormatType == FORMAT_2D_FLOAT)
    {
        float2 randomPos2D = /* generate random 2D pos */;
        SetPosition2D(ID, randomPos2D);
    }
    else
    {
        float3 randomPos3D = /* generate random 3D pos */;
        SetPosition3D(ID, randomPos3D);
    }
}

Summary:

• The code now supports four formats: 2D half, 2D float, 3D half, and 3D float.
• Each format has its own dedicated getter/setter.
• Generic getter/setter functions route calls to the appropriate format-specific functions.
• This modular design makes it easy to switch formats by changing the _FormatType variable.