/*
 * 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
                     // _A8B8G8R8_UNORM_PACK32     |                         |
    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);

} // namespace skgpu::graphite

#endif // skgpu_graphite_TextureFormat_DEFINED