diff --git a/qrenderdoc/Code/FormatElement.cpp b/qrenderdoc/Code/FormatElement.cpp index 3deb57787..e9b4d47e6 100644 --- a/qrenderdoc/Code/FormatElement.cpp +++ b/qrenderdoc/Code/FormatElement.cpp @@ -509,7 +509,10 @@ QString FormatElement::GenerateTextureBufferFormat(const TextureDescription &tex case ResourceFormatType::D16S8: case ResourceFormatType::D24S8: case ResourceFormatType::D32S8: - case ResourceFormatType::YUV: baseType = lit("xint4"); break; + case ResourceFormatType::YUV8: baseType = lit("xbyte4"); break; + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: baseType = lit("xshort4"); break; case ResourceFormatType::S8: case ResourceFormatType::Undefined: baseType = lit("xbyte"); break; } diff --git a/qrenderdoc/Windows/BufferViewer.cpp b/qrenderdoc/Windows/BufferViewer.cpp index 4a2bd2ff1..96bdf503d 100644 --- a/qrenderdoc/Windows/BufferViewer.cpp +++ b/qrenderdoc/Windows/BufferViewer.cpp @@ -844,7 +844,10 @@ private: case ResourceFormatType::D32S8: compCount = 2; break; case ResourceFormatType::BC4: case ResourceFormatType::S8: compCount = 1; break; - case ResourceFormatType::YUV: + case ResourceFormatType::YUV8: + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: case ResourceFormatType::EAC: default: compCount = fmt.format.compCount; } diff --git a/qrenderdoc/Windows/PipelineState/PipelineStateViewer.cpp b/qrenderdoc/Windows/PipelineState/PipelineStateViewer.cpp index 75134c2df..e61cf66c3 100644 --- a/qrenderdoc/Windows/PipelineState/PipelineStateViewer.cpp +++ b/qrenderdoc/Windows/PipelineState/PipelineStateViewer.cpp @@ -938,7 +938,10 @@ static uint32_t byteSize(const ResourceFormat &fmt) case ResourceFormatType::D24S8: case ResourceFormatType::D32S8: case ResourceFormatType::S8: - case ResourceFormatType::YUV: + case ResourceFormatType::YUV8: + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: case ResourceFormatType::PVRTC: return ~0U; case ResourceFormatType::R10G10B10A2: case ResourceFormatType::R11G11B10: return 4; diff --git a/renderdoc/api/replay/data_types.h b/renderdoc/api/replay/data_types.h index 6280ec13a..621406153 100644 --- a/renderdoc/api/replay/data_types.h +++ b/renderdoc/api/replay/data_types.h @@ -184,6 +184,42 @@ struct ResourceFormat :rtype: ``bool`` )"); bool srgbCorrected() const { return (flags & ResourceFormat_SRGB) != 0; } + DOCUMENT(R"(Get the subsampling rate for a YUV format. Only valid when :data:`type` is +a YUV format like :attr:`ResourceFormatType.YUV8`. + +For other formats, 0 is returned. + +:return: The subsampling rate, e.g. 444 for 4:4:4 or 420 for 4:2:0 +:rtype: ``int`` +)"); + uint32_t yuvSubsampling() const + { + if(flags & ResourceFormat_444) + return 444; + else if(flags & ResourceFormat_422) + return 422; + else if(flags & ResourceFormat_420) + return 420; + return 0; + } + + DOCUMENT(R"(Get the number of planes for a YUV format. Only valid when :data:`type` is +a YUV format like :attr:`ResourceFormatType.YUV8`. + +For other formats, 1 is returned. + +:return: The number of planes +:rtype: ``int`` +)"); + uint32_t yuvPlaneCount() const + { + if(flags & ResourceFormat_3Planes) + return 3; + else if(flags & ResourceFormat_2Planes) + return 2; + return 1; + } + DOCUMENT(R"(Set BGRA order flag. See :meth:`bgraOrder`. :param bool flag: The new flag value. @@ -208,6 +244,38 @@ struct ResourceFormat flags &= ~ResourceFormat_SRGB; } + DOCUMENT(R"(Set YUV subsampling rate. See :meth:`yuvSubsampling`. + +The value should be e.g. 444 for 4:4:4 or 422 for 4:2:2. Invalid values will result in 0 being set. + +:param int subsample: The new subsampling rate. +)"); + void setYUVSubsampling(uint32_t subsampling) + { + flags &= ~ResourceFormat_SubSample_Mask; + if(subsampling == 444) + flags |= ResourceFormat_444; + else if(subsampling == 422) + flags |= ResourceFormat_422; + else if(subsampling == 420) + flags |= ResourceFormat_420; + } + + DOCUMENT(R"(Set number of YUV planes. See :meth:`yuvPlaneCount`. + +Invalid values will result in 1 being set. + +:param int planes: The new number of YUV planes. +)"); + void setYUVPlaneCount(uint32_t planes) + { + flags &= ~ResourceFormat_Planes_Mask; + if(planes == 2) + flags |= ResourceFormat_2Planes; + else if(planes == 3) + flags |= ResourceFormat_3Planes; + } + ResourceFormatType type; DOCUMENT("The :class:`type ` of each component."); @@ -222,6 +290,15 @@ private: { ResourceFormat_BGRA = 0x001, ResourceFormat_SRGB = 0x002, + + ResourceFormat_444 = 0x004, + ResourceFormat_422 = 0x008, + ResourceFormat_420 = 0x010, + ResourceFormat_SubSample_Mask = 0x01C, + + ResourceFormat_2Planes = 0x020, + ResourceFormat_3Planes = 0x040, + ResourceFormat_Planes_Mask = 0x060, }; uint16_t flags; diff --git a/renderdoc/api/replay/renderdoc_tostr.inl b/renderdoc/api/replay/renderdoc_tostr.inl index fec59bd12..c1d819304 100644 --- a/renderdoc/api/replay/renderdoc_tostr.inl +++ b/renderdoc/api/replay/renderdoc_tostr.inl @@ -82,7 +82,10 @@ std::string DoStringise(const ResourceFormatType &el) STRINGISE_ENUM_CLASS(D24S8); STRINGISE_ENUM_CLASS(D32S8); STRINGISE_ENUM_CLASS(S8); - STRINGISE_ENUM_CLASS(YUV); + STRINGISE_ENUM_CLASS(YUV8); + STRINGISE_ENUM_CLASS(YUV10); + STRINGISE_ENUM_CLASS(YUV12); + STRINGISE_ENUM_CLASS(YUV16); } END_ENUM_STRINGISE(); } diff --git a/renderdoc/api/replay/replay_enums.h b/renderdoc/api/replay/replay_enums.h index 53f7c4f33..0a38f8166 100644 --- a/renderdoc/api/replay/replay_enums.h +++ b/renderdoc/api/replay/replay_enums.h @@ -1206,9 +1206,25 @@ or formats that don't have equal byte-multiple sizes for each channel. Each pixel is an 8 bit stencil value. -.. data:: YUV +.. data:: YUV8 - The pixel data is in an opaque YUV format. + The pixel data is 8-bit in YUV subsampled format. More information about subsampling setup is + stored separately + +.. data:: YUV10 + + The pixel data is 10-bit in YUV subsampled format. More information about subsampling setup is + stored separately + +.. data:: YUV12 + + The pixel data is 12-bit in YUV subsampled format. More information about subsampling setup is + stored separately + +.. data:: YUV16 + + The pixel data is 16-bit in YUV subsampled format. More information about subsampling setup is + stored separately .. data:: PVRTC @@ -1239,7 +1255,10 @@ enum class ResourceFormatType : uint8_t D24S8, D32S8, S8, - YUV, + YUV8, + YUV10, + YUV12, + YUV16, PVRTC, }; diff --git a/renderdoc/common/dds_readwrite.cpp b/renderdoc/common/dds_readwrite.cpp index b999d1f96..125c5adc9 100644 --- a/renderdoc/common/dds_readwrite.cpp +++ b/renderdoc/common/dds_readwrite.cpp @@ -478,7 +478,10 @@ DXGI_FORMAT ResourceFormat2DXGIFormat(ResourceFormat format) case ResourceFormatType::ETC2: case ResourceFormatType::EAC: case ResourceFormatType::ASTC: - case ResourceFormatType::YUV: + case ResourceFormatType::YUV8: + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: RDCERR("Unsupported writing format %u", format.type); return DXGI_FORMAT_UNKNOWN; } @@ -665,7 +668,10 @@ bool write_dds_to_file(FILE *f, const dds_data &data) case ResourceFormatType::ETC2: case ResourceFormatType::EAC: case ResourceFormatType::ASTC: - case ResourceFormatType::YUV: + case ResourceFormatType::YUV8: + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: RDCERR("Unsupported file format, %u", data.format.type); return false; default: break; @@ -733,7 +739,10 @@ bool write_dds_to_file(FILE *f, const dds_data &data) case ResourceFormatType::R4G4B4A4: bytesPerPixel = 2; break; case ResourceFormatType::D32S8: bytesPerPixel = 8; break; case ResourceFormatType::D16S8: - case ResourceFormatType::YUV: + case ResourceFormatType::YUV8: + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: case ResourceFormatType::R4G4: RDCERR("Unsupported file format %u", data.format.type); return false; @@ -989,7 +998,10 @@ dds_data load_dds_from_file(FILE *f) case ResourceFormatType::R4G4B4A4: bytesPerPixel = 2; break; case ResourceFormatType::D32S8: bytesPerPixel = 8; break; case ResourceFormatType::D16S8: - case ResourceFormatType::YUV: + case ResourceFormatType::YUV8: + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: case ResourceFormatType::R4G4: RDCERR("Unsupported file format %u", ret.format.type); return error; @@ -1012,7 +1024,10 @@ dds_data load_dds_from_file(FILE *f) case ResourceFormatType::ETC2: case ResourceFormatType::EAC: case ResourceFormatType::ASTC: - case ResourceFormatType::YUV: + case ResourceFormatType::YUV8: + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: RDCERR("Unsupported file format, %u", ret.format.type); return error; default: break; diff --git a/renderdoc/driver/d3d11/d3d11_context_wrap.cpp b/renderdoc/driver/d3d11/d3d11_context_wrap.cpp index dee518c01..906114b79 100644 --- a/renderdoc/driver/d3d11/d3d11_context_wrap.cpp +++ b/renderdoc/driver/d3d11/d3d11_context_wrap.cpp @@ -6985,6 +6985,9 @@ void MapIntercept::Init(ID3D11Texture1D *tex, UINT sub, void *appMemory) numRows = RDCMAX(1, numRows >> mip); numSlices = RDCMAX(1, numSlices >> mip); + if(IsYUVPlanarFormat(fmt)) + numRows = GetYUVNumRows(fmt, numRows); + app.RowPitch = GetByteSize(width, 1, 1, fmt, mip); app.DepthPitch = GetByteSize(width, height, 1, fmt, mip); @@ -7017,6 +7020,9 @@ void MapIntercept::Init(ID3D11Texture2D *tex, UINT sub, void *appMemory) numRows = RDCMAX(1, numRows >> mip); numSlices = RDCMAX(1, numSlices >> mip); + if(IsYUVPlanarFormat(fmt)) + numRows = GetYUVNumRows(fmt, numRows); + app.RowPitch = GetByteSize(width, 1, 1, fmt, mip); app.DepthPitch = GetByteSize(width, height, 1, fmt, mip); @@ -7048,6 +7054,9 @@ void MapIntercept::Init(ID3D11Texture3D *tex, UINT sub, void *appMemory) numRows = RDCMAX(1, numRows >> mip); numSlices = RDCMAX(1, numSlices >> mip); + if(IsYUVPlanarFormat(fmt)) + numRows = GetYUVNumRows(fmt, numRows); + app.RowPitch = GetByteSize(width, 1, 1, fmt, mip); app.DepthPitch = GetByteSize(width, height, 1, fmt, mip); } diff --git a/renderdoc/driver/d3d11/d3d11_initstate.cpp b/renderdoc/driver/d3d11/d3d11_initstate.cpp index c6092c6f9..410b8b75f 100644 --- a/renderdoc/driver/d3d11/d3d11_initstate.cpp +++ b/renderdoc/driver/d3d11/d3d11_initstate.cpp @@ -335,6 +335,8 @@ uint32_t WrappedID3D11Device::GetSize_InitialState(ResourceId id, ID3D11DeviceCh uint32_t numRows = RDCMAX(1U, desc.Height >> mip); if(IsBlockFormat(desc.Format)) numRows = AlignUp4(numRows) / 4; + else if(IsYUVPlanarFormat(desc.Format)) + numRows = GetYUVNumRows(desc.Format, numRows); if(stage) { @@ -712,6 +714,8 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId uint32_t numRows = RDCMAX(1U, desc.Height >> mip); if(IsBlockFormat(desc.Format)) numRows = AlignUp4(numRows) / 4; + else if(IsYUVPlanarFormat(desc.Format)) + numRows = GetYUVNumRows(desc.Format, numRows); void *SubresourceContents = NULL; uint32_t ContentsLength = 0; @@ -883,6 +887,8 @@ bool WrappedID3D11Device::Serialise_InitialState(SerialiserType &ser, ResourceId uint32_t numRows = RDCMAX(1U, desc.Height >> mip); if(IsBlockFormat(desc.Format)) numRows = AlignUp4(numRows) / 4; + else if(IsYUVPlanarFormat(desc.Format)) + numRows = GetYUVNumRows(desc.Format, numRows); void *SubresourceContents = NULL; uint32_t ContentsLength = 0; diff --git a/renderdoc/driver/dxgi/dxgi_common.cpp b/renderdoc/driver/dxgi/dxgi_common.cpp index 1b30ca3e4..fb6a7b8ef 100644 --- a/renderdoc/driver/dxgi/dxgi_common.cpp +++ b/renderdoc/driver/dxgi/dxgi_common.cpp @@ -32,152 +32,6 @@ #include #include -UINT GetFormatBPP(DXGI_FORMAT f) -{ - UINT ret = 8; - - switch(f) - { - case DXGI_FORMAT_R32G32B32A32_TYPELESS: - case DXGI_FORMAT_R32G32B32A32_FLOAT: - case DXGI_FORMAT_R32G32B32A32_UINT: - case DXGI_FORMAT_R32G32B32A32_SINT: ret *= 16; break; - case DXGI_FORMAT_R32G32B32_TYPELESS: - case DXGI_FORMAT_R32G32B32_FLOAT: - case DXGI_FORMAT_R32G32B32_UINT: - case DXGI_FORMAT_R32G32B32_SINT: ret *= 12; break; - case DXGI_FORMAT_R16G16B16A16_TYPELESS: - case DXGI_FORMAT_R16G16B16A16_FLOAT: - case DXGI_FORMAT_R16G16B16A16_UNORM: - case DXGI_FORMAT_R16G16B16A16_UINT: - case DXGI_FORMAT_R16G16B16A16_SNORM: - case DXGI_FORMAT_R16G16B16A16_SINT: - case DXGI_FORMAT_R32G32_TYPELESS: - case DXGI_FORMAT_R32G32_FLOAT: - case DXGI_FORMAT_R32G32_UINT: - case DXGI_FORMAT_R32G32_SINT: - case DXGI_FORMAT_R32G8X24_TYPELESS: - case DXGI_FORMAT_D32_FLOAT_S8X24_UINT: - case DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS: - case DXGI_FORMAT_X32_TYPELESS_G8X24_UINT: ret *= 8; break; - case DXGI_FORMAT_R10G10B10A2_TYPELESS: - case DXGI_FORMAT_R10G10B10A2_UNORM: - case DXGI_FORMAT_R10G10B10A2_UINT: - case DXGI_FORMAT_R11G11B10_FLOAT: - case DXGI_FORMAT_R8G8B8A8_TYPELESS: - case DXGI_FORMAT_R8G8B8A8_UNORM: - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - case DXGI_FORMAT_R8G8B8A8_UINT: - case DXGI_FORMAT_R8G8B8A8_SNORM: - case DXGI_FORMAT_R8G8B8A8_SINT: - case DXGI_FORMAT_R16G16_TYPELESS: - case DXGI_FORMAT_R16G16_FLOAT: - case DXGI_FORMAT_R16G16_UNORM: - case DXGI_FORMAT_R16G16_UINT: - case DXGI_FORMAT_R16G16_SNORM: - case DXGI_FORMAT_R16G16_SINT: - case DXGI_FORMAT_R32_TYPELESS: - case DXGI_FORMAT_D32_FLOAT: - case DXGI_FORMAT_R32_FLOAT: - case DXGI_FORMAT_R32_UINT: - case DXGI_FORMAT_R32_SINT: - case DXGI_FORMAT_R24G8_TYPELESS: - case DXGI_FORMAT_D24_UNORM_S8_UINT: - case DXGI_FORMAT_R24_UNORM_X8_TYPELESS: - case DXGI_FORMAT_X24_TYPELESS_G8_UINT: - case DXGI_FORMAT_R9G9B9E5_SHAREDEXP: - case DXGI_FORMAT_R8G8_B8G8_UNORM: - case DXGI_FORMAT_G8R8_G8B8_UNORM: - case DXGI_FORMAT_B8G8R8A8_UNORM: - case DXGI_FORMAT_B8G8R8X8_UNORM: - case DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM: - case DXGI_FORMAT_B8G8R8A8_TYPELESS: - case DXGI_FORMAT_B8G8R8A8_UNORM_SRGB: - case DXGI_FORMAT_B8G8R8X8_TYPELESS: - case DXGI_FORMAT_B8G8R8X8_UNORM_SRGB: ret *= 4; break; - case DXGI_FORMAT_R8G8_TYPELESS: - case DXGI_FORMAT_R8G8_UNORM: - case DXGI_FORMAT_R8G8_UINT: - case DXGI_FORMAT_R8G8_SNORM: - case DXGI_FORMAT_R8G8_SINT: - case DXGI_FORMAT_R16_TYPELESS: - case DXGI_FORMAT_R16_FLOAT: - case DXGI_FORMAT_D16_UNORM: - case DXGI_FORMAT_R16_UNORM: - case DXGI_FORMAT_R16_UINT: - case DXGI_FORMAT_R16_SNORM: - case DXGI_FORMAT_R16_SINT: - case DXGI_FORMAT_B5G6R5_UNORM: - case DXGI_FORMAT_B5G5R5A1_UNORM: ret *= 2; break; - case DXGI_FORMAT_R8_TYPELESS: - case DXGI_FORMAT_R8_UNORM: - case DXGI_FORMAT_R8_UINT: - case DXGI_FORMAT_R8_SNORM: - case DXGI_FORMAT_R8_SINT: - case DXGI_FORMAT_A8_UNORM: ret *= 1; break; - case DXGI_FORMAT_R1_UNORM: ret /= 8; break; - case DXGI_FORMAT_BC1_TYPELESS: - case DXGI_FORMAT_BC1_UNORM: - case DXGI_FORMAT_BC1_UNORM_SRGB: - case DXGI_FORMAT_BC4_TYPELESS: - case DXGI_FORMAT_BC4_UNORM: - case DXGI_FORMAT_BC4_SNORM: - // return block size (in bits) - ret *= 8; - break; - case DXGI_FORMAT_BC2_TYPELESS: - case DXGI_FORMAT_BC2_UNORM: - case DXGI_FORMAT_BC2_UNORM_SRGB: - case DXGI_FORMAT_BC3_TYPELESS: - case DXGI_FORMAT_BC3_UNORM: - case DXGI_FORMAT_BC3_UNORM_SRGB: - case DXGI_FORMAT_BC5_TYPELESS: - case DXGI_FORMAT_BC5_UNORM: - case DXGI_FORMAT_BC5_SNORM: - case DXGI_FORMAT_BC6H_TYPELESS: - case DXGI_FORMAT_BC6H_UF16: - case DXGI_FORMAT_BC6H_SF16: - case DXGI_FORMAT_BC7_TYPELESS: - case DXGI_FORMAT_BC7_UNORM: - case DXGI_FORMAT_BC7_UNORM_SRGB: - // return block size (in bits) - ret *= 16; - break; - - case DXGI_FORMAT_AYUV: - case DXGI_FORMAT_Y410: - case DXGI_FORMAT_YUY2: - case DXGI_FORMAT_Y416: - case DXGI_FORMAT_NV12: - case DXGI_FORMAT_P010: - case DXGI_FORMAT_P016: - case DXGI_FORMAT_420_OPAQUE: - case DXGI_FORMAT_Y210: - case DXGI_FORMAT_Y216: - case DXGI_FORMAT_NV11: - case DXGI_FORMAT_AI44: - case DXGI_FORMAT_IA44: - case DXGI_FORMAT_P8: - case DXGI_FORMAT_A8P8: - case DXGI_FORMAT_P208: - case DXGI_FORMAT_V208: - case DXGI_FORMAT_V408: RDCERR("Video formats not supported"); break; - - case DXGI_FORMAT_B4G4R4A4_UNORM: - ret *= 2; // 4 channels, half a byte each - break; - - case DXGI_FORMAT_UNKNOWN: - ret = 0; - RDCWARN("Getting BPP of DXGI_FORMAT_UNKNOWN"); - break; - - default: RDCERR("Unrecognised DXGI Format: %d", f); break; - } - - return ret; -} - UINT GetByteSize(int Width, int Height, int Depth, DXGI_FORMAT Format, int mip) { UINT ret = RDCMAX(Width >> mip, 1) * RDCMAX(Height >> mip, 1) * RDCMAX(Depth >> mip, 1); @@ -291,28 +145,162 @@ UINT GetByteSize(int Width, int Height, int Depth, DXGI_FORMAT Format, int mip) RDCMAX(Depth >> mip, 1); ret *= 1; break; - case DXGI_FORMAT_AYUV: - case DXGI_FORMAT_Y410: - case DXGI_FORMAT_YUY2: - case DXGI_FORMAT_Y416: - case DXGI_FORMAT_NV12: - case DXGI_FORMAT_P010: - case DXGI_FORMAT_P016: - case DXGI_FORMAT_420_OPAQUE: - case DXGI_FORMAT_Y210: - case DXGI_FORMAT_Y216: - case DXGI_FORMAT_NV11: - case DXGI_FORMAT_AI44: - case DXGI_FORMAT_IA44: - case DXGI_FORMAT_P8: - case DXGI_FORMAT_A8P8: - case DXGI_FORMAT_P208: - case DXGI_FORMAT_V208: - case DXGI_FORMAT_V408: RDCERR("Video formats not supported"); break; - case DXGI_FORMAT_B4G4R4A4_UNORM: ret *= 2; // 4 channels, half a byte each break; + /* + * YUV planar/packed subsampled textures. + * + * In each diagram we indicate (maybe part) of the data for a 4x4 texture: + * + * +---+---+---+---+ + * | 0 | 1 | 2 | 3 | + * +---+---+---+---+ + * | 4 | 5 | 6 | 7 | + * +---+---+---+---+ + * | 8 | 9 | A | B | + * +---+---+---+---+ + * | C | D | E | F | + * +---+---+---+---+ + * + * + * FOURCC decoding: + * - char 0: 'Y' = packed, 'P' = planar + * - char 1: '4' = 4:4:4, '2' = 4:2:2, '1' = 4:2:1, '0' = 4:2:0 + * - char 2+3: '16' = 16-bit, '10' = 10-bit, '08' = 8-bit + * + * planar = Y is first, all together, then UV comes second. + * packed = YUV is interleaved + * + * ======================= 4:4:4 lossless packed ========================= + * + * Equivalent to uncompressed formats, just YUV instead of RGB. For 8-bit: + * + * pixel: 0 1 2 3 + * byte: 0 1 2 3 4 5 6 7 8 9 A B C D E F + * Y0 U0 V0 A0 Y1 U1 V1 A1 Y2 U2 V2 A2 Y3 U3 V3 A3 + * + * 16-bit is similar with two bytes per sample, 10-bit for uncompressed is + * equivalent to R10G10B10A2 but with RGB=>YUV + * + * ============================ 4:2:2 packed ============================= + * + * 50% horizontal subsampling packed, two Y samples for each U/V sample pair. For 8-bit: + * + * pixel: 0 | 1 2 | 3 4 | 5 6 | 7 + * byte: 0 1 2 3 4 5 6 7 8 9 A B C D E F + * Y0 U0 Y1 V0 Y2 U1 Y3 V1 Y4 U2 Y5 V2 Y6 U3 Y7 V3 + * + * 16-bit is similar with two bytes per sample, 10-bit is stored identically to 16-bit but in + * the most significant bits: + * + * bit: FEDCBA9876543210 + * 16-bit: XXXXXXXXXXXXXXXX + * 10-bit: XXXXXXXXXX000000 + * + * Since the data is unorm this just spaces out valid values. + * + * ============================ 4:2:0 planar ============================= + * + * 50% horizontal and vertical subsampled planar, four Y samples for each U/V sample pair. + * For 8-bit: + * + * + * pixel: 0 1 2 3 4 5 6 7 + * byte: 0 1 2 3 4 5 6 7 + * Y0 Y1 Y2 Y3 Y4 Y5 Y6 Y7 + * + * pixel: 8 9 A B C D E F + * byte: 8 9 A B C D E F + * Y8 Y9 Ya Yb Yc Yd Ye Yf + * + * ... all of the rest of Y luma ... + * + * pixel: T&4 | 1&5 2&6 | 3&7 + * byte: 0 1 2 3 4 5 6 7 + * U0 V0 U1 V1 U2 V2 U3 V3 + * + * pixel: 8&C | 9&D A&E | B&F + * byte: 8 9 A B C D E F + * U4 V4 U5 V5 U6 V6 U7 V7 + */ + case DXGI_FORMAT_AYUV: + // 4:4:4 lossless packed, 8-bit. Equivalent size to R8G8B8A8 + ret *= 4; + break; + case DXGI_FORMAT_Y410: + // 4:4:4 lossless packed. Equivalent size to R10G10B10A2, unlike most 10-bit/16-bit formats is + // not equivalent to the 16-bit format. + ret *= 4; + break; + case DXGI_FORMAT_Y416: + // 4:4:4 lossless packed. Equivalent size to R16G16B16A16 + ret *= 8; + break; + case DXGI_FORMAT_NV12: + // 4:2:0 planar. Since we can assume even width and height, resulting size is 1 byte per pixel + // for luma, plus 1 byte per 2 pixels for chroma + ret = ret + ret / 2; + break; + case DXGI_FORMAT_P010: + // 10-bit formats are stored identically to 16-bit formats + // deliberate fallthrough + case DXGI_FORMAT_P016: + // 4:2:0 planar but 16-bit, so pixelCount*2 + (pixelCount*2) / 2 + ret *= 2; + ret = ret + ret / 2; + break; + case DXGI_FORMAT_420_OPAQUE: + // same size as NV12 - planar 4:2:0 but opaque layout + ret = ret + ret / 2; + break; + case DXGI_FORMAT_YUY2: + // 4:2:2 packed 8-bit, so 1 byte per pixel for luma and 1 byte per pixel for chroma (2 chroma + // samples, with 50% subsampling = 1 byte per pixel) + ret *= 2; + break; + case DXGI_FORMAT_Y210: + // 10-bit formats are stored identically to 16-bit formats + // deliberate fallthrough + case DXGI_FORMAT_Y216: + // 4:2:2 packed 16-bit + ret *= 4; + break; + case DXGI_FORMAT_NV11: + // similar to NV11 - planar 4:1:1 4 horizontal downsampling but no vertical downsampling. For + // size calculation amounts to the same result. + ret = ret + ret / 2; + break; + case DXGI_FORMAT_AI44: + // special format, 1 byte per pixel, palletised values in 4 most significant bits, alpha in 4 + // least significant bits. + // deliberate fallthrough + case DXGI_FORMAT_IA44: + // same as above but swapped MSB/LSB + break; + case DXGI_FORMAT_P8: + // 8 bits of palletised data + break; + case DXGI_FORMAT_A8P8: + // 8 bits palletised data, 8 bits alpha data. Seems to be packed (no indication in docs of + // planar) + ret *= 2; + break; + case DXGI_FORMAT_P208: + // 4:2:2 planar 8-bit. 1 byte per pixel of luma, then separately 1 byte per pixel of chroma. + // Identical size to packed 4:2:2, just different layout + ret *= 2; + break; + case DXGI_FORMAT_V208: + // unclear, seems to be packed 4:4:0 8-bit. Thus 1 byte per pixel for luma, 2 chroma samples + // every 2 rows = 1 byte per pixel for chroma + ret *= 2; + break; + case DXGI_FORMAT_V408: + // unclear, seems to be packed 4:4:4 8-bit + ret *= 4; + break; + case DXGI_FORMAT_UNKNOWN: RDCERR("Getting byte size of unknown DXGI format"); ret = 0; @@ -513,6 +501,43 @@ bool IsYUVFormat(DXGI_FORMAT f) return false; } +bool IsYUVPlanarFormat(DXGI_FORMAT f) +{ + switch(f) + { + case DXGI_FORMAT_NV12: + case DXGI_FORMAT_P010: + case DXGI_FORMAT_P016: + case DXGI_FORMAT_420_OPAQUE: + case DXGI_FORMAT_NV11: + case DXGI_FORMAT_P208: return true; + default: break; + } + + return false; +} + +UINT GetYUVNumRows(DXGI_FORMAT f, UINT height) +{ + switch(f) + { + case DXGI_FORMAT_NV12: + case DXGI_FORMAT_P010: + case DXGI_FORMAT_P016: + case DXGI_FORMAT_420_OPAQUE: + // all of these are 4:2:0, so number of rows is equal to height + height/2 + return height + height / 2; + case DXGI_FORMAT_NV11: + case DXGI_FORMAT_P208: + // 4:1:1 and 4:2:2 have the same number of rows for chroma and luma planes, so we have + // height * 2 rows + return height * 2; + default: break; + } + + return height; +} + DXGI_FORMAT GetDepthTypedFormat(DXGI_FORMAT f) { switch(f) @@ -1585,11 +1610,116 @@ DXGI_FORMAT MakeDXGIFormat(ResourceFormat fmt) break; case ResourceFormatType::D24S8: ret = DXGI_FORMAT_R24G8_TYPELESS; break; case ResourceFormatType::D32S8: ret = DXGI_FORMAT_R32G8X24_TYPELESS; break; - case ResourceFormatType::YUV: - // just claim all YUV formats as unsupported. In theory we could add more - // resource format type enums to identify all the types, and return support for - // the ones that exist in D3D + case ResourceFormatType::YUV8: + { + int subsampling = fmt.yuvSubsampling(); + int planeCount = fmt.yuvPlaneCount(); + if(subsampling == 444) + { + // only support AYUV - 4 components + if(fmt.compCount != 4) + return DXGI_FORMAT_UNKNOWN; + + // only support packed 4:4:4 + return planeCount == 1 ? DXGI_FORMAT_AYUV : DXGI_FORMAT_UNKNOWN; + } + else if(subsampling == 422) + { + // only support 3 components + if(fmt.compCount != 3) + return DXGI_FORMAT_UNKNOWN; + + // packed 4:2:2 + if(planeCount == 1) + return DXGI_FORMAT_YUY2; + // planar 4:2:2 + else if(planeCount == 2) + return DXGI_FORMAT_P208; + + return DXGI_FORMAT_UNKNOWN; + } + else if(subsampling == 420) + { + // only support 3 components + if(fmt.compCount != 3) + return DXGI_FORMAT_UNKNOWN; + + // only support 2-planar 4:2:0 + return planeCount == 2 ? DXGI_FORMAT_NV12 : DXGI_FORMAT_UNKNOWN; + } + break; + } + case ResourceFormatType::YUV10: + { + int subsampling = fmt.yuvSubsampling(); + int planeCount = fmt.yuvPlaneCount(); + if(subsampling == 444) + { + // only support Y410 - 4 components + if(fmt.compCount != 4) + return DXGI_FORMAT_UNKNOWN; + + // only support packed 4:4:4 + return planeCount == 1 ? DXGI_FORMAT_Y410 : DXGI_FORMAT_UNKNOWN; + } + else if(subsampling == 422) + { + // only support 3 components + if(fmt.compCount != 3) + return DXGI_FORMAT_UNKNOWN; + + // only support packed 4:2:2 + return planeCount == 1 ? DXGI_FORMAT_Y210 : DXGI_FORMAT_UNKNOWN; + } + else if(subsampling == 420) + { + // only support 3 components + if(fmt.compCount != 3) + return DXGI_FORMAT_UNKNOWN; + + // only support 2-planar 4:2:0 + return planeCount == 2 ? DXGI_FORMAT_P010 : DXGI_FORMAT_UNKNOWN; + } + break; + } + case ResourceFormatType::YUV12: + { + // no 12-bit YUV format support return DXGI_FORMAT_UNKNOWN; + } + case ResourceFormatType::YUV16: + { + int subsampling = fmt.yuvSubsampling(); + int planeCount = fmt.yuvPlaneCount(); + if(subsampling == 444) + { + // only support Y416 - 4 components + if(fmt.compCount != 4) + return DXGI_FORMAT_UNKNOWN; + + // only support packed 4:4:4 + return planeCount == 1 ? DXGI_FORMAT_Y416 : DXGI_FORMAT_UNKNOWN; + } + else if(subsampling == 422) + { + // only support 3 components + if(fmt.compCount != 3) + return DXGI_FORMAT_UNKNOWN; + + // only support packed 4:2:2 + return planeCount == 1 ? DXGI_FORMAT_Y216 : DXGI_FORMAT_UNKNOWN; + } + else if(subsampling == 420) + { + // only support 3 components + if(fmt.compCount != 3) + return DXGI_FORMAT_UNKNOWN; + + // only support 2-planar 4:2:0 + return planeCount == 2 ? DXGI_FORMAT_P016 : DXGI_FORMAT_UNKNOWN; + } + break; + } case ResourceFormatType::S8: // D3D has no stencil-only format case ResourceFormatType::D16S8: // D3D has no D16S8 format default: return DXGI_FORMAT_UNKNOWN; @@ -1788,7 +1918,7 @@ ResourceFormat MakeResourceFormat(DXGI_FORMAT fmt) case DXGI_FORMAT_AYUV: case DXGI_FORMAT_Y410: - case DXGI_FORMAT_Y416: + case DXGI_FORMAT_Y416: ret.compCount = 4; break; case DXGI_FORMAT_NV12: case DXGI_FORMAT_P010: case DXGI_FORMAT_P016: @@ -1797,13 +1927,13 @@ ResourceFormat MakeResourceFormat(DXGI_FORMAT fmt) case DXGI_FORMAT_Y210: case DXGI_FORMAT_Y216: case DXGI_FORMAT_NV11: - case DXGI_FORMAT_AI44: - case DXGI_FORMAT_IA44: - case DXGI_FORMAT_P8: - case DXGI_FORMAT_A8P8: case DXGI_FORMAT_P208: case DXGI_FORMAT_V208: case DXGI_FORMAT_V408: ret.compCount = 3; break; + case DXGI_FORMAT_AI44: + case DXGI_FORMAT_IA44: + case DXGI_FORMAT_P8: + case DXGI_FORMAT_A8P8: ret.compCount = 2; break; case DXGI_FORMAT_UNKNOWN: case DXGI_FORMAT_FORCE_UINT: ret.compCount = 0; break; @@ -2074,18 +2204,75 @@ ResourceFormat MakeResourceFormat(DXGI_FORMAT fmt) case DXGI_FORMAT_NV12: case DXGI_FORMAT_P010: case DXGI_FORMAT_P016: - case DXGI_FORMAT_420_OPAQUE: case DXGI_FORMAT_YUY2: case DXGI_FORMAT_Y210: case DXGI_FORMAT_Y216: + case DXGI_FORMAT_P208: + { + ret.type = ResourceFormatType::YUV8; + + switch(fmt) + { + case DXGI_FORMAT_P010: + case DXGI_FORMAT_Y210: + case DXGI_FORMAT_Y410: ret.type = ResourceFormatType::YUV10; + default: break; + } + + switch(fmt) + { + case DXGI_FORMAT_P016: + case DXGI_FORMAT_Y216: + case DXGI_FORMAT_Y416: ret.type = ResourceFormatType::YUV16; + default: break; + } + + switch(fmt) + { + case DXGI_FORMAT_AYUV: + case DXGI_FORMAT_Y410: + case DXGI_FORMAT_Y416: ret.setYUVSubsampling(444); + default: break; + } + + switch(fmt) + { + case DXGI_FORMAT_YUY2: + case DXGI_FORMAT_Y210: + case DXGI_FORMAT_Y216: + case DXGI_FORMAT_P208: ret.setYUVSubsampling(422); + default: break; + } + + switch(fmt) + { + case DXGI_FORMAT_NV12: + case DXGI_FORMAT_P010: + case DXGI_FORMAT_P016: ret.setYUVSubsampling(420); + default: break; + } + + switch(fmt) + { + case DXGI_FORMAT_NV12: + case DXGI_FORMAT_P010: + case DXGI_FORMAT_P016: + case DXGI_FORMAT_P208: ret.setYUVPlaneCount(2); + } + + break; + } case DXGI_FORMAT_NV11: case DXGI_FORMAT_AI44: case DXGI_FORMAT_IA44: case DXGI_FORMAT_P8: case DXGI_FORMAT_A8P8: - case DXGI_FORMAT_P208: case DXGI_FORMAT_V208: - case DXGI_FORMAT_V408: ret.type = ResourceFormatType::YUV; break; + case DXGI_FORMAT_V408: + case DXGI_FORMAT_420_OPAQUE: + RDCERR("Unsupported YUV format %s", ToStr(fmt).c_str()); + ret.type = ResourceFormatType::Undefined; + break; case DXGI_FORMAT_B4G4R4A4_UNORM: ret.type = ResourceFormatType::R4G4B4A4; @@ -2140,17 +2327,22 @@ TEST_CASE("DXGI formats", "[format][d3d]") { // must be updated by hand DXGI_FORMAT maxFormat = DXGI_FORMAT_V408; - DXGI_FORMAT firstYUVFormat = DXGI_FORMAT_AYUV; // we want to skip formats that we deliberately don't represent or handle. auto isUnsupportedFormat = [](DXGI_FORMAT f) { + // gap in DXGI_FORMAT enum + if(f > DXGI_FORMAT_B4G4R4A4_UNORM && f < DXGI_FORMAT_P208) + return true; return (f == DXGI_FORMAT_R1_UNORM || f == DXGI_FORMAT_A8_UNORM || f == DXGI_FORMAT_R8G8_B8G8_UNORM || f == DXGI_FORMAT_G8R8_G8B8_UNORM || f == DXGI_FORMAT_B8G8R8X8_TYPELESS || f == DXGI_FORMAT_B8G8R8X8_UNORM || - f == DXGI_FORMAT_B8G8R8X8_UNORM_SRGB); + f == DXGI_FORMAT_B8G8R8X8_UNORM_SRGB || f == DXGI_FORMAT_NV11 || + f == DXGI_FORMAT_AI44 || f == DXGI_FORMAT_IA44 || f == DXGI_FORMAT_P8 || + f == DXGI_FORMAT_A8P8 || f == DXGI_FORMAT_P208 || f == DXGI_FORMAT_V208 || + f == DXGI_FORMAT_V408 || f == DXGI_FORMAT_420_OPAQUE); }; - SECTION("Only DXGI_FORMAT_UNKNOWN returns unknown") + SECTION("Only DXGI_FORMAT_UNKNOWN is ResourceFormatType::Undefined") { for(DXGI_FORMAT f = DXGI_FORMAT_UNKNOWN; f <= maxFormat; f = DXGI_FORMAT(f + 1)) { @@ -2168,8 +2360,7 @@ TEST_CASE("DXGI formats", "[format][d3d]") SECTION("MakeDXGIFormat is reflexive with MakeResourceFormat") { - // only consider non-YUV formats - for(DXGI_FORMAT f = DXGI_FORMAT_UNKNOWN; f < firstYUVFormat; f = DXGI_FORMAT(f + 1)) + for(DXGI_FORMAT f = DXGI_FORMAT_UNKNOWN; f <= maxFormat; f = DXGI_FORMAT(f + 1)) { if(isUnsupportedFormat(f)) continue; @@ -2197,8 +2388,7 @@ TEST_CASE("DXGI formats", "[format][d3d]") SECTION("MakeResourceFormat concurs with helpers") { - // only consider non-YUV formats - for(DXGI_FORMAT f = DXGI_FORMAT_UNKNOWN; f < firstYUVFormat; f = DXGI_FORMAT(f + 1)) + for(DXGI_FORMAT f = DXGI_FORMAT_UNKNOWN; f <= maxFormat; f = DXGI_FORMAT(f + 1)) { if(isUnsupportedFormat(f)) continue; @@ -2256,8 +2446,7 @@ TEST_CASE("DXGI formats", "[format][d3d]") SECTION("Get*Format helpers match MakeResourceFormat") { - // only consider non-YUV formats - for(DXGI_FORMAT f = DXGI_FORMAT_UNKNOWN; f < firstYUVFormat; f = DXGI_FORMAT(f + 1)) + for(DXGI_FORMAT f = DXGI_FORMAT_UNKNOWN; f <= maxFormat; f = DXGI_FORMAT(f + 1)) { if(isUnsupportedFormat(f)) continue; @@ -2320,10 +2509,9 @@ TEST_CASE("DXGI formats", "[format][d3d]") } }; - SECTION("GetByteSize and GetFormatBPP return expected values for regular formats") + SECTION("GetByteSize returns expected values for regular formats") { - // only consider non-YUV formats - for(DXGI_FORMAT f = DXGI_FORMAT_UNKNOWN; f < firstYUVFormat; f = DXGI_FORMAT(f + 1)) + for(DXGI_FORMAT f = DXGI_FORMAT_UNKNOWN; f <= maxFormat; f = DXGI_FORMAT(f + 1)) { if(isUnsupportedFormat(f)) continue; @@ -2335,14 +2523,95 @@ TEST_CASE("DXGI formats", "[format][d3d]") INFO("Format is " << ToStr(f)); - uint32_t bpp = fmt.compCount * fmt.compByteWidth * 8; - CHECK(bpp == GetFormatBPP(f)); - uint32_t size = fmt.compCount * fmt.compByteWidth * 123 * 456; CHECK(size == GetByteSize(123, 456, 1, f, 0)); } }; + + SECTION("GetByteSize for BCn formats") + { + const uint32_t width = 24, height = 24; + + // reference: 24x24 = 576, 576/2 = 288 + + const uint32_t bcnsizes[] = { + 288, // DXGI_FORMAT_BC1_TYPELESS + 288, // DXGI_FORMAT_BC1_UNORM + 288, // DXGI_FORMAT_BC1_UNORM_SRGB = 0.5 byte/px + 576, // DXGI_FORMAT_BC2_TYPELESS + 576, // DXGI_FORMAT_BC2_UNORM + 576, // DXGI_FORMAT_BC2_UNORM_SRGB = 1 byte/px + 576, // DXGI_FORMAT_BC3_TYPELESS + 576, // DXGI_FORMAT_BC3_UNORM + 576, // DXGI_FORMAT_BC3_UNORM_SRGB = 1 byte/px + 288, // DXGI_FORMAT_BC4_TYPELESS + 288, // DXGI_FORMAT_BC4_UNORM + 288, // DXGI_FORMAT_BC4_SNORM = 0.5 byte/px + 576, // DXGI_FORMAT_BC5_TYPELESS + 576, // DXGI_FORMAT_BC5_UNORM + 576, // DXGI_FORMAT_BC5_SNORM = 1 byte/px + 576, // DXGI_FORMAT_BC6H_TYPELESS + 576, // DXGI_FORMAT_BC6H_UF16 + 576, // DXGI_FORMAT_BC6H_SF16 = 1 byte/px + 576, // DXGI_FORMAT_BC7_TYPELESS + 576, // DXGI_FORMAT_BC7_UNORM + 576, // DXGI_FORMAT_BC7_UNORM_SRGB = 1 byte/px + }; + + int i = 0; + for(DXGI_FORMAT f : { + DXGI_FORMAT_BC1_TYPELESS, DXGI_FORMAT_BC1_UNORM, DXGI_FORMAT_BC1_UNORM_SRGB, + DXGI_FORMAT_BC2_TYPELESS, DXGI_FORMAT_BC2_UNORM, DXGI_FORMAT_BC2_UNORM_SRGB, + DXGI_FORMAT_BC3_TYPELESS, DXGI_FORMAT_BC3_UNORM, DXGI_FORMAT_BC3_UNORM_SRGB, + DXGI_FORMAT_BC4_TYPELESS, DXGI_FORMAT_BC4_UNORM, DXGI_FORMAT_BC4_SNORM, + DXGI_FORMAT_BC5_TYPELESS, DXGI_FORMAT_BC5_UNORM, DXGI_FORMAT_BC5_SNORM, + DXGI_FORMAT_BC6H_TYPELESS, DXGI_FORMAT_BC6H_UF16, DXGI_FORMAT_BC6H_SF16, + DXGI_FORMAT_BC7_TYPELESS, DXGI_FORMAT_BC7_UNORM, DXGI_FORMAT_BC7_UNORM_SRGB, + }) + { + if(isUnsupportedFormat(f)) + continue; + + INFO("Format is " << ToStr(f)); + + CHECK(bcnsizes[i++] == GetByteSize(width, height, 1, f, 0)); + } + }; + + SECTION("GetByteSize for YUV formats") + { + const uint32_t width = 24, height = 24; + + // reference: 24x24 = 576 + + const uint32_t yuvsizes[] = { + 2304, // DXGI_FORMAT_AYUV (4:4:4 8-bit packed) + 2304, // DXGI_FORMAT_Y410 (4:4:4 10-bit packed) + 4608, // DXGI_FORMAT_Y416 (4:4:4 16-bit packed) + 864, // DXGI_FORMAT_NV12 (4:2:0 8-bit planar) + 1728, // DXGI_FORMAT_P010 (4:2:0 10-bit planar) + 1728, // DXGI_FORMAT_P016 (4:2:0 16-bit planar) + 1152, // DXGI_FORMAT_YUY2 (4:2:2 8-bit packed) + 2304, // DXGI_FORMAT_Y210 (4:2:2 10-bit packed) + 2304, // DXGI_FORMAT_Y216 (4:2:2 16-bit packed) + 1152, // DXGI_FORMAT_P208 (4:2:2 8-bit planar) + }; + + int i = 0; + for(DXGI_FORMAT f : { + DXGI_FORMAT_AYUV, DXGI_FORMAT_Y410, DXGI_FORMAT_Y416, DXGI_FORMAT_NV12, DXGI_FORMAT_P010, + DXGI_FORMAT_P016, DXGI_FORMAT_YUY2, DXGI_FORMAT_Y210, DXGI_FORMAT_Y216, DXGI_FORMAT_P208, + }) + { + if(isUnsupportedFormat(f)) + continue; + + INFO("Format is " << ToStr(f)); + + CHECK(yuvsizes[i++] == GetByteSize(width, height, 1, f, 0)); + } + }; }; #endif // ENABLED(ENABLE_UNIT_TESTS) diff --git a/renderdoc/driver/dxgi/dxgi_common.h b/renderdoc/driver/dxgi/dxgi_common.h index 98acee568..996afd442 100644 --- a/renderdoc/driver/dxgi/dxgi_common.h +++ b/renderdoc/driver/dxgi/dxgi_common.h @@ -33,9 +33,6 @@ DXGI_FORMAT MakeDXGIFormat(ResourceFormat fmt); UINT GetByteSize(int Width, int Height, int Depth, DXGI_FORMAT Format, int mip); -// returns block size for block-compressed formats -UINT GetFormatBPP(DXGI_FORMAT f); - DXGI_FORMAT GetTypelessFormat(DXGI_FORMAT f); DXGI_FORMAT GetTypedFormat(DXGI_FORMAT f); DXGI_FORMAT GetTypedFormat(DXGI_FORMAT f, CompType hint); @@ -56,6 +53,8 @@ bool IsTypelessFormat(DXGI_FORMAT f); bool IsIntFormat(DXGI_FORMAT f); bool IsSRGBFormat(DXGI_FORMAT f); bool IsYUVFormat(DXGI_FORMAT f); +bool IsYUVPlanarFormat(DXGI_FORMAT f); +UINT GetYUVNumRows(DXGI_FORMAT f, UINT height); // not technically DXGI, but makes more sense to have it here common between D3D versions Topology MakePrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY Topo); diff --git a/renderdoc/driver/vulkan/vk_common.cpp b/renderdoc/driver/vulkan/vk_common.cpp index cc4602e71..712c02e93 100644 --- a/renderdoc/driver/vulkan/vk_common.cpp +++ b/renderdoc/driver/vulkan/vk_common.cpp @@ -390,988 +390,6 @@ void DoPipelineBarrier(VkCommandBuffer cmd, uint32_t count, VkMemoryBarrier *bar 0, NULL); // image memory barriers } -ResourceFormat MakeResourceFormat(VkFormat fmt) -{ - ResourceFormat ret; - - ret.type = ResourceFormatType::Regular; - ret.compByteWidth = 0; - ret.compCount = 0; - ret.compType = CompType::Typeless; - - if(fmt == VK_FORMAT_UNDEFINED) - { - ret.type = ResourceFormatType::Undefined; - return ret; - } - - switch(fmt) - { - case VK_FORMAT_R4G4_UNORM_PACK8: ret.type = ResourceFormatType::R4G4; break; - case VK_FORMAT_R4G4B4A4_UNORM_PACK16: - case VK_FORMAT_B4G4R4A4_UNORM_PACK16: ret.type = ResourceFormatType::R4G4B4A4; break; - case VK_FORMAT_A2B10G10R10_UNORM_PACK32: - case VK_FORMAT_A2R10G10B10_UNORM_PACK32: - case VK_FORMAT_A2B10G10R10_SNORM_PACK32: - case VK_FORMAT_A2R10G10B10_SNORM_PACK32: - case VK_FORMAT_A2B10G10R10_USCALED_PACK32: - case VK_FORMAT_A2R10G10B10_USCALED_PACK32: - case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: - case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: - case VK_FORMAT_A2B10G10R10_UINT_PACK32: - case VK_FORMAT_A2R10G10B10_UINT_PACK32: - case VK_FORMAT_A2B10G10R10_SINT_PACK32: - case VK_FORMAT_A2R10G10B10_SINT_PACK32: ret.type = ResourceFormatType::R10G10B10A2; break; - case VK_FORMAT_B10G11R11_UFLOAT_PACK32: ret.type = ResourceFormatType::R11G11B10; break; - case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: ret.type = ResourceFormatType::R9G9B9E5; break; - case VK_FORMAT_R5G6B5_UNORM_PACK16: - case VK_FORMAT_B5G6R5_UNORM_PACK16: ret.type = ResourceFormatType::R5G6B5; break; - case VK_FORMAT_R5G5B5A1_UNORM_PACK16: - case VK_FORMAT_B5G5R5A1_UNORM_PACK16: - case VK_FORMAT_A1R5G5B5_UNORM_PACK16: ret.type = ResourceFormatType::R5G5B5A1; break; - case VK_FORMAT_D16_UNORM_S8_UINT: ret.type = ResourceFormatType::D16S8; break; - case VK_FORMAT_D24_UNORM_S8_UINT: ret.type = ResourceFormatType::D24S8; break; - case VK_FORMAT_D32_SFLOAT_S8_UINT: ret.type = ResourceFormatType::D32S8; break; - case VK_FORMAT_BC1_RGB_UNORM_BLOCK: - case VK_FORMAT_BC1_RGB_SRGB_BLOCK: - case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: - case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: ret.type = ResourceFormatType::BC1; break; - case VK_FORMAT_BC2_UNORM_BLOCK: - case VK_FORMAT_BC2_SRGB_BLOCK: ret.type = ResourceFormatType::BC2; break; - case VK_FORMAT_BC3_UNORM_BLOCK: - case VK_FORMAT_BC3_SRGB_BLOCK: ret.type = ResourceFormatType::BC3; break; - case VK_FORMAT_BC4_UNORM_BLOCK: - case VK_FORMAT_BC4_SNORM_BLOCK: ret.type = ResourceFormatType::BC4; break; - case VK_FORMAT_BC5_UNORM_BLOCK: - case VK_FORMAT_BC5_SNORM_BLOCK: ret.type = ResourceFormatType::BC5; break; - case VK_FORMAT_BC6H_UFLOAT_BLOCK: - case VK_FORMAT_BC6H_SFLOAT_BLOCK: ret.type = ResourceFormatType::BC6; break; - case VK_FORMAT_BC7_UNORM_BLOCK: - case VK_FORMAT_BC7_SRGB_BLOCK: ret.type = ResourceFormatType::BC7; break; - case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: ret.type = ResourceFormatType::ETC2; break; - case VK_FORMAT_EAC_R11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11_SNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: ret.type = ResourceFormatType::EAC; break; - case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: ret.type = ResourceFormatType::ASTC; break; - case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: ret.type = ResourceFormatType::PVRTC; break; - default: break; - } - - switch(fmt) - { - case VK_FORMAT_B4G4R4A4_UNORM_PACK16: - case VK_FORMAT_B5G6R5_UNORM_PACK16: - case VK_FORMAT_B5G5R5A1_UNORM_PACK16: - case VK_FORMAT_A1R5G5B5_UNORM_PACK16: - case VK_FORMAT_B8G8R8A8_UNORM: - case VK_FORMAT_B8G8R8A8_SNORM: - case VK_FORMAT_B8G8R8A8_USCALED: - case VK_FORMAT_B8G8R8A8_SSCALED: - case VK_FORMAT_B8G8R8A8_UINT: - case VK_FORMAT_B8G8R8A8_SINT: - case VK_FORMAT_B8G8R8A8_SRGB: - case VK_FORMAT_A2R10G10B10_UNORM_PACK32: - case VK_FORMAT_A2R10G10B10_SNORM_PACK32: - case VK_FORMAT_A2R10G10B10_USCALED_PACK32: - case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: - case VK_FORMAT_A2R10G10B10_UINT_PACK32: - case VK_FORMAT_A2R10G10B10_SINT_PACK32: ret.setBgraOrder(true); break; - default: break; - } - - switch(fmt) - { - case VK_FORMAT_R8_UNORM: - case VK_FORMAT_R8_SNORM: - case VK_FORMAT_R8_USCALED: - case VK_FORMAT_R8_SSCALED: - case VK_FORMAT_R8_UINT: - case VK_FORMAT_R8_SINT: - case VK_FORMAT_R8_SRGB: - case VK_FORMAT_R16_UNORM: - case VK_FORMAT_R16_SNORM: - case VK_FORMAT_R16_USCALED: - case VK_FORMAT_R16_SSCALED: - case VK_FORMAT_R16_UINT: - case VK_FORMAT_R16_SINT: - case VK_FORMAT_R16_SFLOAT: - case VK_FORMAT_R32_UINT: - case VK_FORMAT_R32_SINT: - case VK_FORMAT_R32_SFLOAT: - case VK_FORMAT_R64_SFLOAT: - case VK_FORMAT_D16_UNORM: - case VK_FORMAT_X8_D24_UNORM_PACK32: - case VK_FORMAT_D32_SFLOAT: - case VK_FORMAT_S8_UINT: - case VK_FORMAT_BC4_UNORM_BLOCK: - case VK_FORMAT_BC4_SNORM_BLOCK: - case VK_FORMAT_EAC_R11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11_SNORM_BLOCK: ret.compCount = 1; break; - case VK_FORMAT_R4G4_UNORM_PACK8: - case VK_FORMAT_R8G8_UNORM: - case VK_FORMAT_R8G8_SNORM: - case VK_FORMAT_R8G8_USCALED: - case VK_FORMAT_R8G8_SSCALED: - case VK_FORMAT_R8G8_UINT: - case VK_FORMAT_R8G8_SINT: - case VK_FORMAT_R8G8_SRGB: - case VK_FORMAT_R16G16_UNORM: - case VK_FORMAT_R16G16_SNORM: - case VK_FORMAT_R16G16_USCALED: - case VK_FORMAT_R16G16_SSCALED: - case VK_FORMAT_R16G16_UINT: - case VK_FORMAT_R16G16_SINT: - case VK_FORMAT_R16G16_SFLOAT: - case VK_FORMAT_R32G32_UINT: - case VK_FORMAT_R32G32_SINT: - case VK_FORMAT_R32G32_SFLOAT: - case VK_FORMAT_R64G64_SFLOAT: - case VK_FORMAT_D16_UNORM_S8_UINT: - case VK_FORMAT_D24_UNORM_S8_UINT: - case VK_FORMAT_D32_SFLOAT_S8_UINT: - case VK_FORMAT_BC5_UNORM_BLOCK: - case VK_FORMAT_BC5_SNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: ret.compCount = 2; break; - case VK_FORMAT_R5G6B5_UNORM_PACK16: - case VK_FORMAT_R8G8B8_UNORM: - case VK_FORMAT_R8G8B8_SNORM: - case VK_FORMAT_R8G8B8_USCALED: - case VK_FORMAT_R8G8B8_SSCALED: - case VK_FORMAT_R8G8B8_UINT: - case VK_FORMAT_R8G8B8_SINT: - case VK_FORMAT_R8G8B8_SRGB: - case VK_FORMAT_R16G16B16_UNORM: - case VK_FORMAT_R16G16B16_SNORM: - case VK_FORMAT_R16G16B16_USCALED: - case VK_FORMAT_R16G16B16_SSCALED: - case VK_FORMAT_R16G16B16_UINT: - case VK_FORMAT_R16G16B16_SINT: - case VK_FORMAT_R16G16B16_SFLOAT: - case VK_FORMAT_R32G32B32_UINT: - case VK_FORMAT_R32G32B32_SINT: - case VK_FORMAT_R32G32B32_SFLOAT: - case VK_FORMAT_R64G64B64_SFLOAT: - case VK_FORMAT_B10G11R11_UFLOAT_PACK32: - case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: - case VK_FORMAT_BC1_RGB_UNORM_BLOCK: - case VK_FORMAT_BC1_RGB_SRGB_BLOCK: - case VK_FORMAT_BC6H_UFLOAT_BLOCK: - case VK_FORMAT_BC6H_SFLOAT_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: - case VK_FORMAT_B5G6R5_UNORM_PACK16: - case VK_FORMAT_B8G8R8_UNORM: - case VK_FORMAT_B8G8R8_SNORM: - case VK_FORMAT_B8G8R8_USCALED: - case VK_FORMAT_B8G8R8_SSCALED: - case VK_FORMAT_B8G8R8_UINT: - case VK_FORMAT_B8G8R8_SINT: - case VK_FORMAT_B8G8R8_SRGB: ret.compCount = 3; break; - case VK_FORMAT_R4G4B4A4_UNORM_PACK16: - case VK_FORMAT_R5G5B5A1_UNORM_PACK16: - case VK_FORMAT_R8G8B8A8_UNORM: - case VK_FORMAT_R8G8B8A8_SNORM: - case VK_FORMAT_R8G8B8A8_USCALED: - case VK_FORMAT_R8G8B8A8_SSCALED: - case VK_FORMAT_R8G8B8A8_UINT: - case VK_FORMAT_R8G8B8A8_SINT: - case VK_FORMAT_R8G8B8A8_SRGB: - case VK_FORMAT_A2R10G10B10_UNORM_PACK32: - case VK_FORMAT_A2R10G10B10_SNORM_PACK32: - case VK_FORMAT_A2R10G10B10_USCALED_PACK32: - case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: - case VK_FORMAT_A2R10G10B10_UINT_PACK32: - case VK_FORMAT_A2R10G10B10_SINT_PACK32: - case VK_FORMAT_R16G16B16A16_UNORM: - case VK_FORMAT_R16G16B16A16_SNORM: - case VK_FORMAT_R16G16B16A16_USCALED: - case VK_FORMAT_R16G16B16A16_SSCALED: - case VK_FORMAT_R16G16B16A16_UINT: - case VK_FORMAT_R16G16B16A16_SINT: - case VK_FORMAT_R16G16B16A16_SFLOAT: - case VK_FORMAT_R32G32B32A32_UINT: - case VK_FORMAT_R32G32B32A32_SINT: - case VK_FORMAT_R32G32B32A32_SFLOAT: - case VK_FORMAT_R64G64B64A64_SFLOAT: - case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: - case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: - case VK_FORMAT_BC2_UNORM_BLOCK: - case VK_FORMAT_BC2_SRGB_BLOCK: - case VK_FORMAT_BC3_UNORM_BLOCK: - case VK_FORMAT_BC3_SRGB_BLOCK: - case VK_FORMAT_BC7_UNORM_BLOCK: - case VK_FORMAT_BC7_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: - case VK_FORMAT_B4G4R4A4_UNORM_PACK16: - case VK_FORMAT_B5G5R5A1_UNORM_PACK16: - case VK_FORMAT_B8G8R8A8_UNORM: - case VK_FORMAT_B8G8R8A8_SNORM: - case VK_FORMAT_B8G8R8A8_USCALED: - case VK_FORMAT_B8G8R8A8_SSCALED: - case VK_FORMAT_B8G8R8A8_UINT: - case VK_FORMAT_B8G8R8A8_SINT: - case VK_FORMAT_B8G8R8A8_SRGB: - case VK_FORMAT_A8B8G8R8_UNORM_PACK32: - case VK_FORMAT_A8B8G8R8_SNORM_PACK32: - case VK_FORMAT_A8B8G8R8_USCALED_PACK32: - case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: - case VK_FORMAT_A8B8G8R8_SINT_PACK32: - case VK_FORMAT_A8B8G8R8_SRGB_PACK32: - case VK_FORMAT_A2B10G10R10_UNORM_PACK32: - case VK_FORMAT_A2B10G10R10_SNORM_PACK32: - case VK_FORMAT_A2B10G10R10_USCALED_PACK32: - case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: - case VK_FORMAT_A2B10G10R10_UINT_PACK32: - case VK_FORMAT_A2B10G10R10_SINT_PACK32: ret.compCount = 4; break; - default: break; - } - - switch(fmt) - { - case VK_FORMAT_R8_SRGB: - case VK_FORMAT_R8G8_SRGB: - case VK_FORMAT_R8G8B8_SRGB: - case VK_FORMAT_R8G8B8A8_SRGB: - case VK_FORMAT_BC1_RGB_SRGB_BLOCK: - case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: - case VK_FORMAT_BC2_SRGB_BLOCK: - case VK_FORMAT_BC3_SRGB_BLOCK: - case VK_FORMAT_BC7_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: - case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: - case VK_FORMAT_B8G8R8_SRGB: - case VK_FORMAT_B8G8R8A8_SRGB: - case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: ret.setSrgbCorrected(true); break; - default: break; - } - - switch(fmt) - { - case VK_FORMAT_R4G4_UNORM_PACK8: - case VK_FORMAT_R4G4B4A4_UNORM_PACK16: - case VK_FORMAT_R5G6B5_UNORM_PACK16: - case VK_FORMAT_R5G5B5A1_UNORM_PACK16: - case VK_FORMAT_R8_UNORM: - case VK_FORMAT_R8_SRGB: - case VK_FORMAT_R8G8_UNORM: - case VK_FORMAT_R8G8_SRGB: - case VK_FORMAT_R8G8B8_UNORM: - case VK_FORMAT_R8G8B8_SRGB: - case VK_FORMAT_R8G8B8A8_UNORM: - case VK_FORMAT_R8G8B8A8_SRGB: - case VK_FORMAT_A2R10G10B10_UNORM_PACK32: - case VK_FORMAT_R16_UNORM: - case VK_FORMAT_R16G16_UNORM: - case VK_FORMAT_R16G16B16_UNORM: - case VK_FORMAT_R16G16B16A16_UNORM: - case VK_FORMAT_BC1_RGB_UNORM_BLOCK: - case VK_FORMAT_BC1_RGB_SRGB_BLOCK: - case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: - case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: - case VK_FORMAT_BC2_UNORM_BLOCK: - case VK_FORMAT_BC2_SRGB_BLOCK: - case VK_FORMAT_BC3_UNORM_BLOCK: - case VK_FORMAT_BC3_SRGB_BLOCK: - case VK_FORMAT_BC4_UNORM_BLOCK: - case VK_FORMAT_BC5_UNORM_BLOCK: - case VK_FORMAT_BC7_UNORM_BLOCK: - case VK_FORMAT_BC7_SRGB_BLOCK: - case VK_FORMAT_BC6H_UFLOAT_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: - case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: - case VK_FORMAT_EAC_R11_UNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: - case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: - case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: - case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: - case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: - case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: - case VK_FORMAT_B4G4R4A4_UNORM_PACK16: - case VK_FORMAT_B5G5R5A1_UNORM_PACK16: - case VK_FORMAT_B5G6R5_UNORM_PACK16: - case VK_FORMAT_B8G8R8_UNORM: - case VK_FORMAT_B8G8R8_SRGB: - case VK_FORMAT_B8G8R8A8_UNORM: - case VK_FORMAT_B8G8R8A8_SRGB: - case VK_FORMAT_A8B8G8R8_UNORM_PACK32: - case VK_FORMAT_A8B8G8R8_SRGB_PACK32: - case VK_FORMAT_A2B10G10R10_UNORM_PACK32: - case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: - case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: - case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: ret.compType = CompType::UNorm; break; - case VK_FORMAT_R8_SNORM: - case VK_FORMAT_R8G8_SNORM: - case VK_FORMAT_R8G8B8_SNORM: - case VK_FORMAT_R8G8B8A8_SNORM: - case VK_FORMAT_A2R10G10B10_SNORM_PACK32: - case VK_FORMAT_R16_SNORM: - case VK_FORMAT_R16G16_SNORM: - case VK_FORMAT_R16G16B16_SNORM: - case VK_FORMAT_R16G16B16A16_SNORM: - case VK_FORMAT_BC4_SNORM_BLOCK: - case VK_FORMAT_BC5_SNORM_BLOCK: - case VK_FORMAT_BC6H_SFLOAT_BLOCK: - case VK_FORMAT_EAC_R11_SNORM_BLOCK: - case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: - case VK_FORMAT_B8G8R8_SNORM: - case VK_FORMAT_B8G8R8A8_SNORM: - case VK_FORMAT_A8B8G8R8_SNORM_PACK32: - case VK_FORMAT_A2B10G10R10_SNORM_PACK32: ret.compType = CompType::SNorm; break; - case VK_FORMAT_R8_USCALED: - case VK_FORMAT_R8G8_USCALED: - case VK_FORMAT_R8G8B8_USCALED: - case VK_FORMAT_R8G8B8A8_USCALED: - case VK_FORMAT_R16_USCALED: - case VK_FORMAT_R16G16_USCALED: - case VK_FORMAT_R16G16B16_USCALED: - case VK_FORMAT_R16G16B16A16_USCALED: - case VK_FORMAT_A2R10G10B10_USCALED_PACK32: - case VK_FORMAT_B8G8R8_USCALED: - case VK_FORMAT_B8G8R8A8_USCALED: - case VK_FORMAT_A2B10G10R10_USCALED_PACK32: ret.compType = CompType::UScaled; break; - case VK_FORMAT_R8_SSCALED: - case VK_FORMAT_R8G8_SSCALED: - case VK_FORMAT_R8G8B8_SSCALED: - case VK_FORMAT_R8G8B8A8_SSCALED: - case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: - case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: - case VK_FORMAT_R16_SSCALED: - case VK_FORMAT_R16G16_SSCALED: - case VK_FORMAT_R16G16B16_SSCALED: - case VK_FORMAT_R16G16B16A16_SSCALED: - case VK_FORMAT_B8G8R8_SSCALED: - case VK_FORMAT_B8G8R8A8_SSCALED: - case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: ret.compType = CompType::SScaled; break; - case VK_FORMAT_R8_UINT: - case VK_FORMAT_R8G8_UINT: - case VK_FORMAT_R8G8B8_UINT: - case VK_FORMAT_R8G8B8A8_UINT: - case VK_FORMAT_R8G8B8A8_SINT: - case VK_FORMAT_A8B8G8R8_UINT_PACK32: - case VK_FORMAT_A2R10G10B10_UINT_PACK32: - case VK_FORMAT_R16_UINT: - case VK_FORMAT_R16G16_UINT: - case VK_FORMAT_R16G16B16_UINT: - case VK_FORMAT_R16G16B16A16_UINT: - case VK_FORMAT_R32_UINT: - case VK_FORMAT_R32G32_UINT: - case VK_FORMAT_R32G32B32_UINT: - case VK_FORMAT_R32G32B32A32_UINT: - // Maybe S8 should be identified by something else? - case VK_FORMAT_S8_UINT: - case VK_FORMAT_B8G8R8_UINT: - case VK_FORMAT_B8G8R8A8_UINT: - case VK_FORMAT_A2B10G10R10_UINT_PACK32: ret.compType = CompType::UInt; break; - case VK_FORMAT_R8_SINT: - case VK_FORMAT_R8G8_SINT: - case VK_FORMAT_R8G8B8_SINT: - case VK_FORMAT_A8B8G8R8_SINT_PACK32: - case VK_FORMAT_A2R10G10B10_SINT_PACK32: - case VK_FORMAT_R16_SINT: - case VK_FORMAT_R16G16_SINT: - case VK_FORMAT_R16G16B16_SINT: - case VK_FORMAT_R16G16B16A16_SINT: - case VK_FORMAT_R32_SINT: - case VK_FORMAT_R32G32_SINT: - case VK_FORMAT_R32G32B32_SINT: - case VK_FORMAT_R32G32B32A32_SINT: - case VK_FORMAT_B8G8R8_SINT: - case VK_FORMAT_B8G8R8A8_SINT: - case VK_FORMAT_A2B10G10R10_SINT_PACK32: ret.compType = CompType::SInt; break; - case VK_FORMAT_R16_SFLOAT: - case VK_FORMAT_R16G16_SFLOAT: - case VK_FORMAT_R16G16B16_SFLOAT: - case VK_FORMAT_R16G16B16A16_SFLOAT: - case VK_FORMAT_R32_SFLOAT: - case VK_FORMAT_R32G32_SFLOAT: - case VK_FORMAT_R32G32B32_SFLOAT: - case VK_FORMAT_R32G32B32A32_SFLOAT: - case VK_FORMAT_B10G11R11_UFLOAT_PACK32: - case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: ret.compType = CompType::Float; break; - case VK_FORMAT_R64_SFLOAT: - case VK_FORMAT_R64G64_SFLOAT: - case VK_FORMAT_R64G64B64_SFLOAT: - case VK_FORMAT_R64G64B64A64_SFLOAT: ret.compType = CompType::Double; break; - case VK_FORMAT_D16_UNORM: - case VK_FORMAT_X8_D24_UNORM_PACK32: - case VK_FORMAT_D32_SFLOAT: - case VK_FORMAT_D16_UNORM_S8_UINT: - case VK_FORMAT_D24_UNORM_S8_UINT: - case VK_FORMAT_D32_SFLOAT_S8_UINT: ret.compType = CompType::Depth; break; - default: break; - } - - switch(fmt) - { - case VK_FORMAT_R8_UNORM: - case VK_FORMAT_R8_SNORM: - case VK_FORMAT_R8_USCALED: - case VK_FORMAT_R8_SSCALED: - case VK_FORMAT_R8_UINT: - case VK_FORMAT_R8_SINT: - case VK_FORMAT_R8_SRGB: - case VK_FORMAT_R8G8_UNORM: - case VK_FORMAT_R8G8_SNORM: - case VK_FORMAT_R8G8_USCALED: - case VK_FORMAT_R8G8_SSCALED: - case VK_FORMAT_R8G8_UINT: - case VK_FORMAT_R8G8_SINT: - case VK_FORMAT_R8G8_SRGB: - case VK_FORMAT_R8G8B8_UNORM: - case VK_FORMAT_R8G8B8_SNORM: - case VK_FORMAT_R8G8B8_USCALED: - case VK_FORMAT_R8G8B8_SSCALED: - case VK_FORMAT_R8G8B8_UINT: - case VK_FORMAT_R8G8B8_SINT: - case VK_FORMAT_R8G8B8_SRGB: - case VK_FORMAT_R8G8B8A8_UNORM: - case VK_FORMAT_R8G8B8A8_SNORM: - case VK_FORMAT_R8G8B8A8_USCALED: - case VK_FORMAT_R8G8B8A8_SSCALED: - case VK_FORMAT_R8G8B8A8_UINT: - case VK_FORMAT_R8G8B8A8_SINT: - case VK_FORMAT_R8G8B8A8_SRGB: - case VK_FORMAT_S8_UINT: - case VK_FORMAT_B8G8R8_UNORM: - case VK_FORMAT_B8G8R8_SNORM: - case VK_FORMAT_B8G8R8_USCALED: - case VK_FORMAT_B8G8R8_SSCALED: - case VK_FORMAT_B8G8R8_UINT: - case VK_FORMAT_B8G8R8_SINT: - case VK_FORMAT_B8G8R8_SRGB: - case VK_FORMAT_A8B8G8R8_UNORM_PACK32: - case VK_FORMAT_A8B8G8R8_SNORM_PACK32: - case VK_FORMAT_A8B8G8R8_USCALED_PACK32: - case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: - case VK_FORMAT_A8B8G8R8_SINT_PACK32: - case VK_FORMAT_A8B8G8R8_SRGB_PACK32: - case VK_FORMAT_B8G8R8A8_UNORM: - case VK_FORMAT_B8G8R8A8_SNORM: - case VK_FORMAT_B8G8R8A8_USCALED: - case VK_FORMAT_B8G8R8A8_SSCALED: - case VK_FORMAT_B8G8R8A8_UINT: - case VK_FORMAT_B8G8R8A8_SINT: - case VK_FORMAT_B8G8R8A8_SRGB: ret.compByteWidth = 1; break; - case VK_FORMAT_R16_UNORM: - case VK_FORMAT_R16_SNORM: - case VK_FORMAT_R16_USCALED: - case VK_FORMAT_R16_SSCALED: - case VK_FORMAT_R16_UINT: - case VK_FORMAT_R16_SINT: - case VK_FORMAT_R16_SFLOAT: - case VK_FORMAT_R16G16_UNORM: - case VK_FORMAT_R16G16_SNORM: - case VK_FORMAT_R16G16_USCALED: - case VK_FORMAT_R16G16_SSCALED: - case VK_FORMAT_R16G16_UINT: - case VK_FORMAT_R16G16_SINT: - case VK_FORMAT_R16G16_SFLOAT: - case VK_FORMAT_R16G16B16_UNORM: - case VK_FORMAT_R16G16B16_SNORM: - case VK_FORMAT_R16G16B16_USCALED: - case VK_FORMAT_R16G16B16_SSCALED: - case VK_FORMAT_R16G16B16_UINT: - case VK_FORMAT_R16G16B16_SINT: - case VK_FORMAT_R16G16B16_SFLOAT: - case VK_FORMAT_R16G16B16A16_UNORM: - case VK_FORMAT_R16G16B16A16_SNORM: - case VK_FORMAT_R16G16B16A16_USCALED: - case VK_FORMAT_R16G16B16A16_SSCALED: - case VK_FORMAT_R16G16B16A16_UINT: - case VK_FORMAT_R16G16B16A16_SINT: - case VK_FORMAT_R16G16B16A16_SFLOAT: - case VK_FORMAT_D16_UNORM: ret.compByteWidth = 2; break; - case VK_FORMAT_X8_D24_UNORM_PACK32: ret.compByteWidth = 3; break; - case VK_FORMAT_R32_UINT: - case VK_FORMAT_R32_SINT: - case VK_FORMAT_R32_SFLOAT: - case VK_FORMAT_R32G32_UINT: - case VK_FORMAT_R32G32_SINT: - case VK_FORMAT_R32G32_SFLOAT: - case VK_FORMAT_R32G32B32_UINT: - case VK_FORMAT_R32G32B32_SINT: - case VK_FORMAT_R32G32B32_SFLOAT: - case VK_FORMAT_R32G32B32A32_UINT: - case VK_FORMAT_R32G32B32A32_SINT: - case VK_FORMAT_R32G32B32A32_SFLOAT: - case VK_FORMAT_D32_SFLOAT: ret.compByteWidth = 4; break; - case VK_FORMAT_R64_SFLOAT: - case VK_FORMAT_R64G64_SFLOAT: - case VK_FORMAT_R64G64B64_SFLOAT: - case VK_FORMAT_R64G64B64A64_SFLOAT: ret.compByteWidth = 8; break; - default: break; - } - - return ret; -} - -VkFormat MakeVkFormat(ResourceFormat fmt) -{ - VkFormat ret = VK_FORMAT_UNDEFINED; - - if(fmt.Special()) - { - switch(fmt.type) - { - case ResourceFormatType::BC1: - { - if(fmt.compCount == 3) - ret = fmt.srgbCorrected() ? VK_FORMAT_BC1_RGB_SRGB_BLOCK : VK_FORMAT_BC1_RGB_UNORM_BLOCK; - else - ret = fmt.srgbCorrected() ? VK_FORMAT_BC1_RGBA_SRGB_BLOCK : VK_FORMAT_BC1_RGBA_UNORM_BLOCK; - break; - } - case ResourceFormatType::BC2: - ret = fmt.srgbCorrected() ? VK_FORMAT_BC2_SRGB_BLOCK : VK_FORMAT_BC2_UNORM_BLOCK; - break; - case ResourceFormatType::BC3: - ret = fmt.srgbCorrected() ? VK_FORMAT_BC3_SRGB_BLOCK : VK_FORMAT_BC3_UNORM_BLOCK; - break; - case ResourceFormatType::BC4: - ret = fmt.compType == CompType::SNorm ? VK_FORMAT_BC4_SNORM_BLOCK : VK_FORMAT_BC4_UNORM_BLOCK; - break; - case ResourceFormatType::BC5: - ret = fmt.compType == CompType::SNorm ? VK_FORMAT_BC5_SNORM_BLOCK : VK_FORMAT_BC5_UNORM_BLOCK; - break; - case ResourceFormatType::BC6: - ret = fmt.compType == CompType::SNorm ? VK_FORMAT_BC6H_SFLOAT_BLOCK - : VK_FORMAT_BC6H_UFLOAT_BLOCK; - break; - case ResourceFormatType::BC7: - ret = fmt.srgbCorrected() ? VK_FORMAT_BC7_SRGB_BLOCK : VK_FORMAT_BC7_UNORM_BLOCK; - break; - case ResourceFormatType::ETC2: - { - if(fmt.compCount == 3) - ret = fmt.srgbCorrected() ? VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK - : VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; - else - ret = fmt.srgbCorrected() ? VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK - : VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; - break; - } - case ResourceFormatType::EAC: - { - if(fmt.compCount == 1) - ret = fmt.compType == CompType::SNorm ? VK_FORMAT_EAC_R11_SNORM_BLOCK - : VK_FORMAT_EAC_R11_UNORM_BLOCK; - else if(fmt.compCount == 2) - ret = fmt.compType == CompType::SNorm ? VK_FORMAT_EAC_R11G11_SNORM_BLOCK - : VK_FORMAT_EAC_R11G11_UNORM_BLOCK; - break; - } - case ResourceFormatType::R10G10B10A2: - if(fmt.compType == CompType::UNorm) - ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_UNORM_PACK32 - : VK_FORMAT_A2B10G10R10_UNORM_PACK32; - else if(fmt.compType == CompType::UInt) - ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_UINT_PACK32 - : VK_FORMAT_A2B10G10R10_UINT_PACK32; - else if(fmt.compType == CompType::UScaled) - ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_USCALED_PACK32 - : VK_FORMAT_A2B10G10R10_USCALED_PACK32; - else if(fmt.compType == CompType::SNorm) - ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_SNORM_PACK32 - : VK_FORMAT_A2B10G10R10_SNORM_PACK32; - else if(fmt.compType == CompType::SInt) - ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_SINT_PACK32 - : VK_FORMAT_A2B10G10R10_SINT_PACK32; - else if(fmt.compType == CompType::SScaled) - ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_SSCALED_PACK32 - : VK_FORMAT_A2B10G10R10_SSCALED_PACK32; - break; - case ResourceFormatType::R11G11B10: ret = VK_FORMAT_B10G11R11_UFLOAT_PACK32; break; - case ResourceFormatType::R5G6B5: ret = VK_FORMAT_B5G6R5_UNORM_PACK16; break; - case ResourceFormatType::R5G5B5A1: - ret = fmt.bgraOrder() ? VK_FORMAT_B5G5R5A1_UNORM_PACK16 : VK_FORMAT_R5G5B5A1_UNORM_PACK16; - break; - case ResourceFormatType::R9G9B9E5: ret = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; break; - case ResourceFormatType::R4G4B4A4: - ret = fmt.bgraOrder() ? VK_FORMAT_R4G4B4A4_UNORM_PACK16 : VK_FORMAT_B4G4R4A4_UNORM_PACK16; - break; - case ResourceFormatType::R4G4: ret = VK_FORMAT_R4G4_UNORM_PACK8; break; - case ResourceFormatType::D24S8: ret = VK_FORMAT_D24_UNORM_S8_UINT; break; - case ResourceFormatType::D32S8: ret = VK_FORMAT_D32_SFLOAT_S8_UINT; break; - default: RDCERR("Unsupported resource format type %u", fmt.type); break; - } - } - else if(fmt.compCount == 4) - { - if(fmt.srgbCorrected()) - { - ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_R8G8B8A8_SRGB; - } - else if(fmt.compByteWidth == 8) - { - if(fmt.compType == CompType::Float || fmt.compType == CompType::Double) - ret = VK_FORMAT_R64G64B64A64_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R64G64B64A64_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R64G64B64A64_UINT; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 4) - { - if(fmt.compType == CompType::Float) - ret = VK_FORMAT_R32G32B32A32_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R32G32B32A32_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R32G32B32A32_UINT; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 2) - { - if(fmt.compType == CompType::Float) - ret = VK_FORMAT_R16G16B16A16_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R16G16B16A16_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R16G16B16A16_UINT; - else if(fmt.compType == CompType::SNorm) - ret = VK_FORMAT_R16G16B16A16_SNORM; - else if(fmt.compType == CompType::UNorm) - ret = VK_FORMAT_R16G16B16A16_UNORM; - else if(fmt.compType == CompType::SScaled) - ret = VK_FORMAT_R16G16B16A16_SSCALED; - else if(fmt.compType == CompType::UScaled) - ret = VK_FORMAT_R16G16B16A16_USCALED; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 1) - { - if(fmt.compType == CompType::SInt) - ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_SINT : VK_FORMAT_R8G8B8A8_SINT; - else if(fmt.compType == CompType::UInt) - ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_UINT : VK_FORMAT_R8G8B8A8_UINT; - else if(fmt.compType == CompType::SNorm) - ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_SNORM : VK_FORMAT_R8G8B8A8_SNORM; - else if(fmt.compType == CompType::UNorm) - ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_UNORM : VK_FORMAT_R8G8B8A8_UNORM; - else if(fmt.compType == CompType::SScaled) - ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_SSCALED : VK_FORMAT_R8G8B8A8_SSCALED; - else if(fmt.compType == CompType::UScaled) - ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_USCALED : VK_FORMAT_R8G8B8A8_USCALED; - else - RDCERR("Unrecognised component type"); - } - else - { - RDCERR("Unrecognised 4-component byte width: %d", fmt.compByteWidth); - } - } - else if(fmt.compCount == 3) - { - if(fmt.srgbCorrected()) - { - ret = VK_FORMAT_R8G8B8_SRGB; - } - else if(fmt.compByteWidth == 8) - { - if(fmt.compType == CompType::Float || fmt.compType == CompType::Double) - ret = VK_FORMAT_R64G64B64_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R64G64B64_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R64G64B64_UINT; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 4) - { - if(fmt.compType == CompType::Float) - ret = VK_FORMAT_R32G32B32_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R32G32B32_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R32G32B32_UINT; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 2) - { - if(fmt.compType == CompType::Float) - ret = VK_FORMAT_R16G16B16_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R16G16B16_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R16G16B16_UINT; - else if(fmt.compType == CompType::SNorm) - ret = VK_FORMAT_R16G16B16_SNORM; - else if(fmt.compType == CompType::UNorm) - ret = VK_FORMAT_R16G16B16_UNORM; - else if(fmt.compType == CompType::SScaled) - ret = VK_FORMAT_R16G16B16_SSCALED; - else if(fmt.compType == CompType::UScaled) - ret = VK_FORMAT_R16G16B16_USCALED; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 1) - { - if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R8G8B8_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R8G8B8_UINT; - else if(fmt.compType == CompType::SNorm) - ret = VK_FORMAT_R8G8B8_SNORM; - else if(fmt.compType == CompType::UNorm) - ret = VK_FORMAT_R8G8B8_UNORM; - else if(fmt.compType == CompType::SScaled) - ret = VK_FORMAT_R8G8B8_SSCALED; - else if(fmt.compType == CompType::UScaled) - ret = VK_FORMAT_R8G8B8_USCALED; - else - RDCERR("Unrecognised component type"); - } - else - { - RDCERR("Unrecognised 3-component byte width: %d", fmt.compByteWidth); - } - } - else if(fmt.compCount == 2) - { - if(fmt.compByteWidth == 8) - { - if(fmt.compType == CompType::Float || fmt.compType == CompType::Double) - ret = VK_FORMAT_R64G64_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R64G64_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R64G64_UINT; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 4) - { - if(fmt.compType == CompType::Float) - ret = VK_FORMAT_R32G32_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R32G32_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R32G32_UINT; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 2) - { - if(fmt.compType == CompType::Float) - ret = VK_FORMAT_R16G16_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R16G16_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R16G16_UINT; - else if(fmt.compType == CompType::SNorm) - ret = VK_FORMAT_R16G16_SNORM; - else if(fmt.compType == CompType::UNorm) - ret = VK_FORMAT_R16G16_UNORM; - else if(fmt.compType == CompType::SScaled) - ret = VK_FORMAT_R16G16_SSCALED; - else if(fmt.compType == CompType::UScaled) - ret = VK_FORMAT_R16G16_USCALED; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 1) - { - if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R8G8_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R8G8_UINT; - else if(fmt.compType == CompType::SNorm) - ret = VK_FORMAT_R8G8_SNORM; - else if(fmt.compType == CompType::UNorm) - ret = VK_FORMAT_R8G8_UNORM; - else if(fmt.compType == CompType::SScaled) - ret = VK_FORMAT_R8G8_SSCALED; - else if(fmt.compType == CompType::UScaled) - ret = VK_FORMAT_R8G8_USCALED; - else - RDCERR("Unrecognised component type"); - } - else - { - RDCERR("Unrecognised 3-component byte width: %d", fmt.compByteWidth); - } - } - else if(fmt.compCount == 1) - { - if(fmt.compByteWidth == 8) - { - if(fmt.compType == CompType::Float || fmt.compType == CompType::Double) - ret = VK_FORMAT_R64_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R64_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R64_UINT; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 4) - { - if(fmt.compType == CompType::Float) - ret = VK_FORMAT_R32_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R32_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R32_UINT; - else if(fmt.compType == CompType::Depth) - ret = VK_FORMAT_D32_SFLOAT; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 2) - { - if(fmt.compType == CompType::Float) - ret = VK_FORMAT_R16_SFLOAT; - else if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R16_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R16_UINT; - else if(fmt.compType == CompType::SNorm) - ret = VK_FORMAT_R16_SNORM; - else if(fmt.compType == CompType::UNorm) - ret = VK_FORMAT_R16_UNORM; - else if(fmt.compType == CompType::Depth) - ret = VK_FORMAT_D16_UNORM; - else if(fmt.compType == CompType::UScaled) - ret = VK_FORMAT_R16_USCALED; - else if(fmt.compType == CompType::SScaled) - ret = VK_FORMAT_R16_SSCALED; - else - RDCERR("Unrecognised component type"); - } - else if(fmt.compByteWidth == 1) - { - if(fmt.compType == CompType::SInt) - ret = VK_FORMAT_R8_SINT; - else if(fmt.compType == CompType::UInt) - ret = VK_FORMAT_R8_UINT; - else if(fmt.compType == CompType::SNorm) - ret = VK_FORMAT_R8_SNORM; - else if(fmt.compType == CompType::UNorm) - ret = VK_FORMAT_R8_UNORM; - else if(fmt.compType == CompType::UScaled) - ret = VK_FORMAT_R8_USCALED; - else if(fmt.compType == CompType::SScaled) - ret = VK_FORMAT_R8_SSCALED; - else - RDCERR("Unrecognised component type"); - } - else - { - RDCERR("Unrecognised 3-component byte width: %d", fmt.compByteWidth); - } - } - else - { - RDCERR("Unrecognised component count: %d", fmt.compCount); - } - - if(ret == VK_FORMAT_UNDEFINED) - RDCERR("No known vulkan format corresponding to resource format!"); - - return ret; -} - Topology MakePrimitiveTopology(VkPrimitiveTopology Topo, uint32_t patchControlPoints) { switch(Topo) diff --git a/renderdoc/driver/vulkan/vk_resources.cpp b/renderdoc/driver/vulkan/vk_resources.cpp index 691026f88..0442777ef 100644 --- a/renderdoc/driver/vulkan/vk_resources.cpp +++ b/renderdoc/driver/vulkan/vk_resources.cpp @@ -279,7 +279,10 @@ bool IsSRGBFormat(VkFormat f) case VK_FORMAT_R8_SRGB: case VK_FORMAT_R8G8_SRGB: case VK_FORMAT_R8G8B8_SRGB: + case VK_FORMAT_B8G8R8_SRGB: case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: case VK_FORMAT_BC1_RGB_SRGB_BLOCK: case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: case VK_FORMAT_BC2_SRGB_BLOCK: @@ -302,8 +305,6 @@ bool IsSRGBFormat(VkFormat f) case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: - case VK_FORMAT_B8G8R8_SRGB: - case VK_FORMAT_B8G8R8A8_SRGB: case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: @@ -360,8 +361,7 @@ bool IsUIntFormat(VkFormat f) case VK_FORMAT_R64_UINT: case VK_FORMAT_R64G64_UINT: case VK_FORMAT_R64G64B64_UINT: - case VK_FORMAT_R64G64B64A64_UINT: - case VK_FORMAT_S8_UINT: return true; + case VK_FORMAT_R64G64B64A64_UINT: return true; default: break; } @@ -443,6 +443,56 @@ bool IsYUVFormat(VkFormat f) return false; } +uint32_t GetYUVPlaneCount(VkFormat f) +{ + switch(f) + { + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: return 2; + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: return 3; + default: break; + } + + return 1; +} + +uint32_t GetYUVNumRows(VkFormat f, uint32_t height) +{ + switch(f) + { + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: + // all of these are 4:2:0, so number of rows is equal to height + height/2 + return height + height / 2; + default: break; + } + + return height; +} + VkFormat GetDepthOnlyFormat(VkFormat f) { switch(f) @@ -456,105 +506,6 @@ VkFormat GetDepthOnlyFormat(VkFormat f) return f; } -VkFormat GetUIntTypedFormat(VkFormat f) -{ - switch(f) - { - case VK_FORMAT_R8_UNORM: - case VK_FORMAT_R8_SNORM: - case VK_FORMAT_R8_USCALED: - case VK_FORMAT_R8_SSCALED: - case VK_FORMAT_R8_SINT: - case VK_FORMAT_R8_SRGB: return VK_FORMAT_R8_UINT; - case VK_FORMAT_R8G8_UNORM: - case VK_FORMAT_R8G8_SNORM: - case VK_FORMAT_R8G8_USCALED: - case VK_FORMAT_R8G8_SSCALED: - case VK_FORMAT_R8G8_SINT: - case VK_FORMAT_R8G8_SRGB: return VK_FORMAT_R8G8_UINT; - case VK_FORMAT_R8G8B8_UNORM: - case VK_FORMAT_R8G8B8_SNORM: - case VK_FORMAT_R8G8B8_USCALED: - case VK_FORMAT_R8G8B8_SSCALED: - case VK_FORMAT_R8G8B8_SINT: - case VK_FORMAT_R8G8B8_SRGB: return VK_FORMAT_R8G8B8_UINT; - case VK_FORMAT_R8G8B8A8_UNORM: - case VK_FORMAT_R8G8B8A8_SNORM: - case VK_FORMAT_R8G8B8A8_USCALED: - case VK_FORMAT_R8G8B8A8_SSCALED: - case VK_FORMAT_R8G8B8A8_SINT: - case VK_FORMAT_R8G8B8A8_SRGB: return VK_FORMAT_R8G8B8A8_UINT; - case VK_FORMAT_B8G8R8_UNORM: - case VK_FORMAT_B8G8R8_SNORM: - case VK_FORMAT_B8G8R8_USCALED: - case VK_FORMAT_B8G8R8_SSCALED: - case VK_FORMAT_B8G8R8_SINT: - case VK_FORMAT_B8G8R8_SRGB: return VK_FORMAT_B8G8R8_UINT; - case VK_FORMAT_B8G8R8A8_UNORM: - case VK_FORMAT_B8G8R8A8_SNORM: - case VK_FORMAT_B8G8R8A8_USCALED: - case VK_FORMAT_B8G8R8A8_SSCALED: - case VK_FORMAT_B8G8R8A8_SINT: - case VK_FORMAT_B8G8R8A8_SRGB: return VK_FORMAT_B8G8R8A8_UINT; - case VK_FORMAT_A8B8G8R8_UNORM_PACK32: - case VK_FORMAT_A8B8G8R8_SNORM_PACK32: - case VK_FORMAT_A8B8G8R8_USCALED_PACK32: - case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: - case VK_FORMAT_A8B8G8R8_SINT_PACK32: - case VK_FORMAT_A8B8G8R8_SRGB_PACK32: return VK_FORMAT_A8B8G8R8_UINT_PACK32; - case VK_FORMAT_A2R10G10B10_UNORM_PACK32: - case VK_FORMAT_A2R10G10B10_SNORM_PACK32: - case VK_FORMAT_A2R10G10B10_USCALED_PACK32: - case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: - case VK_FORMAT_A2R10G10B10_SINT_PACK32: return VK_FORMAT_A2R10G10B10_UINT_PACK32; - case VK_FORMAT_A2B10G10R10_UNORM_PACK32: - case VK_FORMAT_A2B10G10R10_SNORM_PACK32: - case VK_FORMAT_A2B10G10R10_USCALED_PACK32: - case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: - case VK_FORMAT_A2B10G10R10_SINT_PACK32: return VK_FORMAT_A2B10G10R10_UINT_PACK32; - case VK_FORMAT_R16_UNORM: - case VK_FORMAT_R16_SNORM: - case VK_FORMAT_R16_USCALED: - case VK_FORMAT_R16_SSCALED: - case VK_FORMAT_R16_SINT: return VK_FORMAT_R16_UINT; - case VK_FORMAT_R16G16_UNORM: - case VK_FORMAT_R16G16_SNORM: - case VK_FORMAT_R16G16_USCALED: - case VK_FORMAT_R16G16_SSCALED: - case VK_FORMAT_R16G16_SINT: return VK_FORMAT_R16G16_UINT; - case VK_FORMAT_R16G16B16_UNORM: - case VK_FORMAT_R16G16B16_SNORM: - case VK_FORMAT_R16G16B16_USCALED: - case VK_FORMAT_R16G16B16_SSCALED: - case VK_FORMAT_R16G16B16_SINT: return VK_FORMAT_R16G16B16_UINT; - case VK_FORMAT_R16G16B16A16_UNORM: - case VK_FORMAT_R16G16B16A16_SNORM: - case VK_FORMAT_R16G16B16A16_USCALED: - case VK_FORMAT_R16G16B16A16_SSCALED: - case VK_FORMAT_R16G16B16A16_SINT: return VK_FORMAT_R16G16B16A16_UINT; - case VK_FORMAT_R32_SINT: - case VK_FORMAT_R32_SFLOAT: return VK_FORMAT_R32_UINT; - case VK_FORMAT_R32G32_SINT: - case VK_FORMAT_R32G32_SFLOAT: return VK_FORMAT_R32G32_UINT; - case VK_FORMAT_R32G32B32_SINT: - case VK_FORMAT_R32G32B32_SFLOAT: return VK_FORMAT_R32G32B32_UINT; - case VK_FORMAT_R32G32B32A32_SINT: - case VK_FORMAT_R32G32B32A32_SFLOAT: return VK_FORMAT_R32G32B32A32_UINT; - case VK_FORMAT_R64_SINT: - case VK_FORMAT_R64_SFLOAT: return VK_FORMAT_R64_UINT; - case VK_FORMAT_R64G64_SINT: - case VK_FORMAT_R64G64_SFLOAT: return VK_FORMAT_R64G64_UINT; - case VK_FORMAT_R64G64B64_SINT: - case VK_FORMAT_R64G64B64_SFLOAT: return VK_FORMAT_R64G64B64_UINT; - case VK_FORMAT_R64G64B64A64_SINT: - case VK_FORMAT_R64G64B64A64_SFLOAT: return VK_FORMAT_R64G64B64A64_UINT; - case VK_FORMAT_S8_UINT: return VK_FORMAT_S8_UINT; - default: break; - } - - return f; -} - uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat Format, uint32_t mip) { uint32_t w = RDCMAX(Width >> mip, 1U); @@ -567,11 +518,17 @@ uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat F switch(Format) { + case VK_FORMAT_R64G64B64A64_UINT: + case VK_FORMAT_R64G64B64A64_SINT: case VK_FORMAT_R64G64B64A64_SFLOAT: ret *= 32; break; + case VK_FORMAT_R64G64B64_UINT: + case VK_FORMAT_R64G64B64_SINT: case VK_FORMAT_R64G64B64_SFLOAT: ret *= 24; break; case VK_FORMAT_R32G32B32A32_UINT: case VK_FORMAT_R32G32B32A32_SINT: case VK_FORMAT_R32G32B32A32_SFLOAT: + case VK_FORMAT_R64G64_UINT: + case VK_FORMAT_R64G64_SINT: case VK_FORMAT_R64G64_SFLOAT: ret *= 16; break; case VK_FORMAT_R32G32B32_UINT: case VK_FORMAT_R32G32B32_SINT: @@ -586,6 +543,8 @@ uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat F case VK_FORMAT_R32G32_UINT: case VK_FORMAT_R32G32_SINT: case VK_FORMAT_R32G32_SFLOAT: + case VK_FORMAT_R64_UINT: + case VK_FORMAT_R64_SINT: case VK_FORMAT_R64_SFLOAT: ret *= 8; break; case VK_FORMAT_R16G16B16_UNORM: case VK_FORMAT_R16G16B16_SNORM: @@ -640,6 +599,7 @@ uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat F case VK_FORMAT_A8B8G8R8_SNORM_PACK32: case VK_FORMAT_A8B8G8R8_USCALED_PACK32: case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + case VK_FORMAT_A8B8G8R8_UINT_PACK32: case VK_FORMAT_A8B8G8R8_SINT_PACK32: case VK_FORMAT_A8B8G8R8_SRGB_PACK32: case VK_FORMAT_R16G16_UNORM: @@ -802,6 +762,163 @@ uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat F case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: ret = (uint32_t)(ceil(w / 4.0) * ceil(h / 4.0) * 8.0); break; + + /* + * YUV planar/packed subsampled textures. + * + * In each diagram we indicate (maybe part) of the data for a 4x4 texture: + * + * +---+---+---+---+ + * | 0 | 1 | 2 | 3 | + * +---+---+---+---+ + * | 4 | 5 | 6 | 7 | + * +---+---+---+---+ + * | 8 | 9 | A | B | + * +---+---+---+---+ + * | C | D | E | F | + * +---+---+---+---+ + * + * + * FOURCC decoding: + * - char 0: 'Y' = packed, 'P' = planar + * - char 1: '4' = 4:4:4, '2' = 4:2:2, '1' = 4:2:1, '0' = 4:2:0 + * - char 2+3: '16' = 16-bit, '10' = 10-bit, '08' = 8-bit + * + * planar = Y is first, all together, then UV comes second. + * packed = YUV is interleaved + * + * ======================= 4:4:4 lossless packed ========================= + * + * Equivalent to uncompressed formats, just YUV instead of RGB. For 8-bit: + * + * pixel: 0 1 2 3 + * byte: 0 1 2 3 4 5 6 7 8 9 A B C D E F + * Y0 U0 V0 A0 Y1 U1 V1 A1 Y2 U2 V2 A2 Y3 U3 V3 A3 + * + * 16-bit is similar with two bytes per sample, 10-bit for uncompressed is + * equivalent to R10G10B10A2 but with RGB=>YUV + * + * ============================ 4:2:2 packed ============================= + * + * 50% horizontal subsampling packed, two Y samples for each U/V sample pair. For 8-bit: + * + * pixel: 0 | 1 2 | 3 4 | 5 6 | 7 + * byte: 0 1 2 3 4 5 6 7 8 9 A B C D E F + * Y0 U0 Y1 V0 Y2 U1 Y3 V1 Y4 U2 Y5 V2 Y6 U3 Y7 V3 + * + * 16-bit is similar with two bytes per sample, 10-bit is stored identically to 16-bit but in + * the most significant bits: + * + * bit: FEDCBA9876543210 + * 16-bit: XXXXXXXXXXXXXXXX + * 10-bit: XXXXXXXXXX000000 + * + * Since the data is unorm this just spaces out valid values. + * + * ============================ 4:2:0 planar ============================= + * + * 50% horizontal and vertical subsampled planar, four Y samples for each U/V sample pair. + * For 8-bit: + * + * + * pixel: 0 1 2 3 4 5 6 7 + * byte: 0 1 2 3 4 5 6 7 + * Y0 Y1 Y2 Y3 Y4 Y5 Y6 Y7 + * + * pixel: 8 9 A B C D E F + * byte: 8 9 A B C D E F + * Y8 Y9 Ya Yb Yc Yd Ye Yf + * + * ... all of the rest of Y luma ... + * + * pixel: T&4 | 1&5 2&6 | 3&7 + * byte: 0 1 2 3 4 5 6 7 + * U0 V0 U1 V1 U2 V2 U3 V3 + * + * pixel: 8&C | 9&D A&E | B&F + * byte: 8 9 A B C D E F + * U4 V4 U5 V5 U6 V6 U7 V7 + */ + case VK_FORMAT_G8B8G8R8_422_UNORM: + case VK_FORMAT_B8G8R8G8_422_UNORM: + // 4:2:2 packed 8-bit, so 1 byte per pixel for luma and 1 byte per pixel for chroma (2 chroma + // samples, with 50% subsampling = 1 byte per pixel) + ret *= 2; + break; + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + // 4:2:0 planar. Since we can assume even width and height, resulting size is 1 byte per pixel + // for luma, plus 1 byte per 2 pixels for chroma. + // 2 or 3 planes makes no difference to size + ret = ret + ret / 2; + break; + case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: + // 4:2:2 planar 8-bit, same as VK_FORMAT_G8B8G8R8_422_UNORM + // 2 or 3 planes makes no difference to size + ret *= 2; + break; + case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: + // uncompressed with 3 planes, so 3 bytes per pixel + ret *= 3; + break; + // basically just 16-bit format with only top 10-bits used + // 10-bit and 12-bit formats are stored identically to 16-bit formats + case VK_FORMAT_R10X6_UNORM_PACK16: + case VK_FORMAT_R12X4_UNORM_PACK16: ret *= 2; break; + case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: + case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: + // just a 16-bit format with only top N-bits used + // 10-bit and 12-bit formats are stored identically to 16-bit formats + ret *= 4; + break; + case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: + case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: + // just a 16-bit format with only top N-bits used + // 10-bit and 12-bit formats are stored identically to 16-bit formats + ret *= 8; + break; + case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: + case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: + case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: + case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: + case VK_FORMAT_G16B16G16R16_422_UNORM: + case VK_FORMAT_B16G16R16G16_422_UNORM: + // 10-bit and 12-bit formats are stored identically to 16-bit formats + // 4:2:2 packed 16-bit + ret *= 4; + break; + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: + // 10-bit and 12-bit formats are stored identically to 16-bit formats + // 4:2:0 planar but 16-bit, so pixelCount*2 + (pixelCount*2) / 2 + ret *= 2; + ret = ret + ret / 2; + break; + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: + // 10-bit and 12-bit formats are stored identically to 16-bit formats + // 4:2:2 16-bit in means 4 bytes per pixel - 2 bytes for luma, then 2 bytes each for chroma + // samples but half the number of samples = 2 bytes for chroma. Packed vs. planar doesn't + // change overall size + ret *= 4; + break; + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: + // 10-bit and 12-bit formats are stored identically to 16-bit formats + // 4:4:4 16-bit in 3 planes means 6 bytes per pixel + ret *= 6; + break; + default: ret = 1; RDCERR("Unrecognised Vulkan Format: %d", Format); @@ -823,6 +940,1326 @@ uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat F return ret; } +ResourceFormat MakeResourceFormat(VkFormat fmt) +{ + ResourceFormat ret; + + ret.type = ResourceFormatType::Regular; + ret.compByteWidth = 0; + ret.compCount = 0; + ret.compType = CompType::Typeless; + + if(fmt == VK_FORMAT_UNDEFINED) + { + ret.type = ResourceFormatType::Undefined; + return ret; + } + + switch(fmt) + { + case VK_FORMAT_R4G4_UNORM_PACK8: ret.type = ResourceFormatType::R4G4; break; + case VK_FORMAT_R4G4B4A4_UNORM_PACK16: + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: ret.type = ResourceFormatType::R4G4B4A4; break; + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_A2B10G10R10_UINT_PACK32: + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + case VK_FORMAT_A2R10G10B10_SINT_PACK32: ret.type = ResourceFormatType::R10G10B10A2; break; + case VK_FORMAT_B10G11R11_UFLOAT_PACK32: ret.type = ResourceFormatType::R11G11B10; break; + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: ret.type = ResourceFormatType::R9G9B9E5; break; + case VK_FORMAT_R5G6B5_UNORM_PACK16: + case VK_FORMAT_B5G6R5_UNORM_PACK16: ret.type = ResourceFormatType::R5G6B5; break; + case VK_FORMAT_R5G5B5A1_UNORM_PACK16: + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: + case VK_FORMAT_A1R5G5B5_UNORM_PACK16: ret.type = ResourceFormatType::R5G5B5A1; break; + case VK_FORMAT_D16_UNORM_S8_UINT: ret.type = ResourceFormatType::D16S8; break; + case VK_FORMAT_X8_D24_UNORM_PACK32: + case VK_FORMAT_D24_UNORM_S8_UINT: ret.type = ResourceFormatType::D24S8; break; + case VK_FORMAT_D32_SFLOAT_S8_UINT: ret.type = ResourceFormatType::D32S8; break; + case VK_FORMAT_BC1_RGB_UNORM_BLOCK: + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: ret.type = ResourceFormatType::BC1; break; + case VK_FORMAT_BC2_UNORM_BLOCK: + case VK_FORMAT_BC2_SRGB_BLOCK: ret.type = ResourceFormatType::BC2; break; + case VK_FORMAT_BC3_UNORM_BLOCK: + case VK_FORMAT_BC3_SRGB_BLOCK: ret.type = ResourceFormatType::BC3; break; + case VK_FORMAT_BC4_UNORM_BLOCK: + case VK_FORMAT_BC4_SNORM_BLOCK: ret.type = ResourceFormatType::BC4; break; + case VK_FORMAT_BC5_UNORM_BLOCK: + case VK_FORMAT_BC5_SNORM_BLOCK: ret.type = ResourceFormatType::BC5; break; + case VK_FORMAT_BC6H_UFLOAT_BLOCK: + case VK_FORMAT_BC6H_SFLOAT_BLOCK: ret.type = ResourceFormatType::BC6; break; + case VK_FORMAT_BC7_UNORM_BLOCK: + case VK_FORMAT_BC7_SRGB_BLOCK: ret.type = ResourceFormatType::BC7; break; + case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: ret.type = ResourceFormatType::ETC2; break; + case VK_FORMAT_EAC_R11_UNORM_BLOCK: + case VK_FORMAT_EAC_R11_SNORM_BLOCK: + case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: + case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: ret.type = ResourceFormatType::EAC; break; + case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: + case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: + case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: + case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: + case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: ret.type = ResourceFormatType::ASTC; break; + case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: ret.type = ResourceFormatType::PVRTC; break; + case VK_FORMAT_G8B8G8R8_422_UNORM: + case VK_FORMAT_B8G8R8G8_422_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: ret.type = ResourceFormatType::YUV8; break; + case VK_FORMAT_R10X6_UNORM_PACK16: + case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: + case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: + case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: + case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: + ret.type = ResourceFormatType::YUV10; + break; + case VK_FORMAT_R12X4_UNORM_PACK16: + case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: + case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: + case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: + case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: + ret.type = ResourceFormatType::YUV12; + break; + case VK_FORMAT_G16B16G16R16_422_UNORM: + case VK_FORMAT_B16G16R16G16_422_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: ret.type = ResourceFormatType::YUV16; break; + default: break; + } + + switch(fmt) + { + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: + case VK_FORMAT_B5G6R5_UNORM_PACK16: + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_SNORM: + case VK_FORMAT_B8G8R8A8_USCALED: + case VK_FORMAT_B8G8R8A8_SSCALED: + case VK_FORMAT_B8G8R8A8_UINT: + case VK_FORMAT_B8G8R8A8_SINT: + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_B8G8R8_UNORM: + case VK_FORMAT_B8G8R8_SNORM: + case VK_FORMAT_B8G8R8_USCALED: + case VK_FORMAT_B8G8R8_SSCALED: + case VK_FORMAT_B8G8R8_UINT: + case VK_FORMAT_B8G8R8_SINT: + case VK_FORMAT_B8G8R8_SRGB: + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + case VK_FORMAT_B8G8R8G8_422_UNORM: + case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: + case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: + case VK_FORMAT_B16G16R16G16_422_UNORM: ret.setBgraOrder(true); break; + default: break; + } + + switch(fmt) + { + case VK_FORMAT_R8_UNORM: + case VK_FORMAT_R8_SNORM: + case VK_FORMAT_R8_USCALED: + case VK_FORMAT_R8_SSCALED: + case VK_FORMAT_R8_UINT: + case VK_FORMAT_R8_SINT: + case VK_FORMAT_R8_SRGB: + case VK_FORMAT_R16_UNORM: + case VK_FORMAT_R16_SNORM: + case VK_FORMAT_R16_USCALED: + case VK_FORMAT_R16_SSCALED: + case VK_FORMAT_R16_UINT: + case VK_FORMAT_R16_SINT: + case VK_FORMAT_R16_SFLOAT: + case VK_FORMAT_R32_UINT: + case VK_FORMAT_R32_SINT: + case VK_FORMAT_R32_SFLOAT: + case VK_FORMAT_R64_UINT: + case VK_FORMAT_R64_SINT: + case VK_FORMAT_R64_SFLOAT: + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_S8_UINT: + case VK_FORMAT_BC4_UNORM_BLOCK: + case VK_FORMAT_BC4_SNORM_BLOCK: + case VK_FORMAT_EAC_R11_UNORM_BLOCK: + case VK_FORMAT_EAC_R11_SNORM_BLOCK: + case VK_FORMAT_R10X6_UNORM_PACK16: + case VK_FORMAT_R12X4_UNORM_PACK16: ret.compCount = 1; break; + case VK_FORMAT_R4G4_UNORM_PACK8: + case VK_FORMAT_R8G8_UNORM: + case VK_FORMAT_R8G8_SNORM: + case VK_FORMAT_R8G8_USCALED: + case VK_FORMAT_R8G8_SSCALED: + case VK_FORMAT_R8G8_UINT: + case VK_FORMAT_R8G8_SINT: + case VK_FORMAT_R8G8_SRGB: + case VK_FORMAT_R16G16_UNORM: + case VK_FORMAT_R16G16_SNORM: + case VK_FORMAT_R16G16_USCALED: + case VK_FORMAT_R16G16_SSCALED: + case VK_FORMAT_R16G16_UINT: + case VK_FORMAT_R16G16_SINT: + case VK_FORMAT_R16G16_SFLOAT: + case VK_FORMAT_R32G32_UINT: + case VK_FORMAT_R32G32_SINT: + case VK_FORMAT_R32G32_SFLOAT: + case VK_FORMAT_R64G64_UINT: + case VK_FORMAT_R64G64_SINT: + case VK_FORMAT_R64G64_SFLOAT: + case VK_FORMAT_D16_UNORM_S8_UINT: + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: + case VK_FORMAT_BC5_UNORM_BLOCK: + case VK_FORMAT_BC5_SNORM_BLOCK: + case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: + case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: + case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: + case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: ret.compCount = 2; break; + case VK_FORMAT_R5G6B5_UNORM_PACK16: + case VK_FORMAT_R8G8B8_UNORM: + case VK_FORMAT_R8G8B8_SNORM: + case VK_FORMAT_R8G8B8_USCALED: + case VK_FORMAT_R8G8B8_SSCALED: + case VK_FORMAT_R8G8B8_UINT: + case VK_FORMAT_R8G8B8_SINT: + case VK_FORMAT_R8G8B8_SRGB: + case VK_FORMAT_R16G16B16_UNORM: + case VK_FORMAT_R16G16B16_SNORM: + case VK_FORMAT_R16G16B16_USCALED: + case VK_FORMAT_R16G16B16_SSCALED: + case VK_FORMAT_R16G16B16_UINT: + case VK_FORMAT_R16G16B16_SINT: + case VK_FORMAT_R16G16B16_SFLOAT: + case VK_FORMAT_R32G32B32_UINT: + case VK_FORMAT_R32G32B32_SINT: + case VK_FORMAT_R32G32B32_SFLOAT: + case VK_FORMAT_R64G64B64_UINT: + case VK_FORMAT_R64G64B64_SINT: + case VK_FORMAT_R64G64B64_SFLOAT: + case VK_FORMAT_B10G11R11_UFLOAT_PACK32: + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: + case VK_FORMAT_BC1_RGB_UNORM_BLOCK: + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + case VK_FORMAT_BC6H_UFLOAT_BLOCK: + case VK_FORMAT_BC6H_SFLOAT_BLOCK: + case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + case VK_FORMAT_B5G6R5_UNORM_PACK16: + case VK_FORMAT_B8G8R8_UNORM: + case VK_FORMAT_B8G8R8_SNORM: + case VK_FORMAT_B8G8R8_USCALED: + case VK_FORMAT_B8G8R8_SSCALED: + case VK_FORMAT_B8G8R8_UINT: + case VK_FORMAT_B8G8R8_SINT: + case VK_FORMAT_B8G8R8_SRGB: + case VK_FORMAT_G8B8G8R8_422_UNORM: + case VK_FORMAT_B8G8R8G8_422_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: + case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: + case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: + case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G16B16G16R16_422_UNORM: + case VK_FORMAT_B16G16R16G16_422_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: ret.compCount = 3; break; + case VK_FORMAT_R4G4B4A4_UNORM_PACK16: + case VK_FORMAT_R5G5B5A1_UNORM_PACK16: + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R8G8B8A8_SNORM: + case VK_FORMAT_R8G8B8A8_USCALED: + case VK_FORMAT_R8G8B8A8_SSCALED: + case VK_FORMAT_R8G8B8A8_UINT: + case VK_FORMAT_R8G8B8A8_SINT: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + case VK_FORMAT_R16G16B16A16_UNORM: + case VK_FORMAT_R16G16B16A16_SNORM: + case VK_FORMAT_R16G16B16A16_USCALED: + case VK_FORMAT_R16G16B16A16_SSCALED: + case VK_FORMAT_R16G16B16A16_UINT: + case VK_FORMAT_R16G16B16A16_SINT: + case VK_FORMAT_R16G16B16A16_SFLOAT: + case VK_FORMAT_R32G32B32A32_UINT: + case VK_FORMAT_R32G32B32A32_SINT: + case VK_FORMAT_R32G32B32A32_SFLOAT: + case VK_FORMAT_R64G64B64A64_UINT: + case VK_FORMAT_R64G64B64A64_SINT: + case VK_FORMAT_R64G64B64A64_SFLOAT: + case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + case VK_FORMAT_BC2_UNORM_BLOCK: + case VK_FORMAT_BC2_SRGB_BLOCK: + case VK_FORMAT_BC3_UNORM_BLOCK: + case VK_FORMAT_BC3_SRGB_BLOCK: + case VK_FORMAT_BC7_UNORM_BLOCK: + case VK_FORMAT_BC7_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: + case VK_FORMAT_A1R5G5B5_UNORM_PACK16: + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_SNORM: + case VK_FORMAT_B8G8R8A8_USCALED: + case VK_FORMAT_B8G8R8A8_SSCALED: + case VK_FORMAT_B8G8R8A8_UINT: + case VK_FORMAT_B8G8R8A8_SINT: + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + case VK_FORMAT_A8B8G8R8_UINT_PACK32: + case VK_FORMAT_A8B8G8R8_SINT_PACK32: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: + case VK_FORMAT_A2B10G10R10_UINT_PACK32: + case VK_FORMAT_A2B10G10R10_SINT_PACK32: + case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: + case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: ret.compCount = 4; break; + default: break; + } + + switch(fmt) + { + case VK_FORMAT_R8_SRGB: + case VK_FORMAT_R8G8_SRGB: + case VK_FORMAT_R8G8B8_SRGB: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + case VK_FORMAT_BC2_SRGB_BLOCK: + case VK_FORMAT_BC3_SRGB_BLOCK: + case VK_FORMAT_BC7_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: + case VK_FORMAT_B8G8R8_SRGB: + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: ret.setSrgbCorrected(true); break; + default: break; + } + + switch(fmt) + { + case VK_FORMAT_R4G4_UNORM_PACK8: + case VK_FORMAT_R4G4B4A4_UNORM_PACK16: + case VK_FORMAT_R5G6B5_UNORM_PACK16: + case VK_FORMAT_R5G5B5A1_UNORM_PACK16: + case VK_FORMAT_R8_UNORM: + case VK_FORMAT_R8_SRGB: + case VK_FORMAT_R8G8_UNORM: + case VK_FORMAT_R8G8_SRGB: + case VK_FORMAT_R8G8B8_UNORM: + case VK_FORMAT_R8G8B8_SRGB: + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_A2R10G10B10_UNORM_PACK32: + case VK_FORMAT_R16_UNORM: + case VK_FORMAT_R16G16_UNORM: + case VK_FORMAT_R16G16B16_UNORM: + case VK_FORMAT_R16G16B16A16_UNORM: + case VK_FORMAT_BC1_RGB_UNORM_BLOCK: + case VK_FORMAT_BC1_RGB_SRGB_BLOCK: + case VK_FORMAT_BC1_RGBA_UNORM_BLOCK: + case VK_FORMAT_BC1_RGBA_SRGB_BLOCK: + case VK_FORMAT_BC2_UNORM_BLOCK: + case VK_FORMAT_BC2_SRGB_BLOCK: + case VK_FORMAT_BC3_UNORM_BLOCK: + case VK_FORMAT_BC3_SRGB_BLOCK: + case VK_FORMAT_BC4_UNORM_BLOCK: + case VK_FORMAT_BC5_UNORM_BLOCK: + case VK_FORMAT_BC7_UNORM_BLOCK: + case VK_FORMAT_BC7_SRGB_BLOCK: + case VK_FORMAT_BC6H_UFLOAT_BLOCK: + case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: + case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: + case VK_FORMAT_EAC_R11_UNORM_BLOCK: + case VK_FORMAT_EAC_R11G11_UNORM_BLOCK: + case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_4x4_SRGB_BLOCK: + case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x4_SRGB_BLOCK: + case VK_FORMAT_ASTC_5x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_5x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_6x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_6x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_6x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_8x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_8x8_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x5_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x5_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x6_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x6_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x8_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x8_SRGB_BLOCK: + case VK_FORMAT_ASTC_10x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_10x10_SRGB_BLOCK: + case VK_FORMAT_ASTC_12x10_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x10_SRGB_BLOCK: + case VK_FORMAT_ASTC_12x12_UNORM_BLOCK: + case VK_FORMAT_ASTC_12x12_SRGB_BLOCK: + case VK_FORMAT_B4G4R4A4_UNORM_PACK16: + case VK_FORMAT_B5G5R5A1_UNORM_PACK16: + case VK_FORMAT_B5G6R5_UNORM_PACK16: + case VK_FORMAT_B8G8R8_UNORM: + case VK_FORMAT_B8G8R8_SRGB: + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_SRGB: + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + case VK_FORMAT_A2B10G10R10_UNORM_PACK32: + case VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: + case VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: + case VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: ret.compType = CompType::UNorm; break; + case VK_FORMAT_R8_SNORM: + case VK_FORMAT_R8G8_SNORM: + case VK_FORMAT_R8G8B8_SNORM: + case VK_FORMAT_R8G8B8A8_SNORM: + case VK_FORMAT_A2R10G10B10_SNORM_PACK32: + case VK_FORMAT_R16_SNORM: + case VK_FORMAT_R16G16_SNORM: + case VK_FORMAT_R16G16B16_SNORM: + case VK_FORMAT_R16G16B16A16_SNORM: + case VK_FORMAT_BC4_SNORM_BLOCK: + case VK_FORMAT_BC5_SNORM_BLOCK: + case VK_FORMAT_BC6H_SFLOAT_BLOCK: + case VK_FORMAT_EAC_R11_SNORM_BLOCK: + case VK_FORMAT_EAC_R11G11_SNORM_BLOCK: + case VK_FORMAT_B8G8R8_SNORM: + case VK_FORMAT_B8G8R8A8_SNORM: + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: + case VK_FORMAT_A2B10G10R10_SNORM_PACK32: ret.compType = CompType::SNorm; break; + case VK_FORMAT_R8_USCALED: + case VK_FORMAT_R8G8_USCALED: + case VK_FORMAT_R8G8B8_USCALED: + case VK_FORMAT_R8G8B8A8_USCALED: + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: + case VK_FORMAT_R16_USCALED: + case VK_FORMAT_R16G16_USCALED: + case VK_FORMAT_R16G16B16_USCALED: + case VK_FORMAT_R16G16B16A16_USCALED: + case VK_FORMAT_A2R10G10B10_USCALED_PACK32: + case VK_FORMAT_B8G8R8_USCALED: + case VK_FORMAT_B8G8R8A8_USCALED: + case VK_FORMAT_A2B10G10R10_USCALED_PACK32: ret.compType = CompType::UScaled; break; + case VK_FORMAT_R8_SSCALED: + case VK_FORMAT_R8G8_SSCALED: + case VK_FORMAT_R8G8B8_SSCALED: + case VK_FORMAT_R8G8B8A8_SSCALED: + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: + case VK_FORMAT_R16_SSCALED: + case VK_FORMAT_R16G16_SSCALED: + case VK_FORMAT_R16G16B16_SSCALED: + case VK_FORMAT_R16G16B16A16_SSCALED: + case VK_FORMAT_B8G8R8_SSCALED: + case VK_FORMAT_B8G8R8A8_SSCALED: + case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: ret.compType = CompType::SScaled; break; + case VK_FORMAT_R8_UINT: + case VK_FORMAT_R8G8_UINT: + case VK_FORMAT_R8G8B8_UINT: + case VK_FORMAT_R8G8B8A8_UINT: + case VK_FORMAT_A8B8G8R8_UINT_PACK32: + case VK_FORMAT_A2R10G10B10_UINT_PACK32: + case VK_FORMAT_R16_UINT: + case VK_FORMAT_R16G16_UINT: + case VK_FORMAT_R16G16B16_UINT: + case VK_FORMAT_R16G16B16A16_UINT: + case VK_FORMAT_R32_UINT: + case VK_FORMAT_R32G32_UINT: + case VK_FORMAT_R32G32B32_UINT: + case VK_FORMAT_R32G32B32A32_UINT: + case VK_FORMAT_R64_UINT: + case VK_FORMAT_R64G64_UINT: + case VK_FORMAT_R64G64B64_UINT: + case VK_FORMAT_R64G64B64A64_UINT: + case VK_FORMAT_B8G8R8_UINT: + case VK_FORMAT_B8G8R8A8_UINT: + case VK_FORMAT_A2B10G10R10_UINT_PACK32: ret.compType = CompType::UInt; break; + case VK_FORMAT_R8_SINT: + case VK_FORMAT_R8G8_SINT: + case VK_FORMAT_R8G8B8_SINT: + case VK_FORMAT_R8G8B8A8_SINT: + case VK_FORMAT_A8B8G8R8_SINT_PACK32: + case VK_FORMAT_A2R10G10B10_SINT_PACK32: + case VK_FORMAT_R16_SINT: + case VK_FORMAT_R16G16_SINT: + case VK_FORMAT_R16G16B16_SINT: + case VK_FORMAT_R16G16B16A16_SINT: + case VK_FORMAT_R32_SINT: + case VK_FORMAT_R32G32_SINT: + case VK_FORMAT_R32G32B32_SINT: + case VK_FORMAT_R32G32B32A32_SINT: + case VK_FORMAT_R64_SINT: + case VK_FORMAT_R64G64_SINT: + case VK_FORMAT_R64G64B64_SINT: + case VK_FORMAT_R64G64B64A64_SINT: + case VK_FORMAT_B8G8R8_SINT: + case VK_FORMAT_B8G8R8A8_SINT: + case VK_FORMAT_A2B10G10R10_SINT_PACK32: ret.compType = CompType::SInt; break; + case VK_FORMAT_R16_SFLOAT: + case VK_FORMAT_R16G16_SFLOAT: + case VK_FORMAT_R16G16B16_SFLOAT: + case VK_FORMAT_R16G16B16A16_SFLOAT: + case VK_FORMAT_R32_SFLOAT: + case VK_FORMAT_R32G32_SFLOAT: + case VK_FORMAT_R32G32B32_SFLOAT: + case VK_FORMAT_R32G32B32A32_SFLOAT: + case VK_FORMAT_B10G11R11_UFLOAT_PACK32: + case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: ret.compType = CompType::Float; break; + case VK_FORMAT_R64_SFLOAT: + case VK_FORMAT_R64G64_SFLOAT: + case VK_FORMAT_R64G64B64_SFLOAT: + case VK_FORMAT_R64G64B64A64_SFLOAT: ret.compType = CompType::Double; break; + case VK_FORMAT_S8_UINT: + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_X8_D24_UNORM_PACK32: + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_D16_UNORM_S8_UINT: + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: ret.compType = CompType::Depth; break; + default: break; + } + + switch(fmt) + { + case VK_FORMAT_R8_UNORM: + case VK_FORMAT_R8_SNORM: + case VK_FORMAT_R8_USCALED: + case VK_FORMAT_R8_SSCALED: + case VK_FORMAT_R8_UINT: + case VK_FORMAT_R8_SINT: + case VK_FORMAT_R8_SRGB: + case VK_FORMAT_R8G8_UNORM: + case VK_FORMAT_R8G8_SNORM: + case VK_FORMAT_R8G8_USCALED: + case VK_FORMAT_R8G8_SSCALED: + case VK_FORMAT_R8G8_UINT: + case VK_FORMAT_R8G8_SINT: + case VK_FORMAT_R8G8_SRGB: + case VK_FORMAT_R8G8B8_UNORM: + case VK_FORMAT_R8G8B8_SNORM: + case VK_FORMAT_R8G8B8_USCALED: + case VK_FORMAT_R8G8B8_SSCALED: + case VK_FORMAT_R8G8B8_UINT: + case VK_FORMAT_R8G8B8_SINT: + case VK_FORMAT_R8G8B8_SRGB: + case VK_FORMAT_R8G8B8A8_UNORM: + case VK_FORMAT_R8G8B8A8_SNORM: + case VK_FORMAT_R8G8B8A8_USCALED: + case VK_FORMAT_R8G8B8A8_SSCALED: + case VK_FORMAT_R8G8B8A8_UINT: + case VK_FORMAT_R8G8B8A8_SINT: + case VK_FORMAT_R8G8B8A8_SRGB: + case VK_FORMAT_S8_UINT: + case VK_FORMAT_B8G8R8_UNORM: + case VK_FORMAT_B8G8R8_SNORM: + case VK_FORMAT_B8G8R8_USCALED: + case VK_FORMAT_B8G8R8_SSCALED: + case VK_FORMAT_B8G8R8_UINT: + case VK_FORMAT_B8G8R8_SINT: + case VK_FORMAT_B8G8R8_SRGB: + case VK_FORMAT_A8B8G8R8_UNORM_PACK32: + case VK_FORMAT_A8B8G8R8_SNORM_PACK32: + case VK_FORMAT_A8B8G8R8_USCALED_PACK32: + case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: + case VK_FORMAT_A8B8G8R8_UINT_PACK32: + case VK_FORMAT_A8B8G8R8_SINT_PACK32: + case VK_FORMAT_A8B8G8R8_SRGB_PACK32: + case VK_FORMAT_B8G8R8A8_UNORM: + case VK_FORMAT_B8G8R8A8_SNORM: + case VK_FORMAT_B8G8R8A8_USCALED: + case VK_FORMAT_B8G8R8A8_SSCALED: + case VK_FORMAT_B8G8R8A8_UINT: + case VK_FORMAT_B8G8R8A8_SINT: + case VK_FORMAT_B8G8R8A8_SRGB: ret.compByteWidth = 1; break; + case VK_FORMAT_R16_UNORM: + case VK_FORMAT_R16_SNORM: + case VK_FORMAT_R16_USCALED: + case VK_FORMAT_R16_SSCALED: + case VK_FORMAT_R16_UINT: + case VK_FORMAT_R16_SINT: + case VK_FORMAT_R16_SFLOAT: + case VK_FORMAT_R16G16_UNORM: + case VK_FORMAT_R16G16_SNORM: + case VK_FORMAT_R16G16_USCALED: + case VK_FORMAT_R16G16_SSCALED: + case VK_FORMAT_R16G16_UINT: + case VK_FORMAT_R16G16_SINT: + case VK_FORMAT_R16G16_SFLOAT: + case VK_FORMAT_R16G16B16_UNORM: + case VK_FORMAT_R16G16B16_SNORM: + case VK_FORMAT_R16G16B16_USCALED: + case VK_FORMAT_R16G16B16_SSCALED: + case VK_FORMAT_R16G16B16_UINT: + case VK_FORMAT_R16G16B16_SINT: + case VK_FORMAT_R16G16B16_SFLOAT: + case VK_FORMAT_R16G16B16A16_UNORM: + case VK_FORMAT_R16G16B16A16_SNORM: + case VK_FORMAT_R16G16B16A16_USCALED: + case VK_FORMAT_R16G16B16A16_SSCALED: + case VK_FORMAT_R16G16B16A16_UINT: + case VK_FORMAT_R16G16B16A16_SINT: + case VK_FORMAT_R16G16B16A16_SFLOAT: + case VK_FORMAT_D16_UNORM: ret.compByteWidth = 2; break; + case VK_FORMAT_X8_D24_UNORM_PACK32: ret.compByteWidth = 3; break; + case VK_FORMAT_R32_UINT: + case VK_FORMAT_R32_SINT: + case VK_FORMAT_R32_SFLOAT: + case VK_FORMAT_R32G32_UINT: + case VK_FORMAT_R32G32_SINT: + case VK_FORMAT_R32G32_SFLOAT: + case VK_FORMAT_R32G32B32_UINT: + case VK_FORMAT_R32G32B32_SINT: + case VK_FORMAT_R32G32B32_SFLOAT: + case VK_FORMAT_R32G32B32A32_UINT: + case VK_FORMAT_R32G32B32A32_SINT: + case VK_FORMAT_R32G32B32A32_SFLOAT: + case VK_FORMAT_D32_SFLOAT: ret.compByteWidth = 4; break; + case VK_FORMAT_R64_UINT: + case VK_FORMAT_R64G64_UINT: + case VK_FORMAT_R64G64B64_UINT: + case VK_FORMAT_R64G64B64A64_UINT: + case VK_FORMAT_R64_SINT: + case VK_FORMAT_R64G64_SINT: + case VK_FORMAT_R64G64B64_SINT: + case VK_FORMAT_R64G64B64A64_SINT: + case VK_FORMAT_R64_SFLOAT: + case VK_FORMAT_R64G64_SFLOAT: + case VK_FORMAT_R64G64B64_SFLOAT: + case VK_FORMAT_R64G64B64A64_SFLOAT: ret.compByteWidth = 8; break; + default: break; + } + + if(IsYUVFormat(fmt)) + { + ret.setYUVPlaneCount(GetYUVPlaneCount(fmt)); + + switch(fmt) + { + case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: + case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: ret.setYUVSubsampling(420); break; + case VK_FORMAT_G8B8G8R8_422_UNORM: + case VK_FORMAT_B8G8R8G8_422_UNORM: + case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: + case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: + case VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: + case VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: + case VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: + case VK_FORMAT_G16B16G16R16_422_UNORM: + case VK_FORMAT_B16G16R16G16_422_UNORM: + case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: + case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: ret.setYUVSubsampling(422); break; + case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: + case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: + case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: + case VK_FORMAT_R10X6_UNORM_PACK16: + case VK_FORMAT_R10X6G10X6_UNORM_2PACK16: + case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: + case VK_FORMAT_R12X4_UNORM_PACK16: + case VK_FORMAT_R12X4G12X4_UNORM_2PACK16: + case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: ret.setYUVSubsampling(444); break; + } + } + + return ret; +} + +VkFormat MakeVkFormat(ResourceFormat fmt) +{ + VkFormat ret = VK_FORMAT_UNDEFINED; + + if(fmt.Special()) + { + switch(fmt.type) + { + case ResourceFormatType::Undefined: return ret; + case ResourceFormatType::BC1: + { + if(fmt.compCount == 3) + ret = fmt.srgbCorrected() ? VK_FORMAT_BC1_RGB_SRGB_BLOCK : VK_FORMAT_BC1_RGB_UNORM_BLOCK; + else + ret = fmt.srgbCorrected() ? VK_FORMAT_BC1_RGBA_SRGB_BLOCK : VK_FORMAT_BC1_RGBA_UNORM_BLOCK; + break; + } + case ResourceFormatType::BC2: + ret = fmt.srgbCorrected() ? VK_FORMAT_BC2_SRGB_BLOCK : VK_FORMAT_BC2_UNORM_BLOCK; + break; + case ResourceFormatType::BC3: + ret = fmt.srgbCorrected() ? VK_FORMAT_BC3_SRGB_BLOCK : VK_FORMAT_BC3_UNORM_BLOCK; + break; + case ResourceFormatType::BC4: + ret = fmt.compType == CompType::SNorm ? VK_FORMAT_BC4_SNORM_BLOCK : VK_FORMAT_BC4_UNORM_BLOCK; + break; + case ResourceFormatType::BC5: + ret = fmt.compType == CompType::SNorm ? VK_FORMAT_BC5_SNORM_BLOCK : VK_FORMAT_BC5_UNORM_BLOCK; + break; + case ResourceFormatType::BC6: + ret = fmt.compType == CompType::SNorm ? VK_FORMAT_BC6H_SFLOAT_BLOCK + : VK_FORMAT_BC6H_UFLOAT_BLOCK; + break; + case ResourceFormatType::BC7: + ret = fmt.srgbCorrected() ? VK_FORMAT_BC7_SRGB_BLOCK : VK_FORMAT_BC7_UNORM_BLOCK; + break; + case ResourceFormatType::ETC2: + { + if(fmt.compCount == 3) + ret = fmt.srgbCorrected() ? VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK + : VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK; + else + ret = fmt.srgbCorrected() ? VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK + : VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK; + break; + } + case ResourceFormatType::EAC: + { + if(fmt.compCount == 1) + ret = fmt.compType == CompType::SNorm ? VK_FORMAT_EAC_R11_SNORM_BLOCK + : VK_FORMAT_EAC_R11_UNORM_BLOCK; + else if(fmt.compCount == 2) + ret = fmt.compType == CompType::SNorm ? VK_FORMAT_EAC_R11G11_SNORM_BLOCK + : VK_FORMAT_EAC_R11G11_UNORM_BLOCK; + break; + } + case ResourceFormatType::R10G10B10A2: + if(fmt.compType == CompType::UNorm) + ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_UNORM_PACK32 + : VK_FORMAT_A2B10G10R10_UNORM_PACK32; + else if(fmt.compType == CompType::UInt) + ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_UINT_PACK32 + : VK_FORMAT_A2B10G10R10_UINT_PACK32; + else if(fmt.compType == CompType::UScaled) + ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_USCALED_PACK32 + : VK_FORMAT_A2B10G10R10_USCALED_PACK32; + else if(fmt.compType == CompType::SNorm) + ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_SNORM_PACK32 + : VK_FORMAT_A2B10G10R10_SNORM_PACK32; + else if(fmt.compType == CompType::SInt) + ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_SINT_PACK32 + : VK_FORMAT_A2B10G10R10_SINT_PACK32; + else if(fmt.compType == CompType::SScaled) + ret = fmt.bgraOrder() ? VK_FORMAT_A2R10G10B10_SSCALED_PACK32 + : VK_FORMAT_A2B10G10R10_SSCALED_PACK32; + break; + case ResourceFormatType::R11G11B10: ret = VK_FORMAT_B10G11R11_UFLOAT_PACK32; break; + case ResourceFormatType::R5G6B5: + ret = fmt.bgraOrder() ? VK_FORMAT_B5G6R5_UNORM_PACK16 : VK_FORMAT_R5G6B5_UNORM_PACK16; + break; + case ResourceFormatType::R5G5B5A1: + ret = fmt.bgraOrder() ? VK_FORMAT_B5G5R5A1_UNORM_PACK16 : VK_FORMAT_R5G5B5A1_UNORM_PACK16; + break; + case ResourceFormatType::R9G9B9E5: ret = VK_FORMAT_E5B9G9R9_UFLOAT_PACK32; break; + case ResourceFormatType::R4G4B4A4: + ret = fmt.bgraOrder() ? VK_FORMAT_B4G4R4A4_UNORM_PACK16 : VK_FORMAT_R4G4B4A4_UNORM_PACK16; + break; + case ResourceFormatType::R4G4: ret = VK_FORMAT_R4G4_UNORM_PACK8; break; + case ResourceFormatType::D16S8: ret = VK_FORMAT_D16_UNORM_S8_UINT; break; + case ResourceFormatType::D24S8: ret = VK_FORMAT_D24_UNORM_S8_UINT; break; + case ResourceFormatType::D32S8: ret = VK_FORMAT_D32_SFLOAT_S8_UINT; break; + case ResourceFormatType::YUV8: + { + int subsampling = fmt.yuvSubsampling(); + int planeCount = fmt.yuvPlaneCount(); + + // don't support anything but 3 components + if(fmt.compCount != 3) + return VK_FORMAT_UNDEFINED; + + if(subsampling == 444) + { + // only support 3-plane + return planeCount == 3 ? VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM : VK_FORMAT_UNDEFINED; + } + else if(subsampling == 422) + { + if(planeCount == 1) + return fmt.bgraOrder() ? VK_FORMAT_B8G8R8G8_422_UNORM : VK_FORMAT_G8B8G8R8_422_UNORM; + else if(planeCount == 2) + return VK_FORMAT_G8_B8R8_2PLANE_422_UNORM; + else if(planeCount == 3) + return VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM; + } + else if(subsampling == 420) + { + if(planeCount == 2) + return VK_FORMAT_G8_B8R8_2PLANE_420_UNORM; + else if(planeCount == 3) + return VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM; + else + return VK_FORMAT_UNDEFINED; + } + + return VK_FORMAT_UNDEFINED; + } + case ResourceFormatType::YUV10: + { + int subsampling = fmt.yuvSubsampling(); + int planeCount = fmt.yuvPlaneCount(); + + if(fmt.compCount == 1) + { + if(subsampling == 444 && planeCount == 1) + return VK_FORMAT_R10X6_UNORM_PACK16; + return VK_FORMAT_UNDEFINED; + } + else if(fmt.compCount == 2) + { + if(subsampling == 444 && planeCount == 1) + return VK_FORMAT_R10X6G10X6_UNORM_2PACK16; + return VK_FORMAT_UNDEFINED; + } + else if(fmt.compCount == 4) + { + if(subsampling == 444 && planeCount == 1) + return VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16; + return VK_FORMAT_UNDEFINED; + } + + if(subsampling == 444) + { + // only support 3-plane + return planeCount == 3 ? VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 + : VK_FORMAT_UNDEFINED; + } + else if(subsampling == 422) + { + if(planeCount == 1) + return fmt.bgraOrder() ? VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 + : VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16; + else if(planeCount == 2) + return VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16; + else if(planeCount == 3) + return VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16; + } + else if(subsampling == 420) + { + if(planeCount == 2) + return VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16; + else if(planeCount == 3) + return VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16; + else + return VK_FORMAT_UNDEFINED; + } + + return VK_FORMAT_UNDEFINED; + } + case ResourceFormatType::YUV12: + { + int subsampling = fmt.yuvSubsampling(); + int planeCount = fmt.yuvPlaneCount(); + + if(fmt.compCount == 1) + { + if(subsampling == 444 && planeCount == 1) + return VK_FORMAT_R12X4_UNORM_PACK16; + return VK_FORMAT_UNDEFINED; + } + else if(fmt.compCount == 2) + { + if(subsampling == 444 && planeCount == 1) + return VK_FORMAT_R12X4G12X4_UNORM_2PACK16; + return VK_FORMAT_UNDEFINED; + } + else if(fmt.compCount == 4) + { + if(subsampling == 444 && planeCount == 1) + return VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16; + return VK_FORMAT_UNDEFINED; + } + + if(subsampling == 444) + { + // only support 3-plane + return planeCount == 3 ? VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 + : VK_FORMAT_UNDEFINED; + } + else if(subsampling == 422) + { + if(planeCount == 1) + return fmt.bgraOrder() ? VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 + : VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16; + else if(planeCount == 2) + return VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16; + else if(planeCount == 3) + return VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16; + } + else if(subsampling == 420) + { + if(planeCount == 2) + return VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16; + else if(planeCount == 3) + return VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16; + else + return VK_FORMAT_UNDEFINED; + } + + return VK_FORMAT_UNDEFINED; + } + case ResourceFormatType::YUV16: + { + int subsampling = fmt.yuvSubsampling(); + int planeCount = fmt.yuvPlaneCount(); + + if(subsampling == 444) + { + // only support 3-plane + return planeCount == 3 ? VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM : VK_FORMAT_UNDEFINED; + } + else if(subsampling == 422) + { + if(planeCount == 1) + return fmt.bgraOrder() ? VK_FORMAT_B16G16R16G16_422_UNORM + : VK_FORMAT_G16B16G16R16_422_UNORM; + else if(planeCount == 2) + return VK_FORMAT_G16_B16R16_2PLANE_422_UNORM; + else if(planeCount == 3) + return VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM; + } + else if(subsampling == 420) + { + if(planeCount == 2) + return VK_FORMAT_G16_B16R16_2PLANE_420_UNORM; + else if(planeCount == 3) + return VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM; + else + return VK_FORMAT_UNDEFINED; + } + + return VK_FORMAT_UNDEFINED; + } + default: RDCERR("Unsupported resource format type %u", fmt.type); break; + } + } + else if(fmt.compCount == 4) + { + if(fmt.srgbCorrected()) + { + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_R8G8B8A8_SRGB; + } + else if(fmt.compByteWidth == 8) + { + if(fmt.compType == CompType::Float || fmt.compType == CompType::Double) + ret = VK_FORMAT_R64G64B64A64_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R64G64B64A64_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R64G64B64A64_UINT; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 4) + { + if(fmt.compType == CompType::Float) + ret = VK_FORMAT_R32G32B32A32_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R32G32B32A32_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R32G32B32A32_UINT; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 2) + { + if(fmt.compType == CompType::Float) + ret = VK_FORMAT_R16G16B16A16_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R16G16B16A16_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R16G16B16A16_UINT; + else if(fmt.compType == CompType::SNorm) + ret = VK_FORMAT_R16G16B16A16_SNORM; + else if(fmt.compType == CompType::UNorm) + ret = VK_FORMAT_R16G16B16A16_UNORM; + else if(fmt.compType == CompType::SScaled) + ret = VK_FORMAT_R16G16B16A16_SSCALED; + else if(fmt.compType == CompType::UScaled) + ret = VK_FORMAT_R16G16B16A16_USCALED; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 1) + { + if(fmt.compType == CompType::SInt) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_SINT : VK_FORMAT_R8G8B8A8_SINT; + else if(fmt.compType == CompType::UInt) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_UINT : VK_FORMAT_R8G8B8A8_UINT; + else if(fmt.compType == CompType::SNorm) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_SNORM : VK_FORMAT_R8G8B8A8_SNORM; + else if(fmt.compType == CompType::UNorm) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_UNORM : VK_FORMAT_R8G8B8A8_UNORM; + else if(fmt.compType == CompType::SScaled) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_SSCALED : VK_FORMAT_R8G8B8A8_SSCALED; + else if(fmt.compType == CompType::UScaled) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8A8_USCALED : VK_FORMAT_R8G8B8A8_USCALED; + else + RDCERR("Unrecognised component type"); + } + else + { + RDCERR("Unrecognised 4-component byte width: %d", fmt.compByteWidth); + } + } + else if(fmt.compCount == 3) + { + if(fmt.srgbCorrected()) + { + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8_SRGB : VK_FORMAT_R8G8B8_SRGB; + } + else if(fmt.compByteWidth == 8) + { + if(fmt.compType == CompType::Float || fmt.compType == CompType::Double) + ret = VK_FORMAT_R64G64B64_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R64G64B64_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R64G64B64_UINT; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 4) + { + if(fmt.compType == CompType::Float) + ret = VK_FORMAT_R32G32B32_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R32G32B32_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R32G32B32_UINT; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 2) + { + if(fmt.compType == CompType::Float) + ret = VK_FORMAT_R16G16B16_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R16G16B16_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R16G16B16_UINT; + else if(fmt.compType == CompType::SNorm) + ret = VK_FORMAT_R16G16B16_SNORM; + else if(fmt.compType == CompType::UNorm) + ret = VK_FORMAT_R16G16B16_UNORM; + else if(fmt.compType == CompType::SScaled) + ret = VK_FORMAT_R16G16B16_SSCALED; + else if(fmt.compType == CompType::UScaled) + ret = VK_FORMAT_R16G16B16_USCALED; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 1) + { + if(fmt.compType == CompType::SInt) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8_SINT : VK_FORMAT_R8G8B8_SINT; + else if(fmt.compType == CompType::UInt) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8_UINT : VK_FORMAT_R8G8B8_UINT; + else if(fmt.compType == CompType::SNorm) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8_SNORM : VK_FORMAT_R8G8B8_SNORM; + else if(fmt.compType == CompType::UNorm) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8_UNORM : VK_FORMAT_R8G8B8_UNORM; + else if(fmt.compType == CompType::SScaled) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8_SSCALED : VK_FORMAT_R8G8B8_SSCALED; + else if(fmt.compType == CompType::UScaled) + ret = fmt.bgraOrder() ? VK_FORMAT_B8G8R8_USCALED : VK_FORMAT_R8G8B8_USCALED; + else + RDCERR("Unrecognised component type"); + } + else + { + RDCERR("Unrecognised 3-component byte width: %d", fmt.compByteWidth); + } + } + else if(fmt.compCount == 2) + { + if(fmt.srgbCorrected()) + { + ret = VK_FORMAT_R8G8_SRGB; + } + else if(fmt.compByteWidth == 8) + { + if(fmt.compType == CompType::Float || fmt.compType == CompType::Double) + ret = VK_FORMAT_R64G64_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R64G64_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R64G64_UINT; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 4) + { + if(fmt.compType == CompType::Float) + ret = VK_FORMAT_R32G32_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R32G32_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R32G32_UINT; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 2) + { + if(fmt.compType == CompType::Float) + ret = VK_FORMAT_R16G16_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R16G16_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R16G16_UINT; + else if(fmt.compType == CompType::SNorm) + ret = VK_FORMAT_R16G16_SNORM; + else if(fmt.compType == CompType::UNorm) + ret = VK_FORMAT_R16G16_UNORM; + else if(fmt.compType == CompType::SScaled) + ret = VK_FORMAT_R16G16_SSCALED; + else if(fmt.compType == CompType::UScaled) + ret = VK_FORMAT_R16G16_USCALED; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 1) + { + if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R8G8_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R8G8_UINT; + else if(fmt.compType == CompType::SNorm) + ret = VK_FORMAT_R8G8_SNORM; + else if(fmt.compType == CompType::UNorm) + ret = VK_FORMAT_R8G8_UNORM; + else if(fmt.compType == CompType::SScaled) + ret = VK_FORMAT_R8G8_SSCALED; + else if(fmt.compType == CompType::UScaled) + ret = VK_FORMAT_R8G8_USCALED; + else + RDCERR("Unrecognised component type"); + } + else + { + RDCERR("Unrecognised 2-component byte width: %d", fmt.compByteWidth); + } + } + else if(fmt.compCount == 1) + { + if(fmt.srgbCorrected()) + { + ret = VK_FORMAT_R8_SRGB; + } + else if(fmt.compByteWidth == 8) + { + if(fmt.compType == CompType::Float || fmt.compType == CompType::Double) + ret = VK_FORMAT_R64_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R64_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R64_UINT; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 4) + { + if(fmt.compType == CompType::Float) + ret = VK_FORMAT_R32_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R32_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R32_UINT; + else if(fmt.compType == CompType::Depth) + ret = VK_FORMAT_D32_SFLOAT; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 2) + { + if(fmt.compType == CompType::Float) + ret = VK_FORMAT_R16_SFLOAT; + else if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R16_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R16_UINT; + else if(fmt.compType == CompType::SNorm) + ret = VK_FORMAT_R16_SNORM; + else if(fmt.compType == CompType::UNorm) + ret = VK_FORMAT_R16_UNORM; + else if(fmt.compType == CompType::Depth) + ret = VK_FORMAT_D16_UNORM; + else if(fmt.compType == CompType::UScaled) + ret = VK_FORMAT_R16_USCALED; + else if(fmt.compType == CompType::SScaled) + ret = VK_FORMAT_R16_SSCALED; + else + RDCERR("Unrecognised component type"); + } + else if(fmt.compByteWidth == 1) + { + if(fmt.compType == CompType::SInt) + ret = VK_FORMAT_R8_SINT; + else if(fmt.compType == CompType::UInt) + ret = VK_FORMAT_R8_UINT; + else if(fmt.compType == CompType::SNorm) + ret = VK_FORMAT_R8_SNORM; + else if(fmt.compType == CompType::UNorm) + ret = VK_FORMAT_R8_UNORM; + else if(fmt.compType == CompType::UScaled) + ret = VK_FORMAT_R8_USCALED; + else if(fmt.compType == CompType::SScaled) + ret = VK_FORMAT_R8_SSCALED; + else if(fmt.compType == CompType::Depth) + ret = VK_FORMAT_S8_UINT; + else + RDCERR("Unrecognised component type"); + } + else + { + RDCERR("Unrecognised 1-component byte width: %d", fmt.compByteWidth); + } + } + else + { + RDCERR("Unrecognised component count: %d", fmt.compCount); + } + + if(ret == VK_FORMAT_UNDEFINED) + RDCERR("No known vulkan format corresponding to resource format!"); + + return ret; +} + VkResourceRecord::~VkResourceRecord() { VkResourceType resType = Resource != NULL ? IdentifyTypeByPtr(Resource) : eResUnknown; @@ -1087,3 +2524,516 @@ void ResourceInfo::Update(uint32_t numBindings, const VkSparseMemoryBind *pBindi opaquemappings.push_back(curRange); } } + +#if ENABLED(ENABLE_UNIT_TESTS) +#include "3rdparty/catch/catch.hpp" + +TEST_CASE("Vulkan formats", "[format][vulkan]") +{ + // must be updated by hand + std::initializer_list formats = { + VK_FORMAT_UNDEFINED, + VK_FORMAT_R4G4_UNORM_PACK8, + VK_FORMAT_R4G4B4A4_UNORM_PACK16, + VK_FORMAT_B4G4R4A4_UNORM_PACK16, + VK_FORMAT_R5G6B5_UNORM_PACK16, + VK_FORMAT_B5G6R5_UNORM_PACK16, + VK_FORMAT_R5G5B5A1_UNORM_PACK16, + VK_FORMAT_B5G5R5A1_UNORM_PACK16, + VK_FORMAT_A1R5G5B5_UNORM_PACK16, + VK_FORMAT_R8_UNORM, + VK_FORMAT_R8_SNORM, + VK_FORMAT_R8_USCALED, + VK_FORMAT_R8_SSCALED, + VK_FORMAT_R8_UINT, + VK_FORMAT_R8_SINT, + VK_FORMAT_R8_SRGB, + VK_FORMAT_R8G8_UNORM, + VK_FORMAT_R8G8_SNORM, + VK_FORMAT_R8G8_USCALED, + VK_FORMAT_R8G8_SSCALED, + VK_FORMAT_R8G8_UINT, + VK_FORMAT_R8G8_SINT, + VK_FORMAT_R8G8_SRGB, + VK_FORMAT_R8G8B8_UNORM, + VK_FORMAT_R8G8B8_SNORM, + VK_FORMAT_R8G8B8_USCALED, + VK_FORMAT_R8G8B8_SSCALED, + VK_FORMAT_R8G8B8_UINT, + VK_FORMAT_R8G8B8_SINT, + VK_FORMAT_R8G8B8_SRGB, + VK_FORMAT_B8G8R8_UNORM, + VK_FORMAT_B8G8R8_SNORM, + VK_FORMAT_B8G8R8_USCALED, + VK_FORMAT_B8G8R8_SSCALED, + VK_FORMAT_B8G8R8_UINT, + VK_FORMAT_B8G8R8_SINT, + VK_FORMAT_B8G8R8_SRGB, + VK_FORMAT_R8G8B8A8_UNORM, + VK_FORMAT_R8G8B8A8_SNORM, + VK_FORMAT_R8G8B8A8_USCALED, + VK_FORMAT_R8G8B8A8_SSCALED, + VK_FORMAT_R8G8B8A8_UINT, + VK_FORMAT_R8G8B8A8_SINT, + VK_FORMAT_R8G8B8A8_SRGB, + VK_FORMAT_B8G8R8A8_UNORM, + VK_FORMAT_B8G8R8A8_SNORM, + VK_FORMAT_B8G8R8A8_USCALED, + VK_FORMAT_B8G8R8A8_SSCALED, + VK_FORMAT_B8G8R8A8_UINT, + VK_FORMAT_B8G8R8A8_SINT, + VK_FORMAT_B8G8R8A8_SRGB, + VK_FORMAT_A8B8G8R8_UNORM_PACK32, + VK_FORMAT_A8B8G8R8_SNORM_PACK32, + VK_FORMAT_A8B8G8R8_USCALED_PACK32, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32, + VK_FORMAT_A8B8G8R8_UINT_PACK32, + VK_FORMAT_A8B8G8R8_SINT_PACK32, + VK_FORMAT_A8B8G8R8_SRGB_PACK32, + VK_FORMAT_A2R10G10B10_UNORM_PACK32, + VK_FORMAT_A2R10G10B10_SNORM_PACK32, + VK_FORMAT_A2R10G10B10_USCALED_PACK32, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32, + VK_FORMAT_A2R10G10B10_UINT_PACK32, + VK_FORMAT_A2R10G10B10_SINT_PACK32, + VK_FORMAT_A2B10G10R10_UNORM_PACK32, + VK_FORMAT_A2B10G10R10_SNORM_PACK32, + VK_FORMAT_A2B10G10R10_USCALED_PACK32, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32, + VK_FORMAT_A2B10G10R10_UINT_PACK32, + VK_FORMAT_A2B10G10R10_SINT_PACK32, + VK_FORMAT_R16_UNORM, + VK_FORMAT_R16_SNORM, + VK_FORMAT_R16_USCALED, + VK_FORMAT_R16_SSCALED, + VK_FORMAT_R16_UINT, + VK_FORMAT_R16_SINT, + VK_FORMAT_R16_SFLOAT, + VK_FORMAT_R16G16_UNORM, + VK_FORMAT_R16G16_SNORM, + VK_FORMAT_R16G16_USCALED, + VK_FORMAT_R16G16_SSCALED, + VK_FORMAT_R16G16_UINT, + VK_FORMAT_R16G16_SINT, + VK_FORMAT_R16G16_SFLOAT, + VK_FORMAT_R16G16B16_UNORM, + VK_FORMAT_R16G16B16_SNORM, + VK_FORMAT_R16G16B16_USCALED, + VK_FORMAT_R16G16B16_SSCALED, + VK_FORMAT_R16G16B16_UINT, + VK_FORMAT_R16G16B16_SINT, + VK_FORMAT_R16G16B16_SFLOAT, + VK_FORMAT_R16G16B16A16_UNORM, + VK_FORMAT_R16G16B16A16_SNORM, + VK_FORMAT_R16G16B16A16_USCALED, + VK_FORMAT_R16G16B16A16_SSCALED, + VK_FORMAT_R16G16B16A16_UINT, + VK_FORMAT_R16G16B16A16_SINT, + VK_FORMAT_R16G16B16A16_SFLOAT, + VK_FORMAT_R32_UINT, + VK_FORMAT_R32_SINT, + VK_FORMAT_R32_SFLOAT, + VK_FORMAT_R32G32_UINT, + VK_FORMAT_R32G32_SINT, + VK_FORMAT_R32G32_SFLOAT, + VK_FORMAT_R32G32B32_UINT, + VK_FORMAT_R32G32B32_SINT, + VK_FORMAT_R32G32B32_SFLOAT, + VK_FORMAT_R32G32B32A32_UINT, + VK_FORMAT_R32G32B32A32_SINT, + VK_FORMAT_R32G32B32A32_SFLOAT, + VK_FORMAT_R64_UINT, + VK_FORMAT_R64_SINT, + VK_FORMAT_R64_SFLOAT, + VK_FORMAT_R64G64_UINT, + VK_FORMAT_R64G64_SINT, + VK_FORMAT_R64G64_SFLOAT, + VK_FORMAT_R64G64B64_UINT, + VK_FORMAT_R64G64B64_SINT, + VK_FORMAT_R64G64B64_SFLOAT, + VK_FORMAT_R64G64B64A64_UINT, + VK_FORMAT_R64G64B64A64_SINT, + VK_FORMAT_R64G64B64A64_SFLOAT, + VK_FORMAT_B10G11R11_UFLOAT_PACK32, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32, + VK_FORMAT_D16_UNORM, + VK_FORMAT_X8_D24_UNORM_PACK32, + VK_FORMAT_D32_SFLOAT, + VK_FORMAT_S8_UINT, + VK_FORMAT_D16_UNORM_S8_UINT, + VK_FORMAT_D24_UNORM_S8_UINT, + VK_FORMAT_D32_SFLOAT_S8_UINT, + VK_FORMAT_BC1_RGB_UNORM_BLOCK, + VK_FORMAT_BC1_RGB_SRGB_BLOCK, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + VK_FORMAT_BC2_UNORM_BLOCK, + VK_FORMAT_BC2_SRGB_BLOCK, + VK_FORMAT_BC3_UNORM_BLOCK, + VK_FORMAT_BC3_SRGB_BLOCK, + VK_FORMAT_BC4_UNORM_BLOCK, + VK_FORMAT_BC4_SNORM_BLOCK, + VK_FORMAT_BC5_UNORM_BLOCK, + VK_FORMAT_BC5_SNORM_BLOCK, + VK_FORMAT_BC6H_UFLOAT_BLOCK, + VK_FORMAT_BC6H_SFLOAT_BLOCK, + VK_FORMAT_BC7_UNORM_BLOCK, + VK_FORMAT_BC7_SRGB_BLOCK, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK, + VK_FORMAT_EAC_R11_UNORM_BLOCK, + VK_FORMAT_EAC_R11_SNORM_BLOCK, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK, + VK_FORMAT_G8B8G8R8_422_UNORM, + VK_FORMAT_B8G8R8G8_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + VK_FORMAT_R10X6_UNORM_PACK16, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_R12X4_UNORM_PACK16, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16B16G16R16_422_UNORM, + VK_FORMAT_B16G16R16G16_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG, + }; + + SECTION("Only VK_FORMAT_UNDEFINED is ResourceFormatType::Undefined") + { + for(VkFormat f : formats) + { + ResourceFormat fmt = MakeResourceFormat(f); + + if(f == VK_FORMAT_UNDEFINED) + CHECK(fmt.type == ResourceFormatType::Undefined); + else + CHECK(fmt.type != ResourceFormatType::Undefined); + } + }; + + SECTION("MakeVkFormat is reflexive with MakeResourceFormat") + { + for(VkFormat f : formats) + { + ResourceFormat fmt = MakeResourceFormat(f); + + // astc and pvrtc are not properly supported, collapse to a single type + if(f >= VK_FORMAT_ASTC_4x4_UNORM_BLOCK && f <= VK_FORMAT_ASTC_12x12_SRGB_BLOCK) + { + CHECK(fmt.type == ResourceFormatType::ASTC); + continue; + } + if(f >= VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG && f <= VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG) + { + CHECK(fmt.type == ResourceFormatType::PVRTC); + continue; + } + + VkFormat vkf = MakeVkFormat(fmt); + + // we are OK with remapping these variants to another similar one, where our format doesn't + // have enough flexibility to represent the exact type (as a trade-off vs simplicity of + // processing/storage). + if(f == VK_FORMAT_A1R5G5B5_UNORM_PACK16) + { + CHECK(vkf == VK_FORMAT_R5G5B5A1_UNORM_PACK16); + } + else if(f == VK_FORMAT_A8B8G8R8_UNORM_PACK32) + { + CHECK(vkf == VK_FORMAT_R8G8B8A8_UNORM); + } + else if(f == VK_FORMAT_A8B8G8R8_SNORM_PACK32) + { + CHECK(vkf == VK_FORMAT_R8G8B8A8_SNORM); + } + else if(f == VK_FORMAT_A8B8G8R8_USCALED_PACK32) + { + CHECK(vkf == VK_FORMAT_R8G8B8A8_USCALED); + } + else if(f == VK_FORMAT_A8B8G8R8_SSCALED_PACK32) + { + CHECK(vkf == VK_FORMAT_R8G8B8A8_SSCALED); + } + else if(f == VK_FORMAT_A8B8G8R8_UINT_PACK32) + { + CHECK(vkf == VK_FORMAT_R8G8B8A8_UINT); + } + else if(f == VK_FORMAT_A8B8G8R8_SINT_PACK32) + { + CHECK(vkf == VK_FORMAT_R8G8B8A8_SINT); + } + else if(f == VK_FORMAT_A8B8G8R8_SRGB_PACK32) + { + CHECK(vkf == VK_FORMAT_R8G8B8A8_SRGB); + } + else if(f == VK_FORMAT_X8_D24_UNORM_PACK32) + { + CHECK(vkf == VK_FORMAT_D24_UNORM_S8_UINT); + } + else if(f == VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK) + { + CHECK(vkf == VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK); + } + else if(f == VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK) + { + CHECK(vkf == VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK); + } + else + { + CHECK(vkf == f); + } + } + }; + + SECTION("MakeVkFormat concurs with helpers") + { + for(VkFormat f : formats) + { + ResourceFormat fmt = MakeResourceFormat(f); + + INFO("Format is " << ToStr(f)); + + if(IsBlockFormat(f)) + { + INFO("Format type is " << ToStr(fmt.type)); + + bool bcn = fmt.type >= ResourceFormatType::BC1 && fmt.type <= ResourceFormatType::BC7; + + CHECK((bcn || fmt.type == ResourceFormatType::ASTC || fmt.type == ResourceFormatType::EAC || + fmt.type == ResourceFormatType::ETC2 || fmt.type == ResourceFormatType::PVRTC)); + } + + if(IsYUVFormat(f)) + { + CHECK(fmt.type >= ResourceFormatType::YUV8); + CHECK(fmt.type <= ResourceFormatType::YUV16); + } + + if(IsDepthOrStencilFormat(f)) + { + CHECK(fmt.compType == CompType::Depth); + } + else if(IsUIntFormat(f)) + { + CHECK(fmt.compType == CompType::UInt); + } + else if(IsSIntFormat(f)) + { + CHECK(fmt.compType == CompType::SInt); + } + + if(IsSRGBFormat(f)) + { + CHECK(fmt.srgbCorrected()); + } + } + }; + + SECTION("GetByteSize return expected values for regular formats") + { + for(VkFormat f : formats) + { + ResourceFormat fmt = MakeResourceFormat(f); + + if(fmt.type != ResourceFormatType::Regular) + continue; + + INFO("Format is " << ToStr(f)); + + uint32_t size = fmt.compCount * fmt.compByteWidth * 123 * 456; + + CHECK(size == GetByteSize(123, 456, 1, f, 0)); + } + }; + + SECTION("GetByteSize for BCn formats") + { + const uint32_t width = 24, height = 24; + + // reference: 24x24 = 576, 576/2 = 288 + + const uint32_t bcnsizes[] = { + 288, // VK_FORMAT_BC1_RGB_UNORM_BLOCK + 288, // VK_FORMAT_BC1_RGB_SRGB_BLOCK + 288, // VK_FORMAT_BC1_RGBA_UNORM_BLOCK + 288, // VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 0.5 byte/px + 576, // VK_FORMAT_BC2_UNORM_BLOCK + 576, // VK_FORMAT_BC2_SRGB_BLOCK = 1 byte/px + 576, // VK_FORMAT_BC3_UNORM_BLOCK + 576, // VK_FORMAT_BC3_SRGB_BLOCK = 1 byte/px + 288, // VK_FORMAT_BC4_UNORM_BLOCK + 288, // VK_FORMAT_BC4_SNORM_BLOCK = 0.5 byte/px + 576, // VK_FORMAT_BC5_UNORM_BLOCK + 576, // VK_FORMAT_BC5_SNORM_BLOCK = 1 byte/px + 576, // VK_FORMAT_BC6H_UFLOAT_BLOCK + 576, // VK_FORMAT_BC6H_SFLOAT_BLOCK = 1 byte/px + 576, // VK_FORMAT_BC7_UNORM_BLOCK + 576, // VK_FORMAT_BC7_SRGB_BLOCK = 1 byte/px + }; + + int i = 0; + for(VkFormat f : { + VK_FORMAT_BC1_RGB_UNORM_BLOCK, VK_FORMAT_BC1_RGB_SRGB_BLOCK, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK, VK_FORMAT_BC1_RGBA_SRGB_BLOCK, + VK_FORMAT_BC2_UNORM_BLOCK, VK_FORMAT_BC2_SRGB_BLOCK, VK_FORMAT_BC3_UNORM_BLOCK, + VK_FORMAT_BC3_SRGB_BLOCK, VK_FORMAT_BC4_UNORM_BLOCK, VK_FORMAT_BC4_SNORM_BLOCK, + VK_FORMAT_BC5_UNORM_BLOCK, VK_FORMAT_BC5_SNORM_BLOCK, VK_FORMAT_BC6H_UFLOAT_BLOCK, + VK_FORMAT_BC6H_SFLOAT_BLOCK, VK_FORMAT_BC7_UNORM_BLOCK, VK_FORMAT_BC7_SRGB_BLOCK, + }) + { + INFO("Format is " << ToStr(f)); + + CHECK(bcnsizes[i++] == GetByteSize(width, height, 1, f, 0)); + } + }; + + SECTION("GetByteSize for YUV formats") + { + const uint32_t width = 24, height = 24; + + const uint32_t yuvsizes[] = { + 1152, // VK_FORMAT_G8B8G8R8_422_UNORM (4:2:2 8-bit packed) + 1152, // VK_FORMAT_B8G8R8G8_422_UNORM (4:2:2 8-bit packed) + 864, // VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM (4:2:0 8-bit 3-plane) + 864, // VK_FORMAT_G8_B8R8_2PLANE_420_UNORM (4:2:0 8-bit 2-plane) + 1152, // VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM (4:2:2 8-bit 3-plane) + 1152, // VK_FORMAT_G8_B8R8_2PLANE_422_UNORM (4:2:2 8-bit 2-plane) + 1728, // VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM (4:4:4 8-bit 3-plane) + 1152, // VK_FORMAT_R10X6_UNORM_PACK16 (4:4:4 10-bit packed) + 2304, // VK_FORMAT_R10X6G10X6_UNORM_2PACK16 (4:4:4 10-bit packed) + 4608, // VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 (4:4:4 10-bit packed) + 2304, // VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 (4:2:2 10-bit packed) + 2304, // VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 (4:2:2 10-bit packed) + 1728, // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 (4:2:0 10-bit 3-plane) + 1728, // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 (4:2:0 10-bit 2-plane) + 2304, // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 (4:2:2 10-bit 3-plane) + 2304, // VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 (4:2:2 10-bit 2-plane) + 3456, // VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 (4:4:4 10-bit 3-plane) + 1152, // VK_FORMAT_R12X4_UNORM_PACK16 (4:4:4 12-bit packed) + 2304, // VK_FORMAT_R12X4G12X4_UNORM_2PACK16 (4:4:4 12-bit packed) + 4608, // VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 (4:4:4 12-bit packed) + 2304, // VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 (4:2:2 12-bit packed) + 2304, // VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 (4:2:2 12-bit packed) + 1728, // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 (4:2:0 12-bit 3-plane) + 1728, // VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 (4:2:0 12-bit 2-plane) + 2304, // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 (4:2:2 12-bit 3-plane) + 2304, // VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 (4:2:2 12-bit 2-plane) + 3456, // VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 (4:4:4 12-bit 3-plane) + 2304, // VK_FORMAT_G16B16G16R16_422_UNORM (4:2:2 16-bit packed) + 2304, // VK_FORMAT_B16G16R16G16_422_UNORM (4:2:2 16-bit packed) + 1728, // VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM (4:2:0 16-bit 3-plane) + 1728, // VK_FORMAT_G16_B16R16_2PLANE_420_UNORM (4:2:0 16-bit 2-plane) + 2304, // VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM (4:2:2 16-bit 3-plane) + 2304, // VK_FORMAT_G16_B16R16_2PLANE_422_UNORM (4:2:2 16-bit 2-plane) + 3456, // VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM (4:4:4 16-bit 3-plane) + }; + + int i = 0; + for(VkFormat f : { + VK_FORMAT_G8B8G8R8_422_UNORM, + VK_FORMAT_B8G8R8G8_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + VK_FORMAT_R10X6_UNORM_PACK16, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_R12X4_UNORM_PACK16, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16B16G16R16_422_UNORM, + VK_FORMAT_B16G16R16G16_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + }) + { + INFO("Format is " << ToStr(f)); + + CHECK(yuvsizes[i++] == GetByteSize(width, height, 1, f, 0)); + } + }; +}; + +#endif // ENABLED(ENABLE_UNIT_TESTS) diff --git a/renderdoc/driver/vulkan/vk_resources.h b/renderdoc/driver/vulkan/vk_resources.h index 052f6a2c7..e634de49b 100644 --- a/renderdoc/driver/vulkan/vk_resources.h +++ b/renderdoc/driver/vulkan/vk_resources.h @@ -1227,6 +1227,5 @@ bool IsSIntFormat(VkFormat f); bool IsYUVFormat(VkFormat f); VkFormat GetDepthOnlyFormat(VkFormat f); -VkFormat GetUIntTypedFormat(VkFormat f); uint32_t GetByteSize(uint32_t Width, uint32_t Height, uint32_t Depth, VkFormat Format, uint32_t mip); diff --git a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp index 0fcd4ac83..082607448 100644 --- a/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp +++ b/renderdoc/driver/vulkan/wrappers/vk_device_funcs.cpp @@ -141,7 +141,7 @@ ReplayStatus WrappedVulkan::Initialise(VkInitParams ¶ms, uint64_t sectionVer // PORTABILITY verify that layers/extensions are available StripUnwantedLayers(params.Layers); -#if ENABLED(FORCE_VALIDATION_LAYERS) && DISABLED(RDOC_ANDROID) +#if 1 // ENABLED(FORCE_VALIDATION_LAYERS) && DISABLED(RDOC_ANDROID) params.Layers.push_back("VK_LAYER_LUNARG_standard_validation"); #endif diff --git a/renderdoc/replay/entry_points.cpp b/renderdoc/replay/entry_points.cpp index 4d46ee213..4a02633f1 100644 --- a/renderdoc/replay/entry_points.cpp +++ b/renderdoc/replay/entry_points.cpp @@ -675,7 +675,61 @@ static std::string ResourceFormatName(const ResourceFormat &fmt) case ResourceFormatType::D32S8: return fmt.compType == CompType::Typeless ? "D32S8_TYPELESS" : "D32S8"; case ResourceFormatType::S8: return "S8"; - case ResourceFormatType::YUV: return "YUV"; + case ResourceFormatType::YUV8: + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: + { + int yuvbits = 0; + + switch(fmt.type) + { + case ResourceFormatType::YUV8: yuvbits = 8; break; + case ResourceFormatType::YUV10: yuvbits = 10; break; + case ResourceFormatType::YUV12: yuvbits = 12; break; + case ResourceFormatType::YUV16: yuvbits = 16; break; + default: break; + } + + uint32_t planeCount = fmt.yuvPlaneCount(); + uint32_t subsampling = fmt.yuvSubsampling(); + + // special case formats that don't match the FOURCC format + if(yuvbits == 8 && planeCount == 2 && subsampling == 420) + return "NV12"; + if(yuvbits == 8 && planeCount == 1 && subsampling == 444) + return "AYUV"; + if(yuvbits == 8 && planeCount == 1 && subsampling == 422) + return "YUY2"; + + switch(subsampling) + { + case 444: + if(planeCount == 1) + return StringFormat::Fmt("Y4%02u", yuvbits); + else if(planeCount == 2) + return StringFormat::Fmt("P4%02u", yuvbits); + else + return StringFormat::Fmt("YUV_%uPlane_%ubit", planeCount, yuvbits); + case 422: + if(planeCount == 1) + return StringFormat::Fmt("Y2%02u", yuvbits); + else if(planeCount == 2) + return StringFormat::Fmt("P2%02u", yuvbits); + else + return StringFormat::Fmt("YUV_%uPlane_%ubit", planeCount, yuvbits); + case 420: + if(planeCount == 1) + return StringFormat::Fmt("Y0%02u", yuvbits); + else if(planeCount == 2) + return StringFormat::Fmt("P0%02u", yuvbits); + else + return StringFormat::Fmt("YUV_%uPlane_%ubit", planeCount, yuvbits); + default: RDCERR("Unexpected YUV Subsampling amount %u", subsampling); + } + + return StringFormat::Fmt("YUV_%u_%uPlane_%ubit", subsampling, planeCount, yuvbits); + } case ResourceFormatType::PVRTC: return "PVRTC"; } } diff --git a/renderdoc/replay/replay_controller.cpp b/renderdoc/replay/replay_controller.cpp index ab5f0661c..a1a7a301d 100644 --- a/renderdoc/replay/replay_controller.cpp +++ b/renderdoc/replay/replay_controller.cpp @@ -865,7 +865,10 @@ bool ReplayController::SaveTexture(const TextureSave &saveData, const char *path case ResourceFormatType::R4G4B4A4: bytesPerPixel = 2; break; case ResourceFormatType::D32S8: bytesPerPixel = 8; break; case ResourceFormatType::D16S8: - case ResourceFormatType::YUV: + case ResourceFormatType::YUV8: + case ResourceFormatType::YUV10: + case ResourceFormatType::YUV12: + case ResourceFormatType::YUV16: case ResourceFormatType::R4G4: RDCERR("Unsupported file format %u", td.format.type); return false;