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).
Los arreglos de textura necesitan ser compatibles con la API gráfica subyacente y la GPU. Están disponibles en:
Otras plataformas no admiten arreglos de textura (Direct3D 9, OpenGL ES 2.0 o WebGL 1.0). Utilice SystemInfo.supports2DArrayTextures para determinar el soporte de arreglo de textura en tiempo de ejecución.
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.
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.
Dado que los arreglos de textura no funcionan en todas las plataformas, los shaders deben utilizar un objetivo de compilación adecuado para acceder a ellos. El objetivo de compilación del modelo shader mínimo que admite arreglos de textura es 3.5.
Utilice estas macros para declarar y muestrar arreglos de textura:
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
// to use texture arrays we need to target DX10/OpenGLES3 which
// is shader model 3.5 minimum
#pragma target 3.5
#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
}
}
}