| /* | |
| * Copyright 2025 Google LLC | |
| * | |
| * Use of this source code is governed by a BSD-style license that can be | |
| * found in the LICENSE file. | |
| */ | |
| #ifndef skgpu_graphite_TextureFormat_DEFINED | |
| #define skgpu_graphite_TextureFormat_DEFINED | |
| #include "include/core/SkTextureCompressionType.h" | |
| #include <stddef.h> | |
| #include <cstdint> | |
| namespace skgpu::graphite { | |
| /** | |
| * TextureFormat encapsulates all formats that Graphite backends support for color, depth, and | |
| * stencil textures. Not every TextureFormat is available on every backend or every device. | |
| * | |
| * TextureFormat names follow the convention of components being written in little Endian order. | |
| * The channel's or groups of identically typed channel's bit depth and type follow the channel | |
| * name. A numeral `n` represents an unsigned integer of bit depth `n` normalized to [0,1] while | |
| * `nF` represents a floating point number having `n` bits. If a component has a different bit | |
| * depth than the previous, an underscore separates them. Optional behavioral tags follow, such as | |
| * hardware sRGB decoding, extended range, or compression algorithms. | |
| * | |
| * TextureFormat is the union of texture formats from each backend that are of interest to Skia | |
| * and Graphite. As such, the non-floating point formats are restricted to just the unsigned | |
| * normalized varieties (vs. signed normalized or integral textures). The exception to this is | |
| * formats that include a stencil channel, which is always an unsigned integer. Floating point | |
| * formats are limited to 16-bit and 32-bit; there is not enough demand yet for 64-bit doubles yet. | |
| * | |
| * Not all backends support all texture format enum values, and not all backends will always support | |
| * a given format on the current device. Backends are responsible for mapping from TextureFormat to | |
| * the actual backend format value in Caps. A TextureFormat is considered supported when such a | |
| * mapping is defined. | |
| * | |
| * TextureFormat describes the data representation that the texture holds when copied to or from | |
| * a buffer. Regardless of the data channel ordering, the GPU will automatically swizzle reads and | |
| * writes to map to/from the in-shader RGBA order: | |
| * - R formats sample in the shader as R001; and store only R of the out color. | |
| * - A formats sample in the shader as 000A; and store only A of the out color. | |
| * - RG formats sample in the shader as RG01; and store only RG of the out color. | |
| * - RGB/BGR formats sample as RGB1; and store only RGB of the out color. | |
| * - RGBA/BGRA/ARGB/ABGR all sample as RGBA and store RGBA. | |
| * | |
| * Unlike TextureFormat, SkColorType encapsulates both a data representation and semantics that | |
| * introduce a possible layer of indirection when using a TextureFormat to fulfill an SkColorType. | |
| * These operations may require modifying how the values are rendered or sampled, and/or performing | |
| * transformations on the CPU before/after a copy. Every SkColorType has a list of TextureFormats | |
| * that can be used with that type with minimal intervention. Formats are ordered from most to least | |
| * compatible by: | |
| * 1. Exact match: does not require any shader swizzling or CPU manipulation. | |
| * 2. Lossless w/ no semantic differences: does not require shader swizzling, but does require | |
| * CPU manipulation (e.g. swap RG or force opaque). | |
| * 3. Lossless w/ semantic differences: requires shader swizzling, and may or may not require | |
| * CPU manipulation for upload and readback. | |
| * 4. Lossy or data mismatch w/o any better fit. This is to support TextureFormats that aren't | |
| * representable by any SkColorType on the CPU, but requires a valid SkColorType for the | |
| * SkImageInfo of the textures' SkImage or SkSurface, e.g. compressed texture formats, | |
| * multiplanar formats, or 32-bit float formats that can be used entirely within the GPU without | |
| * needing to interpret it as a SkColorType on the CPU. | |
| * | |
| * The mapping between SkColorType and TextureFormat is defined statically. When a client creates a | |
| * new SkImage or SkSurface from an SkImageInfo, the TextureFormat is chosen as the first compatible | |
| * format for that SkColorType that has backend support on the device. When a client wraps a | |
| * BackendTexture, they also provide an SkColorType. The wrap fails if that color type's compatible | |
| * format list does not include the format of the provided BackendTexture. | |
| */ | |
| enum class TextureFormat : uint8_t { | |
| kUnsupported, | |
| // Name // VK_FORMAT | wgpu::TextureFormat | MTLPixelFormat | |
| // --------------//----------------------------|-------------------------|---------------------- | |
| // 1 channel // | | | |
| kR8, // _R8_UNORM | ::R8Unorm | R8Unorm | |
| kR16, // _R16_UNORM | ::R16Unorm | R16Unorm | |
| kR16F, // _R16_SFLOAT | ::R16Float | R16Float | |
| kR32F, // _R32_SFLOAT | ::R32Float | R32Float | |
| kA8, // - | - | A8Unorm | |
| // 2 channel //----------------------------|-------------------------|---------------------- | |
| kRG8, // _R8G8_UNORM | ::RG8Unorm | RG8Unorm | |
| kRG16, // _R16G16_UNORM | ::RG16Unorm | RG16Unorm | |
| kRG16F, // _R16G16_SFLOAT | ::RG16Float | RG16Float | |
| kRG32F, // _R32G32_SFLOAT | ::RG32Float | RG32Float | |
| // 3 channel //----------------------------|-------------------------|---------------------- | |
| kRGB8, // _R8G8B8_UNORM | - | - | |
| kBGR8, // _B8G8R8_UNORM | - | - | |
| kB5_G6_R5, // _R5G6B5_UNORM_PACK16 | - | B5G6R5Unorm | |
| kR5_G6_B5, // _B5G6R5_UNORM_PACK16 | - | - | |
| kRGB16, // _R16G16B16_UNORM | - | - | |
| kRGB16F, // _R16G16B16_SFLOAT | - | - | |
| kRGB32F, // _R32G32B32_SFLOAT | - | - | |
| kRGB8_sRGB, // _R8G8B8_SRGB | - | - | |
| kBGR10_XR, // - | - | BGR10_XR | |
| // 4 channel //----------------------------|-------------------------|---------------------- | |
| kRGBA8, // _R8G8B8A8_UNORM | ::RGBA8Unorm | RGBA8Unorm | |
| kRGBA16, // _R16G16B16A16_UNORM | ::RGBA16Unorm | RGBA16Unorm | |
| kRGBA16F, // _R16G16B16A16_SFLOAT | ::RGBA16Float | RGBA16Float | |
| kRGBA32F, // _R32G32B32A32_SFLOAT | ::RGBA32Float | RGBA32Float | |
| kRGB10_A2, // _A2B10G10R10_UNORM_PACK32 | ::RGB10A2Unorm | RGB10A2Unorm | |
| kRGBA8_sRGB, // _R8G8B8A8_SRGB | ::RGBA8UnormSrgb | RGBA8Unorm_sRGB | |
| kBGRA8, // _B8G8R8A8_UNORM | ::BGRA8Unorm | BGRA8Unorm | |
| kBGR10_A2, // _A2R10G10B10_UNORM_PACK32 | - | BGR10A2Unorm | |
| kBGRA8_sRGB, // _B8G8R8A8_SRGB | ::BGRA8UnormSrgb | BGRA8Unorm_sRGB | |
| kABGR4, // _R4G4B4A4_UNORM_PACK16 | - | ABGR4Unorm | |
| kARGB4, // _B4G4R4A4_UNORM_PACK16 | - | - | |
| kBGRA10x6_XR, // - | - | BGRA10_XR | |
| // Compressed //----------------------------|-------------------------|---------------------- | |
| kRGB8_ETC2, // _ETC2_R8G8B8_UNORM_BLOCK | ::ETC2RGB8Unorm | ETC2_RGB8 | |
| kRGB8_ETC2_sRGB, // _ETC2_R8G8B8_SRGB_BLOCK | ::ETC2RGB8UnormSrgb | ETC2_RGB8_sRGB | |
| kRGB8_BC1, // _BC1_RGB_UNORM_BLOCK | - | - | |
| kRGBA8_BC1, // _BC1_RGBA_UNORM_BLOCK | ::BC1RGBAUnorm | BC1_RGBA | |
| kRGBA8_BC1_sRGB, // _BC1_RGBA_SRGB_BLOCK | ::BC1RGBAUnormSrgb | BC1_RGBA_sRGB | |
| // Multi-planar //----------------------------|-------------------------|---------------------- | |
| kYUV8_P2_420, // _G8_B8R8_2PLANE_420_UNORM | ::R8BG8Biplanar420Unorm | - | |
| kYUV8_P3_420, // _G8_B8_R8_3PLANE_420_UNORM | - | - | |
| kYUV10x6_P2_420, // _G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 | - | |
| // | ::R10X6BG10X6Biplanar420Unorm | |
| kExternal, // VkExternalFormatANDROID | ::External | - | |
| // Non-color //----------------------------|-------------------------|---------------------- | |
| kS8, // _S8_UINT | ::Stencil8 | Stencil8 | |
| kD16, // _D16_UNORM | ::Depth16Unorm | Depth16Unorm | |
| kD32F, // _D32_SFLOAT | ::Depth32Float | Depth32Float | |
| kD24_S8, // _D24_UNORM_S8_UINT | ::Depth24PlusStencil8 | Depth24Unorm_Stencil8 | |
| kD32F_S8, // _D32_SFLOAT_S8_UINT | ::Depth32FloatStencil8 | Depth32Float_Stencil8 | |
| kLast = kD32F_S8 | |
| }; | |
| static constexpr int kTextureFormatCount = static_cast<int>(TextureFormat::kLast) + 1; | |
| const char* TextureFormatName(TextureFormat); | |
| SkTextureCompressionType TextureFormatCompressionType(TextureFormat); | |
| size_t TextureFormatBytesPerBlock(TextureFormat); | |
| // The value is mask of SkColorChannelFlag values. | |
| uint32_t TextureFormatChannelMask(TextureFormat); | |
| bool TextureFormatIsDepthOrStencil(TextureFormat); | |
| bool TextureFormatHasDepth(TextureFormat); | |
| bool TextureFormatHasStencil(TextureFormat); | |
| bool TextureFormatIsMultiplanar(TextureFormat); | |
| // True if writes to a color attachment of this format automatically clamp to [0,1]. | |
| bool TextureFormatAutoClamps(TextureFormat); | |
| bool TextureFormatIsFloatingPoint(TextureFormat); | |
| } // namespace skgpu::graphite | |
| #endif // skgpu_graphite_TextureFormat_DEFINED |