GraphicsFormat
GraphicsFormat is used to specify the pixel format of a texture, including the number of color channels, the bit depth of each channel, and whether compression is used. GraphicsFormat contains a large number of enumeration values to support various pixel formats.
| attributes | description |
|---|---|
| None | Represents no specified pixel format, typically used to indicate no texture or render target. |
| R8_SRGB | Use an 8-bit pixel format that contains only a red channel, using the sRGB color space to represent color values. |
| R8G8_SRGB | Use a 16-bit pixel format that includes two channels for the sRGB color space (SRGB), with each channel represented by 8 bits for color values. |
| R8G8B8_SRGB | Use a 24-bit pixel format that includes three unsigned integer channels in SRGB format, with 8 bits used to represent the color value for each channel. |
| R8G8B8A8_SRGB | Use a 32-bit pixel format that includes an alpha channel and three SRGB (Standard RGB) channels, with each channel using 8 bits to represent color values. |
| R8_UNorm | Using an 8-bit pixel format that contains only a single R channel, with each channel using 8 bits to represent the color value, without an alpha channel. |
| R8G8_UNorm | Use a 16-bit pixel format that includes two unsigned normalized (UNorm) integer channels, with each channel using 8 bits to represent color values. |
| R8G8B8_UNorm | Use a 24-bit pixel format that includes three RGB channels, with each channel represented by an 8-bit unsigned integer to represent color values ranging from 0 to 255. |
| R8G8B8A8_UNorm | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with 8 bits used to represent the color value for each channel. |
| R8_SNorm | Use an 8-bit pixel format that contains only one R channel, with 1 sign bit and 7 bits used to represent the color value. |
| R8G8_SNorm | Use a 16-bit pixel format that includes two signed normalized (SNorm) channels, with each channel using 8 bits to represent color values. |
| R8G8B8_SNorm | Use a 24-bit pixel format that includes three signed normalized integer channels (SNorm), with each channel using 8 bits to represent color values. |
| R8G8B8A8_SNorm | Use a 32-bit pixel format that includes four signed normalized integer channels (SNorm), with each channel represented by 8 bits for color values. |
| R8_UInt | A pixel format that uses 8-bit unsigned integers. This pixel format is commonly used for storing data for a single channel, such as height maps or light maps. |
| R8G8_UInt | Use a 16-bit pixel format that includes two unsigned integer channels (UInt), with each channel using 8 bits to represent color values. |
| R8G8B8_UInt | Use a 24-bit pixel format that includes three unsigned integer channels (UInt), with 8 bits used to represent the color value for each channel. |
| R8G8B8A8_UInt | Use a 32-bit pixel format that includes four unsigned integer channels (UInt), with each channel using 8 bits to represent color values. |
| R8_SInt | Use an 8-bit pixel format that contains only a red channel, with each channel represented by an 8-bit signed integer value. |
| R8G8_SInt | Use a 16-bit pixel format that includes two signed integer channels (SInt), with each channel using 8 bits to represent color values. |
| R8G8B8_SInt | Use a 24-bit pixel format that includes three signed integer channels (SInt), with each channel using 8 bits to represent color values. |
| R8G8B8A8_SInt | Use a 32-bit pixel format that includes an alpha channel and three signed integer channels (SInt), with 8 bits used to represent each color value. |
| R16_UNorm | Use a 16-bit pixel format that includes an unsigned integer channel to represent color values using 16 bits. |
| R16G16_UNorm | Use a 32-bit pixel format that includes two unsigned integer channels (UNorm), with each channel represented by 16 bits for color values. |
| R16G16B16_UNorm | Use a 48-bit pixel format that includes three RGB channels, with each channel represented by 16 bits for color values, without an alpha channel. |
| R16G16B16A16_UNorm | Use a 64-bit pixel format that includes four channels, with each channel represented by 16 bits for color values ranging from 0 to 1, expressed as unsigned integers (UNorm). |
| R16_SNorm | Use a 16-bit pixel format that contains only one signed normalized integer channel (SNorm) to represent color values using 16 bits. |
| R16G16_SNorm | Use a 32-bit pixel format that includes two signed normalized integer channels (SNorm), with each channel represented by 16 bits for color values. |
| R16G16B16_SNorm | Use a 48-bit pixel format that includes three signed normalized integer channels (SNorm), with each channel represented by 16 bits for color values. |
| R16G16B16A16_SNorm | Use a 64-bit pixel format that includes four signed integer channels (SNorm), with each channel represented by 16 bits for color values. |
| R16_UInt | Use a 16-bit pixel format that contains only one unsigned integer channel (UInt) to represent color values using 16 bits. |
| R16G16_UInt | Use a 32-bit pixel format that includes two unsigned integer channels (UInt), with each channel using 16 bits to represent color values. |
| R16G16B16_UInt | Use a 48-bit pixel format that includes three unsigned integer channels (UInt), with each channel represented by 16 bits to represent color values. |
| R16G16B16A16_UInt | Use a 64-bit pixel format that includes four unsigned integer channels (UInt), with each channel using 16 bits to represent color values and alpha values. |
| R16_SInt | Use a 16-bit pixel format that includes a signed integer channel (SInt) to represent color values using 16 bits. |
| R16G16_SInt | Use a 32-bit pixel format that includes two signed integer channels (SInt), with each channel using 16 bits to represent color values. |
| R16G16B16_SInt | Use a 48-bit pixel format that includes three signed integer channels (SInt), with each channel using 16 bits to represent color values. |
| R16G16B16A16_SInt | Use a 64-bit pixel format that includes four signed integer channels (SInt), with each channel represented by 16 bits for color values. |
| R32_UInt | Use a 32-bit pixel format that includes an unsigned integer channel, which can be used for implementing special textures or GPU computing operations. |
| R32G32_UInt | Use a 64-bit pixel format that includes two unsigned integer channels (UInt), with each channel using 32 bits to represent color values. |
| R32G32B32_UInt | Use a 96-bit pixel format that includes three unsigned integer channels (UInt), with each channel using 32 bits to represent color values. |
| R32G32B32A32_UInt | Use a 128-bit pixel format that includes four unsigned integer channels (UInt), with each channel using 32 bits to represent color values. |
| R32_SInt | Use a 32-bit pixel format that includes a signed integer channel (SInt) to represent color values using 32 bits. |
| R32G32_SInt | Use a 64-bit pixel format that includes two signed integer channels (SInt), with each channel using 32 bits to represent color values. |
| R32G32B32_SInt | Use a 96-bit pixel format that includes three signed integer channels (SInt), with each channel using 32 bits to represent color values. |
| R32G32B32A32_SInt | Use a 128-bit pixel format that includes four signed integer channels (SInt), with each channel using 32 bits to represent color values. |
| R16_SFloat | Use a 16-bit pixel format that includes a floating-point channel (SFloat) to represent color values using 16 bits. |
| R16G16_SFloat | Use a 32-bit pixel format that includes two floating-point channels (SFloat), with each channel using 16 bits to represent color values. |
| R16G16B16_SFloat | Use a 48-bit pixel format that includes three floating-point channels, with each channel using 16 bits to represent color values. |
| R16G16B16A16_SFloat | Use a 64-bit pixel format that includes four floating-point channels (SFloat), with each channel represented by 16 bits to store color values. |
| R32_SFloat | Use a 32-bit pixel format that includes a single-precision floating-point (SFloat) channel to represent the value of each pixel in the texture. |
| R32G32_SFloat | Use a 64-bit pixel format that includes two floating-point channels (SFloat), with each channel using 32 bits to represent color values. |
| R32G32B32_SFloat | Use a 96-bit pixel format that includes three floating-point channels (SFloat), with each channel using 32 bits to represent color values. |
| R32G32B32A32_SFloat | Use a 128-bit pixel format that includes four floating-point channels (SFloat), with each channel using 32 bits to represent color values. |
| B8G8R8_SRGB | Use a 24-bit pixel format that includes three RGB channels, with each channel using 8 bits to represent color values. There is no alpha channel. |
| B8G8R8A8_SRGB | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with 8 bits used to represent color values for each channel. Color conversion is performed using the sRGB color space. |
| B8G8R8_UNorm | Use a 24-bit pixel format that includes three RGB channels, with each channel using 8 bits to represent color values. There is no alpha channel. |
| B8G8R8A8_UNorm | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with 8 bits used to represent the color value for each channel. |
| B8G8R8_SNorm | Use a 24-bit pixel format that includes three RGB channels, with each channel represented by 8 bits to represent the color value using signed integers. |
| B8G8R8A8_SNorm | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 8 bits to represent color values ranging from -1 to 1. |
| B8G8R8_UInt | Use a 24-bit pixel format that includes three RGB channels, with each channel using 8 bits to represent color values. There is no alpha channel. |
| B8G8R8A8_UInt | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with 8 bits used to represent the color value for each channel. |
| B8G8R8_SInt | Use a 24-bit pixel format that includes three signed integer RGB channels, with each channel using 8 bits to represent the color value. There is no alpha channel. |
| B8G8R8A8_SInt | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with 8 bits used to represent the color value for each channel, where the alpha channel uses only 8 bits. |
| R4G4B4A4_UNormPack16 | Use a 16-bit pixel format that includes an alpha channel and three RGB channels, with 4 bits used to represent the color value for each channel. |
| B4G4R4A4_UNormPack16 | Use a 16-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 4 bits to represent color values, where the alpha channel uses only 4 bits. |
| R5G6B5_UNormPack16 | Use a 16-bit pixel format that includes three RGB channels, with each channel using 5 or 6 bits to represent color values. There is no alpha channel. |
| B5G6R5_UNormPack16 | Use a 16-bit pixel format that includes three RGB channels, with each channel using 5 or 6 bits to represent color values. There is no alpha channel in this pixel format. This pixel format is commonly used for colored textures in games, as it can provide better color accuracy than the A1R5G5B5_UNormPack16 and B4G4R4A4_UNormPack16 formats, and does not require transparency effects. |
| R5G5B5A1_UNormPack16 | Use a 16-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 5 bits to represent color values. |
| B5G5R5A1_UNormPack16 | Use a 16-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 5 bits to represent color values, where the alpha channel uses only 1 bit. |
| A1R5G5B5_UNormPack16 | Use a 16-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 5 bits to represent color values. The alpha channel only uses 1 bit. This pixel format is commonly used for transparent textures in games, as it can provide a certain level of translucency while also reducing memory usage. |
| E5B9G9R9_UFloatPack32 | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with 9 bits used to represent the color value for each channel, excluding the alpha channel. |
| B10G11R11_UFloatPack32 | Use a 32-bit pixel format that includes three RGB channels, with each channel using 10 or 11 bits to represent color values. There is no alpha channel. |
| A2B10G10R10_UNormPack32 | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 10 bits to represent color values. This pixel format is commonly used in games for scenarios that require high-precision color values, such as HDR rendering and color correction. |
| A2B10G10R10_UIntPack32 | Use a 32-bit pixel format that includes an alpha channel and three RGB channels. Each channel uses 10 bits to represent color values, while the remaining 2 bits are used to represent other information such as normals, heights, etc. This pixel format provides higher precision and a wider color space, while also supporting more image processing and editing operations such as HDR and color correction. |
| A2B10G10R10_SIntPack32 | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 10 bits to represent color values, where the alpha channel only uses 2 bits. This pixel format is commonly used for processing high dynamic range (HDR) images, as it provides a very high color depth and precision. |
| A2R10G10B10_UNormPack32 | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 10 bits to represent color values. The alpha channel uses 2 bits, allowing for more subtle transparency effects. This pixel format is commonly used in scenes that require fine transparency effects, such as semi-transparent parts of character models. |
| A2R10G10B10_UIntPack32 | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 10 bits to represent color values, where the alpha channel only uses 2 bits. This pixel format is commonly used for high-fidelity images and rendering effects as it provides higher color accuracy. |
| A2R10G10B10_SIntPack32 | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with 10 bits used to represent the color value for each channel, and an additional 2 bits reserved. This pixel format is commonly used in scenarios that require high-precision color representation, such as rendering HDR images or high-quality lighting effects. |
| A2R10G10B10_XRSRGBPack32 | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 10 bits to represent color values. This pixel format is commonly used in situations that require higher precision color representation, such as high dynamic range (HDR) rendering in games. |
| A2R10G10B10_XRUNormPack32 | Use a 32-bit pixel format that includes a 10-bit alpha channel and three 10-bit RGB channels, with an additional 2-bit reserved for special data storage in certain cases. This pixel format is commonly used in scenarios that require high-precision color values, such as HDR rendering. |
| R10G10B10_XRSRGBPack32 | Use a 32-bit pixel format that includes three RGB channels, with each channel using 10 bits to represent color values. There is no alpha channel. |
| R10G10B10_XRUNormPack32 | Use a 32-bit pixel format that includes three RGB channels and an unsigned integer alpha channel, with 10 bits used to represent the color value for each channel. |
| A10R10G10B10_XRSRGBPack32 | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with each channel using 10 bits to represent color values. This pixel format adopts the sRGB color space, which provides more realistic color representation and improves rendering performance. |
| A10R10G10B10_XRUNormPack32 | Use a 32-bit pixel format that includes four channels: three RGB channels and one 10-bit XRU channel, which provides higher precision and a wider color range. The XRU channel represents unknown/unused data and is typically used for scenarios that require additional channels, such as particle effects. |
| D16_UNorm | Use a 16-bit depth texture format where each pixel is represented by 16 bits to store depth values. This format is commonly used for depth testing and shadow effects. |
| D24_UNorm | Use a 24-bit depth buffer. This pixel format is commonly used in games for scenes that require depth testing, such as rendering and occlusion culling in 3D games. |
| D24_UNorm_S8_UInt | Uses a 32-bit pixel format, which includes a 24-bit depth buffer and an 8-bit stencil buffer. |
| D32_SFloat | Use a 32-bit depth format where each pixel is represented by a single-precision floating-point number to store depth information. |
| D32_SFloat_S8_UInt | Use a 64-bit pixel format that includes a 32-bit depth channel and an 8-bit stencil channel, which can be used for depth testing and stencil testing operations. |
| S8_UInt | A texture without color channels, but containing an 8-bit data for each pixel to represent the corresponding depth buffer. |
| RGB_DXT1_SRGB | Using a 4-byte compressed format that includes three channels, and utilizing the DXT1 compression format to represent these three channels. The DXT1 compression format is a block-based compression method commonly used for texture compression in games, providing high-quality compression ratios. |
| RGBA_DXT1_SRGB | SRGB texture format using DXT1 compression format. This format supports specifying the compression quality for the red, green, blue, and alpha channels of the texture, and is widely used in computer graphics contexts. |
| RGB_DXT1_UNorm | Uses a 4-byte compressed format, which includes three channels, and utilizes the DXT1 compression format to represent these three channels. |
| RGBA_DXT1_UNorm | Represents a compressed texture format that allows for storing texture data with smaller memory footprint. It uses BC1 or DXT1 (DirectX Texture Compression) compression method. |
| RGBA_DXT3_SRGB | Represents a compressed texture format using DXT3 compression format and sRGB color space. |
| RGBA_DXT3_UNorm | Represents a compressed texture format that uses DXT3 (DirectX Texture Compression) compression method, allowing for storing texture data with smaller memory footprint. |
| RGBA_DXT5_SRGB | Represents a compressed texture format that allows for storing texture data with smaller memory footprint. It uses the DXT5 compression scheme. |
| RGBA_DXT5_UNorm | Compresses texture colors using the DXT5 compression algorithm, achieving a compression ratio of 4:1. This compression method is highly effective for images that require a lot of detail, such as surface textures and shadows, as it significantly reduces the amount of memory space occupied by the textures, thereby improving game performance. |
| R_BC4_UNorm | Use compressed format to store single-channel unsigned floating-point values, typically used for height maps, normal maps, etc. in games. |
| R_BC4_SNorm | A single-channel pixel format using BC4 compression algorithm. Each pixel is stored in 4 bytes and can represent a signed floating-point number ranging from -1 to 1. |
| RG_BC5_UNorm | Using an 8-byte compressed format that includes two channels, and utilizing the BC5 compression format to represent these two channels. The BC5 compression format is a block-based compression method commonly used for compressing textures in games, providing high-quality compression ratios. |
| RG_BC5_SNorm | Using an 8-byte compressed format that includes two channels, and utilizing the BC5 compression format to represent these two channels. The BC5 compression format is a block-based compression method commonly used for compressing textures in games, providing high-quality compression ratios. |
| RGB_BC6H_UFloat | Using a 16-byte compressed format that includes three channels, and utilizing the BC6H compression format to represent these three channels. The BC6H compression format is a block-based compression method commonly used for texture compression in games, providing high-quality compression ratios while preserving high-precision floating-point data. |
| RGB_BC6H_SFloat | Using a 16-byte compressed format that includes three channels, and utilizing the BC6H compression format to represent these three channels. The BC6H compression format is a block-based compression method commonly used for texture compression in games, providing high-quality compression ratios while preserving high-precision floating-point data. |
| RGBA_BC7_SRGB | Represents the use of BC7 compression algorithm to compress color data and encode it using the sRGB color space. |
| RGBA_BC7_UNorm | Represents unsigned normalized colors in RGBA32 format that have been compressed using the BC7 compression algorithm. |
| RGB_PVRTC_2Bpp_SRGB | Using a 4-byte compressed format that includes three channels, and utilizing the PVRTC (PowerVR Texture Compression) compression format to represent these three channels. PVRTC compression format is a texture compression format suitable for mobile devices, with high compression ratio that significantly reduces texture storage space while improving rendering efficiency. |
| RGB_PVRTC_2Bpp_UNorm | Using a 4-byte compressed format that includes three channels, and utilizing the PVRTC (PowerVR Texture Compression) compression format to represent these three channels. PVRTC compression is a block-based compression method commonly used on resource-constrained platforms such as mobile devices, providing high-quality compression ratios. |
| RGB_PVRTC_4Bpp_SRGB | Uses a 4-byte compressed format that includes three channels and utilizes the PVRTC compression format to represent these three channels. |
| RGB_PVRTC_4Bpp_UNorm | Uses a 4-byte compressed format that includes three channels and utilizes the PVRTC compression format to represent these three channels. |
| RGBA_PVRTC_2Bpp_SRGB | A texture format that uses the PVRTC (PowerVR Texture Compression) algorithm to compress images with sRGB color space. Each pixel is encoded using 2 bits (i.e., 4 pixels occupy 1 compression block). This enum property is commonly used in Unity for textures on mobile devices, and due to its high compression ratio, it can save memory space and improve performance. |
| RGBA_PVRTC_2Bpp_UNorm | Represents each pixel using 2 bits encoding and uses unsigned normalized integers to represent the values of each channel. This means it can provide smaller file sizes but may result in loss of quality. |
| RGBA_PVRTC_4Bpp_SRGB | When encoding PVRTC, the RGBA channels are used and each pixel contains 4 bits, which is 4Bpp (bytes per pixel). The sRGB color space is also used, which is a technology that renders more natural and realistic colors on displays. |
| RGBA_PVRTC_4Bpp_UNorm | Represents the image format where four channels (R, G, B, A) are compressed using the PVRTC compression algorithm. This format is an unsigned normalized format and uses 4 bits per pixel (bpp) compression. |
| RGB_ETC_UNorm | Using a compressed format of 8 bytes, which includes three channels, and using the ETC compression format to represent these three channels. The ETC compression format is a block-based compression method commonly used for compressing textures in games, providing high-quality compression ratios. |
| RGB_ETC2_SRGB | Using a compressed format of 8 bytes, which includes three channels, and utilizing the ETC2 compression format to represent these three channels. The ETC2 compression format is a block-based compression method commonly used for compressing textures in games, providing high-quality compression ratios. |
| RGB_ETC2_UNorm | Using a compressed format of 8 bytes, which includes three channels, and utilizing the ETC2 compression format to represent these three channels. The ETC2 compression format is a block-based compression method commonly used for compressing textures in games, providing high-quality compression ratios. |
| RGB_A1_ETC2_SRGB | The compressed format uses 8 bytes and includes RGB and an A channel, using the ETC2 compression format to represent these channels. The ETC2 compression format is a block-based compression method commonly used for compressing textures in games, providing a high-quality compression ratio. |
| RGB_A1_ETC2_UNorm | Uses a compressed format of 8 bytes, which includes RGB color and an alpha channel, and utilizes the ETC2 compression format to represent these four channels. |
| RGBA_ETC2_SRGB | Represents the use of the ETC2 compression format to store texture data and decode it in the SRGB color space. |
| RGBA_ETC2_UNorm | The image data is compressed using a block-based compression method. This format is a raster image format that uses the ETC2 (Ericsson Texture Compression) algorithm for compression. This algorithm allows you to reduce the memory footprint of textures while reducing texture quality. |
| R_EAC_UNorm | Uses an 8-bit compressed format, containing only a red channel without an alpha channel or other color channels. |
| R_EAC_SNorm | A format for storing texture data using 8-bit compression, defined in the OpenGL ES 3.0 specification. |
| RG_EAC_UNorm | Uses an 8-byte compressed format that includes two channels and utilizes the EAC compression format to represent these two channels. |
| RG_EAC_SNorm | Uses a compressed format of 8 bytes, containing two channels, and utilizes the EAC compression format to represent these two channels. |
| RGBA_ASTC4X4_SRGB | Represents each pixel containing four 8-bit color channels (RGBA). It has a size of 4x4 pixel blocks and uses the sRGB color space. Therefore, this texture format is commonly used for storing color images and textures, such as textures, background images, and environment maps. |
| RGBA_ASTC4X4_UNorm | Using a compressed format of 8 bytes, which includes four channels, and utilizing the ASTC compression format to represent these four channels. ASTC is an efficient compression format widely used in mobile devices and games, providing high-quality compression ratios. |
| RGBA_ASTC5X5_SRGB | Represents each pixel containing four 8-bit color channels (RGBA). It has a size of 5x5 pixel blocks and uses the sRGB color space. Therefore, this texture format is commonly used for storing color images and textures, such as textures, background images, and environment maps. |
| RGBA_ASTC5X5_UNorm | Uses an 8-byte compressed format that includes four channels and utilizes the ASTC compression format to represent these four channels. |
| RGBA_ASTC6X6_SRGB | Represents each pixel containing four 8-bit color channels (RGBA). It has a size of 6x6 pixel blocks and uses the sRGB color space. Therefore, this texture format is commonly used for storing color images and textures, such as textures, background images, and environment maps. |
| RGBA_ASTC6X6_UNorm | Represents each texel (pixel element) containing four unsigned normalized color components (R, G, B, and A). This format utilizes ASTC texture compression technology, providing better performance and smaller storage footprint during image compression and decompression. |
| RGBA_ASTC8X8_SRGB | Represents each pixel containing four 8-bit color channels (RGBA). It has a size of 8x8 pixel blocks and uses the sRGB color space. Therefore, this texture format is commonly used for storing color images and textures, such as textures, background images, and environment maps. |
| RGBA_ASTC8X8_UNorm | Compress using the ASTC algorithm, with each texel containing four channels (RGBA), and each channel represented using 8 bits. |
| RGBA_ASTC10X10_SRGB | This format represents each pixel with four 8-bit color channels (RGBA). It has a size of 10x10 pixel blocks and uses the sRGB color space. Therefore, this texture format is commonly used for storing color images and textures, such as textures, background images, and environment maps. |
| RGBA_ASTC10X10_UNorm | Represents a four-channel (red, green, blue, and alpha) texture compressed using the ASTC (Adaptive Scalable Texture Compression) algorithm, storing pixel color values in a non-normalized (UNorm) format. |
| RGBA_ASTC12X12_SRGB | Represents each pixel containing four 8-bit color channels (RGBA). It has a size of 12x12 pixel blocks and uses the sRGB color space. Therefore, this texture format is commonly used for storing color images and textures, such as textures, background images, and environment maps. |
| RGBA_ASTC12X12_UNorm | Represents the ASTC12x12 compressed unsigned floating-point texture format with four channels (red, green, blue, alpha). |
| YUV2 | YUV2 format is an image data format that separates luminance and chrominance information. In YUV2 format, the luminance value and chrominance value of each pixel are stored separately, which helps to save storage space. Additionally, YUV2 format can be used for video encoding, decoding, and transmission, as it provides better compression efficiency. |
| DepthAuto | This property is a special format for the depth buffer, which automatically selects the best depth format based on the platform. |
| ShadowAuto | Use a method to automatically detect the shadow cache format, which selects the appropriate shadow cache format based on the rendering needs of the scene. |
| VideoAuto | |
| RGBA_ASTC4X4_UFloat | The 8-byte ASTC compression format is used, which includes four channels and represents these four channels using the ASTC compression format. ASTC compression format is a block-based compression method commonly used for compressing textures in games, providing high-quality compression ratios. |
| RGBA_ASTC5X5_UFloat | The ASTC (Adaptive Scalable Texture Compression) compression format is used, which uses 8 bytes and contains four channels. Each channel is represented by a 32-bit unsigned floating-point number (UFloat) to represent color values. |
| RGBA_ASTC6X6_UFloat | Based on the ASTC (Adaptive Scalable Texture Compression) compression algorithm, it can be used to store RGBA data and supports floating-point precision. Each texel occupies 16 bytes, resulting in high compression ratio and saving storage space. It also allows for a higher number of textures stored in GPU memory. This texture format is commonly used in mobile devices and VR scenes. |
| RGBA_ASTC8X8_UFloat | ASTC (Adaptive Scalable Texture Compression) is a technology used to compress image data and store color information using 32-bit floating-point numbers. |
| RGBA_ASTC10X10_UFloat | The ASTC (Adaptive Scalable Texture Compression) algorithm is used to compress texture data, allowing for a smaller memory footprint. Textures in this format can store RGBA color values, with each color channel represented using 10-bit unsigned floating-point numbers, i.e., 10-bit floating-point numbers. |
| RGBA_ASTC12X12_UFloat | The ASTC compression algorithm is used, specifically with a block size of 4x4. It utilizes 12 blocks on the x-axis and 12 blocks on the y-axis. Each pixel is represented using a 16-bit floating-point number. The use of the RGBA_ASTC12X12_UFloat format allows for high precision and compression ratio, while occupying less storage space in image processing. |
| A8R8G8B8_UNorm | Use a 32-bit pixel format that includes an alpha channel and three RGB channels, with 8 bits used to represent color values for each channel. This pixel format is commonly used for textures and other graphic resources in games, as it can provide highly detailed colors and transparency effects, while also handling large amounts of graphic data. |