# Constantes de Textura

## Modos de Mapeamento

`THREE.UVMapping THREE.CubeReflectionMapping THREE.CubeRefractionMapping THREE.EquirectangularReflectionMapping THREE.EquirectangularRefractionMapping THREE.CubeUVReflectionMapping`

Definem o modo de mapeamento da textura.
[page:Constant UVMapping] é o padrão e mapeia a textura usando as coordenadas UV do mesh.
O restante define tipos de mapeamento de ambiente.
[page:Constant CubeReflectionMapping] e [page:Constant CubeRefractionMapping] são usados com um [page:CubeTexture CubeTexture], que é composto por seis texturas, uma para cada face do cubo. [page:Constant CubeReflectionMapping] é o padrão para um [page:CubeTexture CubeTexture].
[page:Constant EquirectangularReflectionMapping] e [page:Constant EquirectangularRefractionMapping] são para uso com um mapa de ambiente equirretangular. Também chamado de mapa lat-long, uma textura equirretangular representa uma vista de 360 ​​graus ao longo da linha central horizontal e uma vista de 180 graus ao longo da eixo vertical, com as bordas superior e inferior da imagem correspondendo aos pólos norte e sul de uma esfera mapeada.
Veja o exemplo [example:webgl_materials_envmaps materials / envmaps].

## Modos de Envolvimento (Wrapping Modes)

`THREE.RepeatWrapping THREE.ClampToEdgeWrapping THREE.MirroredRepeatWrapping`

Eles definem as propriedades [page:Texture.wrapS wrapS] e [page:Texture.wrapT wrapT] da textura, que definem o envolvimento de textura horizontal e vertical.
Com [page:constant RepeatWrapping] a textura simplesmente se repetirá até o infinito.
[page:constant ClampToEdgeWrapping] é o padrão. O último pixel da textura se estende até a borda da malha.
Com [page:constant MirroredRepeatWrapping] a textura se repetirá ao infinito, espelhando-se em cada repetição.

## Filtros de Ampliação (Magnification Filters)

`THREE.NearestFilter THREE.LinearFilter`

Para uso com a propriedade [page:Texture.magFilter magFilter] de uma textura, eles definem a função de ampliação de textura que é usada quando o pixel que está sendo texturizado mapeia para uma área menor ou igual a um elemento de textura (texel).
[page:constant NearestFilter] retorna o valor do elemento de textura mais próximo (na distância Manhattan) para as coordenadas de textura especificadas.
[page:constant LinearFilter] é o padrão e retorna a média ponderada dos quatro elementos de textura que estão mais próximos das coordenadas de textura especificadas, e pode incluir itens embrulhados ou repetidos de outras partes de uma textura, dependendo dos valores de [page:Texture.wrapS wrapS] e [page:Texture.wrapT wrapT], e no mapeamento exato.

## Filtros de Redução (Minification Filters)

`THREE.NearestFilter THREE.NearestMipmapNearestFilter THREE.NearestMipmapLinearFilter THREE.LinearFilter THREE.LinearMipmapNearestFilter THREE.LinearMipmapLinearFilter`

Para uso com a propriedade [page:Texture.minFilter minFilter] de uma textura, eles definem a função de redução de textura que é usada sempre que o pixel que está sendo texturizado mapeia para uma área maior que um elemento de textura (texel).
Além do [page:constant NearestFilter] e do [page:constant LinearFilter], as quatro funções a seguir podem ser usadas para minificação:
[page:constant NearestMipmapNearestFilter] escolhe o mipmap que mais se aproxima ao tamanho do pixel que está sendo texturizado e usa o critério [page:constant NearestFilter] (o texel mais próximo do centro do pixel) para produzir um valor de textura.
[page:constant NearestMipmapLinearFilter] escolhe os dois mipmaps que mais se aproximam ao tamanho do pixel que está sendo texturizado e usa o critério [page:constant NearestFilter] para produzir um valor de textura de cada mipmap. O valor final da textura é uma média ponderada desses dois valores.
[page:constant LinearMipmapNearestFilter] escolhe o mipmap que mais se aproxima do tamanho do pixel que está sendo texturizado e usa o critério [page:constant LinearFilter] (uma média ponderada dos quatro texels que estão mais próximos do centro do pixel) para produzir um valor de textura.
[page:constant LinearMipmapLinearFilter] é o padrão e escolhe os dois mipmaps que mais se aproximam do tamanho do pixel que está sendo texturizado e usa o critério [page:constant LinearFilter] para produzir um valor de textura de cada mipmap. O valor final da textura é uma média ponderada desses dois valores.
Veja o exemplo [example:webgl_materials_texture_filters materials / texture / filters].

## Tipos

`THREE.UnsignedByteType THREE.ByteType THREE.ShortType THREE.UnsignedShortType THREE.IntType THREE.UnsignedIntType THREE.FloatType THREE.HalfFloatType THREE.UnsignedShort4444Type THREE.UnsignedShort5551Type THREE.UnsignedInt248Type THREE.UnsignedInt5999Type`

Para uso com a propriedade [page:Texture.type type] de uma textura, que deve corresponder ao formato correto. Veja abaixo para detalhes.
[page:constant UnsignedByteType] é o padrão.

## Formatos

`THREE.AlphaFormat THREE.RedFormat THREE.RedIntegerFormat THREE.RGFormat THREE.RGIntegerFormat THREE.RGBFormat THREE.RGBAFormat THREE.RGBAIntegerFormat THREE.LuminanceFormat THREE.LuminanceAlphaFormat THREE.DepthFormat THREE.DepthStencilFormat`

Para uso com a propriedade [page:Texture.format format] de uma textura, eles definem como os elementos de uma textura 2D, ou `texels`, são lidos por shaders.
[page:constant AlphaFormat] descarta os componentes vermelho, verde e azul e lê apenas o componente alfa.
[page:constant RedFormat] descarta os componentes verde e azul e lê apenas o componente vermelho.
[page:constant RedIntegerFormat] descarta os componentes verde e azul e lê apenas o componente vermelho. Os texels são lidos como inteiros em vez de ponto flutuante.
[page:constant RGFormat] descarta os componentes alfa e azul e lê os componentes vermelho e verde.
[page:constant RGIntegerFormat] descarta os componentes alfa e azul e lê os componentes vermelho e verde. Os texels são lidos como inteiros em vez de ponto flutuante.
[page:constant RGBAFormat] é o padrão e lê os componentes vermelho, verde, azul e alfa.
[page:constant RGBAIntegerFormat] é o padrão e lê os componentes vermelho, verde, azul e alfa. Os texels são lidos como inteiros em vez de ponto flutuante.
[page:constant LuminanceFormat] lê cada elemento como um único componente de luminância. Este é então convertido em um ponto flutuante, fixado no intervalo [0,1], e então montado em um elemento RGBA, colocando o valor de luminância nos canais vermelho, verde e azul, e anexando 1.0 ao canal alfa.
[page:constant LuminanceAlphaFormat] lê cada elemento como um duplo de luminância/alfa. O mesmo processo ocorre para o [page:constant LuminanceFormat], exceto que o o canal alfa pode ter valores diferentes de `1.0`.
[page:constant DepthFormat] lê cada elemento como um único valor de profundidade, converte-o em ponto flutuante e fixa no intervalo [0,1]. Este é o padrão para [page:DepthTexture DepthTexture].
[page:constant DepthStencilFormat] lê cada elemento como um par de valores de profundidade e estêncil. O componente de profundidade do par é interpretado como um [page:constant DepthFormat]. O componente de estêncil é interpretado com base no formato interno de profundidade + estêncil.
Observe que a textura deve ter o conjunto [page:Texture.type type] correto, conforme descrito acima. Veja [link:https://developer.mozilla.org/en/docs/Web/API/WebGLRenderingContext/texImage2D WebGLRenderingContext.texImage2D] para detalhes.

## Formatos de Textura Compactados DDS / ST3C

`THREE.RGB_S3TC_DXT1_Format THREE.RGBA_S3TC_DXT1_Format THREE.RGBA_S3TC_DXT3_Format THREE.RGBA_S3TC_DXT5_Format`

Para uso com a propriedade [page:Texture.format format] de uma [page:CompressedTexture CompressedTexture], requerem suporte para a extensão [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_s3tc/ WEBGL_compressed_texture_s3tc].
Existem quatro formatos [link:https://en.wikipedia.org/wiki/S3_Texture_Compression S3TC] disponíveis por meio desta extensão. São esses:
[page:constant RGB_S3TC_DXT1_Format]: Uma imagem compactada em DXT1 em um formato de imagem RGB.
[page:constant RGBA_S3TC_DXT1_Format]: Uma imagem compactada em DXT1 em um formato de imagem RGB com um valor alfa de ativação/desativação simples.
[page:constant RGBA_S3TC_DXT3_Format]: Uma imagem compactada em DXT3 em um formato de imagem RGBA. Comparado a uma textura RGBA de 32 bits, oferece compressão 4:1.
[page:constant RGBA_S3TC_DXT5_Format]: Uma imagem compactada em DXT5 em um formato de imagem RGBA. Ele também fornece uma compactação 4:1, mas difere da compactação DXT3 na forma como a compactação alfa é feita.

## Formato de Textura Compactado PVRTC

`THREE.RGB_PVRTC_4BPPV1_Format THREE.RGB_PVRTC_2BPPV1_Format THREE.RGBA_PVRTC_4BPPV1_Format THREE.RGBA_PVRTC_2BPPV1_Format`

Para uso com a propriedade [page:Texture.format format] de uma [page:CompressedTexture CompressedTexture], requerem suporte para a extensão [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_pvrtc/ WEBGL_compressed_texture_pvrtc].
PVRTC is typically only available on mobile devices with PowerVR chipsets, which are mainly Apple devices.
Existem quatro formatos [link:https://en.wikipedia.org/wiki/PVRTC PVRTC] disponíveis por meio desta extensão. São esses:
[page:constant RGB_PVRTC_4BPPV1_Format]: Compressão RGB no modo de 4 bits. Um bloco para cada 4×4 pixels.
[page:constant RGB_PVRTC_2BPPV1_Format]: Compressão RGB no modo de 2 bits. Um bloco para cada 8×4 pixels.
[page:constant RGBA_PVRTC_4BPPV1_Format]: Compressão RGBA no modo de 4 bits. Um bloco para cada 4×4 pixels.
[page:constant RGBA_PVRTC_2BPPV1_Format]: Compressão RGBA no modo de 2 bits. Um bloco para cada 8×4 pixels.

## Formato de Textura Compactado ETC

`THREE.RGB_ETC1_Format THREE.RGB_ETC2_Format THREE.RGBA_ETC2_EAC_Format`

Para uso com a propriedade [page:Texture.format format] de uma [page:CompressedTexture CompressedTexture], requerem suporte para a extensão [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_etc1/ WEBGL_compressed_texture_etc1] (ETC1) ou [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_etc/ WEBGL_compressed_texture_etc] (ETC2).

## Formato de Textura Compactado ASTC

`THREE.RGBA_ASTC_4x4_Format THREE.RGBA_ASTC_5x4_Format THREE.RGBA_ASTC_5x5_Format THREE.RGBA_ASTC_6x5_Format THREE.RGBA_ASTC_6x6_Format THREE.RGBA_ASTC_8x5_Format THREE.RGBA_ASTC_8x6_Format THREE.RGBA_ASTC_8x8_Format THREE.RGBA_ASTC_10x5_Format THREE.RGBA_ASTC_10x6_Format THREE.RGBA_ASTC_10x8_Format THREE.RGBA_ASTC_10x10_Format THREE.RGBA_ASTC_12x10_Format THREE.RGBA_ASTC_12x12_Format`

Para uso com a propriedade [page:Texture.format format] de uma [page:CompressedTexture CompressedTexture], requerem suporte para a extensão [link:https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/ WEBGL_compressed_texture_astc].

## BPTC Compressed Texture Format

`THREE.RGBA_BPTC_Format`

Para uso com a propriedade [page:Texture.format format] de uma [page:CompressedTexture CompressedTexture], requerem suporte para a extensão [link:https://www.khronos.org/registry/webgl/extensions/EXT_texture_compression_bptc/ EXT_texture_compression_bptc].

## Formatos Internos

`'ALPHA' 'RGB' 'RGBA' 'LUMINANCE' 'LUMINANCE_ALPHA' 'RED_INTEGER' 'R8' 'R8_SNORM' 'R8I' 'R8UI' 'R16I' 'R16UI' 'R16F' 'R32I' 'R32UI' 'R32F' 'RG8' 'RG8_SNORM' 'RG8I' 'RG8UI' 'RG16I' 'RG16UI' 'RG16F' 'RG32I' 'RG32UI' 'RG32F' 'RGB565' 'RGB8' 'RGB8_SNORM' 'RGB8I' 'RGB8UI' 'RGB16I' 'RGB16UI' 'RGB16F' 'RGB32I' 'RGB32UI' 'RGB32F' 'RGB9_E5' 'SRGB8' 'R11F_G11F_B10F' 'RGBA4' 'RGBA8' 'RGBA8_SNORM' 'RGBA8I' 'RGBA8UI' 'RGBA16I' 'RGBA16UI' 'RGBA16F' 'RGBA32I' 'RGBA32UI' 'RGBA32F' 'RGB5_A1' 'RGB10_A2' 'RGB10_A2UI' 'SRGB8_ALPHA8' 'DEPTH_COMPONENT16' 'DEPTH_COMPONENT24' 'DEPTH_COMPONENT32F' 'DEPTH24_STENCIL8' 'DEPTH32F_STENCIL8'`

Para uso com a propriedade [page:Texture.internalFormat internalFormat] de uma textura, definem como os elementos de uma textura, ou `texels`, são armazenados na GPU.
[page:constant R8] armazena o componente vermelho em 8 bits.
[page:constant R8_SNORM] armazena o componente vermelho em 8 bits. O componente é armazenado como normalizado.
[page:constant R8I] armazena o componente vermelho em 8 bits. O componente é armazenado como um inteiro.
[page:constant R8UI] armazena o componente vermelho em 8 bits. O componente é armazenado como um inteiro sem sinal.
[page:constant R16I] armazena o componente vermelho em 16 bits. O componente é armazenado como um inteiro.
[page:constant R16UI] armazena o componente vermelho em 16 bits. O componente é armazenado como um inteiro sem sinal.
[page:constant R16F] armazena o componente vermelho em 16 bits. O componente é armazenado como ponto flutuante.
[page:constant R32I] armazena o componente vermelho em 32 bits. O componente é armazenado como um inteiro.
[page:constant R32UI] armazena o componente vermelho em 32 bits. O componente é armazenado como um inteiro sem sinal.
[page:constant R32F] armazena o componente vermelho em 32 bits. O componente é armazenado como ponto flutuante.
[page:constant RG8] armazena os componentes vermelho e verde em 8 bits cada.
[page:constant RG8_SNORM] armazena os componentes vermelho e verde em 8 bits cada. Cada componente é armazenado como normalizado.
[page:constant RG8I] armazena os componentes vermelho e verde em 8 bits cada. Cada componente é armazenado como um inteiro.
[page:constant RG8UI] armazena os componentes vermelho e verde em 8 bits cada. Cada componente é armazenado como um inteiro sem sinal.
[page:constant RG16I] armazena os componentes vermelho e verde em 16 bits cada. Cada componente é armazenado como um inteiro.
[page:constant RG16UI] armazena os componentes vermelho e verde em 16 bits cada. Cada componente é armazenado como um inteiro sem sinal.
[page:constant RG16F] armazena os componentes vermelho e verde em 16 bits cada. Cada componente é armazenado como ponto flutuante.
[page:constant RG32I] armazena os componentes vermelho e verde em 32 bits cada. Cada componente é armazenado como um inteiro.
[page:constant RG32UI] armazena os componentes vermelho e verde em 32 bits. Cada componente é armazenado como um inteiro sem sinal.
[page:constant RG32F] armazena os componentes vermelho e verde em 32 bits. Cada componente é armazenado como ponto flutuante.
[page:constant RGB8] armazena os componentes vermelho, verde e azul em 8 bits cada. [page:constant RGB8_SNORM] armazena os componentes vermelho, verde e azul em 8 bits cada. Cada componente é armazenado como normalizado.
[page:constant RGB8I] armazena os componentes vermelho, verde e azul em 8 bits cada. Cada componente é armazenado como um inteiro.
[page:constant RGB8UI] armazena os componentes vermelho, verde e azul em 8 bits cada. Cada componente é armazenado como um inteiro sem sinal.
[page:constant RGB16I] armazena os componentes vermelho, verde e azul em 16 bits cada. Cada componente é armazenado como um inteiro.
[page:constant RGB16UI] armazena os componentes vermelho, verde e azul em 16 bits cada. Cada componente é armazenado como um inteiro sem sinal.
[page:constant RGB16F] armazena os componentes vermelho, verde e azul em 16 bits cada. Cada componente é armazenado como ponto flutuante.
[page:constant RGB32I] armazena os componentes vermelho, verde e azul em 32 bits cada. Cada componente é armazenado como um inteiro.
[page:constant RGB32UI] armazena os componentes vermelho, verde e azul em 32 bits cada. Cada componente é armazenado como um inteiro sem sinal.
[page:constant RGB32F] armazena os componentes vermelho, verde e azul em 32 bits cada. Cada componente é armazenado como ponto flutuante.
[page:constant R11F_G11F_B10F] armazena os componentes vermelho, verde e azul, respectivamente, em 11 bits, 11 bits e 10 bits. Cada componente é armazenado como ponto flutuante.
[page:constant RGB565] armazena os componentes vermelho, verde e azul, respectivamente, em 5 bits, 6 bits e 5 bits.
[page:constant RGB9_E5] armazena os componentes vermelho, verde e azul em 9 bits cada.
[page:constant RGBA8] armazena os componentes vermelho, verde, azul e alfa em 8 bits cada.
[page:constant RGBA8_SNORM] armazena os componentes vermelho, verde, azul e alfa em 8 bits. Cada componente é armazenado como normalizado.
[page:constant RGBA8I] armazena os componentes vermelho, verde, azul e alfa em 8 bits cada. Cada componente é armazenado como um inteiro.
[page:constant RGBA8UI] armazena os componentes vermelho, verde, azul e alfa em 8 bits. Cada componente é armazenado como um inteiro sem sinal.
[page:constant RGBA16I] armazena os componentes vermelho, verde, azul e alfa em 16 bits. Cada componente é armazenado como um inteiro.
[page:constant RGBA16UI] armazena os componentes vermelho, verde, azul e alfa em 16 bits. Cada componente é armazenado como um inteiro sem sinal.
[page:constant RGBA16F] armazena os componentes vermelho, verde, azul e alfa em 16 bits. Cada componente é armazenado como ponto flutuante.
[page:constant RGBA32I] armazena os componentes vermelho, verde, azul e alfa em 32 bits. Cada componente é armazenado como um inteiro.
[page:constant RGBA32UI] armazena os componentes vermelho, verde, azul e alfa em 32 bits. Cada componente é armazenado como um inteiro sem sinal.
[page:constant RGBA32F] armazena os componentes vermelho, verde, azul e alfa em 32 bits. Cada componente é armazenado como ponto flutuante.
[page:constant RGB5_A1] armazena os componentes vermelho, verde, azul e alfa, respectivamente, em 5 bits, 5 bits, 5 bits e 1 bit.
[page:constant RGB10_A2] armazena os componentes vermelho, verde, azul e alfa, respectivamente, em 10 bits, 10 bits, 10 bits e 2 bits.
[page:constant RGB10_A2UI] armazena os componentes vermelho, verde, azul e alfa, respectivamente, em 10 bits, 10 bits, 10 bits e 2 bits. Cada componente é armazenado como um inteiro sem sinal.
[page:constant SRGB8] armazena os componentes vermelho, verde e azul em 8 bits cada.
[page:constant SRGB8_ALPHA8] armazena os componentes vermelho, verde, azul e alfa em 8 bits cada.
[page:constant DEPTH_COMPONENT16] armazena o componente de profundidade em 16 bits.
[page:constant DEPTH_COMPONENT24] armazena o componente de profundidade em 24 bits.
[page:constant DEPTH_COMPONENT32F] armazena o componente de profundidade em 32 bits. O componente é armazenado como ponto flutuante.
[page:constant DEPTH24_STENCIL8] armazena os componentes de profundidade e estêncil, respectivamente, em 24 bits e 8 bits. O componente de estêncil é armazenado como um inteiro sem sinal.
[page:constant DEPTH32F_STENCIL8] armazena os componentes de profundidade e estêncil, respectivamente, em 32 bits e 8 bits. O componente de profundidade é armazenado como ponto flutuante e o componente de estêncil como um inteiro sem sinal.
Observe que a textura deve ter o [page:Texture.type type] correto, bem como o [page:Texture.format format] correto. Veja [link:https://developer.mozilla.org/en/docs/Web/API/WebGLRenderingContext/texImage2D WebGLRenderingContext.texImage2D], e [link:https://developer.mozilla.org/en-US/docs/Web/API/WebGL2RenderingContext/texImage3D WebGL2RenderingContext.texImage3D], para obter mais detalhes sobre a possível combinação de [page:Texture.format format], [page:Texture.internalFormat internalFormat], e [page:Texture.type type].
Para obter informações mais detalhadas sobre os formatos internos, você também pode consultar diretamente a especificação [link:https://www.khronos.org/registry/webgl/specs/latest/2.0/ WebGL2] e a especificação [link:https://www.khronos.org/registry/OpenGL/specs/es/3.0/es_spec_3.0.pdf OpenGL ES 3.0].

## Depth Packing

`THREE.BasicDepthPacking THREE.RGBADepthPacking`

For use with the [page:MeshDepthMaterial.depthPacking depthPacking] property of `MeshDepthMaterial`.

## Color Space

`THREE.NoColorSpace = "" THREE.SRGBColorSpace = "srgb" THREE.LinearSRGBColorSpace = "srgb-linear"`

Used to define the color space of textures (and the output color space of the renderer).
If the color space type is changed after the texture has already been used by a material, you will need to set [page:Material.needsUpdate Material.needsUpdate] to `true` to make the material recompile.

## Source

[link:https://github.com/mrdoob/three.js/blob/master/src/constants.js src/constants.js]