sábado 15 marzo 2025

¿Qué lenguaje usa Unity para definir Shaders?

En Unity, los shaders se programan principalmente usando HLSL (High-Level Shading Language), aunque también se utilizan estructuras específicas de Unity como ShaderLab para definir propiedades y configuraciones. A continuación, te explico los detalles:

Lenguajes utilizados en shaders de Unity

1. HLSL (High-Level Shading Language)

Es el lenguaje principal para escribir la lógica de los shaders en Unity (cálculos de vértices, fragmentos, iluminación, etc.).
Es compatible con DirectX y se utiliza en la mayoría de las plataformas (Windows, Xbox, etc.).
Unity traduce automáticamente el HLSL a otros lenguajes (como GLSL para OpenGL o Metal Shading Language para iOS) según la plataforma.

2. ShaderLab

Es un lenguaje declarativo propio de Unity que estructura el shader (propiedades, subshaders, passes, etc.).
No se usa para cálculos, sino para organizar el shader y definir configuraciones de renderizado.
Envuelve el código HLSL dentro de bloques HLSLPROGRAM/ENDHLSL.

3. Cg (Deprecated)

En versiones antiguas de Unity, se usaba Cg (desarrollado por NVIDIA), pero hoy está en desuso.
Unity aún soporta sintaxis similar a Cg por compatibilidad, pero internamente lo convierte a HLSL.

Estructura básica de un shader en Unity

Un shader en Unity se divide en bloques definidos por ShaderLab, con código HLSL incrustado. Aquí un ejemplo básico:

Shader "Custom/MiShader"  // Ruta/nombre del shader en el editor
{
    Properties  // Propiedades editables en el Inspector
    {
        _Color ("Color", Color) = (1,1,1,1)
        _MainTex ("Textura", 2D) = "white" {}
    }

    SubShader  // Bloque para configurar el renderizado
    {
        Tags { "RenderType" = "Opaque" }  // Etiquetas de renderizado

        Pass  // Un "paso" de renderizado (ej: un efecto)
        {
            CGPROGRAM  // Antiguamente se usaba CGPROGRAM, ahora HLSLPROGRAM
            #pragma vertex vert  // Define la función del vértice
            #pragma fragment frag  // Define la función del fragmento

            #include "UnityCG.cginc"  // Incluye funciones útiles de Unity

            // Variables desde Properties
            float4 _Color;
            sampler2D _MainTex;

            // Estructuras de datos para vértices y fragmentos
            struct appdata  // Entrada del vértice
            {
                float4 vertex : POSITION;
                float2 uv : TEXCOORD0;
            };

            struct v2f  // Salida del vértice → Entrada del fragmento
            {
                float2 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            // Vertex Shader: Transforma vértices al espacio de pantalla
            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);  // Convierte a coordenadas de pantalla
                o.uv = v.uv;
                return o;
            }

            // Fragment Shader: Calcula el color de cada píxel
            float4 frag (v2f i) : SV_Target
            {
                float4 texColor = tex2D(_MainTex, i.uv);  // Muestra la textura
                return texColor * _Color;  // Aplica el color
            }
            ENDCG  // Fin del bloque HLSL/CG
        }
    }
}

Partes clave del shader

1. Properties

Variables editables en el Inspector de Unity (colores, texturas, valores numéricos).
Se declaran con: _Nombre ("Etiqueta", Tipo) = ValorPorDefecto.

2. SubShader

Contiene uno o más Passes (cada Pass es una ejecución de renderizado).
Puedes definir múltiples SubShader para diferentes niveles de hardware.

3. Pass

Cada Pass ejecuta un conjunto de operaciones de renderizado.
Aquí se incluye el código HLSL con las funciones vert (vertex shader) y frag (fragment shader).

4. Structs (appdata y v2f)

appdata: Datos de entrada del vértice (posición, UVs, normales, etc.).
v2f: Datos interpolados que pasan del vertex al fragment shader.

5. Funciones HLSL

Vertex Shader (vert): Transforma vértices al espacio de pantalla (SV_POSITION).
Fragment Shader (frag): Calcula el color final del píxel (SV_Target).

Tipos de shaders en Unity

1. Vertex-Fragment Shaders

Shaders personalizados escritos manualmente (como el ejemplo anterior).

2. Surface Shaders

Abstracción de Unity para simplificar shaders con iluminación.
Se escribe en una sintaxis similar a HLSL, pero Unity genera automáticamente el código complejo de iluminación.
Ejemplo:

#pragma surface surf Lambert
     void surf (Input IN, inout SurfaceOutput o) {
         o.Albedo = _Color.rgb;
     }

3. Shader Graph

Herramienta visual para crear shaders sin código (usado en URP y HDRP).
Genera automáticamente código HLSL detrás de escena.

Etiquetas:

csharp unity

Creado por:

Jorge García

Fullstack developer

¿Qué lenguaje usa Unity para definir Shaders?

Lenguajes utilizados en shaders de Unity

Estructura básica de un shader en Unity

Partes clave del shader

Tipos de shaders en Unity

Valoramos tu privacidad