Español

Un shader. Cinco formas de escribirlo.

Los cinco proyectos de sintaxis declaran atributos C# inspirados en HLSL, GLSL, MSL, SPIR-V y WGSL. Sus conceptos están diseñados para compartir una ruta de salida; el pipeline completo del compilador sigue en desarrollo. Existen atributos de autoría WGSL, mientras que su salida está prevista para 2027.

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.HlslSyntax;
using YotsubaShader.HlslSyntax.Resources;

public struct VertexOutput
{
    [SV_Position]
    public Vector4 Position;
}

public class Triangle
{
    [register(RegisterPrefix.u, 0)]
    public RWStructuredBuffer<float> Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([SV_VertexID] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    [return: SV_Target(0)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    [ShaderStage(Stage.Compute)]
    [numthreads(8, 8, 1)]
    public void Compute([SV_DispatchThreadID] UInt3 id)
    {
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.GlslSyntax;
using YotsubaShader.GlslSyntax.Resources;

public struct VertexOutput
{
    [gl_Position]
    public Vector4 Position;
}

public class Triangle
{
    [buffer, layout(0, 0)]
    public float[] Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([gl_VertexIndex] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    [ShaderStage(Stage.Compute)]
    [layout_local_size(8, 8, 1)]
    public void Compute([gl_GlobalInvocationID] UInt3 id)
    {
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.MslSyntax;
using YotsubaShader.MslSyntax.Resources;

public struct VertexOutput
{
    [position]
    public Vector4 Position;
}

public class Triangle
{
    [device, buffer(0)]
    public float[] Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([vertex_id] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    // El tamaño del workgroup lo define el host
    [ShaderStage(Stage.Compute)]
    public void Compute([thread_position_in_grid] UInt3 id)
    {
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.SpirvSyntax;
using YotsubaShader.SpirvSyntax.Resources;

public struct VertexOutput
{
    [BuiltIn_Position]
    public Vector4 Position;
}

public class Triangle
{
    [StorageBuffer, DescriptorSet(0), @Binding(0)]
    public float[] Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([BuiltIn_VertexIndex] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    // El tamaño del workgroup lo define el host
    [ShaderStage(Stage.Compute)]
    public void Compute([BuiltIn_GlobalInvocationId] UInt3 id)
    {
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.WgslSyntax;
using YotsubaShader.WgslSyntax.Resources;

public struct VertexOutput
{
    [@builtin_position]
    public Vector4 Position;
}

public class Triangle
{
    [storage(storage_use.read_write), @group(0), @binding(0)]
    public float[] Output;

    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex([@builtin_vertex_index] uint id)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(0, 0, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(VertexOutput input)
    {
        return new Vector4(1, 0.4f, 0.7f, 1);
    }

    [ShaderStage(Stage.Compute)]
    [@workgroup_size(8, 8, 1)]
    public void Compute([@builtin_global_invocation_id] UInt3 id)
    {
    }
}

Elige tu vocabulario

Sintaxis HLSL Equipos que vienen de Direct3D y HLSL. 31 atributos. Más información Sintaxis GLSL Equipos que vienen de OpenGL y GLSL de Vulkan. 35 atributos. Más información Sintaxis MSL Equipos que vienen de Metal Shading Language. 32 atributos. Más información Sintaxis SPIR-V Equipos que piensan en SPIR-V y en descriptores de Vulkan. 34 atributos. Más información Sintaxis WGSL Equipos que vienen de WebGPU y WGSL. 24 atributos. Más información Referencia lado a lado Cada valor integrado de las cinco sintaxis en una sola tabla. Más información

El mismo concepto, cinco formas de escribirlo

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.HlslSyntax;

public struct VertexOutput
{
    // Posición en clip space (salida de vertex)
    [SV_Position]
    public Vector4 Position;
}

public class BuiltIns
{
    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex(
        // Índice de vértice
        [SV_VertexID] uint vertex,
        // Índice de instancia
        [SV_InstanceID] uint instance)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(vertex, instance, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(
        // Coordenada de fragmento
        [SV_Position] Vector4 coord)
    {
        return new Vector4(coord.X, coord.Y, 0, 1);
    }

    [ShaderStage(Stage.Compute)]
    // Tamaño del workgroup (atributo de método)
    [numthreads(8, 8, 1)]
    public void Compute(
        // Id de invocación global
        [SV_DispatchThreadID] uint id)
    {
        uint index = id;
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.GlslSyntax;

public struct VertexOutput
{
    // Posición en clip space (salida de vertex)
    [gl_Position]
    public Vector4 Position;
}

public class BuiltIns
{
    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex(
        // Índice de vértice
        [gl_VertexIndex] uint vertex,
        // Índice de instancia
        [gl_InstanceIndex] uint instance)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(vertex, instance, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(
        // Coordenada de fragmento
        [gl_FragCoord] Vector4 coord)
    {
        return new Vector4(coord.X, coord.Y, 0, 1);
    }

    [ShaderStage(Stage.Compute)]
    // Tamaño del workgroup (atributo de método)
    [layout_local_size(8, 8, 1)]
    public void Compute(
        // Id de invocación global
        [gl_GlobalInvocationID] uint id)
    {
        uint index = id;
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.MslSyntax;

public struct VertexOutput
{
    // Posición en clip space (salida de vertex)
    [position]
    public Vector4 Position;
}

public class BuiltIns
{
    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex(
        // Índice de vértice
        [vertex_id] uint vertex,
        // Índice de instancia
        [instance_id] uint instance)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(vertex, instance, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(
        // Coordenada de fragmento
        [position] Vector4 coord)
    {
        return new Vector4(coord.X, coord.Y, 0, 1);
    }

    [ShaderStage(Stage.Compute)]
    // Sin atributo de método: el tamaño del workgroup es un valor integrado
    public void Compute(
        // Id de invocación global
        [thread_position_in_grid] uint id)
    {
        uint index = id;
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.SpirvSyntax;

public struct VertexOutput
{
    // Posición en clip space (salida de vertex)
    [BuiltIn_Position]
    public Vector4 Position;
}

public class BuiltIns
{
    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex(
        // Índice de vértice
        [BuiltIn_VertexIndex] uint vertex,
        // Índice de instancia
        [BuiltIn_InstanceIndex] uint instance)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(vertex, instance, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(
        // Coordenada de fragmento
        [BuiltIn_FragCoord] Vector4 coord)
    {
        return new Vector4(coord.X, coord.Y, 0, 1);
    }

    [ShaderStage(Stage.Compute)]
    // Sin atributo de método: el tamaño del workgroup es un valor integrado
    public void Compute(
        // Id de invocación global
        [BuiltIn_GlobalInvocationId] uint id)
    {
        uint index = id;
    }
}

Triangle.cs

using YotsubaShader.Language;
using YotsubaShader.WgslSyntax;

public struct VertexOutput
{
    // Posición en clip space (salida de vertex)
    [@builtin_position]
    public Vector4 Position;
}

public class BuiltIns
{
    [ShaderStage(Stage.Vertex)]
    public VertexOutput Vertex(
        // Índice de vértice
        [@builtin_vertex_index] uint vertex,
        // Índice de instancia
        [@builtin_instance_index] uint instance)
    {
        VertexOutput output = new VertexOutput();
        output.Position = new Vector4(vertex, instance, 0, 1);
        return output;
    }

    [ShaderStage(Stage.Fragment)]
    public Vector4 Fragment(
        // Coordenada de fragmento
        [@builtin_position] Vector4 coord)
    {
        return new Vector4(coord.X, coord.Y, 0, 1);
    }

    [ShaderStage(Stage.Compute)]
    // Tamaño del workgroup (atributo de método)
    [@workgroup_size(8, 8, 1)]
    public void Compute(
        // Id de invocación global
        [@builtin_global_invocation_id] uint id)
    {
        uint index = id;
    }
}

Referencia completa de valores integrados