Escribiendo Vertex y fragment shaders

Los shaders ShaderLab abarcan más que simplemente “shaders de hardware”. Ellos hacen muchas cosas. Ellos describen propiedades que son mostradas en el Inspector del Material, contiene múltiples implementaciones de shader para diferente hardware de gráficos, configura el estado de hardware de funciones fijas y así. Los shaders programables actuales - como los programas vertex y fragment - son simplemente una parte de todo el concepto “shader” del ShaderLab. Eche un vistazo al totorial shader para una introducción básica. Aquí nosotros llamaremos los shaders de baja gama de hardware shader programs.

If you want to write shaders that interact with lighting, take a look at Surface Shaders documentation. For some examples, take a look at Vertex and Fragment Shader Examples. The rest of this page assumes shaders do not interact with Unity lights (for example special effects, post-processed effects etc.)

Shader programs are written in HLSL language, by embedding “snippets” in the shader text, somewhere inside the Pass command. They usually look like this:

  Pass {
        // ... the usual pass state setup ...
      
        CGPROGRAM
        // compilation directives for this snippet, e.g.:
        #pragma vertex vert
        #pragma fragment frag
      
        // the Cg/HLSL code itself
      
        ENDCG
        // ... the rest of pass setup ...
    }

Fragmentos HLSL

Los fragmentos del programa HLSL se escriben entre las palabras clave CGPROGRAM y ENDCG, o alternativamente entre HLSLPROGRAM y ENDHLSL. La última forma no incluye automáticamente HLSLSupport y UnityShaderVariables archivos de cabecera incorporados.

Al comienzo de las directivas de compilación snippet pueden ser dadas como declaraciones #pragma. Las directivas indican qué funciones del shader van a ser compiladas:

#pragma vertex name - compile la función name como el vertex shader.
#pragma fragment name - compile la función name como el fragment shader.
#pragma geometry name - compile la función name como el DX10 geometry shader. Tener esta opción automáticamente prende el #pragma target 4.0 (objetivo) , descrito a continuación.
#pragma hull name - compile la función name como el DX11 hull shader. Tener esta opción automáticamente prende el #pragma target 5.0 (objetivo), descrito a continuación.
#pragma domain name - compile la función name como DX11 domain shader. Tener esta opción automáticamente prende el #pragma target 5.0 (objetivo), descrito a continuación.

Otras directivas de compilación;

#pragma target name - qué shader target a compilar. Mire la página Shader Compilation Targets para detalles.
#pragma require feature … - fine grained control on which GPU features a shader needs, see Shader Compilation Targets page for details.
#pragma only_renderers space separated names - compile la función shader solamente para dados renderizados. Por defecto los shaders son compilados a todos los renderizados. Mire Renderers a continuación para más detalles.
#pragma exclude_renderers space separated names - no compile el shader para los dados renderizadores. Por defecto, los shaders son compilados a todos los renderizadores. Mire Renderers a continuación para más detalles.
#pragma multi_compile … - for working with multiple shader variants. Unused variants of multi_compile shaders are included in the game build.
#pragma multi_compile_local … - similar to multi_compile, but enumerated keywords are local. See Making multiple shader program variants: Keyword limits for more information.
#pragma shader_feature … - for working with multiple shader variants. Unused variants of shader_feature shaders are not included in the game build.
#pragma shader_feature_local … - similar to shader_feature, but enumerated keywords are local. See Making multiple shader program variants: Keyword limits for more information.
#pragma enable_d3d11_debug_symbols - genera información de depuración para los shaders compilados para DirectX 11, esto le permite a usted depurar shaders vía el depurador de Gráficos Visual Studio 2012 (o la última versión). #pragma hardware_tier_variants renderer name - genera varios shader hardware variants de cada shader compilado, para cada nivel de hardware que podría ejecutar el renderizador seleccionado. Mire Renderers para más detalles.
#pragma hlslcc_bytecode_disassembly - embed disassembled HLSLcc bytecode into translated shader.
#pragma disable_fastmath - enables precise IEEE 754 rules, mostly involving NaN handling (currently only affects Metal platform).
#pragma glsl_es2 - When set in a GLSL shader, generate a GLSL ES 1.0(OpenGL ES 2.0), even when the shader target is OpenGL ES 3.
#pragma editor_sync_compilation - Force synchronous compilation (affects Editor only).

Cada snippet debe contener al menos un programa vertex y un programa fragment. Por lo tanto, las directivas #pragma vertex y #pragma fragment son requeridas.

Directivas de compilación que no hacen nada a partir de Unity 5.0 y pueden eliminarse con seguridad: #pragma glsl, #pragma glsl_no_auto_normalization, #pragma profileoption, #pragma fragmentoption.

Unity only supports #pragma directives in the shader files, and not in the includes.

Plataformas de Renderizado

Unity supports several rendering APIs (e.g. Direct3D 11 and OpenGL), and by default all shader programs are compiled into all supported renderers. You can indicate which renderers to compile to using #pragma only_renderers or #pragma exclude_renderers directives. This is mostly useful in cases where you are explicitly using some shader language features that you know aren’t possible on some platforms. Supported renderer names are:

d3d11 - Direct3D 11/12
glcore - OpenGL 3.x/4.x
gles - OpenGL ES 2.0
gles3 - OpenGL ES 3.x
metal - iOS/Mac Metal
vulkan - Vulkan
d3d11_9x - Direct3D 11 9.x feature level, as commonly used on WSA platforms
xboxone - Xbox One
ps4 - PlayStation 4
n3ds - Nintendo 3DS
wiiu - Nintendo Wii U

For example, this line would only compile shader into D3D11 mode:

#pragma only_renderers d3d11

Véase también

2018–03–20 Page amended
Shader #pragma directives added in Unity 2018.1

Surface Shaders con Teselación DX11 / OpenGL Core

Ejemplos del Vertex y Fragment Shader