Just out on interest, I grabbed glslangValidator + spirv-cross to see how translating from HLSL to SPIR-V to GLSL/MSL goes, and after testing on vs/ps/cs, it seems like it will work pretty nicely! Only thing that would need some modifications to in code gen looks to be register mapping for UAVs/SRVs to the appropriate image/texture/SSBO slots. Here's some HLSL I fed into it:

////////////////////////////////////////////////////////////////////////////////////////////////////
// generated shader for shader_tests/00-basic.esf
////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////
// structs
struct View
{
    float4x4 view_;
    float4x4 proj_;
};

struct Object
{
    float4x4 world_;
};

struct VS_IN
{
    float4 position : POSITION;
    float2 uv : TEXCOORD0;
};

struct VS_OUT
{
    float4 position : SV_POSITION;
    float2 uv : TEXCOORD0;
};

////////////////////////////////////////////////////////////////////////////////////////////////////
// cbuffers
cbuffer ObjectCBuffer: register(b0)
{
    Object o_;
};

cbuffer ViewCBuffer: register(b1)
{
    View v_;
};

////////////////////////////////////////////////////////////////////////////////////////////////////
// sampler states
SamplerState SS_DEFAULT : register(s0);

////////////////////////////////////////////////////////////////////////////////////////////////////
// vars
Texture2D tex_diffuse : register(t0);

////////////////////////////////////////////////////////////////////////////////////////////////////
// functions
VS_OUT vs_main(in VS_IN _in)
{
VS_OUT _out = (VS_OUT)0;
_out.position = _in.position;
_out.uv = _in.uv;
return _out;
}

and after HLSL -> SPIR-V -> GLSL for vs_main:

#version 430

struct VS_IN
{
    vec4 position;
    vec2 uv;
};

struct VS_OUT
{
    vec4 position;
    vec2 uv;
};

struct Object
{
    mat4 world_;
};

struct View
{
    mat4 view_;
    mat4 proj_;
};

layout(location = 0) in vec4 _in_position;
layout(location = 1) in vec2 _in_uv;
layout(location = 0) out vec2 _entryPointOutput_uv;

VS_OUT _vs_main(VS_IN _in)
{
    VS_OUT _out = VS_OUT(vec4(0.0), vec2(0.0));
    _out.position = _in.position;
    _out.uv = _in.uv;
    return _out;
}

void main()
{
    VS_IN _in;
    _in.position = _in_position;
    _in.uv = _in_uv;
    VS_IN param = _in;
    VS_OUT flattenTemp = _vs_main(param);
    gl_Position = flattenTemp.position;
    _entryPointOutput_uv = flattenTemp.uv;
}

And doing it with a compute shader using an SRV + UAV:

////////////////////////////////////////////////////////////////////////////////////////////////////
// generated shader for shader_tests/00-particle.esf
////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////
// structs
struct Particle
{
    float3 position;
    float3 velocity;
};

struct VS_IN
{
    float4 position : POSITION;
};

struct VS_OUT
{
    float4 position : SV_POSITION;
    uint idx : SV_INSTANCEID;
};

////////////////////////////////////////////////////////////////////////////////////////////////////
// cbuffers
cbuffer ParticleConfig: register(b0)
{
    float4 time;
    float4 tick;
    int maxWidth;
};

cbuffer Camera: register(b1)
{
    float4x4 view;
    float4x4 viewProj;
};

////////////////////////////////////////////////////////////////////////////////////////////////////
// sampler states

////////////////////////////////////////////////////////////////////////////////////////////////////
// vars
RWStructuredBuffer<Particle> inout_particles : register(u0);
StructuredBuffer<Particle> in_particles : register(t0);

////////////////////////////////////////////////////////////////////////////////////////////////////
// functions
float noise(float x)
{
return sin(x) +
sin(x * 0.61423) * 0.5 +
sin(x * 0.3123) * 0.25 +
sin(x * 0.142) * 0.125;
}

[numthreads(1, 1, 1)]
void cs_main(int3 id : SV_DispatchThreadID)
{
const uint idx = id.x + id.y * maxWidth;
Particle particle = in_particles[idx];
particle.position = particle.position + particle.velocity * tick.x;
particle.velocity += float3(0.0, -9.8, 0.0) * tick.x;
float offset = (float)idx / 1024.0;
particle.velocity.y += noise(time.x + offset) * 0.01;
if(particle.position.y < 0.0)
{
particle.velocity = reflect(particle.velocity, float3(0.0, 1.0, 0.0)) * 0.5;
particle.position.y = 0.0;
}
inout_particles[idx] = particle;
}

and after HLSL -> SPIR-V -> GLSL for cs_main:

#version 430
layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;

struct Particle
{
    vec3 position;
    vec3 velocity;
};

layout(binding = 0, std140) uniform ParticleConfig
{
    vec4 time;
    vec4 tick;
    int maxWidth;
} _57;

layout(binding = 0, std430) readonly buffer _71
{
    Particle _data[];
} in_particles;

layout(binding = 0, std430) buffer _137
{
    Particle _data[];
} inout_particles;

float noise(float x)
{
    return ((sin(x) + (sin(x * 0.614229977130889892578125) * 0.5)) + (sin(x * 0.3122999966144561767578125) * 0.25)) + (sin(x * 0.14200000464916229248046875) * 0.125);
}

void _cs_main(ivec3 id)
{
    uint idx = uint(id.x + (id.y * _57.maxWidth));
    Particle particle;
    particle.position = in_particles._data[idx].position;
    particle.velocity = in_particles._data[idx].velocity;
    particle.position += (particle.velocity * _57.tick.x);
    particle.velocity += (vec3(0.0, -9.80000019073486328125, 0.0) * _57.tick.x);
    float param = _57.time.x + (float(idx) / 1024.0);
    particle.velocity.y += (noise(param) * 0.00999999977648258209228515625);
    if (particle.position.y < 0.0)
    {
        particle.velocity = reflect(particle.velocity, vec3(0.0, 1.0, 0.0)) * 0.5;
        particle.position.y = 0.0;
    }
    inout_particles._data[idx].position = particle.position;
    inout_particles._data[idx].velocity = particle.velocity;
}

void main()
{
    ivec3 param = gl_GlobalInvocationID;
    _cs_main(param);
}

Vulkan support #8

Description

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions