Yotsuba ShaderAprende
Get Started

Shader 1: un atardecer

20 min de lectura

Tu primer shader. Escribes en C# cada parte que ya conoces, lo compilas con add y usas el resultado.

Este es el shader que vas a hacer en este capítulo. Pinta toda la pantalla con un degradado, de rosa arriba a amarillo abajo:

Un degradado de rosa arriba a amarillo abajo

Es sencillo a propósito. Lo importante aquí no es el dibujo, sino que escribas en C#, una por una, las cinco cosas que viste en Cómo se construye un shader. Los cuatro shaders que vienen después usan exactamente estas mismas partes.

El plan#

Cómo se construye un shader terminó con una lista de cinco decisiones. Así se escribe cada una en C#:

Lo que decidesCómo se escribe en C#
1Qué datos lleva cada vértice (puerta A)Un struct, con [location] en cada campo.
2Qué le deja pasar Vertex a Fragment (puerta B)Otro struct.
3Qué hace la función VertexUn método marcado con [ShaderStage(Stage.Vertex)].
4Qué hace la función FragmentUn método marcado con [ShaderStage(Stage.Fragment)].
5A dónde va el color (puerta C)[return: location(0)] encima del método Fragment.

No hay nada más. Un shader en C# son unos struct y una clase con dos métodos.

La figura: un rectángulo que cubre toda la pantalla#

Allí seguimos un triángulo. Ahora queremos pintar la pantalla entera, así que la figura va a ser un rectángulo que la cubra de borde a borde: dos triángulos, cuatro vértices.

¿Qué datos lleva cada vértice? Dos:

  • La posición, como siempre. Las cuatro esquinas de la pantalla: (-1, 1), (1, 1), (-1, -1) y (1, -1).
  • Un dato que se suele llamar Uv, y que es nuevo.

¿Qué es Uv y para qué lo quiero?#

Para hacer un degradado, cada píxel necesita saber si está arriba o abajo. Pero ya viste que un píxel no sabe nada por sí mismo: solo conoce lo que le llega por el reparto.

Así que le vamos a mandar justo eso. A cada vértice le ponemos un par de números que dice en qué esquina del rectángulo está:

Un cuadrado con sus cuatro esquinas marcadas: (0,0) arriba a la izquierda, (1,0) arriba a la derecha, (0,1) abajo a la izquierda y (1,1) abajo a la derecha

Y el reparto hace el resto. Un píxel a mitad de camino entre la esquina (0, 0) y la esquina (1, 0) recibe (0.5, 0). Uno justo en el centro recibe (0.5, 0.5). Cada píxel termina sabiendo dónde está dentro del rectángulo, con dos números de 0 a 1.

El nombre Uv es una costumbre: en gráficos se usan las letras "U" y "V" para no confundirlas con la X y la Y de la posición. No significa nada más.

Con eso, las tres puertas de este shader quedan así:

Las tres puertas del shader del atardecer. Puerta A: Posicion en el casillero 0 y Uv en el 1. Puerta B: Posicion marcada con una estrella y Uv en el casillero 0. Puerta C: el color en el casillero 0

Es el mismo dibujo de las tres puertas que ya conoces, cambiando "color" por Uv. Tenlo a mano, porque cada casillero de ese dibujo va a ser una línea de C#.

Los vectores: números que van juntos#

Antes de escribir las puertas te falta una herramienta. Una posición son dos números. Un color son cuatro. En un shader casi nunca trabajas con un número suelto, y por eso existen tres tipos que agrupan números float:

TipoCuántos float tieneSus camposPara qué se usa casi siempre
vec22X, YUna posición en 2D, o un Uv.
vec33X, Y, ZUna posición en 3D, o un color sin opacidad.
vec44X, Y, Z, WUn color con opacidad, o la posición final.

A estos tipos se les llama vectores. No hace falta saber matemáticas para usarlos: piensa en ellos como un struct con dos, tres o cuatro float.

Cuando un vec4 guarda un color, sus campos se siguen llamando X, Y, Z y W, así que tienes que acordarte del orden:

CampoEn un color es
Xel rojo
Yel verde
Zel azul
Wla opacidad

Primer archivo: un ayudante para crear vectores#

Vas a crear vectores todo el rato, así que conviene tener una forma corta de hacerlo. Crea el archivo Crear.cs dentro de MisShaders:

MisShaders/Crear.cs
using YotsubaShader.GlslSyntax.Types;

namespace MisShaders;

public static class Crear
{
    public static vec2 Vec2(float x, float y)
    {
        vec2 v;
        v.X = x;
        v.Y = y;
        return v;
    }

    public static vec3 Vec3(float x, float y, float z)
    {
        vec3 v;
        v.X = x;
        v.Y = y;
        v.Z = z;
        return v;
    }

    public static vec4 Vec4(float x, float y, float z, float w)
    {
        vec4 v;
        v.X = x;
        v.Y = y;
        v.Z = z;
        v.W = w;
        return v;
    }
}

Las tres funciones hacen lo mismo: crean un vector vacío, le llenan los campos uno por uno y lo devuelven. Ahora, para tener el color rojo, basta con escribir Crear.Vec4(1f, 0f, 0f, 1f).

  • using YotsubaShader.GlslSyntax.Types; es de donde salen vec2, vec3 y vec4.
  • La f de 1f dice que el número es un float. Acostúmbrate a ponerla siempre: con un número con decimales, como 0.5, es obligatoria, porque sin ella C# lo toma por un double y no compila.

Esto ya te enseña algo importante: desde un shader puedes llamar a tus propias funciones. Crear.Vec4 es un método de C# normal y corriente, y el compilador lo lleva a la GPU junto con tu shader.

Segundo archivo: las puertas A y B#

Ahora sí, las puertas. Van las dos en un archivo que se llama Pantalla.cs. Lo vas a escribir en dos partes.

La puerta A: lo que lleva cada vértice#

Crea Pantalla.cs con esto:

MisShaders/Pantalla.cs
using YotsubaShader.GlslSyntax;
using YotsubaShader.GlslSyntax.Types;

namespace MisShaders;

public struct Vertice
{
    [location(0)] public vec2 Posicion;
    [location(1)] public vec2 Uv;
}

Esto es la puerta A, escrita en C#. Línea por línea:

  • public struct Vertice: un vértice es un paquete de datos, y en C# un paquete de datos es un struct. El nombre Vertice lo elegí yo. Puedes ponerle el que quieras.
  • [location(0)] public vec2 Posicion;: "en el casillero 0 de esta puerta viajan dos float, y yo los voy a llamar Posicion".
  • [location(1)] public vec2 Uv;: "en el casillero 1 viajan otros dos float, y los voy a llamar Uv".

[location] sale de using YotsubaShader.GlslSyntax;, por eso está ese using arriba.

Compáralo con el dibujo de las puertas: en la puerta A hay un casillero 0 con Posicion y un casillero 1 con Uv. Es exactamente lo que acabas de escribir.

Tres preguntas que es normal hacerse aquí:

¿Quién llena esos casilleros? Tu juego. Cuando llegues a tu Game Engine vas a escribir las cuatro esquinas con su posición y su Uv, y vas a decirle que la posición va en el casillero 0 y el Uv en el 1. Aquí, en el shader, solo declaras qué esperas recibir.

¿Importan los nombres Posicion y Uv? A la GPU no. Ella solo ve el número del casillero y el tipo. Los nombres son para ti, para que el código se pueda leer.

¿Qué pasa si me equivoco de número? Que el shader lee el dato que no es. Si aquí pusieras Uv en el casillero 0, recibirías la posición creyendo que es el Uv. No sale ningún error: simplemente el dibujo sale mal. Por eso conviene tener claro qué va en cada casillero.

La puerta B: lo que Vertex le deja pasar a Fragment#

Añade el segundo struct debajo del primero. El archivo completo queda así:

MisShaders/Pantalla.cs
using YotsubaShader.GlslSyntax;
using YotsubaShader.GlslSyntax.Types;

namespace MisShaders;

public struct Vertice
{
    [location(0)] public vec2 Posicion;
    [location(1)] public vec2 Uv;
}

public struct Pixel
{
    [gl_Position] public vec4 Posicion;
    [location(0)] public vec2 Uv;
}

public struct PixelIn
{
    [location(0)] public vec2 Uv;
}

Pixel es la puerta B vista desde Vertex. Tiene los dos tipos de datos que salen de Vertex, el especial y los tuyos:

  • [gl_Position] public vec4 Posicion; es el dato especial, el de la estrella. [gl_Position] le dice a la GPU: "esta es la posición final del vértice, quédatela". Por eso no lleva número. Y es un vec4 porque la posición final tiene cuatro números.
  • [location(0)] public vec2 Uv; es un dato tuyo: "en el casillero 0 de esta puerta viaja el Uv".

"Un momento: ¿otra vez location(0)?"#

Sí. Y es el momento de mirarlo bien, porque es justo la confusión de la que te avisé.

En Vertice, el casillero 0 es la posición. En Pixel, el casillero 0 es el Uv. No chocan, porque son dos puertas distintas, y cada puerta cuenta desde 0 por su cuenta:

Casillero 0Casillero 1
Vertice (puerta A)PosicionUv
Pixel (puerta B)Uvno hay

El Uv entró por el casillero 1 de la puerta A y sale por el casillero 0 de la puerta B. No pasa nada: el número solo vale dentro de su puerta.

¿Y por qué en Pixel el Uv no es el casillero 1, para que quede igual? Podrías ponerlo en el 1 y funcionaría. Pero en la puerta B la posición no ocupa casillero, así que el primero que queda libre es el 0. Lo normal es numerar desde 0 sin dejar huecos.

¿Por qué se llama Pixel?#

Porque es lo que le llega a cada píxel. La función Vertex lo llena tres veces, una por vértice, la GPU lo reparte, y la función Fragment lo recibe una vez por píxel, ya mezclado.

Fragment no recibe el Pixel completo. La posición final sirve para que la GPU coloque el triángulo, y una función Fragment no la necesita (en GLSL, gl_Position ni siquiera existe en esa etapa, y el compilador te avisa si lo intentas). Por eso el archivo tiene un segundo struct, PixelIn, con solo los datos tuyos: lo que recibe Fragment.

Los dos lados de la puerta B tienen que coincidir: el mismo número de location y el mismo tipo. Aquí Uv es location(0) y vec2 en los dos. Si un lado dijera vec3, o el casillero 1, el shader no compilaría.

Tercer archivo: las dos funciones#

Quedan las decisiones 3, 4 y 5: las dos funciones y la puerta C. Van juntas en una clase. Primero te las enseño por separado, y después el archivo completo para que lo copies.

La función Vertex#

[ShaderStage(Stage.Vertex)]
public Pixel Vertex(Vertice vertice)
{
    Pixel pixel;
    pixel.Posicion = Crear.Vec4(vertice.Posicion.X, vertice.Posicion.Y, 0f, 1f);
    pixel.Uv = vertice.Uv;
    return pixel;
}

Empieza por la primera línea y la firma, que ya lo dicen casi todo:

  • [ShaderStage(Stage.Vertex)] es lo que convierte a este método en la etapa Vertex. Sin ese atributo sería un método cualquiera y la GPU no lo llamaría nunca.
  • (Vertice vertice): lo que recibe. Es la puerta A: un vértice, con su Posicion y su Uv. Recuerda que es uno solo. La GPU llama al método cuatro veces, una por esquina.
  • public Pixel: lo que devuelve. Es la puerta B.
  • El nombre Vertex es libre. Podría llamarse ColocarEsquina. Lo que manda es el atributo.

Y el cuerpo hace los dos trabajos de la etapa Vertex:

Trabajo 1, decir dónde va el vértice:

pixel.Posicion = Crear.Vec4(vertice.Posicion.X, vertice.Posicion.Y, 0f, 1f);

Aquí no queremos mover nada, así que la posición final es la misma que llegó. Lo único que cambia es que llegó con dos números y hay que entregarla con cuatro. Por eso tomamos la X y la Y que llegaron y rellenamos con 0f y 1f, que son la profundidad y la perspectiva de las que hablamos.

Trabajo 2, dejar pasar lo que Fragment va a necesitar:

pixel.Uv = vertice.Uv;

Copiamos el Uv tal cual. Si no lo hicieras, a la función Fragment no le llegaría nada con qué saber dónde está cada píxel.

Pixel pixel; al principio y return pixel; al final son lo mismo que hiciste en Crear.cs: declarar el struct vacío, llenar sus dos campos y devolverlo.

La función Fragment y la puerta C#

[ShaderStage(Stage.Fragment)]
[return: location(0)]
public vec4 Fragment(PixelIn pixel)
{
    return Crear.Vec4(1f, 0f, 0f, 1f);
}
  • [ShaderStage(Stage.Fragment)] convierte a este método en la etapa Fragment.
  • (PixelIn pixel): lo que recibe. Es el otro lado de la puerta B: solo tus datos, sin la posición. Pero ojo con lo que aprendiste del reparto: este pixel no es ninguno de los cuatro que devolvió Vertex. Es una mezcla de ellos, distinta para cada píxel.
  • public vec4: lo que devuelve. Un color, o sea, cuatro números.
  • [return: location(0)] es la puerta C: "el color que devuelvo va al casillero 0". Y el casillero 0 de la puerta C es la pantalla.

Si nunca habías visto [return: ...], es C# normal. Los atributos se ponen encima de lo que describen: encima de un campo, de un método, de una clase. Pero lo que un método devuelve no tiene un sitio propio donde poner nada encima, así que C# te deja escribir return: delante para decir "este atributo no es para el método, es para lo que devuelve".

Por ahora el cuerpo hace lo más simple posible. Devuelve siempre Crear.Vec4(1f, 0f, 0f, 1f), que es rojo: todo el rojo, nada de verde, nada de azul, y opacidad completa. Ni siquiera usa el pixel que recibe. Así que toda la pantalla va a quedar roja.

Los tres ceros#

Ya escribiste las tres puertas, y en las tres hay un location(0). Ahora puedes leerlos sin confundirte:

Dónde lo escribisteQué puerta esQué viaja en su casillero 0
[location(0)] en VerticeA: del juego a VertexLa posición del vértice.
[location(0)] en Pixel y en PixelInB: de Vertex a FragmentEl Uv.
[return: location(0)] en FragmentC: de Fragment a la pantallaEl color del píxel.

Tres ceros, tres puertas, tres cosas distintas.

El archivo completo#

Crea Degradado.cs con las dos funciones dentro de una clase:

MisShaders/Degradado.cs
using YotsubaShader.GlslSyntax;
using YotsubaShader.GlslSyntax.Types;
using YotsubaShader.Language;

namespace MisShaders;

public class Degradado
{
    [ShaderStage(Stage.Vertex)]
    public Pixel Vertex(Vertice vertice)
    {
        Pixel pixel;
        pixel.Posicion = Crear.Vec4(vertice.Posicion.X, vertice.Posicion.Y, 0f, 1f);
        pixel.Uv = vertice.Uv;
        return pixel;
    }

    [ShaderStage(Stage.Fragment)]
    [return: location(0)]
    public vec4 Fragment(PixelIn pixel)
    {
        return Crear.Vec4(1f, 0f, 0f, 1f);
    }
}

Un shader es una clase normal, con un método por cada etapa. La clase se llama Degradado porque ese es el nombre del shader: así lo vas a pedir después, con new Degradado().

Hay un using nuevo, YotsubaShader.Language. De ahí salen [ShaderStage] y Stage.

Compílalo con add#

Ya tienes un shader escrito. Ahora hay que convertirlo en algo que la GPU entienda. Desde la carpeta Tutorial, ejecuta el comando que viste en el capítulo anterior:

dotnet yotsuba add MisShaders/MisShaders.csproj --target spirv

La primera vez tarda un poco, porque también se compila el propio compilador. Al terminar verás algo así:

Archivo generado: /ruta/a/Tutorial/MisShaders/YotsubaShader.g.cs

Abre la carpeta MisShaders. Hay un archivo nuevo que tú no escribiste: YotsubaShader.g.cs.

Degradado.cs entra en el comando add y sale YotsubaShader.g.cs, que añade los métodos ToSpirV, ToGlsl, ToHlsl, ToMSL y ToMGFX

Eso es lo que hace add: compila todos los shaders de tu proyecto y añade a tu proyecto un archivo de C# con el resultado. Ese archivo le pone métodos nuevos a tu clase Degradado:

MétodoLo que devuelve
ToGlsl(etapa)El shader traducido a GLSL (OpenGL), como texto.
ToGlslEs(etapa)Lo mismo, en la variante de GLSL para móviles y web.
ToHlsl(etapa)El shader traducido a HLSL (DirectX), como texto.
ToMSL(etapa)El shader traducido a Metal (Apple), como texto.
ToSpirV()El shader en SPIR-V, el formato binario de Vulkan, como byte[].
ToMGFX(plataforma), ToKNIWebGL_FX(), ToFNA_FX()El shader listo para cargar en MonoGame, KNI o FNA, como byte[]. Estos tres aparecen solo si pides el plugin del motor con --target kni, --target kni o --target fna. Lo harás en Tu ventana para ver shaders.

Es decir, no tienes que cargar archivos ni recordar rutas. Tu shader es una clase, y el resultado compilado se lo pides a esa misma clase.

Usa el resultado#

Vamos a pedirle a Degradado su versión en GLSL y a mostrarla en la consola. Abre Probar/Program.cs, borra lo que tenga y escribe esto:

Probar/Program.cs
using MisShaders;
using YotsubaShader;
using YotsubaShader.Language;

var shader = new Degradado();

Console.WriteLine(shader.ToGlsl(Stage.Fragment));

Y ejecútalo:

dotnet run --project Probar

Esto es lo que sale:

#version 450

struct Pixel
{
    vec4 Posicion;
    vec2 Uv;
};

layout(location = 0) in vec2 pixel_Uv;
layout(location = 0) out vec4 _return;

vec4 Vec4(float x, float y, float z, float w)
{
    vec4 v;
    v.x = x;
    v.y = y;
    v.z = z;
    v.w = w;
    return v;
}

void main()
{
    _return = Vec4(1.0, 0.0, 0.0, 1.0);
}

Míralo con calma, porque ahí está todo lo que escribiste, traducido a otro lenguaje:

  • Tu struct Pixel está ahí.
  • Tu función Crear.Vec4 está ahí, aunque la escribiste en otro archivo. El compilador se trajo solo lo que el shader usa: Vec2 y Vec3 no aparecen.
  • Tu método Fragment es el main() del final.

Y tus puertas también están ahí. Mira estas dos líneas:

layout(location = 0) in vec2 pixel_Uv;
layout(location = 0) out vec4 _return;

La primera dice in, que es "entra": es el Uv que llega por el casillero 0 de la puerta B. La segunda dice out, que es "sale": es el color que se va por el casillero 0 de la puerta C. Dos ceros, uno de entrada y otro de salida, y GLSL los distingue igual que tú: por la puerta.

Ese texto es un shader de GLSL de verdad. Si se lo das a OpenGL, pinta la pantalla de rojo.

Mira también la etapa Vertex#

Cambia Stage.Fragment por Stage.Vertex en Probar/Program.cs y ejecútalo otra vez. Ahora sale tu método Vertex:

#version 450

struct Pixel
{
    vec4 Posicion;
    vec2 Uv;
};

layout(location = 0) in vec2 vertice_Posicion;
layout(location = 1) in vec2 vertice_Uv;
layout(location = 0) out vec2 _return_Uv;

vec4 Vec4(float x, float y, float z, float w)
{
    vec4 v;
    v.x = x;
    v.y = y;
    v.z = z;
    v.w = w;
    return v;
}

void main()
{
    Pixel pixel;
    pixel.Posicion = Vec4(vertice_Posicion.x, vertice_Posicion.y, 0.0, 1.0);
    pixel.Uv = vertice_Uv;
    gl_Position = pixel.Posicion;
    _return_Uv = pixel.Uv;
}

Aquí se ven las puertas A y B enteras:

  • Las dos líneas con in son la puerta A: la posición en el casillero 0 y el Uv en el 1.
  • La línea con out es la puerta B: el Uv saliendo por el casillero 0.
  • Y la posición final no tiene layout ni número. Aparece al final como gl_Position = pixel.Posicion;. Es el dato especial, el que se queda la GPU.

Vuelve a dejar Stage.Fragment antes de seguir.

Ahora sí, el degradado#

Una pantalla roja no es muy emocionante. Para hacer un degradado, el color tiene que ser distinto en cada píxel. ¿Y qué tiene de distinto un píxel respecto a otro? Su Uv.

Recuerda que el Uv solo existe en las cuatro esquinas, pero la función Fragment se ejecuta para todos los píxeles, también los del medio. Es el reparto otra vez: la GPU le da a cada píxel la mezcla que le toca.

Así que dentro de Fragment, pixel.Uv.Y vale 0 en los píxeles de arriba, 1 en los de abajo, y va subiendo poco a poco entre medias. Eso es justo lo que necesita un degradado.

Cambia el método Fragment por este. El archivo completo queda así:

MisShaders/Degradado.cs
using YotsubaShader.GlslSyntax;
using YotsubaShader.GlslSyntax.Types;
using YotsubaShader.Language;

namespace MisShaders;

public class Degradado
{
    [ShaderStage(Stage.Vertex)]
    public Pixel Vertex(Vertice vertice)
    {
        Pixel pixel;
        pixel.Posicion = Crear.Vec4(vertice.Posicion.X, vertice.Posicion.Y, 0f, 1f);
        pixel.Uv = vertice.Uv;
        return pixel;
    }

    [ShaderStage(Stage.Fragment)]
    [return: location(0)]
    public vec4 Fragment(PixelIn pixel)
    {
        float rojo = 1f;
        float verde = 0.25f + 0.6f * pixel.Uv.Y;
        float azul = 0.45f - 0.35f * pixel.Uv.Y;
        return Crear.Vec4(rojo, verde, azul, 1f);
    }
}

Haz la cuenta para dos píxeles y lo verás claro:

PíxelUv.YRojoVerdeAzulColor
Uno de arriba010.250.45Rosa
Uno de abajo110.850.10Amarillo anaranjado

Los píxeles del medio quedan entre un color y otro. No escribiste ningún bucle: la GPU ejecuta esas cuatro líneas para cada píxel, y cada uno llega con su propio Uv.

Vuelve a compilar y a ejecutar:

dotnet yotsuba add MisShaders/MisShaders.csproj --target spirv
dotnet run --project Probar

Ahora el main() de la salida es este:

void main()
{
    float rojo = 1.0;
    float verde = 0.25 + (0.60000002384185791015625 * pixel_Uv.y);
    float azul = 0.449999988079071044921875 - (0.3499999940395355224609375 * pixel_Uv.y);
    _return = Vec4(rojo, verde, azul, 1.0);
}

Son tus mismas líneas. Los números largos son tus 0.6f, 0.45f y 0.35f, escritos con todos los decimales que un float guarda por dentro.

El mismo shader, para otras APIs gráficas#

Hasta aquí pediste GLSL. Pero el archivo que generó add trae todos los formatos. Cambia Probar/Program.cs por esto:

Probar/Program.cs
using MisShaders;
using YotsubaShader;
using YotsubaShader.Language;

var shader = new Degradado();

Console.WriteLine("--- GLSL ---");
Console.WriteLine(shader.ToGlsl(Stage.Fragment));

Console.WriteLine("--- HLSL ---");
Console.WriteLine(shader.ToHlsl(Stage.Fragment));

Console.WriteLine("--- Metal ---");
Console.WriteLine(shader.ToMSL(Stage.Fragment));

byte[] spirv = shader.ToSpirV();
File.WriteAllBytes("Degradado.spv", spirv);
Console.WriteLine($"Degradado.spv: {spirv.Length} bytes");

Esta vez no hace falta ejecutar add, porque el shader no cambió. Solo ejecuta dotnet run --project Probar.

Verás tu shader tres veces, en tres lenguajes distintos, y un archivo Degradado.spv nuevo en la carpeta desde donde lo ejecutaste. Por ejemplo, así queda tu método en HLSL:

void Fragment_inner()
{
    float rojo = 1.0f;
    float verde = 0.25f + (0.60000002384185791015625f * pixel_Uv.y);
    float azul = 0.449999988079071044921875f - (0.3499999940395355224609375f * pixel_Uv.y);
    _return = Vec4(rojo, verde, azul, 1.0f);
}

Escribiste el shader una sola vez, en C#, y lo tienes para OpenGL, DirectX, Metal y Vulkan.

¿Y cómo lo veo en pantalla?#

Hasta aquí solo has visto el degradado como una imagen del tutorial y como texto en la consola. Para verlo dibujado de verdad hace falta una ventana y algo que le mande el rectángulo a la GPU. Eso lo hace un Game Engine o una API gráfica, y cada uno lo hace a su manera.

Por eso el siguiente capítulo te hace una ventana pequeña, un visor, que dibuja el shader que le indiques. Es una herramienta de trabajo y no depende de ningún motor en particular: tus shaders siguen siendo los mismos. Con ella, cada capítulo que viene te va a pedir que escribas, ejecutes y veas lo que haces. Al terminar, en ¿Y ahora qué?, eliges tu engine y ves cómo cargar allí lo que te da add.

Lo que aprendiste#

  • Un shader en C# son unos struct y una clase con dos métodos.
  • La puerta A es un struct con [location(n)] en cada campo: lo que tu juego manda por cada vértice.
  • La puerta B es otro struct: la posición final marcada con [gl_Position], y tus datos con [location(n)].
  • La puerta C es [return: location(0)] encima del método Fragment.
  • Cada puerta cuenta sus casilleros desde 0. Por eso hay tres location(0) y no chocan.
  • Cada etapa es un método marcado con [ShaderStage]. Vertex devuelve la posición y deja pasar datos; Fragment devuelve el color, un vec4 con valores de 0 a 1.
  • Lo que devuelve Vertex le llega a Fragment repartido entre los píxeles. Por eso Uv es distinto en cada uno.
  • El comando add compila tus shaders y añade YotsubaShader.g.cs a tu proyecto. Desde ahí, new Degradado().ToGlsl(...) y sus hermanos te dan el shader compilado.

Siguiente: Tu ventana para ver shaders.