ShaderLab: Pass
ShaderLab: Blending

ShaderLab: Culling & Depth Testing

Culling es una optimización que no renderiza polígonos que se alejen del espectador. Todos los polígonos tienen un lado frontal y trasero. Culling se aprovecha del hecho de que la mayoría de los objetos están cerrado; si usted tiene un cubo, usted nunca verá los que están de espaldas (siempre hay una cara frente a usted) por lo que no necesitamos dibujar los lados que están de espaldas. Por lo tanto el término: Backface culling.

La otra característica que hace que el renderizado se vea correcto es Depth testing. Depth testing se asegura que solamente las superficies de los objetos cercanas sean dibujadas.

Sintaxis

Cull

Cull Back | Front | Off

Controla qué lados de los polígonos deberían ser culled (no dibujados)

  • Back No renderiza polígonos que estén de espaldas al espectador (predeterminado).

  • Front No renderiza los polígonos que encaran al espectador. Utilizado para voltear objetos de adentro hacia afuera.

  • Off Desactiva el culling - todas las caras son dibujadas. Utilizado para efectos especiales.

ZWrite

ZWrite On | Off

Controla si los pixeles de esté objeto están escritos al depth buffer (predeterminado es On). Si usted está dibujando objetos sólidos, deje esto prendido. Si usted está dibujando efectos semi-transparentes, cambie a ZWrite Off. Para más detalles lea abajo.

ZTest

ZTest Less | Greater | LEqual | GEqual | Equal | NotEqual | Always

Cómo se debería realizar el depth testing. El predeterminado es LEqual (dibuja los objeto o en la distancia como objetos existentes; oculta los objetos detrás de ellos).

Offset

Offset Factor, Units

Le permite a usted especificar un offset (desfase) de depth (profundidad) con dos parámetros. factor y units. Factor escala la pendiente Z máxima, con respecto a X o Y del polígono, y units escala el valor mínimo depth buffer. Esto le permite a usted obligarle a un polígono en ser dibujado encima de otro aunque en realidad estén en la misma posición. Por ejemplo Offset 0, –1 tira el polígono más cerca a la cámara ignorado la pendiente del polígono, dónde el Offset –1, –1 va a tirar el polígono incluso más cuando se mire desde un ángulo de incidencia.

Ejemplos

Este objeto solo va a renderizar las caras traseras de un objeto:

Shader "Show Insides" {
    SubShader {
        Pass {
            Material {
                Diffuse (1,1,1,1)
            }
            Lighting On
            Cull Front
        }
    }
}

Intente aplicarlo a un cubo, y mire cómo la geometría se siente todo mal cuando gira alrededor de este. Esto se debe a que usted solamente está viendo partes internas de su cubo.

Transparent shader con escrituras depth (profundas)

Usualmente los shaders semi-transparentes no escriben al depth buffer. Sin embargo, esto puede crear problemas de orden de dibujo, especialmente con meshes complejos no-convexos. Si usted quiere desvanecer de entrada y salida meshes así, entonces utilizar un shader que llene el depth buffer antes de renderizar transparencia podría ser útil.

Objeto semi-transparente; izquierda: Transparent/Diffuse shader; derecha: shader que escribe al depth buffer.
Objeto semi-transparente; izquierda: Transparent/Diffuse shader; derecha: shader que escribe al depth buffer.
Shader "Transparent/Diffuse ZWrite" {
Properties {
    _Color ("Main Color", Color) = (1,1,1,1)
    _MainTex ("Base (RGB) Trans (A)", 2D) = "white" {}
}
SubShader {
    Tags {"Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent"}
    LOD 200

    // extra pass that renders to depth buffer only
    Pass {
        ZWrite On
        ColorMask 0
    }

    // paste in forward rendering passes from Transparent/Diffuse
    UsePass "Transparent/Diffuse/FORWARD"
}
Fallback "Transparent/VertexLit"
}

Depurando normales

El siguiente es más interesante; primero renderizamos el objeto con una iluminación normal vertex, luego renderizamos las caras traseras con un brillo rosado. Esto tiene el efecto de resaltar dónde sea que sus normales necesiten ser volteadas. Si usted ve que los objetos que están controlados por físicas son ‘chupados’ por cualquier mesh, intente asignar este shader a ellos. Si cualquier parte rosada está visible, estas partes van a jalar cualquier cosa que tenga la desdicha de tocarla.

Aquí vamos:

Shader "Reveal Backfaces" {
    Properties {
        _MainTex ("Base (RGB)", 2D) = "white" { }
    }
    SubShader {
        // Render the front-facing parts of the object.
        // We use a simple white material, and apply the main texture.
        Pass {
            Material {
                Diffuse (1,1,1,1)
            }
            Lighting On
            SetTexture [_MainTex] {
                Combine Primary * Texture
            }
        }

        // Now we render the back-facing triangles in the most
        // irritating color in the world: BRIGHT PINK!
        Pass {
            Color (1,0,1,1)
            Cull Front
        }
    }
}

Glass (vidrio) Culling

Controlar Culling es útil para más que depurar caras traseras. Si usted tiene objetos transparentes, usualmente usted quiere mostrar el lado trasero de un objeto. Si usted renderiza sin ningún culling (Cull Off), es bastante probable que usted tenga algunas caras traseras sobre-poniéndose a las caras delanteras.

Aquí hay un shader simple que funcionará en los objetos convexos (esferas, cubos, parabrisas de coches).

Shader "Simple Glass" {
    Properties {
        _Color ("Main Color", Color) = (1,1,1,0)
        _SpecColor ("Spec Color", Color) = (1,1,1,1)
        _Emission ("Emmisive Color", Color) = (0,0,0,0)
        _Shininess ("Shininess", Range (0.01, 1)) = 0.7
        _MainTex ("Base (RGB)", 2D) = "white" { }
    }

    SubShader {
        // We use the material in many passes by defining them in the subshader.
        // Anything defined here becomes default values for all contained passes.
        Material {
            Diffuse [_Color]
            Ambient [_Color]
            Shininess [_Shininess]
            Specular [_SpecColor]
            Emission [_Emission]
        }
        Lighting On
        SeparateSpecular On

        // Set up alpha blending
        Blend SrcAlpha OneMinusSrcAlpha

        // Render the back facing parts of the object.
        // If the object is convex, these will always be further away
        // than the front-faces.
        Pass {
            Cull Front
            SetTexture [_MainTex] {
                Combine Primary * Texture
            }
        }
        // Render the parts of the object facing us.
        // If the object is convex, these will be closer than the
        // back-faces.
        Pass {
            Cull Back
            SetTexture [_MainTex] {
                Combine Primary * Texture
            }
        }
    }
}
ShaderLab: Pass
ShaderLab: Blending