Texture arrays (arreglos de Textura)

Similar a las texturas 2D normales (clase Texture2D, sampler2D en shaders), cube maps (clase Cubemap , samplerCUBE en shaders) y texturas 3D (clase Texture3D, sampler3D en shaders), Unity también soporta arreglos de textura 2D.

Una arreglo de textura es una colección de texturas con el mismo tamaño/formato/banderas que se ven como un solo objeto en la GPU, y se pueden muestrear en el shader con un índice de elementos de textura. Son útiles para implementar sistemas personalizados de renderización del terreno u otros efectos especiales donde se necesita una forma eficiente de acceder a muchas texturas del mismo tamaño y formato. Los elementos de un arreglo de textura 2D también se conocen como slices (rebanadas) o layers (capas).

Soporte de Plataforma

Los arreglos de textura necesitan ser compatibles con la API gráfica subyacente y la GPU. Están disponibles en:

• Direct3D 11/12 (Windows, Xbox One)
• OpenGL Core (Mac OS X, Linux)
• Metal (iOS, Mac OS X)
• OpenGL ES 3.0 (Android, iOS, WebGL 2.0)
• PlayStation 4

Other platforms do not support texture arrays (OpenGL ES 2.0 or WebGL 1.0). Use SystemInfo.supports2DArrayTextures to determine texture array support at runtime.

Creando y manipulando arreglos de Textura

Dado que no hay una pipeline de importación de texturas para arreglos de textura, estas deben crearse desde sus scripts. Utilice la clase Texture2DArray para crearlos y manipularlos. Tenga en cuenta que los arrays de textura se pueden serializar como assets, por lo que es posible crearlos y rellenarlos con los datos de los scripts del editor.

Normalmente, los arreglos de textura se utilizan puramente dentro de la memoria GPU, pero puede utilizar Graphics.CopyTexture, Texture2DArray.GetPixels y Texture2DArray.SetPixels para transferir píxeles hacia y desde la memoria del sistema.

Utilizando arreglos de textura como render targets

Los elementos del arreglo de textura también se pueden utilizar como render targets. Utilice RenderTexture.dimension para especificar de antemano si el render target debe ser una arreglo de textura 2D. El argumento depthSlice a Graphics.SetRenderTarget especifica el nivel de mipmap o la cara del mapa de cubos para renderizar. En plataformas que admiten “renderizado en capas” (es decir, geometry shaders), puede configurar el argumento depthSlice en –1 para establecer toda la arreglo de textura como un render target. También puede utilizar un geometry shader para renderizar en elementos individuales.

Utilizando arreglos de textura en shaders

Since texture arrays do not work on all platforms, shaders need to use an appropriate compilation target or feature requirement to access them. The minimum shader model compilation target that supports texture arrays is 3.5, and the feature name is 2darray.

Utilice estas macros para declarar y muestrar arreglos de textura:

• UNITY_DECLARE_TEX2DARRAY(name) declara una variable texture array sampler dentro del código HLSL.
• UNITY_SAMPLE_TEX2DARRAY(name,uv) muestrea un arreglo de textura con un float3 UV; El componente z de la coordenada es un índice de elemento del arreglo.
• UNITY_SAMPLE_TEX2DARRAY_LOD(name,uv,lod) muestrea un arreglo de textura con un nivel mipmap explícito.

Ejemplos

El siguiente ejemplo shader muestrea un arreglo de textura utilizando las posiciones de vértice del espacio de objetos como coordenadas:

Shader "Example/Sample2DArrayTexture"
{
    Properties
    {
        _MyArr ("Tex", 2DArray) = "" {}
        _SliceRange ("Slices", Range(0,16)) = 6
        _UVScale ("UVScale", Float) = 1.0
    }
    SubShader
    {
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            // texture arrays are not available everywhere,
            // only compile shader on platforms where they are
            #pragma require 2darray
            
            #include "UnityCG.cginc"

            struct v2f
            {
                float3 uv : TEXCOORD0;
                float4 vertex : SV_POSITION;
            };

            float _SliceRange;
            float _UVScale;

            v2f vert (float4 vertex : POSITION)
            {
                v2f o;
                o.vertex = mul(UNITY_MATRIX_MVP, vertex);
                o.uv.xy = (vertex.xy + 0.5) * _UVScale;
                o.uv.z = (vertex.z + 0.5) * _SliceRange;
                return o;
            }
            
            UNITY_DECLARE_TEX2DARRAY(_MyArr);

            half4 frag (v2f i) : SV_Target
            {
                return UNITY_SAMPLE_TEX2DARRAY(_MyArr, i.uv);
            }
            ENDCG
        }
    }
}

Mirar también

• Introducción A Texturas en la documentación de Direct3D.
• Textures Arreglo en OpenGL Wiki.

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