From 52ded6ab56729cb4f0da2e7b5768db1ad2fc07a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Cle=CC=81ment=20Foucault?= Date: Sat, 25 Feb 2023 21:44:41 +0100 Subject: [PATCH] GPUTexture: Make sure all available texture format are supported This remove default casses from the `switch` statements to catch where the missing cases are. Uncomment unimplemented cases for the sake of completeness. Improving the overall API. This make the format conversion lists exhaustive and documented. This replace `validate_data_format_mtl` by the common version as they don't differ at all now. --- source/blender/gpu/GPU_texture.h | 94 +- source/blender/gpu/intern/gpu_texture.cc | 71 +- .../blender/gpu/intern/gpu_texture_private.hh | 835 +++++++++++++----- source/blender/gpu/metal/mtl_texture.hh | 54 -- source/blender/gpu/metal/mtl_texture.mm | 8 +- source/blender/gpu/metal/mtl_texture_util.mm | 92 +- source/blender/gpu/opengl/gl_texture.hh | 170 ++-- source/blender/gpu/vulkan/vk_common.cc | 265 ++++-- 8 files changed, 1110 insertions(+), 479 deletions(-) diff --git a/source/blender/gpu/GPU_texture.h b/source/blender/gpu/GPU_texture.h index bd75e3ea7c2..cc67c6b0d22 100644 --- a/source/blender/gpu/GPU_texture.h +++ b/source/blender/gpu/GPU_texture.h @@ -105,92 +105,92 @@ ENUM_OPERATORS(eGPUSamplerState, GPU_SAMPLER_ICON) * Types of texture internal storage. Defines how the data is stored inside the video memory. * Be aware that some formats are not supported by render-buffers. */ -/** - * TODO(fclem): Enable and implement all of them. Encouraging new usage and avoiding missing cases - * in switch statements. - */ typedef enum eGPUTextureFormat { /* Formats texture & render-buffer. */ + GPU_RGBA8UI, GPU_RGBA8I, GPU_RGBA8, - GPU_RGBA32UI, - GPU_RGBA32I, - GPU_RGBA32F, GPU_RGBA16UI, GPU_RGBA16I, GPU_RGBA16F, GPU_RGBA16, + GPU_RGBA32UI, + GPU_RGBA32I, + GPU_RGBA32F, + GPU_RG8UI, GPU_RG8I, GPU_RG8, - GPU_RG32UI, - GPU_RG32I, - GPU_RG32F, GPU_RG16UI, GPU_RG16I, GPU_RG16F, GPU_RG16, + GPU_RG32UI, + GPU_RG32I, + GPU_RG32F, + GPU_R8UI, GPU_R8I, GPU_R8, - GPU_R32UI, - GPU_R32I, - GPU_R32F, GPU_R16UI, GPU_R16I, GPU_R16F, - GPU_R16, /* Max texture buffer format. */ + GPU_R16, + GPU_R32UI, + GPU_R32I, + GPU_R32F, /* Special formats texture & render-buffer. */ + GPU_RGB10_A2, + GPU_RGB10_A2UI, GPU_R11F_G11F_B10F, GPU_DEPTH32F_STENCIL8, GPU_DEPTH24_STENCIL8, GPU_SRGB8_A8, -#if 0 - GPU_RGB10_A2UI, -#endif - /* Texture only format */ - GPU_RGB16F, -#if 0 - GPU_RGBA16_SNORM, + /* Texture only formats. */ + GPU_RGBA8_SNORM, - GPU_RGB32F, - GPU_RGB32I, - GPU_RGB32UI, - GPU_RGB16_SNORM, - GPU_RGB16I, - GPU_RGB16UI, - GPU_RGB16, - GPU_RGB8_SNORM, - GPU_RGB8, - GPU_RGB8I, - GPU_RGB8UI, - GPU_RG16_SNORM, - GPU_RG8_SNORM, - GPU_R16_SNORM, - GPU_R8_SNORM, -#endif + GPU_RGBA16_SNORM, - /* Special formats texture only */ - GPU_SRGB8_A8_DXT1, - GPU_SRGB8_A8_DXT3, - GPU_SRGB8_A8_DXT5, - GPU_RGBA8_DXT1, - GPU_RGBA8_DXT3, - GPU_RGBA8_DXT5, -#if 0 + GPU_RGB8UI, + GPU_RGB8I, + GPU_RGB8, + GPU_RGB8_SNORM, + GPU_RGB16UI, + GPU_RGB16I, + GPU_RGB16F, + GPU_RGB16, + GPU_RGB16_SNORM, + GPU_RGB32UI, + GPU_RGB32I, + GPU_RGB32F, + + GPU_RG8_SNORM, + GPU_RG16_SNORM, + + GPU_R8_SNORM, + GPU_R16_SNORM, + + /* Special formats, texture only. */ + GPU_SRGB8_A8_DXT1, /* BC1 */ + GPU_SRGB8_A8_DXT3, /* BC2 */ + GPU_SRGB8_A8_DXT5, /* BC3 */ + GPU_RGBA8_DXT1, /* BC1 */ + GPU_RGBA8_DXT3, /* BC2 */ + GPU_RGBA8_DXT5, /* BC3 */ GPU_SRGB8, GPU_RGB9_E5, +#if 0 /* TODO: Add support for them. */ GPU_COMPRESSED_RG_RGTC2, GPU_COMPRESSED_SIGNED_RG_RGTC2, GPU_COMPRESSED_RED_RGTC1, GPU_COMPRESSED_SIGNED_RED_RGTC1, #endif - /* Depth Formats */ + /* Depth Formats. */ GPU_DEPTH_COMPONENT32F, GPU_DEPTH_COMPONENT24, GPU_DEPTH_COMPONENT16, @@ -200,7 +200,7 @@ typedef enum eGPUTextureFormat { * Types of data for data specification. * Used for formatting upload and download of data. * When used with textures, they need to match or be compatible with the `eGPUTextureFormat` used. - * Check `validate_data_format` and `validate_data_format_mtl` for compatibility list. + * Check `validate_data_format` for compatibility list. */ typedef enum eGPUDataFormat { GPU_DATA_FLOAT, diff --git a/source/blender/gpu/intern/gpu_texture.cc b/source/blender/gpu/intern/gpu_texture.cc index e141e09de97..bfe495c7378 100644 --- a/source/blender/gpu/intern/gpu_texture.cc +++ b/source/blender/gpu/intern/gpu_texture.cc @@ -735,6 +735,7 @@ eGPUTextureFormat GPU_texture_format(const GPUTexture *tex) const char *GPU_texture_format_name(eGPUTextureFormat texture_format) { switch (texture_format) { + /* Formats texture & render-buffer */ case GPU_RGBA8UI: return "RGBA8UI"; case GPU_RGBA8I: @@ -795,24 +796,57 @@ const char *GPU_texture_format_name(eGPUTextureFormat texture_format) return "R16F"; case GPU_R16: return "R16"; - - /* Special formats texture & render-buffer. */ + /* Special formats texture & render-buffer */ case GPU_RGB10_A2: - return "RGB10A2"; + return "RGB10_A2"; + case GPU_RGB10_A2UI: + return "RGB10_A2UI"; case GPU_R11F_G11F_B10F: - return "R11FG11FB10F"; + return "R11F_G11F_B10F"; case GPU_DEPTH32F_STENCIL8: - return "DEPTH32FSTENCIL8"; + return "DEPTH32F_STENCIL8"; case GPU_DEPTH24_STENCIL8: - return "DEPTH24STENCIL8"; + return "DEPTH24_STENCIL8"; case GPU_SRGB8_A8: - return "SRGB8A8"; - - /* Texture only format */ - case (GPU_RGB16F): + return "SRGB8_A8"; + /* Texture only formats. */ + case GPU_RGB16F: return "RGB16F"; - - /* Special formats texture only */ + case GPU_RGB16_SNORM: + return "RGB16_SNORM"; + case GPU_RGB16I: + return "RGB16I"; + case GPU_RGB16UI: + return "RGB16UI"; + case GPU_RGB16: + return "RGB16"; + case GPU_RGBA16_SNORM: + return "RGBA16_SNORM"; + case GPU_RGBA8_SNORM: + return "RGBA8_SNORM"; + case GPU_RGB32F: + return "RGB32F"; + case GPU_RGB32I: + return "RGB32I"; + case GPU_RGB32UI: + return "RGB32UI"; + case GPU_RGB8_SNORM: + return "RGB8_SNORM"; + case GPU_RGB8: + return "RGB8"; + case GPU_RGB8I: + return "RGB8I"; + case GPU_RGB8UI: + return "RGB8UI"; + case GPU_RG16_SNORM: + return "RG16_SNORM"; + case GPU_RG8_SNORM: + return "RG8_SNORM"; + case GPU_R16_SNORM: + return "R16_SNORM"; + case GPU_R8_SNORM: + return "R8_SNORM"; + /* Special formats, texture only. */ case GPU_SRGB8_A8_DXT1: return "SRGB8_A8_DXT1"; case GPU_SRGB8_A8_DXT3: @@ -825,14 +859,17 @@ const char *GPU_texture_format_name(eGPUTextureFormat texture_format) return "RGBA8_DXT3"; case GPU_RGBA8_DXT5: return "RGBA8_DXT5"; - - /* Depth Formats */ + case GPU_SRGB8: + return "SRGB8"; + case GPU_RGB9_E5: + return "RGB9_E5"; + /* Depth Formats. */ case GPU_DEPTH_COMPONENT32F: - return "DEPTH32F"; + return "DEPTH_COMPONENT32F"; case GPU_DEPTH_COMPONENT24: - return "DEPTH24"; + return "DEPTH_COMPONENT24"; case GPU_DEPTH_COMPONENT16: - return "DEPTH16"; + return "DEPTH_COMPONENT16"; } BLI_assert_unreachable(); return ""; diff --git a/source/blender/gpu/intern/gpu_texture_private.hh b/source/blender/gpu/intern/gpu_texture_private.hh index 1b3c04a78f9..798a410eaae 100644 --- a/source/blender/gpu/intern/gpu_texture_private.hh +++ b/source/blender/gpu/intern/gpu_texture_private.hh @@ -17,16 +17,27 @@ namespace blender { namespace gpu { typedef enum eGPUTextureFormatFlag { + /* The format has a depth component and can be used as depth attachment. */ GPU_FORMAT_DEPTH = (1 << 0), + /* The format has a stencil component and can be used as stencil attachment. */ GPU_FORMAT_STENCIL = (1 << 1), + /* The format represent non-normalized integers data, either signed or unsigned. */ GPU_FORMAT_INTEGER = (1 << 2), - GPU_FORMAT_FLOAT = (1 << 3), - GPU_FORMAT_COMPRESSED = (1 << 4), + /* The format is using normalized integers, either signed or unsigned. */ + GPU_FORMAT_NORMALIZED_INTEGER = (1 << 3), + /* The format represent floating point data, either signed or unsigned. */ + GPU_FORMAT_FLOAT = (1 << 4), + /* The format is using block compression. */ + GPU_FORMAT_COMPRESSED = (1 << 5), + /* The format is using sRGB encoded storage. */ + GPU_FORMAT_SRGB = (1 << 6), + /* The format can store negative values. */ + GPU_FORMAT_SIGNED = (1 << 7), GPU_FORMAT_DEPTH_STENCIL = (GPU_FORMAT_DEPTH | GPU_FORMAT_STENCIL), } eGPUTextureFormatFlag; -ENUM_OPERATORS(eGPUTextureFormatFlag, GPU_FORMAT_DEPTH_STENCIL) +ENUM_OPERATORS(eGPUTextureFormatFlag, GPU_FORMAT_SIGNED) typedef enum eGPUTextureType { GPU_TEXTURE_1D = (1 << 0), @@ -265,7 +276,37 @@ class Texture { BLI_assert(slot == 0); return GPU_FB_DEPTH_STENCIL_ATTACHMENT; default: + /* Valid color attachment formats. */ return GPU_FB_COLOR_ATTACHMENT0 + slot; + + case GPU_RGB16F: + case GPU_RGBA16_SNORM: + case GPU_RGBA8_SNORM: + case GPU_RGB32F: + case GPU_RGB32I: + case GPU_RGB32UI: + case GPU_RGB16_SNORM: + case GPU_RGB16I: + case GPU_RGB16UI: + case GPU_RGB16: + case GPU_RGB8_SNORM: + case GPU_RGB8: + case GPU_RGB8I: + case GPU_RGB8UI: + case GPU_RG16_SNORM: + case GPU_RG8_SNORM: + case GPU_R16_SNORM: + case GPU_R8_SNORM: + case GPU_SRGB8_A8_DXT1: + case GPU_SRGB8_A8_DXT3: + case GPU_SRGB8_A8_DXT5: + case GPU_RGBA8_DXT1: + case GPU_RGBA8_DXT3: + case GPU_RGBA8_DXT5: + case GPU_SRGB8: + case GPU_RGB9_E5: + BLI_assert_msg(0, "Texture cannot be attached to a framebuffer because of its type"); + return GPU_FB_COLOR_ATTACHMENT0; } } @@ -323,54 +364,114 @@ static inline const PixelBuffer *unwrap(const GPUPixelBuffer *pixbuf) inline size_t to_bytesize(eGPUTextureFormat format) { switch (format) { + /* Formats texture & render-buffer */ + case GPU_RGBA8UI: + case GPU_RGBA8I: + case GPU_RGBA8: + return (4 * 8) / 8; + case GPU_RGBA32UI: + case GPU_RGBA32I: case GPU_RGBA32F: - return 32; - case GPU_RG32F: + return (4 * 32) / 8; + case GPU_RGBA16UI: + case GPU_RGBA16I: case GPU_RGBA16F: case GPU_RGBA16: - return 16; - case GPU_RGB16F: - return 12; - case GPU_DEPTH32F_STENCIL8: /* 32-bit depth, 8 bits stencil, and 24 unused bits. */ - return 8; - case GPU_RG16F: - case GPU_RG16I: + return (4 * 16) / 8; + case GPU_RG8UI: + case GPU_RG8I: + case GPU_RG8: + return (2 * 8) / 8; + case GPU_RG32UI: + case GPU_RG32I: + case GPU_RG32F: + return (2 * 32) / 8; case GPU_RG16UI: + case GPU_RG16I: + case GPU_RG16F: case GPU_RG16: - case GPU_DEPTH24_STENCIL8: - case GPU_DEPTH_COMPONENT32F: - case GPU_RGBA8UI: - case GPU_RGBA8: - case GPU_SRGB8_A8: - case GPU_RGB10_A2: - case GPU_R11F_G11F_B10F: - case GPU_R32F: + return (2 * 16) / 8; + case GPU_R8UI: + case GPU_R8I: + case GPU_R8: + return 8 / 8; case GPU_R32UI: case GPU_R32I: - return 4; - case GPU_DEPTH_COMPONENT24: - return 3; - case GPU_DEPTH_COMPONENT16: - case GPU_R16F: + case GPU_R32F: + return 32 / 8; case GPU_R16UI: case GPU_R16I: - case GPU_RG8: + case GPU_R16F: case GPU_R16: - return 2; - case GPU_R8: - case GPU_R8UI: - return 1; + return 16 / 8; + + /* Special formats texture & render-buffer */ + case GPU_RGB10_A2: + case GPU_RGB10_A2UI: + return (3 * 10 + 2) / 8; + case GPU_R11F_G11F_B10F: + return (11 + 11 + 10) / 8; + case GPU_DEPTH32F_STENCIL8: + /* 32-bit depth, 8 bits stencil, and 24 unused bits. */ + return (32 + 8 + 24) / 8; + case GPU_DEPTH24_STENCIL8: + return (24 + 8) / 8; + case GPU_SRGB8_A8: + return (3 * 8 + 8) / 8; + + /* Texture only formats. */ + case GPU_RGB16F: + case GPU_RGB16_SNORM: + case GPU_RGB16I: + case GPU_RGB16UI: + case GPU_RGB16: + return (3 * 16) / 8; + case GPU_RGBA16_SNORM: + return (4 * 16) / 8; + case GPU_RGBA8_SNORM: + return (4 * 8) / 8; + case GPU_RGB32F: + case GPU_RGB32I: + case GPU_RGB32UI: + return (3 * 32) / 8; + case GPU_RGB8_SNORM: + case GPU_RGB8: + case GPU_RGB8I: + case GPU_RGB8UI: + return (3 * 8) / 8; + case GPU_RG16_SNORM: + return (2 * 16) / 8; + case GPU_RG8_SNORM: + return (2 * 8) / 8; + case GPU_R16_SNORM: + return (1 * 16) / 8; + case GPU_R8_SNORM: + return (1 * 8) / 8; + + /* Special formats, texture only. */ case GPU_SRGB8_A8_DXT1: case GPU_SRGB8_A8_DXT3: case GPU_SRGB8_A8_DXT5: case GPU_RGBA8_DXT1: case GPU_RGBA8_DXT3: case GPU_RGBA8_DXT5: - return 1; /* Incorrect but actual size is fractional. */ - default: - BLI_assert_msg(0, "Texture format incorrect or unsupported"); - return 0; + /* Incorrect but actual size is fractional. */ + return 1; + case GPU_SRGB8: + return (3 * 8) / 8; + case GPU_RGB9_E5: + return (3 * 9 + 5) / 8; + + /* Depth Formats. */ + case GPU_DEPTH_COMPONENT32F: + return 32 / 8; + case GPU_DEPTH_COMPONENT24: + return 24 / 8; + case GPU_DEPTH_COMPONENT16: + return 16 / 8; } + BLI_assert_unreachable(); + return 0; } inline size_t to_block_size(eGPUTextureFormat data_type) @@ -393,65 +494,235 @@ inline size_t to_block_size(eGPUTextureFormat data_type) inline eGPUTextureFormatFlag to_format_flag(eGPUTextureFormat format) { switch (format) { - case GPU_DEPTH_COMPONENT24: - case GPU_DEPTH_COMPONENT16: - case GPU_DEPTH_COMPONENT32F: - return GPU_FORMAT_DEPTH; - case GPU_DEPTH24_STENCIL8: - case GPU_DEPTH32F_STENCIL8: - return GPU_FORMAT_DEPTH_STENCIL; - case GPU_R8UI: - case GPU_RG16I: - case GPU_R16I: + /* Formats texture & render-buffer */ + case GPU_RGBA8UI: + return GPU_FORMAT_INTEGER; + case GPU_RGBA8I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RGBA8: + return GPU_FORMAT_NORMALIZED_INTEGER; + case GPU_RGBA32UI: + return GPU_FORMAT_INTEGER; + case GPU_RGBA32I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RGBA32F: + return GPU_FORMAT_FLOAT | GPU_FORMAT_SIGNED; + case GPU_RGBA16UI: + return GPU_FORMAT_INTEGER; + case GPU_RGBA16I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RGBA16F: + return GPU_FORMAT_FLOAT | GPU_FORMAT_SIGNED; + case GPU_RGBA16: + return GPU_FORMAT_NORMALIZED_INTEGER; + case GPU_RG8UI: + return GPU_FORMAT_INTEGER; + case GPU_RG8I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RG8: + return GPU_FORMAT_NORMALIZED_INTEGER; + case GPU_RG32UI: + return GPU_FORMAT_INTEGER; + case GPU_RG32I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RG32F: + return GPU_FORMAT_FLOAT | GPU_FORMAT_SIGNED; case GPU_RG16UI: - case GPU_R16UI: + return GPU_FORMAT_INTEGER; + case GPU_RG16I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RG16F: + return GPU_FORMAT_FLOAT | GPU_FORMAT_SIGNED; + case GPU_RG16: + return GPU_FORMAT_NORMALIZED_INTEGER; + case GPU_R8UI: + return GPU_FORMAT_INTEGER; + case GPU_R8I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_R8: + return GPU_FORMAT_NORMALIZED_INTEGER; case GPU_R32UI: return GPU_FORMAT_INTEGER; + case GPU_R32I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_R32F: + return GPU_FORMAT_FLOAT | GPU_FORMAT_SIGNED; + case GPU_R16UI: + return GPU_FORMAT_INTEGER; + case GPU_R16I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_R16F: + return GPU_FORMAT_FLOAT | GPU_FORMAT_SIGNED; + case GPU_R16: + return GPU_FORMAT_NORMALIZED_INTEGER; + + /* Special formats texture & render-buffer */ + case GPU_RGB10_A2: + return GPU_FORMAT_NORMALIZED_INTEGER; + case GPU_RGB10_A2UI: + return GPU_FORMAT_INTEGER; + case GPU_R11F_G11F_B10F: + return GPU_FORMAT_FLOAT; + case GPU_DEPTH32F_STENCIL8: + case GPU_DEPTH24_STENCIL8: + return GPU_FORMAT_DEPTH_STENCIL; + case GPU_SRGB8_A8: + return GPU_FORMAT_NORMALIZED_INTEGER | GPU_FORMAT_SRGB; + + /* Texture only formats. */ + case GPU_RGB16F: + return GPU_FORMAT_FLOAT | GPU_FORMAT_SIGNED; + case GPU_RGB16_SNORM: + return GPU_FORMAT_NORMALIZED_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RGB16I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RGB16UI: + return GPU_FORMAT_INTEGER; + case GPU_RGB16: + return GPU_FORMAT_NORMALIZED_INTEGER; + case GPU_RGBA16_SNORM: + case GPU_RGBA8_SNORM: + return GPU_FORMAT_NORMALIZED_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RGB32F: + return GPU_FORMAT_FLOAT | GPU_FORMAT_SIGNED; + case GPU_RGB32I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RGB32UI: + return GPU_FORMAT_INTEGER; + case GPU_RGB8_SNORM: + return GPU_FORMAT_NORMALIZED_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RGB8: + return GPU_FORMAT_NORMALIZED_INTEGER; + case GPU_RGB8I: + return GPU_FORMAT_INTEGER | GPU_FORMAT_SIGNED; + case GPU_RGB8UI: + return GPU_FORMAT_INTEGER; + case GPU_RG16_SNORM: + case GPU_RG8_SNORM: + case GPU_R16_SNORM: + case GPU_R8_SNORM: + return GPU_FORMAT_NORMALIZED_INTEGER | GPU_FORMAT_SIGNED; + + /* Special formats, texture only. */ + case GPU_SRGB8_A8_DXT1: + case GPU_SRGB8_A8_DXT3: + case GPU_SRGB8_A8_DXT5: + return GPU_FORMAT_NORMALIZED_INTEGER | GPU_FORMAT_COMPRESSED | GPU_FORMAT_SRGB; + case GPU_RGBA8_DXT1: + case GPU_RGBA8_DXT3: + case GPU_RGBA8_DXT5: + return GPU_FORMAT_NORMALIZED_INTEGER | GPU_FORMAT_COMPRESSED; + case GPU_SRGB8: + return GPU_FORMAT_NORMALIZED_INTEGER | GPU_FORMAT_SRGB; + case GPU_RGB9_E5: + return GPU_FORMAT_FLOAT; + + /* Depth Formats. */ + case GPU_DEPTH_COMPONENT32F: + case GPU_DEPTH_COMPONENT24: + case GPU_DEPTH_COMPONENT16: + return GPU_FORMAT_DEPTH; + } + BLI_assert_unreachable(); + return GPU_FORMAT_FLOAT; +} + +inline int to_component_len(eGPUTextureFormat format) +{ + switch (format) { + /* Formats texture & render-buffer */ + case GPU_RGBA8UI: + case GPU_RGBA8I: + case GPU_RGBA8: + case GPU_RGBA32UI: + case GPU_RGBA32I: + case GPU_RGBA32F: + case GPU_RGBA16UI: + case GPU_RGBA16I: + case GPU_RGBA16F: + case GPU_RGBA16: + return 4; + case GPU_RG8UI: + case GPU_RG8I: + case GPU_RG8: + case GPU_RG32UI: + case GPU_RG32I: + case GPU_RG32F: + case GPU_RG16UI: + case GPU_RG16I: + case GPU_RG16F: + case GPU_RG16: + return 2; + case GPU_R8UI: + case GPU_R8I: + case GPU_R8: + case GPU_R32UI: + case GPU_R32I: + case GPU_R32F: + case GPU_R16UI: + case GPU_R16I: + case GPU_R16F: + case GPU_R16: + return 1; + + /* Special formats texture & render-buffer */ + case GPU_RGB10_A2: + case GPU_RGB10_A2UI: + return 4; + case GPU_R11F_G11F_B10F: + return 3; + case GPU_DEPTH32F_STENCIL8: + case GPU_DEPTH24_STENCIL8: + /* Only count depth component. */ + return 1; + case GPU_SRGB8_A8: + return 4; + + /* Texture only formats. */ + case GPU_RGB16F: + case GPU_RGB16_SNORM: + case GPU_RGB16I: + case GPU_RGB16UI: + case GPU_RGB16: + return 3; + case GPU_RGBA16_SNORM: + case GPU_RGBA8_SNORM: + return 4; + case GPU_RGB32F: + case GPU_RGB32I: + case GPU_RGB32UI: + case GPU_RGB8_SNORM: + case GPU_RGB8: + case GPU_RGB8I: + case GPU_RGB8UI: + return 3; + case GPU_RG16_SNORM: + case GPU_RG8_SNORM: + return 2; + case GPU_R16_SNORM: + case GPU_R8_SNORM: + return 1; + + /* Special formats, texture only. */ case GPU_SRGB8_A8_DXT1: case GPU_SRGB8_A8_DXT3: case GPU_SRGB8_A8_DXT5: case GPU_RGBA8_DXT1: case GPU_RGBA8_DXT3: case GPU_RGBA8_DXT5: - return GPU_FORMAT_COMPRESSED; - default: - return GPU_FORMAT_FLOAT; - } -} - -inline int to_component_len(eGPUTextureFormat format) -{ - switch (format) { - case GPU_RGBA8: - case GPU_RGBA8I: - case GPU_RGBA8UI: - case GPU_RGBA16: - case GPU_RGBA16F: - case GPU_RGBA16I: - case GPU_RGBA16UI: - case GPU_RGBA32F: - case GPU_RGBA32I: - case GPU_RGBA32UI: - case GPU_SRGB8_A8: - case GPU_RGB10_A2: return 4; - case GPU_RGB16F: - case GPU_R11F_G11F_B10F: + case GPU_SRGB8: + case GPU_RGB9_E5: return 3; - case GPU_RG8: - case GPU_RG8I: - case GPU_RG8UI: - case GPU_RG16: - case GPU_RG16F: - case GPU_RG16I: - case GPU_RG16UI: - case GPU_RG32F: - case GPU_RG32I: - case GPU_RG32UI: - return 2; - default: + + /* Depth Formats. */ + case GPU_DEPTH_COMPONENT32F: + case GPU_DEPTH_COMPONENT24: + case GPU_DEPTH_COMPONENT16: return 1; } + BLI_assert_unreachable(); + return 1; } inline size_t to_bytesize(eGPUDataFormat data_format) @@ -469,10 +740,9 @@ inline size_t to_bytesize(eGPUDataFormat data_format) case GPU_DATA_10_11_11_REV: case GPU_DATA_2_10_10_10_REV: return 4; - default: - BLI_assert_msg(0, "Data format incorrect or unsupported"); - return 0; } + BLI_assert_unreachable(); + return 0; } inline size_t to_bytesize(eGPUTextureFormat tex_format, eGPUDataFormat data_format) @@ -492,172 +762,315 @@ inline size_t to_bytesize(eGPUTextureFormat tex_format, eGPUDataFormat data_form inline bool validate_data_format(eGPUTextureFormat tex_format, eGPUDataFormat data_format) { switch (tex_format) { - case GPU_DEPTH_COMPONENT24: - case GPU_DEPTH_COMPONENT16: - case GPU_DEPTH_COMPONENT32F: - return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_UINT); - case GPU_DEPTH24_STENCIL8: - case GPU_DEPTH32F_STENCIL8: - return ELEM(data_format, GPU_DATA_UINT_24_8, GPU_DATA_UINT); - case GPU_R16UI: - case GPU_RG16UI: - case GPU_RGBA16UI: - case GPU_R32UI: - case GPU_RG32UI: + /* Formats texture & render-buffer */ case GPU_RGBA32UI: - return data_format == GPU_DATA_UINT; - case GPU_R8I: - case GPU_RG8I: - case GPU_RGBA8I: - case GPU_R16I: - case GPU_RG16I: - case GPU_RGBA16I: - case GPU_R32I: - case GPU_RG32I: - case GPU_RGBA32I: - return data_format == GPU_DATA_INT; - case GPU_R8: - case GPU_RG8: - case GPU_RGBA8: - case GPU_R8UI: - case GPU_RG8UI: + case GPU_RG32UI: + case GPU_R32UI: + return ELEM(data_format, GPU_DATA_UINT); + case GPU_RGBA16UI: + case GPU_RG16UI: + case GPU_R16UI: + return ELEM(data_format, GPU_DATA_UINT); /* Also GPU_DATA_USHORT if needed. */ case GPU_RGBA8UI: - case GPU_SRGB8_A8: - return ELEM(data_format, GPU_DATA_UBYTE, GPU_DATA_FLOAT); - case GPU_RGB10_A2: - return ELEM(data_format, GPU_DATA_2_10_10_10_REV, GPU_DATA_FLOAT); - case GPU_R11F_G11F_B10F: - return ELEM(data_format, GPU_DATA_10_11_11_REV, GPU_DATA_FLOAT); - case GPU_RGBA16F: - return ELEM(data_format, GPU_DATA_HALF_FLOAT, GPU_DATA_FLOAT); - default: - return data_format == GPU_DATA_FLOAT; - } -} + case GPU_RG8UI: + case GPU_R8UI: + return ELEM(data_format, GPU_DATA_UINT, GPU_DATA_UBYTE); -/* Ensure valid upload formats. With format conversion support, certain types can be extended to - * allow upload from differing source formats. If these cases are added, amend accordingly. */ -inline bool validate_data_format_mtl(eGPUTextureFormat tex_format, eGPUDataFormat data_format) -{ - switch (tex_format) { - case GPU_DEPTH_COMPONENT24: - case GPU_DEPTH_COMPONENT16: - case GPU_DEPTH_COMPONENT32F: - return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_UINT); - case GPU_DEPTH24_STENCIL8: - case GPU_DEPTH32F_STENCIL8: - /* Data can be provided as a 4-byte UINT. */ - return ELEM(data_format, GPU_DATA_UINT_24_8, GPU_DATA_UINT); - case GPU_R8UI: - case GPU_R16UI: - case GPU_RG16UI: - case GPU_R32UI: - case GPU_RGBA32UI: - case GPU_RGBA16UI: - case GPU_RG8UI: - case GPU_RG32UI: - return data_format == GPU_DATA_UINT; + case GPU_RGBA32I: + case GPU_RG32I: case GPU_R32I: + return ELEM(data_format, GPU_DATA_INT); + case GPU_RGBA16I: case GPU_RG16I: case GPU_R16I: + return ELEM(data_format, GPU_DATA_INT); /* Also GPU_DATA_SHORT if needed. */ case GPU_RGBA8I: - case GPU_RGBA32I: - case GPU_RGBA16I: case GPU_RG8I: - case GPU_RG32I: case GPU_R8I: - return data_format == GPU_DATA_INT; - case GPU_R8: - case GPU_RG8: + return ELEM(data_format, GPU_DATA_INT); /* Also GPU_DATA_BYTE if needed. */ + + case GPU_RGBA32F: + case GPU_RG32F: + case GPU_R32F: + return ELEM(data_format, GPU_DATA_FLOAT); + case GPU_RGBA16F: + case GPU_RG16F: + case GPU_R16F: + return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_HALF_FLOAT); + case GPU_RGBA16: + case GPU_RG16: + case GPU_R16: + return ELEM(data_format, GPU_DATA_FLOAT); /* Also GPU_DATA_USHORT if needed. */ case GPU_RGBA8: - case GPU_RGBA8_DXT1: - case GPU_RGBA8_DXT3: - case GPU_RGBA8_DXT5: - case GPU_RGBA8UI: + case GPU_RG8: + case GPU_R8: + return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_UBYTE); + + /* Special formats texture & render-buffer */ + case GPU_RGB10_A2: + case GPU_RGB10_A2UI: + return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_2_10_10_10_REV); + case GPU_R11F_G11F_B10F: + return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_10_11_11_REV); + case GPU_DEPTH32F_STENCIL8: + /* Should have its own type. For now, we rely on the backend to do the conversion. */ + ATTR_FALLTHROUGH; + case GPU_DEPTH24_STENCIL8: + return ELEM(data_format, GPU_DATA_UINT_24_8, GPU_DATA_UINT); case GPU_SRGB8_A8: + return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_UBYTE); + + /* Texture only formats. */ + case GPU_RGB32UI: + return ELEM(data_format, GPU_DATA_UINT); + case GPU_RGB16UI: + return ELEM(data_format, GPU_DATA_UINT); /* Also GPU_DATA_SHORT if needed. */ + case GPU_RGB8UI: + return ELEM(data_format, GPU_DATA_UINT); /* Also GPU_DATA_BYTE if needed. */ + case GPU_RGB32I: + return ELEM(data_format, GPU_DATA_INT); + case GPU_RGB16I: + return ELEM(data_format, GPU_DATA_INT); /* Also GPU_DATA_USHORT if needed. */ + case GPU_RGB8I: + return ELEM(data_format, GPU_DATA_INT, GPU_DATA_UBYTE); + case GPU_RGB16: + return ELEM(data_format, GPU_DATA_FLOAT); /* Also GPU_DATA_USHORT if needed. */ + case GPU_RGB8: + return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_UBYTE); + case GPU_RGBA16_SNORM: + case GPU_RGB16_SNORM: + case GPU_RG16_SNORM: + case GPU_R16_SNORM: + return ELEM(data_format, GPU_DATA_FLOAT); /* Also GPU_DATA_SHORT if needed. */ + case GPU_RGBA8_SNORM: + case GPU_RGB8_SNORM: + case GPU_RG8_SNORM: + case GPU_R8_SNORM: + return ELEM(data_format, GPU_DATA_FLOAT); /* Also GPU_DATA_BYTE if needed. */ + case GPU_RGB32F: + return ELEM(data_format, GPU_DATA_FLOAT); + case GPU_RGB16F: + return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_HALF_FLOAT); + + /* Special formats, texture only. */ case GPU_SRGB8_A8_DXT1: case GPU_SRGB8_A8_DXT3: case GPU_SRGB8_A8_DXT5: - return ELEM(data_format, GPU_DATA_UBYTE, GPU_DATA_FLOAT); - case GPU_RGB10_A2: - return ELEM(data_format, GPU_DATA_2_10_10_10_REV, GPU_DATA_FLOAT); - case GPU_R11F_G11F_B10F: - return ELEM(data_format, GPU_DATA_10_11_11_REV, GPU_DATA_FLOAT); - case GPU_RGBA16F: - return ELEM(data_format, GPU_DATA_HALF_FLOAT, GPU_DATA_FLOAT); - case GPU_RGBA32F: - case GPU_RGBA16: - case GPU_RG32F: - case GPU_RG16F: - case GPU_RG16: - case GPU_R32F: - case GPU_R16F: - case GPU_R16: - case GPU_RGB16F: - return data_format == GPU_DATA_FLOAT; - default: - BLI_assert_msg(0, "Unrecognized data format"); - return data_format == GPU_DATA_FLOAT; + case GPU_RGBA8_DXT1: + case GPU_RGBA8_DXT3: + case GPU_RGBA8_DXT5: + /* TODO(fclem): GPU_DATA_COMPRESSED for each compression? Wouldn't it be overkill? + * For now, expect format to be set to float. */ + return ELEM(data_format, GPU_DATA_FLOAT); + case GPU_SRGB8: + return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_UBYTE); + case GPU_RGB9_E5: + return ELEM(data_format, GPU_DATA_FLOAT); + + /* Depth Formats. */ + case GPU_DEPTH_COMPONENT32F: + case GPU_DEPTH_COMPONENT24: + case GPU_DEPTH_COMPONENT16: + return ELEM(data_format, GPU_DATA_FLOAT, GPU_DATA_UINT); } + BLI_assert_unreachable(); + return data_format == GPU_DATA_FLOAT; } +/* Return default data format for an internal texture format. */ inline eGPUDataFormat to_data_format(eGPUTextureFormat tex_format) { switch (tex_format) { - case GPU_DEPTH_COMPONENT24: - case GPU_DEPTH_COMPONENT16: - case GPU_DEPTH_COMPONENT32F: - return GPU_DATA_FLOAT; - case GPU_DEPTH24_STENCIL8: - case GPU_DEPTH32F_STENCIL8: - return GPU_DATA_UINT_24_8; - case GPU_R16UI: - case GPU_R32UI: - case GPU_RG16UI: - case GPU_RG32UI: - case GPU_RGBA16UI: + /* Formats texture & render-buffer */ case GPU_RGBA32UI: - return GPU_DATA_UINT; - case GPU_R16I: - case GPU_R32I: - case GPU_R8I: - case GPU_RG16I: - case GPU_RG32I: - case GPU_RG8I: - case GPU_RGBA16I: - case GPU_RGBA32I: - case GPU_RGBA8I: - return GPU_DATA_INT; - case GPU_R8: - case GPU_R8UI: - case GPU_RG8: - case GPU_RG8UI: - case GPU_RGBA8: + case GPU_RG32UI: + case GPU_R32UI: + case GPU_RGBA16UI: + case GPU_RG16UI: + case GPU_R16UI: case GPU_RGBA8UI: - case GPU_SRGB8_A8: - return GPU_DATA_UBYTE; + case GPU_RG8UI: + case GPU_R8UI: + return GPU_DATA_UINT; + + case GPU_RGBA32I: + case GPU_RG32I: + case GPU_R32I: + case GPU_RGBA16I: + case GPU_RG16I: + case GPU_R16I: + case GPU_RGBA8I: + case GPU_RG8I: + case GPU_R8I: + return GPU_DATA_INT; + + case GPU_RGBA32F: + case GPU_RG32F: + case GPU_R32F: + case GPU_RGBA16F: + case GPU_RG16F: + case GPU_R16F: + case GPU_RGBA16: + case GPU_RG16: + case GPU_R16: + case GPU_RGBA8: + case GPU_RG8: + case GPU_R8: + return GPU_DATA_FLOAT; + + /* Special formats texture & render-buffer */ case GPU_RGB10_A2: + case GPU_RGB10_A2UI: return GPU_DATA_2_10_10_10_REV; case GPU_R11F_G11F_B10F: return GPU_DATA_10_11_11_REV; - default: + case GPU_DEPTH32F_STENCIL8: + /* Should have its own type. For now, we rely on the backend to do the conversion. */ + ATTR_FALLTHROUGH; + case GPU_DEPTH24_STENCIL8: + return GPU_DATA_UINT_24_8; + case GPU_SRGB8_A8: + return GPU_DATA_FLOAT; + + /* Texture only formats. */ + case GPU_RGB32UI: + case GPU_RGB16UI: + case GPU_RGB8UI: + return GPU_DATA_UINT; + case GPU_RGB32I: + case GPU_RGB16I: + case GPU_RGB8I: + return GPU_DATA_INT; + case GPU_RGB16: + case GPU_RGB8: + return GPU_DATA_FLOAT; + case GPU_RGBA16_SNORM: + case GPU_RGB16_SNORM: + case GPU_RG16_SNORM: + case GPU_R16_SNORM: + return GPU_DATA_FLOAT; + case GPU_RGBA8_SNORM: + case GPU_RGB8_SNORM: + case GPU_RG8_SNORM: + case GPU_R8_SNORM: + return GPU_DATA_FLOAT; + case GPU_RGB32F: + case GPU_RGB16F: + return GPU_DATA_FLOAT; + + /* Special formats, texture only. */ + case GPU_SRGB8_A8_DXT1: + case GPU_SRGB8_A8_DXT3: + case GPU_SRGB8_A8_DXT5: + case GPU_RGBA8_DXT1: + case GPU_RGBA8_DXT3: + case GPU_RGBA8_DXT5: + /* TODO(fclem): GPU_DATA_COMPRESSED for each compression? Wouldn't it be overkill? + * For now, expect format to be set to float. */ + return GPU_DATA_FLOAT; + case GPU_SRGB8: + return GPU_DATA_FLOAT; + case GPU_RGB9_E5: + return GPU_DATA_FLOAT; + + /* Depth Formats. */ + case GPU_DEPTH_COMPONENT32F: + case GPU_DEPTH_COMPONENT24: + case GPU_DEPTH_COMPONENT16: return GPU_DATA_FLOAT; } + BLI_assert_unreachable(); + return GPU_DATA_FLOAT; } inline eGPUFrameBufferBits to_framebuffer_bits(eGPUTextureFormat tex_format) { switch (tex_format) { + /* Formats texture & render-buffer */ + case GPU_RGBA32UI: + case GPU_RG32UI: + case GPU_R32UI: + case GPU_RGBA16UI: + case GPU_RG16UI: + case GPU_R16UI: + case GPU_RGBA8UI: + case GPU_RG8UI: + case GPU_R8UI: + case GPU_RGBA32I: + case GPU_RG32I: + case GPU_R32I: + case GPU_RGBA16I: + case GPU_RG16I: + case GPU_R16I: + case GPU_RGBA8I: + case GPU_RG8I: + case GPU_R8I: + case GPU_RGBA32F: + case GPU_RG32F: + case GPU_R32F: + case GPU_RGBA16F: + case GPU_RG16F: + case GPU_R16F: + case GPU_RGBA16: + case GPU_RG16: + case GPU_R16: + case GPU_RGBA8: + case GPU_RG8: + case GPU_R8: + return GPU_COLOR_BIT; + + /* Special formats texture & render-buffer */ + case GPU_RGB10_A2: + case GPU_RGB10_A2UI: + case GPU_R11F_G11F_B10F: + case GPU_SRGB8_A8: + return GPU_COLOR_BIT; + case GPU_DEPTH32F_STENCIL8: + case GPU_DEPTH24_STENCIL8: + return GPU_DEPTH_BIT | GPU_STENCIL_BIT; + + /* Depth Formats. */ + case GPU_DEPTH_COMPONENT32F: case GPU_DEPTH_COMPONENT24: case GPU_DEPTH_COMPONENT16: - case GPU_DEPTH_COMPONENT32F: return GPU_DEPTH_BIT; - case GPU_DEPTH24_STENCIL8: - case GPU_DEPTH32F_STENCIL8: - return GPU_DEPTH_BIT | GPU_STENCIL_BIT; - default: + + /* Texture only formats. */ + case GPU_RGB32UI: + case GPU_RGB16UI: + case GPU_RGB8UI: + case GPU_RGB32I: + case GPU_RGB16I: + case GPU_RGB8I: + case GPU_RGB16: + case GPU_RGB8: + case GPU_RGBA16_SNORM: + case GPU_RGB16_SNORM: + case GPU_RG16_SNORM: + case GPU_R16_SNORM: + case GPU_RGBA8_SNORM: + case GPU_RGB8_SNORM: + case GPU_RG8_SNORM: + case GPU_R8_SNORM: + case GPU_RGB32F: + case GPU_RGB16F: + BLI_assert_msg(0, "This texture format is not compatible with framebuffer attachment."); + return GPU_COLOR_BIT; + + /* Special formats, texture only. */ + case GPU_SRGB8_A8_DXT1: + case GPU_SRGB8_A8_DXT3: + case GPU_SRGB8_A8_DXT5: + case GPU_RGBA8_DXT1: + case GPU_RGBA8_DXT3: + case GPU_RGBA8_DXT5: + case GPU_SRGB8: + case GPU_RGB9_E5: + BLI_assert_msg(0, "This texture format is not compatible with framebuffer attachment."); return GPU_COLOR_BIT; } + BLI_assert_unreachable(); + return GPU_COLOR_BIT; } static inline eGPUTextureFormat to_texture_format(const GPUVertFormat *format) diff --git a/source/blender/gpu/metal/mtl_texture.hh b/source/blender/gpu/metal/mtl_texture.hh index 7a9cee97d24..ed0576f14ec 100644 --- a/source/blender/gpu/metal/mtl_texture.hh +++ b/source/blender/gpu/metal/mtl_texture.hh @@ -558,60 +558,6 @@ inline MTLPixelFormat mtl_format_get_writeable_view_format(MTLPixelFormat format return format; } -/* Returns the associated engine data type with a given texture: - * Definitely not complete, edit according to the METAL specification. */ -inline eGPUDataFormat to_mtl_internal_data_format(eGPUTextureFormat tex_format) -{ - switch (tex_format) { - case GPU_RGBA8: - case GPU_RGBA32F: - case GPU_RGBA16F: - case GPU_RGBA16: - case GPU_RG8: - case GPU_RG32F: - case GPU_RG16F: - case GPU_RG16: - case GPU_R8: - case GPU_R32F: - case GPU_R16F: - case GPU_R16: - case GPU_RGB16F: - case GPU_DEPTH_COMPONENT24: - case GPU_DEPTH_COMPONENT16: - case GPU_DEPTH_COMPONENT32F: - case GPU_SRGB8_A8: - return GPU_DATA_FLOAT; - case GPU_DEPTH24_STENCIL8: - case GPU_DEPTH32F_STENCIL8: - return GPU_DATA_UINT_24_8; - case GPU_RGBA8UI: - case GPU_RGBA32UI: - case GPU_RGBA16UI: - case GPU_RG8UI: - case GPU_RG32UI: - case GPU_R8UI: - case GPU_R16UI: - case GPU_RG16UI: - case GPU_R32UI: - return GPU_DATA_UINT; - case GPU_R8I: - case GPU_RG8I: - case GPU_R16I: - case GPU_R32I: - case GPU_RG16I: - case GPU_RGBA8I: - case GPU_RGBA32I: - case GPU_RGBA16I: - case GPU_RG32I: - return GPU_DATA_INT; - case GPU_R11F_G11F_B10F: - return GPU_DATA_10_11_11_REV; - default: - BLI_assert(false && "Texture not yet handled"); - return GPU_DATA_FLOAT; - } -} - inline MTLTextureUsage mtl_usage_from_gpu(eGPUTextureUsage usage) { MTLTextureUsage mtl_usage = MTLTextureUsageUnknown; diff --git a/source/blender/gpu/metal/mtl_texture.mm b/source/blender/gpu/metal/mtl_texture.mm index 55e25f5be50..252f8ac70a0 100644 --- a/source/blender/gpu/metal/mtl_texture.mm +++ b/source/blender/gpu/metal/mtl_texture.mm @@ -275,7 +275,7 @@ void gpu::MTLTexture::blit(id blit_encoder, uint depth) { - BLI_assert(this && dest); + BLI_assert(dest); BLI_assert(width > 0 && height > 0 && depth > 0); MTLSize src_size = MTLSizeMake(width, height, depth); MTLOrigin src_origin = MTLOriginMake(src_x_offset, src_y_offset, src_z_offset); @@ -1347,7 +1347,7 @@ void *gpu::MTLTexture::read(int mip, eGPUDataFormat type) /* Prepare Array for return data. */ BLI_assert(!(format_flag_ & GPU_FORMAT_COMPRESSED)); BLI_assert(mip <= mipmaps_); - BLI_assert(validate_data_format_mtl(format_, type)); + BLI_assert(validate_data_format(format_, type)); /* NOTE: mip_size_get() won't override any dimension that is equal to 0. */ int extent[3] = {1, 1, 1}; @@ -1406,7 +1406,7 @@ void gpu::MTLTexture::read_internal(int mip, bool is_depth_format = (format_flag_ & GPU_FORMAT_DEPTH); /* Verify if we need to use compute read. */ - eGPUDataFormat data_format = to_mtl_internal_data_format(this->format_get()); + eGPUDataFormat data_format = to_data_format(this->format_get()); bool format_conversion_needed = (data_format != desired_output_format); bool can_use_simple_read = (desired_output_bpp == image_bpp) && (!format_conversion_needed) && (num_output_components == image_components); @@ -1420,7 +1420,7 @@ void gpu::MTLTexture::read_internal(int mip, BLI_assert(num_output_components == 1); BLI_assert(image_components == 1); BLI_assert(data_format == GPU_DATA_FLOAT || data_format == GPU_DATA_UINT_24_8); - BLI_assert(validate_data_format_mtl(format_, data_format)); + BLI_assert(validate_data_format(format_, data_format)); } /* SPECIAL Workaround for R11G11B10 textures requesting a read using: GPU_DATA_10_11_11_REV. */ diff --git a/source/blender/gpu/metal/mtl_texture_util.mm b/source/blender/gpu/metal/mtl_texture_util.mm index 6b0951a5122..dde1816220f 100644 --- a/source/blender/gpu/metal/mtl_texture_util.mm +++ b/source/blender/gpu/metal/mtl_texture_util.mm @@ -32,9 +32,8 @@ namespace blender::gpu { MTLPixelFormat gpu_texture_format_to_metal(eGPUTextureFormat tex_format) { - switch (tex_format) { - /* Formats texture & render-buffer. */ + /* Texture & Render-Buffer Formats. */ case GPU_RGBA8UI: return MTLPixelFormatRGBA8Uint; case GPU_RGBA8I: @@ -74,7 +73,7 @@ MTLPixelFormat gpu_texture_format_to_metal(eGPUTextureFormat tex_format) case GPU_RG16F: return MTLPixelFormatRG16Float; case GPU_RG16: - return MTLPixelFormatRG16Float; + return MTLPixelFormatRG16Unorm; case GPU_R8UI: return MTLPixelFormatR8Uint; case GPU_R8I: @@ -94,38 +93,100 @@ MTLPixelFormat gpu_texture_format_to_metal(eGPUTextureFormat tex_format) case GPU_R16F: return MTLPixelFormatR16Float; case GPU_R16: - return MTLPixelFormatR16Snorm; - - /* Special formats texture & renderbuffer. */ + return MTLPixelFormatR16Unorm; + /* Special formats texture & renderbuffer */ + case GPU_RGB10_A2: + return MTLPixelFormatRGB10A2Unorm; + case GPU_RGB10_A2UI: + return MTLPixelFormatRGB10A2Uint; case GPU_R11F_G11F_B10F: return MTLPixelFormatRG11B10Float; case GPU_DEPTH32F_STENCIL8: return MTLPixelFormatDepth32Float_Stencil8; - case GPU_DEPTH24_STENCIL8: { + case GPU_DEPTH24_STENCIL8: BLI_assert_msg(false, "GPU_DEPTH24_STENCIL8 not supported by Apple Silicon."); return MTLPixelFormatDepth24Unorm_Stencil8; - } case GPU_SRGB8_A8: return MTLPixelFormatRGBA8Unorm_sRGB; + /* Texture only formats. */ case GPU_RGB16F: + /* 48-Bit pixel format are not supported. Emulate using a padded type with alpha. */ return MTLPixelFormatRGBA16Float; - + case GPU_RGBA16_SNORM: + return MTLPixelFormatRGBA16Snorm; + case GPU_RGBA8_SNORM: + return MTLPixelFormatRGBA8Snorm; + case GPU_RGB32F: + /* 96-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA32Float; + case GPU_RGB32I: + /* 96-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA32Sint; + case GPU_RGB32UI: + /* 96-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA32Uint; + case GPU_RGB16_SNORM: + /* 48-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA16Snorm; + case GPU_RGB16I: + /* 48-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA16Sint; + case GPU_RGB16UI: + /* 48-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA16Uint; + case GPU_RGB16: + /* 48-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA16Unorm; + case GPU_RGB8_SNORM: + /* 24-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA8Snorm; + case GPU_RGB8: + /* 24-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA8Unorm; + case GPU_RGB8I: + /* 24-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA8Sint; + case GPU_RGB8UI: + /* 24-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA8Uint; + case GPU_RG16_SNORM: + return MTLPixelFormatRG16Snorm; + case GPU_RG8_SNORM: + return MTLPixelFormatRG8Snorm; + case GPU_R16_SNORM: + return MTLPixelFormatR16Snorm; + case GPU_R8_SNORM: + return MTLPixelFormatR8Snorm; + /* Special formats, texture only. */ + case GPU_SRGB8_A8_DXT1: + case GPU_SRGB8_A8_DXT3: + case GPU_SRGB8_A8_DXT5: + case GPU_RGBA8_DXT1: + case GPU_RGBA8_DXT3: + case GPU_RGBA8_DXT5: + BLI_assert_msg(false, "Compressed texture not implemented yet!\n"); + return MTLPixelFormatRGBA8Unorm; + case GPU_SRGB8: + /* 24-Bit pixel format are not supported. Emulate using a padded type with alpha. */ + return MTLPixelFormatRGBA8Unorm_sRGB; + case GPU_RGB9_E5: + return MTLPixelFormatRGB9E5Float; /* Depth Formats. */ case GPU_DEPTH_COMPONENT32F: + return MTLPixelFormatDepth32Float; case GPU_DEPTH_COMPONENT24: + /* This formal is not supported on Metal. + * Use 32Float depth instead with some conversion steps for download and upload. */ return MTLPixelFormatDepth32Float; case GPU_DEPTH_COMPONENT16: return MTLPixelFormatDepth16Unorm; - - default: - BLI_assert_msg(false, "Unrecognised GPU pixel format!\n"); - return MTLPixelFormatRGBA8Unorm; } + BLI_assert_msg(false, "Unrecognised GPU pixel format!\n"); + return MTLPixelFormatRGBA8Unorm; } int get_mtl_format_bytesize(MTLPixelFormat tex_format) { - switch (tex_format) { case MTLPixelFormatRGBA8Uint: case MTLPixelFormatRGBA8Sint: @@ -184,7 +245,6 @@ int get_mtl_format_bytesize(MTLPixelFormat tex_format) int get_mtl_format_num_components(MTLPixelFormat tex_format) { - switch (tex_format) { case MTLPixelFormatRGBA8Uint: case MTLPixelFormatRGBA8Sint: @@ -485,7 +545,7 @@ void gpu::MTLTexture::update_sub_depth_2d( GPU_DEPTH_COMPONENT16, GPU_DEPTH24_STENCIL8, GPU_DEPTH32F_STENCIL8)); - BLI_assert(validate_data_format_mtl(format_, type)); + BLI_assert(validate_data_format(format_, type)); BLI_assert(ELEM(type, GPU_DATA_FLOAT, GPU_DATA_UINT_24_8, GPU_DATA_UINT)); /* Determine whether we are in GPU_DATA_UINT_24_8 or GPU_DATA_FLOAT mode. */ diff --git a/source/blender/gpu/opengl/gl_texture.hh b/source/blender/gpu/opengl/gl_texture.hh index efc3c743dd5..773ea4dc716 100644 --- a/source/blender/gpu/opengl/gl_texture.hh +++ b/source/blender/gpu/opengl/gl_texture.hh @@ -109,10 +109,8 @@ class GLPixelBuffer : public PixelBuffer { inline GLenum to_gl_internal_format(eGPUTextureFormat format) { - /* You can add any of the available type to this list - * For available types see GPU_texture.h */ switch (format) { - /* Formats texture & renderbuffer */ + /* Texture & Render-Buffer Formats. */ case GPU_RGBA8UI: return GL_RGBA8UI; case GPU_RGBA8I: @@ -176,6 +174,8 @@ inline GLenum to_gl_internal_format(eGPUTextureFormat format) /* Special formats texture & renderbuffer */ case GPU_RGB10_A2: return GL_RGB10_A2; + case GPU_RGB10_A2UI: + return GL_RGB10_A2UI; case GPU_R11F_G11F_B10F: return GL_R11F_G11F_B10F; case GPU_DEPTH32F_STENCIL8: @@ -184,10 +184,44 @@ inline GLenum to_gl_internal_format(eGPUTextureFormat format) return GL_DEPTH24_STENCIL8; case GPU_SRGB8_A8: return GL_SRGB8_ALPHA8; - /* Texture only format */ + /* Texture only formats. */ case GPU_RGB16F: return GL_RGB16F; - /* Special formats texture only */ + case GPU_RGBA16_SNORM: + return GL_RGBA16_SNORM; + case GPU_RGBA8_SNORM: + return GL_RGBA8_SNORM; + case GPU_RGB32F: + return GL_RGB32F; + case GPU_RGB32I: + return GL_RGB32I; + case GPU_RGB32UI: + return GL_RGB32UI; + case GPU_RGB16_SNORM: + return GL_RGB16_SNORM; + case GPU_RGB16I: + return GL_RGB16I; + case GPU_RGB16UI: + return GL_RGB16UI; + case GPU_RGB16: + return GL_RGB16; + case GPU_RGB8_SNORM: + return GL_RGB8_SNORM; + case GPU_RGB8: + return GL_RGB8; + case GPU_RGB8I: + return GL_RGB8I; + case GPU_RGB8UI: + return GL_RGB8UI; + case GPU_RG16_SNORM: + return GL_RG16_SNORM; + case GPU_RG8_SNORM: + return GL_RG8_SNORM; + case GPU_R16_SNORM: + return GL_R16_SNORM; + case GPU_R8_SNORM: + return GL_R8_SNORM; + /* Special formats, texture only. */ case GPU_SRGB8_A8_DXT1: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; case GPU_SRGB8_A8_DXT3: @@ -200,17 +234,20 @@ inline GLenum to_gl_internal_format(eGPUTextureFormat format) return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; case GPU_RGBA8_DXT5: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - /* Depth Formats */ + case GPU_SRGB8: + return GL_SRGB8; + case GPU_RGB9_E5: + return GL_RGB9_E5; + /* Depth Formats. */ case GPU_DEPTH_COMPONENT32F: return GL_DEPTH_COMPONENT32F; case GPU_DEPTH_COMPONENT24: return GL_DEPTH_COMPONENT24; case GPU_DEPTH_COMPONENT16: return GL_DEPTH_COMPONENT16; - default: - BLI_assert_msg(0, "Texture format incorrect or unsupported"); - return 0; } + BLI_assert_msg(0, "Texture format incorrect or unsupported"); + return 0; } inline GLenum to_gl_target(eGPUTextureType type) @@ -310,62 +347,80 @@ inline GLenum to_gl(eGPUDataFormat format) } } -/** - * Definitely not complete, edit according to the OpenGL specification. - */ inline GLenum to_gl_data_format(eGPUTextureFormat format) { - /* You can add any of the available type to this list - * For available types see GPU_texture.h */ switch (format) { - case GPU_R8I: - case GPU_R8UI: - case GPU_R16I: - case GPU_R16UI: - case GPU_R32I: - case GPU_R32UI: - return GL_RED_INTEGER; - case GPU_RG8I: - case GPU_RG8UI: - case GPU_RG16I: - case GPU_RG16UI: - case GPU_RG32I: - case GPU_RG32UI: - return GL_RG_INTEGER; - case GPU_RGBA8I: + /* Texture & Render-Buffer Formats. */ + case GPU_RGBA8: + case GPU_RGBA32F: + case GPU_RGBA16F: + case GPU_RGBA16: + return GL_RGBA; case GPU_RGBA8UI: - case GPU_RGBA16I: - case GPU_RGBA16UI: + case GPU_RGBA8I: case GPU_RGBA32I: case GPU_RGBA32UI: + case GPU_RGBA16UI: + case GPU_RGBA16I: return GL_RGBA_INTEGER; - case GPU_R8: - case GPU_R16: - case GPU_R16F: - case GPU_R32F: - return GL_RED; case GPU_RG8: - case GPU_RG16: - case GPU_RG16F: case GPU_RG32F: + case GPU_RG16I: + case GPU_RG16F: + case GPU_RG16: return GL_RG; - case GPU_R11F_G11F_B10F: - case GPU_RGB16F: - return GL_RGB; - case GPU_RGBA8: - case GPU_SRGB8_A8: - case GPU_RGBA16: - case GPU_RGBA16F: - case GPU_RGBA32F: + case GPU_RG8UI: + case GPU_RG8I: + case GPU_RG32UI: + case GPU_RG32I: + case GPU_RG16UI: + return GL_RG_INTEGER; + case GPU_R8: + case GPU_R32F: + case GPU_R16F: + case GPU_R16: + return GL_RED; + case GPU_R8UI: + case GPU_R8I: + case GPU_R32UI: + case GPU_R32I: + case GPU_R16UI: + case GPU_R16I: + return GL_RED_INTEGER; + /* Special formats texture & renderbuffer */ + case GPU_RGB10_A2UI: case GPU_RGB10_A2: + case GPU_SRGB8_A8: return GL_RGBA; - case GPU_DEPTH24_STENCIL8: + case GPU_R11F_G11F_B10F: + return GL_RGB; case GPU_DEPTH32F_STENCIL8: + case GPU_DEPTH24_STENCIL8: return GL_DEPTH_STENCIL; - case GPU_DEPTH_COMPONENT16: - case GPU_DEPTH_COMPONENT24: - case GPU_DEPTH_COMPONENT32F: - return GL_DEPTH_COMPONENT; + /* Texture only formats. */ + case GPU_RGBA16_SNORM: + case GPU_RGBA8_SNORM: + return GL_RGBA; + case GPU_RGB16F: + case GPU_RGB32F: + case GPU_RGB32I: + case GPU_RGB32UI: + case GPU_RGB16_SNORM: + case GPU_RGB16I: + case GPU_RGB16UI: + case GPU_RGB16: + case GPU_RGB8_SNORM: + case GPU_RGB8: + case GPU_RGB8I: + case GPU_RGB8UI: + return GL_RGB; + case GPU_RG16_SNORM: + case GPU_RG8_SNORM: + return GL_RG; + case GPU_R16_SNORM: + case GPU_R8_SNORM: + return GL_RED; + /* Special formats, texture only. */ case GPU_SRGB8_A8_DXT1: return GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT; case GPU_SRGB8_A8_DXT3: @@ -378,10 +433,17 @@ inline GLenum to_gl_data_format(eGPUTextureFormat format) return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; case GPU_RGBA8_DXT5: return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; - default: - BLI_assert_msg(0, "Texture format incorrect or unsupported\n"); - return 0; + case GPU_SRGB8: + case GPU_RGB9_E5: + return GL_RGB; + /* Depth Formats. */ + case GPU_DEPTH_COMPONENT32F: + case GPU_DEPTH_COMPONENT24: + case GPU_DEPTH_COMPONENT16: + return GL_DEPTH_COMPONENT; } + BLI_assert_msg(0, "Texture format incorrect or unsupported\n"); + return 0; } /** diff --git a/source/blender/gpu/vulkan/vk_common.cc b/source/blender/gpu/vulkan/vk_common.cc index ecfccad8294..1a8dc6769cd 100644 --- a/source/blender/gpu/vulkan/vk_common.cc +++ b/source/blender/gpu/vulkan/vk_common.cc @@ -11,121 +11,234 @@ namespace blender::gpu { VkImageAspectFlagBits to_vk_image_aspect_flag_bits(const eGPUTextureFormat format) { switch (format) { - case GPU_RGBA32F: - case GPU_RGBA8UI: - case GPU_RGBA8I: - case GPU_RGBA8: + /* Formats texture & render-buffer */ case GPU_RGBA32UI: - case GPU_RGBA32I: - case GPU_RGBA16UI: - case GPU_RGBA16I: - case GPU_RGBA16F: - case GPU_RGBA16: - case GPU_RG8UI: - case GPU_RG8I: - case GPU_RG8: case GPU_RG32UI: - case GPU_RG32I: - case GPU_RG32F: - case GPU_RG16UI: - case GPU_RG16I: - case GPU_RG16F: - case GPU_RG16: - case GPU_R8UI: - case GPU_R8I: - case GPU_R8: case GPU_R32UI: - case GPU_R32I: - case GPU_R32F: + case GPU_RGBA16UI: + case GPU_RG16UI: case GPU_R16UI: + case GPU_RGBA8UI: + case GPU_RG8UI: + case GPU_R8UI: + case GPU_RGBA32I: + case GPU_RG32I: + case GPU_R32I: + case GPU_RGBA16I: + case GPU_RG16I: case GPU_R16I: + case GPU_RGBA8I: + case GPU_RG8I: + case GPU_R8I: + case GPU_RGBA32F: + case GPU_RG32F: + case GPU_R32F: + case GPU_RGBA16F: + case GPU_RG16F: case GPU_R16F: + case GPU_RGBA16: + case GPU_RG16: case GPU_R16: + case GPU_RGBA8: + case GPU_RG8: + case GPU_R8: + return VK_IMAGE_ASPECT_COLOR_BIT; + + /* Special formats texture & render-buffer */ case GPU_RGB10_A2: + case GPU_RGB10_A2UI: case GPU_R11F_G11F_B10F: case GPU_SRGB8_A8: + return VK_IMAGE_ASPECT_COLOR_BIT; + case GPU_DEPTH32F_STENCIL8: + case GPU_DEPTH24_STENCIL8: + return static_cast(VK_IMAGE_ASPECT_DEPTH_BIT | + VK_IMAGE_ASPECT_STENCIL_BIT); + + /* Depth Formats. */ + case GPU_DEPTH_COMPONENT32F: + case GPU_DEPTH_COMPONENT24: + case GPU_DEPTH_COMPONENT16: + return VK_IMAGE_ASPECT_DEPTH_BIT; + + /* Texture only formats. */ + case GPU_RGB32UI: + case GPU_RGB16UI: + case GPU_RGB8UI: + case GPU_RGB32I: + case GPU_RGB16I: + case GPU_RGB8I: + case GPU_RGB16: + case GPU_RGB8: + case GPU_RGBA16_SNORM: + case GPU_RGB16_SNORM: + case GPU_RG16_SNORM: + case GPU_R16_SNORM: + case GPU_RGBA8_SNORM: + case GPU_RGB8_SNORM: + case GPU_RG8_SNORM: + case GPU_R8_SNORM: + case GPU_RGB32F: case GPU_RGB16F: + return VK_IMAGE_ASPECT_COLOR_BIT; + + /* Special formats, texture only. */ case GPU_SRGB8_A8_DXT1: case GPU_SRGB8_A8_DXT3: case GPU_SRGB8_A8_DXT5: case GPU_RGBA8_DXT1: case GPU_RGBA8_DXT3: case GPU_RGBA8_DXT5: + case GPU_SRGB8: + case GPU_RGB9_E5: return VK_IMAGE_ASPECT_COLOR_BIT; - - case GPU_DEPTH32F_STENCIL8: - case GPU_DEPTH24_STENCIL8: - return static_cast(VK_IMAGE_ASPECT_DEPTH_BIT | - VK_IMAGE_ASPECT_STENCIL_BIT); - - case GPU_DEPTH_COMPONENT24: - case GPU_DEPTH_COMPONENT16: - return VK_IMAGE_ASPECT_DEPTH_BIT; - - case GPU_DEPTH_COMPONENT32F: - /* Not supported by Vulkan*/ - BLI_assert_unreachable(); } + BLI_assert_unreachable(); return static_cast(0); } VkFormat to_vk_format(const eGPUTextureFormat format) { switch (format) { + /* Formats texture & render-buffer */ + case GPU_RGBA32UI: + return VK_FORMAT_R32G32B32A32_UINT; + case GPU_RG32UI: + return VK_FORMAT_R32G32_UINT; + case GPU_R32UI: + return VK_FORMAT_R32_UINT; + case GPU_RGBA16UI: + return VK_FORMAT_R16G16B16A16_UINT; + case GPU_RG16UI: + return VK_FORMAT_R16G16_UINT; + case GPU_R16UI: + return VK_FORMAT_R16_UINT; + case GPU_RGBA8UI: + return VK_FORMAT_R8G8B8A8_UINT; + case GPU_RG8UI: + return VK_FORMAT_R8G8_UINT; + case GPU_R8UI: + return VK_FORMAT_R8_UINT; + case GPU_RGBA32I: + return VK_FORMAT_R32G32B32A32_SINT; + case GPU_RG32I: + return VK_FORMAT_R32G32_SINT; + case GPU_R32I: + return VK_FORMAT_R32_SINT; + case GPU_RGBA16I: + return VK_FORMAT_R16G16B16A16_SINT; + case GPU_RG16I: + return VK_FORMAT_R16G16_SINT; + case GPU_R16I: + return VK_FORMAT_R16_SINT; + case GPU_RGBA8I: + return VK_FORMAT_R8G8B8A8_SINT; + case GPU_RG8I: + return VK_FORMAT_R8G8_SINT; + case GPU_R8I: + return VK_FORMAT_R8_SINT; case GPU_RGBA32F: return VK_FORMAT_R32G32B32A32_SFLOAT; - case GPU_RGBA8UI: - case GPU_RGBA8I: - case GPU_RGBA8: - case GPU_RGBA32UI: - case GPU_RGBA32I: - case GPU_RGBA16UI: - case GPU_RGBA16I: - case GPU_RGBA16F: - case GPU_RGBA16: - case GPU_RG8UI: - case GPU_RG8I: - case GPU_RG8: - case GPU_RG32UI: - case GPU_RG32I: case GPU_RG32F: - case GPU_RG16UI: - case GPU_RG16I: - case GPU_RG16F: - case GPU_RG16: - case GPU_R8UI: - case GPU_R8I: - case GPU_R8: - case GPU_R32UI: - case GPU_R32I: + return VK_FORMAT_R32G32_SFLOAT; case GPU_R32F: - case GPU_R16UI: - case GPU_R16I: + return VK_FORMAT_R32_SFLOAT; + case GPU_RGBA16F: + return VK_FORMAT_R16G16B16A16_SFLOAT; + case GPU_RG16F: + return VK_FORMAT_R16G16_SFLOAT; case GPU_R16F: + return VK_FORMAT_R16_SFLOAT; + case GPU_RGBA16: + return VK_FORMAT_R16G16B16A16_UNORM; + case GPU_RG16: + return VK_FORMAT_R16G16_UNORM; case GPU_R16: + return VK_FORMAT_R16_UNORM; + case GPU_RGBA8: + return VK_FORMAT_R8G8B8A8_UNORM; + case GPU_RG8: + return VK_FORMAT_R8G8_UNORM; + case GPU_R8: + return VK_FORMAT_R8_UNORM; + /* Special formats texture & render-buffer */ case GPU_RGB10_A2: + return VK_FORMAT_A2B10G10R10_UNORM_PACK32; + case GPU_RGB10_A2UI: + return VK_FORMAT_A2B10G10R10_UINT_PACK32; case GPU_R11F_G11F_B10F: - case GPU_DEPTH32F_STENCIL8: - case GPU_DEPTH24_STENCIL8: + return VK_FORMAT_B10G11R11_UFLOAT_PACK32; case GPU_SRGB8_A8: + return VK_FORMAT_R8G8B8A8_SRGB; + case GPU_DEPTH32F_STENCIL8: + return VK_FORMAT_D32_SFLOAT_S8_UINT; + case GPU_DEPTH24_STENCIL8: + return VK_FORMAT_D24_UNORM_S8_UINT; - /* Texture only format */ - case GPU_RGB16F: - - /* Special formats texture only */ - case GPU_SRGB8_A8_DXT1: - case GPU_SRGB8_A8_DXT3: - case GPU_SRGB8_A8_DXT5: - case GPU_RGBA8_DXT1: - case GPU_RGBA8_DXT3: - case GPU_RGBA8_DXT5: - - /* Depth Formats */ + /* Depth Formats. */ case GPU_DEPTH_COMPONENT32F: + return VK_FORMAT_D32_SFLOAT; case GPU_DEPTH_COMPONENT24: + return VK_FORMAT_X8_D24_UNORM_PACK32; case GPU_DEPTH_COMPONENT16: - BLI_assert_unreachable(); + return VK_FORMAT_D16_UNORM; + + /* Texture only formats. */ + case GPU_RGB32UI: + return VK_FORMAT_R32G32B32_UINT; + case GPU_RGB16UI: + return VK_FORMAT_R16G16B16_UINT; + case GPU_RGB8UI: + return VK_FORMAT_R8G8B8_UINT; + case GPU_RGB32I: + return VK_FORMAT_R32G32B32_SINT; + case GPU_RGB16I: + return VK_FORMAT_R16G16B16_SINT; + case GPU_RGB8I: + return VK_FORMAT_R8G8B8_SINT; + case GPU_RGB16: + return VK_FORMAT_R16G16B16_UNORM; + case GPU_RGB8: + return VK_FORMAT_R8G8B8_UNORM; + case GPU_RGBA16_SNORM: + return VK_FORMAT_R16G16B16A16_SNORM; + case GPU_RGB16_SNORM: + return VK_FORMAT_R16G16B16_SNORM; + case GPU_RG16_SNORM: + return VK_FORMAT_R16G16_SNORM; + case GPU_R16_SNORM: + return VK_FORMAT_R16_SNORM; + case GPU_RGBA8_SNORM: + return VK_FORMAT_R8G8B8A8_SNORM; + case GPU_RGB8_SNORM: + return VK_FORMAT_R8G8B8_SNORM; + case GPU_RG8_SNORM: + return VK_FORMAT_R8G8_SNORM; + case GPU_R8_SNORM: + return VK_FORMAT_R8_SNORM; + case GPU_RGB32F: + return VK_FORMAT_R32G32B32_SFLOAT; + case GPU_RGB16F: + return VK_FORMAT_R16G16B16_SFLOAT; + + /* Special formats, texture only. */ + case GPU_SRGB8_A8_DXT1: + return VK_FORMAT_BC1_RGBA_SRGB_BLOCK; + case GPU_SRGB8_A8_DXT3: + return VK_FORMAT_BC2_SRGB_BLOCK; + case GPU_SRGB8_A8_DXT5: + return VK_FORMAT_BC3_SRGB_BLOCK; + case GPU_RGBA8_DXT1: + return VK_FORMAT_BC1_RGBA_UNORM_BLOCK; + case GPU_RGBA8_DXT3: + return VK_FORMAT_BC2_UNORM_BLOCK; + case GPU_RGBA8_DXT5: + return VK_FORMAT_BC3_UNORM_BLOCK; + case GPU_SRGB8: + return VK_FORMAT_R8G8B8_SRGB; + case GPU_RGB9_E5: + return VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; } return VK_FORMAT_UNDEFINED; }