Shaders são programas essenciais que rodam na GPU para determinar como os objetos são renderizados na tela. Eles definem a aparência visual dos materiais, controlando iluminação, texturas e efeitos. No Unity, comprenedemos os shaders como um componente crucial para a criação de gráficos visuais impactantes.

Tipos de Shaders no Unity

O Unity suporta diversos tipos de shaders, cada um com suas particularidades e aplicações:

• Shaders de Superfície (Surface Shaders): São uma abstração de alto nível que simplifica a criação de shaders com modelos de iluminação complexos. O Unity cuida da maior parte da cmoplexidade da iluminação, permitindo que o desenvolvedor se concentre na aparência do material.
• Shaders de Vértice e Fragmento (Vertex and Fragment Shaders): Oferecem controle total sobre o pipeline gráfico. O shader de vértice manipula as coordenadas dos vértices, enquanto o shader de fragmento determina a cor final de cada pixel. São mais flexíveis, mas exigem um conhecimento mais aprofundado.
• Shaders de Computação (Compute Shaders): Não estão diretamente ligados à renderização de objetos na cena, mas são utilizados para tarefas de computação de propósito geral na GPU (GPGPU), como simulações físicas ou processamento de dados em massa.

Estrutura do ShaderLab

Os shaders no Unity são escritos em uma linguagem chamada ShaderLab. Ela possui uma estrutura hierárquica:

Shader "Custom/MySimpleShader"
{
    // Seção de propriedades visíveis no Inspector do Unity
    Properties
    {
        _MainTexture ("Base Texture", 2D) = "white" {}
        _TintColor ("Tint Color", Color) = (1,1,1,1)
    }

    // Contém uma ou mais passes para renderizar o objeto
    SubShader
    {
        // Define a ordem de renderização e outras tags
        Tags { "RenderType"="Opaque" }
        LOD 100

        // Uma unidade de renderização individual
        Pass
        {
            // Bloco para código Cg/HLSL
            CGPROGRAM
            // Diretivas de compilação para Surface Shader
            #pragma surface surf Lambert

            // Estrutura para entrada de dados no shader de superfície
            struct Input
            {
                float2 uv_MainTexture; // Mapeamento UV para a textura principal
            };

            // Declaração das variáveis do shader
            sampler2D _MainTexture;
            fixed4 _TintColor;

            // Função principal do Surface Shader
            void surf (Input IN, inout SurfaceOutput o)
            {
                // Combina a textura principal com a cor de realce
                fixed4 texColor = tex2D(_MainTexture, IN.uv_MainTexture);
                o.Albedo = texColor.rgb * _TintColor.rgb;
            }
            ENDCG
        }
    }
    // Fallback para um shader mais simples se este não puder ser renderizado
    FallBack "Diffuse"
}

• Shader "Nome/DoShader": Define o nome e o caminho do shader no menu de criação de materiais.
• Properties: Seção onde as propriedades do material são declaradas. Essas propriedades aparecem no Inspector do Unity, permitindo que os artistas ajustem valores como texturas, cores, sliders, etc.
• SubShader: Um shader pode conter múltiplos SubShaders. O Unity tentará usar o primeiro SubShader que for compatível com o hardware do jogador.
• Pass: Cada SubShader é composto por uma ou mais Passes. Uma Pass define um conjunto de estados de renderização e contém o código Cg/HLSL que será executado.
• CGPROGRAM / ENDCG: Delimitam o bloco de código escrito em Cg ou HLSL, que são as linguagens de shader utilizadas.

Exemplo de Shader de Superfície Simples

O código acima é um exemplo de um shader de superfície que aplica uma textura e uma cor de realce ao objeto. A função surf calcula a cor final baseada nesses inputs e nas configurações de iluminação do modelo Lambert.

Exemplo de Shader de Vértice e Fragmento

Para um controle mais granular, podemos usar shaders de vértice e fragmento:

Shader "Custom/VertexFragmentShader"
{
    Properties
    {
        _MyTexture ("Base Texture", 2D) = "white" {}
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            // Diretivas para compilar os shaders de vértice e fragmento
            #pragma vertex vert_main
            #pragma fragment frag_main

            // Inclui um arquivo de cabeçalho comum do Unity
            #include "UnityCG.cginc"

            // Estrutura de dados de entrada para o shader de vértice
            struct appdata_custom
            {
                float4 vertex : POSITION;   // Posição do vértice no espaço do modelo
                float2 uv : TEXCOORD0;      // Coordenadas de textura
            };

            // Estrutura de dados para passar informações do vértice para o fragmento
            struct v2f_custom
            {
                float2 texcoord : TEXCOORD0; // Coordenadas de textura para o fragmento
                float4 clip_pos : SV_POSITION; // Posição do vértice no espaço de clip
            };

            // Declaração da textura
            sampler2D _MyTexture;

            // Função do shader de vértice
            v2f_custom vert_main (appdata_custom v)
            {
                v2f_custom o;
                // Transforma a posição do vértice do espaço do modelo para o espaço de clip
                o.clip_pos = UnityObjectToClipPos(v.vertex);
                // Passa as coordenadas de textura diretamente para o fragmento
                o.texcoord = v.uv;
                return o;
            }

            // Função do shader de fragmento
            fixed4 frag_main (v2f_custom i) : SV_Target
            {
                // Retorna a cor da textura nas coordenadas de textura recebidas
                return tex2D(_MyTexture, i.texcoord);
            }
            ENDCG
        }
    }
}

Neste exemplo, o shader de vértice vert_main transforma a posição do vértice para o espaço de tela e passa as coordenadas de textura. O shader de fragmneto frag_main usa essas coordenadas para amostrar a cor de uma textura.

Temas Avançados

• Variantes de Shader e Palavras-chave (Keywords): Permitem criar múltiplas versões de um shader que podem ser compiladas condicionalmente. Isso é crucial para otimizar o desempenho, ativando ou desativando certas características do shader (como efeitos de iluminação específicos) com base nas capacidades do hardware ou em configurações do jogo. A diretiva #pragma multi_compile é comumente usada para gerar essas variantes.
• Shaders de Computação: Utilizados para tarefas de computação na GPU que não envolvem diretamente a renderização de polígonos. Exemplos incluem simulações de partículas, processamento de imagens em tempo real, ou cálculos complexos de física.
• Performance de Shaders: Otimizar shaders é fundamental, especialmente para plataformas com recursos limitados como dispositivos móveis. Técnicas incluem minimizar o número de acessos a texturas, reduzir a complexidade dos cálculos matemáticos, otimizar o uso de registradores e escolher os modelos de iluminação adequados.