Browse Source
Merge pull request #1614 from ReinUsesLisp/surface-params
Merge pull request #1614 from ReinUsesLisp/surface-params
video_core: Move surface declarations out of gl_rasterizer_cachepull/15/merge
bunnei
7 years ago
committed by
GitHub
GitHub
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 954 additions and 898 deletions
-
2src/video_core/CMakeLists.txt
-
7src/video_core/renderer_opengl/gl_rasterizer.cpp
-
170src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
-
789src/video_core/renderer_opengl/gl_rasterizer_cache.h
-
499src/video_core/surface.cpp
-
385src/video_core/surface.h
@ -0,0 +1,499 @@ |
|||
// Copyright 2014 Citra Emulator Project
|
|||
// Licensed under GPLv2 or any later version
|
|||
// Refer to the license.txt file included.
|
|||
|
|||
#include "common/common_types.h"
|
|||
#include "common/math_util.h"
|
|||
#include "video_core/surface.h"
|
|||
|
|||
namespace VideoCore::Surface { |
|||
|
|||
SurfaceTarget SurfaceTargetFromTextureType(Tegra::Texture::TextureType texture_type) { |
|||
switch (texture_type) { |
|||
case Tegra::Texture::TextureType::Texture1D: |
|||
return SurfaceTarget::Texture1D; |
|||
case Tegra::Texture::TextureType::Texture2D: |
|||
case Tegra::Texture::TextureType::Texture2DNoMipmap: |
|||
return SurfaceTarget::Texture2D; |
|||
case Tegra::Texture::TextureType::Texture3D: |
|||
return SurfaceTarget::Texture3D; |
|||
case Tegra::Texture::TextureType::TextureCubemap: |
|||
return SurfaceTarget::TextureCubemap; |
|||
case Tegra::Texture::TextureType::Texture1DArray: |
|||
return SurfaceTarget::Texture1DArray; |
|||
case Tegra::Texture::TextureType::Texture2DArray: |
|||
return SurfaceTarget::Texture2DArray; |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented texture_type={}", static_cast<u32>(texture_type)); |
|||
UNREACHABLE(); |
|||
return SurfaceTarget::Texture2D; |
|||
} |
|||
} |
|||
|
|||
bool SurfaceTargetIsLayered(SurfaceTarget target) { |
|||
switch (target) { |
|||
case SurfaceTarget::Texture1D: |
|||
case SurfaceTarget::Texture2D: |
|||
case SurfaceTarget::Texture3D: |
|||
return false; |
|||
case SurfaceTarget::Texture1DArray: |
|||
case SurfaceTarget::Texture2DArray: |
|||
case SurfaceTarget::TextureCubemap: |
|||
return true; |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented surface_target={}", static_cast<u32>(target)); |
|||
UNREACHABLE(); |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format) { |
|||
switch (format) { |
|||
case Tegra::DepthFormat::S8_Z24_UNORM: |
|||
return PixelFormat::S8Z24; |
|||
case Tegra::DepthFormat::Z24_S8_UNORM: |
|||
return PixelFormat::Z24S8; |
|||
case Tegra::DepthFormat::Z32_FLOAT: |
|||
return PixelFormat::Z32F; |
|||
case Tegra::DepthFormat::Z16_UNORM: |
|||
return PixelFormat::Z16; |
|||
case Tegra::DepthFormat::Z32_S8_X24_FLOAT: |
|||
return PixelFormat::Z32FS8; |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format)); |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format) { |
|||
switch (format) { |
|||
// TODO (Hexagon12): Converting SRGBA to RGBA is a hack and doesn't completely correct the
|
|||
// gamma.
|
|||
case Tegra::RenderTargetFormat::RGBA8_SRGB: |
|||
return PixelFormat::RGBA8_SRGB; |
|||
case Tegra::RenderTargetFormat::RGBA8_UNORM: |
|||
return PixelFormat::ABGR8U; |
|||
case Tegra::RenderTargetFormat::RGBA8_SNORM: |
|||
return PixelFormat::ABGR8S; |
|||
case Tegra::RenderTargetFormat::RGBA8_UINT: |
|||
return PixelFormat::ABGR8UI; |
|||
case Tegra::RenderTargetFormat::BGRA8_SRGB: |
|||
return PixelFormat::BGRA8_SRGB; |
|||
case Tegra::RenderTargetFormat::BGRA8_UNORM: |
|||
return PixelFormat::BGRA8; |
|||
case Tegra::RenderTargetFormat::RGB10_A2_UNORM: |
|||
return PixelFormat::A2B10G10R10U; |
|||
case Tegra::RenderTargetFormat::RGBA16_FLOAT: |
|||
return PixelFormat::RGBA16F; |
|||
case Tegra::RenderTargetFormat::RGBA16_UNORM: |
|||
return PixelFormat::RGBA16U; |
|||
case Tegra::RenderTargetFormat::RGBA16_UINT: |
|||
return PixelFormat::RGBA16UI; |
|||
case Tegra::RenderTargetFormat::RGBA32_FLOAT: |
|||
return PixelFormat::RGBA32F; |
|||
case Tegra::RenderTargetFormat::RG32_FLOAT: |
|||
return PixelFormat::RG32F; |
|||
case Tegra::RenderTargetFormat::R11G11B10_FLOAT: |
|||
return PixelFormat::R11FG11FB10F; |
|||
case Tegra::RenderTargetFormat::B5G6R5_UNORM: |
|||
return PixelFormat::B5G6R5U; |
|||
case Tegra::RenderTargetFormat::BGR5A1_UNORM: |
|||
return PixelFormat::A1B5G5R5U; |
|||
case Tegra::RenderTargetFormat::RGBA32_UINT: |
|||
return PixelFormat::RGBA32UI; |
|||
case Tegra::RenderTargetFormat::R8_UNORM: |
|||
return PixelFormat::R8U; |
|||
case Tegra::RenderTargetFormat::R8_UINT: |
|||
return PixelFormat::R8UI; |
|||
case Tegra::RenderTargetFormat::RG16_FLOAT: |
|||
return PixelFormat::RG16F; |
|||
case Tegra::RenderTargetFormat::RG16_UINT: |
|||
return PixelFormat::RG16UI; |
|||
case Tegra::RenderTargetFormat::RG16_SINT: |
|||
return PixelFormat::RG16I; |
|||
case Tegra::RenderTargetFormat::RG16_UNORM: |
|||
return PixelFormat::RG16; |
|||
case Tegra::RenderTargetFormat::RG16_SNORM: |
|||
return PixelFormat::RG16S; |
|||
case Tegra::RenderTargetFormat::RG8_UNORM: |
|||
return PixelFormat::RG8U; |
|||
case Tegra::RenderTargetFormat::RG8_SNORM: |
|||
return PixelFormat::RG8S; |
|||
case Tegra::RenderTargetFormat::R16_FLOAT: |
|||
return PixelFormat::R16F; |
|||
case Tegra::RenderTargetFormat::R16_UNORM: |
|||
return PixelFormat::R16U; |
|||
case Tegra::RenderTargetFormat::R16_SNORM: |
|||
return PixelFormat::R16S; |
|||
case Tegra::RenderTargetFormat::R16_UINT: |
|||
return PixelFormat::R16UI; |
|||
case Tegra::RenderTargetFormat::R16_SINT: |
|||
return PixelFormat::R16I; |
|||
case Tegra::RenderTargetFormat::R32_FLOAT: |
|||
return PixelFormat::R32F; |
|||
case Tegra::RenderTargetFormat::R32_UINT: |
|||
return PixelFormat::R32UI; |
|||
case Tegra::RenderTargetFormat::RG32_UINT: |
|||
return PixelFormat::RG32UI; |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format)); |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format, |
|||
Tegra::Texture::ComponentType component_type, |
|||
bool is_srgb) { |
|||
// TODO(Subv): Properly implement this
|
|||
switch (format) { |
|||
case Tegra::Texture::TextureFormat::A8R8G8B8: |
|||
if (is_srgb) { |
|||
return PixelFormat::RGBA8_SRGB; |
|||
} |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::ABGR8U; |
|||
case Tegra::Texture::ComponentType::SNORM: |
|||
return PixelFormat::ABGR8S; |
|||
case Tegra::Texture::ComponentType::UINT: |
|||
return PixelFormat::ABGR8UI; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::B5G6R5: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::B5G6R5U; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::A2B10G10R10: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::A2B10G10R10U; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::A1B5G5R5: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::A1B5G5R5U; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::R8: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::R8U; |
|||
case Tegra::Texture::ComponentType::UINT: |
|||
return PixelFormat::R8UI; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::G8R8: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::G8R8U; |
|||
case Tegra::Texture::ComponentType::SNORM: |
|||
return PixelFormat::G8R8S; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::R16_G16_B16_A16: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::RGBA16U; |
|||
case Tegra::Texture::ComponentType::FLOAT: |
|||
return PixelFormat::RGBA16F; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::BF10GF11RF11: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::FLOAT: |
|||
return PixelFormat::R11FG11FB10F; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::R32_G32_B32_A32: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::FLOAT: |
|||
return PixelFormat::RGBA32F; |
|||
case Tegra::Texture::ComponentType::UINT: |
|||
return PixelFormat::RGBA32UI; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::R32_G32: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::FLOAT: |
|||
return PixelFormat::RG32F; |
|||
case Tegra::Texture::ComponentType::UINT: |
|||
return PixelFormat::RG32UI; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::R32_G32_B32: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::FLOAT: |
|||
return PixelFormat::RGB32F; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::R16: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::FLOAT: |
|||
return PixelFormat::R16F; |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::R16U; |
|||
case Tegra::Texture::ComponentType::SNORM: |
|||
return PixelFormat::R16S; |
|||
case Tegra::Texture::ComponentType::UINT: |
|||
return PixelFormat::R16UI; |
|||
case Tegra::Texture::ComponentType::SINT: |
|||
return PixelFormat::R16I; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::R32: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::FLOAT: |
|||
return PixelFormat::R32F; |
|||
case Tegra::Texture::ComponentType::UINT: |
|||
return PixelFormat::R32UI; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::ZF32: |
|||
return PixelFormat::Z32F; |
|||
case Tegra::Texture::TextureFormat::Z16: |
|||
return PixelFormat::Z16; |
|||
case Tegra::Texture::TextureFormat::Z24S8: |
|||
return PixelFormat::Z24S8; |
|||
case Tegra::Texture::TextureFormat::DXT1: |
|||
return is_srgb ? PixelFormat::DXT1_SRGB : PixelFormat::DXT1; |
|||
case Tegra::Texture::TextureFormat::DXT23: |
|||
return is_srgb ? PixelFormat::DXT23_SRGB : PixelFormat::DXT23; |
|||
case Tegra::Texture::TextureFormat::DXT45: |
|||
return is_srgb ? PixelFormat::DXT45_SRGB : PixelFormat::DXT45; |
|||
case Tegra::Texture::TextureFormat::DXN1: |
|||
return PixelFormat::DXN1; |
|||
case Tegra::Texture::TextureFormat::DXN2: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::DXN2UNORM; |
|||
case Tegra::Texture::ComponentType::SNORM: |
|||
return PixelFormat::DXN2SNORM; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
case Tegra::Texture::TextureFormat::BC7U: |
|||
return is_srgb ? PixelFormat::BC7U_SRGB : PixelFormat::BC7U; |
|||
case Tegra::Texture::TextureFormat::BC6H_UF16: |
|||
return PixelFormat::BC6H_UF16; |
|||
case Tegra::Texture::TextureFormat::BC6H_SF16: |
|||
return PixelFormat::BC6H_SF16; |
|||
case Tegra::Texture::TextureFormat::ASTC_2D_4X4: |
|||
return is_srgb ? PixelFormat::ASTC_2D_4X4_SRGB : PixelFormat::ASTC_2D_4X4; |
|||
case Tegra::Texture::TextureFormat::ASTC_2D_5X4: |
|||
return is_srgb ? PixelFormat::ASTC_2D_5X4_SRGB : PixelFormat::ASTC_2D_5X4; |
|||
case Tegra::Texture::TextureFormat::ASTC_2D_8X8: |
|||
return is_srgb ? PixelFormat::ASTC_2D_8X8_SRGB : PixelFormat::ASTC_2D_8X8; |
|||
case Tegra::Texture::TextureFormat::ASTC_2D_8X5: |
|||
return is_srgb ? PixelFormat::ASTC_2D_8X5_SRGB : PixelFormat::ASTC_2D_8X5; |
|||
case Tegra::Texture::TextureFormat::R16_G16: |
|||
switch (component_type) { |
|||
case Tegra::Texture::ComponentType::FLOAT: |
|||
return PixelFormat::RG16F; |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return PixelFormat::RG16; |
|||
case Tegra::Texture::ComponentType::SNORM: |
|||
return PixelFormat::RG16S; |
|||
case Tegra::Texture::ComponentType::UINT: |
|||
return PixelFormat::RG16UI; |
|||
case Tegra::Texture::ComponentType::SINT: |
|||
return PixelFormat::RG16I; |
|||
} |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component_type={}", static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented format={}, component_type={}", static_cast<u32>(format), |
|||
static_cast<u32>(component_type)); |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
ComponentType ComponentTypeFromTexture(Tegra::Texture::ComponentType type) { |
|||
// TODO(Subv): Implement more component types
|
|||
switch (type) { |
|||
case Tegra::Texture::ComponentType::UNORM: |
|||
return ComponentType::UNorm; |
|||
case Tegra::Texture::ComponentType::FLOAT: |
|||
return ComponentType::Float; |
|||
case Tegra::Texture::ComponentType::SNORM: |
|||
return ComponentType::SNorm; |
|||
case Tegra::Texture::ComponentType::UINT: |
|||
return ComponentType::UInt; |
|||
case Tegra::Texture::ComponentType::SINT: |
|||
return ComponentType::SInt; |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented component type={}", static_cast<u32>(type)); |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
ComponentType ComponentTypeFromRenderTarget(Tegra::RenderTargetFormat format) { |
|||
// TODO(Subv): Implement more render targets
|
|||
switch (format) { |
|||
case Tegra::RenderTargetFormat::RGBA8_UNORM: |
|||
case Tegra::RenderTargetFormat::RGBA8_SRGB: |
|||
case Tegra::RenderTargetFormat::BGRA8_UNORM: |
|||
case Tegra::RenderTargetFormat::BGRA8_SRGB: |
|||
case Tegra::RenderTargetFormat::RGB10_A2_UNORM: |
|||
case Tegra::RenderTargetFormat::R8_UNORM: |
|||
case Tegra::RenderTargetFormat::RG16_UNORM: |
|||
case Tegra::RenderTargetFormat::R16_UNORM: |
|||
case Tegra::RenderTargetFormat::B5G6R5_UNORM: |
|||
case Tegra::RenderTargetFormat::BGR5A1_UNORM: |
|||
case Tegra::RenderTargetFormat::RG8_UNORM: |
|||
case Tegra::RenderTargetFormat::RGBA16_UNORM: |
|||
return ComponentType::UNorm; |
|||
case Tegra::RenderTargetFormat::RGBA8_SNORM: |
|||
case Tegra::RenderTargetFormat::RG16_SNORM: |
|||
case Tegra::RenderTargetFormat::R16_SNORM: |
|||
case Tegra::RenderTargetFormat::RG8_SNORM: |
|||
return ComponentType::SNorm; |
|||
case Tegra::RenderTargetFormat::RGBA16_FLOAT: |
|||
case Tegra::RenderTargetFormat::R11G11B10_FLOAT: |
|||
case Tegra::RenderTargetFormat::RGBA32_FLOAT: |
|||
case Tegra::RenderTargetFormat::RG32_FLOAT: |
|||
case Tegra::RenderTargetFormat::RG16_FLOAT: |
|||
case Tegra::RenderTargetFormat::R16_FLOAT: |
|||
case Tegra::RenderTargetFormat::R32_FLOAT: |
|||
return ComponentType::Float; |
|||
case Tegra::RenderTargetFormat::RGBA32_UINT: |
|||
case Tegra::RenderTargetFormat::RGBA16_UINT: |
|||
case Tegra::RenderTargetFormat::RG16_UINT: |
|||
case Tegra::RenderTargetFormat::R8_UINT: |
|||
case Tegra::RenderTargetFormat::R16_UINT: |
|||
case Tegra::RenderTargetFormat::RG32_UINT: |
|||
case Tegra::RenderTargetFormat::R32_UINT: |
|||
case Tegra::RenderTargetFormat::RGBA8_UINT: |
|||
return ComponentType::UInt; |
|||
case Tegra::RenderTargetFormat::RG16_SINT: |
|||
case Tegra::RenderTargetFormat::R16_SINT: |
|||
return ComponentType::SInt; |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format)); |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format) { |
|||
switch (format) { |
|||
case Tegra::FramebufferConfig::PixelFormat::ABGR8: |
|||
return PixelFormat::ABGR8U; |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format)); |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
ComponentType ComponentTypeFromDepthFormat(Tegra::DepthFormat format) { |
|||
switch (format) { |
|||
case Tegra::DepthFormat::Z16_UNORM: |
|||
case Tegra::DepthFormat::S8_Z24_UNORM: |
|||
case Tegra::DepthFormat::Z24_S8_UNORM: |
|||
return ComponentType::UNorm; |
|||
case Tegra::DepthFormat::Z32_FLOAT: |
|||
case Tegra::DepthFormat::Z32_S8_X24_FLOAT: |
|||
return ComponentType::Float; |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unimplemented format={}", static_cast<u32>(format)); |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
SurfaceType GetFormatType(PixelFormat pixel_format) { |
|||
if (static_cast<std::size_t>(pixel_format) < |
|||
static_cast<std::size_t>(PixelFormat::MaxColorFormat)) { |
|||
return SurfaceType::ColorTexture; |
|||
} |
|||
|
|||
if (static_cast<std::size_t>(pixel_format) < |
|||
static_cast<std::size_t>(PixelFormat::MaxDepthFormat)) { |
|||
return SurfaceType::Depth; |
|||
} |
|||
|
|||
if (static_cast<std::size_t>(pixel_format) < |
|||
static_cast<std::size_t>(PixelFormat::MaxDepthStencilFormat)) { |
|||
return SurfaceType::DepthStencil; |
|||
} |
|||
|
|||
// TODO(Subv): Implement the other formats
|
|||
ASSERT(false); |
|||
|
|||
return SurfaceType::Invalid; |
|||
} |
|||
|
|||
bool IsPixelFormatASTC(PixelFormat format) { |
|||
switch (format) { |
|||
case PixelFormat::ASTC_2D_4X4: |
|||
case PixelFormat::ASTC_2D_5X4: |
|||
case PixelFormat::ASTC_2D_8X8: |
|||
case PixelFormat::ASTC_2D_8X5: |
|||
case PixelFormat::ASTC_2D_4X4_SRGB: |
|||
case PixelFormat::ASTC_2D_5X4_SRGB: |
|||
case PixelFormat::ASTC_2D_8X8_SRGB: |
|||
case PixelFormat::ASTC_2D_8X5_SRGB: |
|||
return true; |
|||
default: |
|||
return false; |
|||
} |
|||
} |
|||
|
|||
std::pair<u32, u32> GetASTCBlockSize(PixelFormat format) { |
|||
switch (format) { |
|||
case PixelFormat::ASTC_2D_4X4: |
|||
return {4, 4}; |
|||
case PixelFormat::ASTC_2D_5X4: |
|||
return {5, 4}; |
|||
case PixelFormat::ASTC_2D_8X8: |
|||
return {8, 8}; |
|||
case PixelFormat::ASTC_2D_8X5: |
|||
return {8, 5}; |
|||
case PixelFormat::ASTC_2D_4X4_SRGB: |
|||
return {4, 4}; |
|||
case PixelFormat::ASTC_2D_5X4_SRGB: |
|||
return {5, 4}; |
|||
case PixelFormat::ASTC_2D_8X8_SRGB: |
|||
return {8, 8}; |
|||
case PixelFormat::ASTC_2D_8X5_SRGB: |
|||
return {8, 5}; |
|||
default: |
|||
LOG_CRITICAL(HW_GPU, "Unhandled format: {}", static_cast<u32>(format)); |
|||
UNREACHABLE(); |
|||
} |
|||
} |
|||
|
|||
bool IsFormatBCn(PixelFormat format) { |
|||
switch (format) { |
|||
case PixelFormat::DXT1: |
|||
case PixelFormat::DXT23: |
|||
case PixelFormat::DXT45: |
|||
case PixelFormat::DXN1: |
|||
case PixelFormat::DXN2SNORM: |
|||
case PixelFormat::DXN2UNORM: |
|||
case PixelFormat::BC7U: |
|||
case PixelFormat::BC6H_UF16: |
|||
case PixelFormat::BC6H_SF16: |
|||
case PixelFormat::DXT1_SRGB: |
|||
case PixelFormat::DXT23_SRGB: |
|||
case PixelFormat::DXT45_SRGB: |
|||
case PixelFormat::BC7U_SRGB: |
|||
return true; |
|||
} |
|||
return false; |
|||
} |
|||
|
|||
} // namespace VideoCore::Surface
|
|||
@ -0,0 +1,385 @@ |
|||
// Copyright 2014 Citra Emulator Project |
|||
// Licensed under GPLv2 or any later version |
|||
// Refer to the license.txt file included. |
|||
|
|||
#pragma once |
|||
|
|||
#include <climits> |
|||
#include <utility> |
|||
#include "common/assert.h" |
|||
#include "common/common_types.h" |
|||
#include "common/logging/log.h" |
|||
#include "video_core/gpu.h" |
|||
#include "video_core/textures/texture.h" |
|||
|
|||
namespace VideoCore::Surface { |
|||
|
|||
enum class PixelFormat { |
|||
ABGR8U = 0, |
|||
ABGR8S = 1, |
|||
ABGR8UI = 2, |
|||
B5G6R5U = 3, |
|||
A2B10G10R10U = 4, |
|||
A1B5G5R5U = 5, |
|||
R8U = 6, |
|||
R8UI = 7, |
|||
RGBA16F = 8, |
|||
RGBA16U = 9, |
|||
RGBA16UI = 10, |
|||
R11FG11FB10F = 11, |
|||
RGBA32UI = 12, |
|||
DXT1 = 13, |
|||
DXT23 = 14, |
|||
DXT45 = 15, |
|||
DXN1 = 16, // This is also known as BC4 |
|||
DXN2UNORM = 17, |
|||
DXN2SNORM = 18, |
|||
BC7U = 19, |
|||
BC6H_UF16 = 20, |
|||
BC6H_SF16 = 21, |
|||
ASTC_2D_4X4 = 22, |
|||
G8R8U = 23, |
|||
G8R8S = 24, |
|||
BGRA8 = 25, |
|||
RGBA32F = 26, |
|||
RG32F = 27, |
|||
R32F = 28, |
|||
R16F = 29, |
|||
R16U = 30, |
|||
R16S = 31, |
|||
R16UI = 32, |
|||
R16I = 33, |
|||
RG16 = 34, |
|||
RG16F = 35, |
|||
RG16UI = 36, |
|||
RG16I = 37, |
|||
RG16S = 38, |
|||
RGB32F = 39, |
|||
RGBA8_SRGB = 40, |
|||
RG8U = 41, |
|||
RG8S = 42, |
|||
RG32UI = 43, |
|||
R32UI = 44, |
|||
ASTC_2D_8X8 = 45, |
|||
ASTC_2D_8X5 = 46, |
|||
ASTC_2D_5X4 = 47, |
|||
BGRA8_SRGB = 48, |
|||
DXT1_SRGB = 49, |
|||
DXT23_SRGB = 50, |
|||
DXT45_SRGB = 51, |
|||
BC7U_SRGB = 52, |
|||
ASTC_2D_4X4_SRGB = 53, |
|||
ASTC_2D_8X8_SRGB = 54, |
|||
ASTC_2D_8X5_SRGB = 55, |
|||
ASTC_2D_5X4_SRGB = 56, |
|||
|
|||
MaxColorFormat, |
|||
|
|||
// Depth formats |
|||
Z32F = 57, |
|||
Z16 = 58, |
|||
|
|||
MaxDepthFormat, |
|||
|
|||
// DepthStencil formats |
|||
Z24S8 = 59, |
|||
S8Z24 = 60, |
|||
Z32FS8 = 61, |
|||
|
|||
MaxDepthStencilFormat, |
|||
|
|||
Max = MaxDepthStencilFormat, |
|||
Invalid = 255, |
|||
}; |
|||
|
|||
static constexpr std::size_t MaxPixelFormat = static_cast<std::size_t>(PixelFormat::Max); |
|||
|
|||
enum class ComponentType { |
|||
Invalid = 0, |
|||
SNorm = 1, |
|||
UNorm = 2, |
|||
SInt = 3, |
|||
UInt = 4, |
|||
Float = 5, |
|||
}; |
|||
|
|||
enum class SurfaceType { |
|||
ColorTexture = 0, |
|||
Depth = 1, |
|||
DepthStencil = 2, |
|||
Fill = 3, |
|||
Invalid = 4, |
|||
}; |
|||
|
|||
enum class SurfaceTarget { |
|||
Texture1D, |
|||
Texture2D, |
|||
Texture3D, |
|||
Texture1DArray, |
|||
Texture2DArray, |
|||
TextureCubemap, |
|||
}; |
|||
|
|||
/** |
|||
* Gets the compression factor for the specified PixelFormat. This applies to just the |
|||
* "compressed width" and "compressed height", not the overall compression factor of a |
|||
* compressed image. This is used for maintaining proper surface sizes for compressed |
|||
* texture formats. |
|||
*/ |
|||
static constexpr u32 GetCompressionFactor(PixelFormat format) { |
|||
if (format == PixelFormat::Invalid) |
|||
return 0; |
|||
|
|||
constexpr std::array<u32, MaxPixelFormat> compression_factor_table = {{ |
|||
1, // ABGR8U |
|||
1, // ABGR8S |
|||
1, // ABGR8UI |
|||
1, // B5G6R5U |
|||
1, // A2B10G10R10U |
|||
1, // A1B5G5R5U |
|||
1, // R8U |
|||
1, // R8UI |
|||
1, // RGBA16F |
|||
1, // RGBA16U |
|||
1, // RGBA16UI |
|||
1, // R11FG11FB10F |
|||
1, // RGBA32UI |
|||
4, // DXT1 |
|||
4, // DXT23 |
|||
4, // DXT45 |
|||
4, // DXN1 |
|||
4, // DXN2UNORM |
|||
4, // DXN2SNORM |
|||
4, // BC7U |
|||
4, // BC6H_UF16 |
|||
4, // BC6H_SF16 |
|||
4, // ASTC_2D_4X4 |
|||
1, // G8R8U |
|||
1, // G8R8S |
|||
1, // BGRA8 |
|||
1, // RGBA32F |
|||
1, // RG32F |
|||
1, // R32F |
|||
1, // R16F |
|||
1, // R16U |
|||
1, // R16S |
|||
1, // R16UI |
|||
1, // R16I |
|||
1, // RG16 |
|||
1, // RG16F |
|||
1, // RG16UI |
|||
1, // RG16I |
|||
1, // RG16S |
|||
1, // RGB32F |
|||
1, // RGBA8_SRGB |
|||
1, // RG8U |
|||
1, // RG8S |
|||
1, // RG32UI |
|||
1, // R32UI |
|||
4, // ASTC_2D_8X8 |
|||
4, // ASTC_2D_8X5 |
|||
4, // ASTC_2D_5X4 |
|||
1, // BGRA8_SRGB |
|||
4, // DXT1_SRGB |
|||
4, // DXT23_SRGB |
|||
4, // DXT45_SRGB |
|||
4, // BC7U_SRGB |
|||
4, // ASTC_2D_4X4_SRGB |
|||
4, // ASTC_2D_8X8_SRGB |
|||
4, // ASTC_2D_8X5_SRGB |
|||
4, // ASTC_2D_5X4_SRGB |
|||
1, // Z32F |
|||
1, // Z16 |
|||
1, // Z24S8 |
|||
1, // S8Z24 |
|||
1, // Z32FS8 |
|||
}}; |
|||
|
|||
ASSERT(static_cast<std::size_t>(format) < compression_factor_table.size()); |
|||
return compression_factor_table[static_cast<std::size_t>(format)]; |
|||
} |
|||
|
|||
static constexpr u32 GetDefaultBlockHeight(PixelFormat format) { |
|||
if (format == PixelFormat::Invalid) |
|||
return 0; |
|||
|
|||
constexpr std::array<u32, MaxPixelFormat> block_height_table = {{ |
|||
1, // ABGR8U |
|||
1, // ABGR8S |
|||
1, // ABGR8UI |
|||
1, // B5G6R5U |
|||
1, // A2B10G10R10U |
|||
1, // A1B5G5R5U |
|||
1, // R8U |
|||
1, // R8UI |
|||
1, // RGBA16F |
|||
1, // RGBA16U |
|||
1, // RGBA16UI |
|||
1, // R11FG11FB10F |
|||
1, // RGBA32UI |
|||
4, // DXT1 |
|||
4, // DXT23 |
|||
4, // DXT45 |
|||
4, // DXN1 |
|||
4, // DXN2UNORM |
|||
4, // DXN2SNORM |
|||
4, // BC7U |
|||
4, // BC6H_UF16 |
|||
4, // BC6H_SF16 |
|||
4, // ASTC_2D_4X4 |
|||
1, // G8R8U |
|||
1, // G8R8S |
|||
1, // BGRA8 |
|||
1, // RGBA32F |
|||
1, // RG32F |
|||
1, // R32F |
|||
1, // R16F |
|||
1, // R16U |
|||
1, // R16S |
|||
1, // R16UI |
|||
1, // R16I |
|||
1, // RG16 |
|||
1, // RG16F |
|||
1, // RG16UI |
|||
1, // RG16I |
|||
1, // RG16S |
|||
1, // RGB32F |
|||
1, // RGBA8_SRGB |
|||
1, // RG8U |
|||
1, // RG8S |
|||
1, // RG32UI |
|||
1, // R32UI |
|||
8, // ASTC_2D_8X8 |
|||
5, // ASTC_2D_8X5 |
|||
4, // ASTC_2D_5X4 |
|||
1, // BGRA8_SRGB |
|||
4, // DXT1_SRGB |
|||
4, // DXT23_SRGB |
|||
4, // DXT45_SRGB |
|||
4, // BC7U_SRGB |
|||
4, // ASTC_2D_4X4_SRGB |
|||
8, // ASTC_2D_8X8_SRGB |
|||
5, // ASTC_2D_8X5_SRGB |
|||
4, // ASTC_2D_5X4_SRGB |
|||
1, // Z32F |
|||
1, // Z16 |
|||
1, // Z24S8 |
|||
1, // S8Z24 |
|||
1, // Z32FS8 |
|||
}}; |
|||
|
|||
ASSERT(static_cast<std::size_t>(format) < block_height_table.size()); |
|||
return block_height_table[static_cast<std::size_t>(format)]; |
|||
} |
|||
|
|||
static constexpr u32 GetFormatBpp(PixelFormat format) { |
|||
if (format == PixelFormat::Invalid) |
|||
return 0; |
|||
|
|||
constexpr std::array<u32, MaxPixelFormat> bpp_table = {{ |
|||
32, // ABGR8U |
|||
32, // ABGR8S |
|||
32, // ABGR8UI |
|||
16, // B5G6R5U |
|||
32, // A2B10G10R10U |
|||
16, // A1B5G5R5U |
|||
8, // R8U |
|||
8, // R8UI |
|||
64, // RGBA16F |
|||
64, // RGBA16U |
|||
64, // RGBA16UI |
|||
32, // R11FG11FB10F |
|||
128, // RGBA32UI |
|||
64, // DXT1 |
|||
128, // DXT23 |
|||
128, // DXT45 |
|||
64, // DXN1 |
|||
128, // DXN2UNORM |
|||
128, // DXN2SNORM |
|||
128, // BC7U |
|||
128, // BC6H_UF16 |
|||
128, // BC6H_SF16 |
|||
32, // ASTC_2D_4X4 |
|||
16, // G8R8U |
|||
16, // G8R8S |
|||
32, // BGRA8 |
|||
128, // RGBA32F |
|||
64, // RG32F |
|||
32, // R32F |
|||
16, // R16F |
|||
16, // R16U |
|||
16, // R16S |
|||
16, // R16UI |
|||
16, // R16I |
|||
32, // RG16 |
|||
32, // RG16F |
|||
32, // RG16UI |
|||
32, // RG16I |
|||
32, // RG16S |
|||
96, // RGB32F |
|||
32, // RGBA8_SRGB |
|||
16, // RG8U |
|||
16, // RG8S |
|||
64, // RG32UI |
|||
32, // R32UI |
|||
16, // ASTC_2D_8X8 |
|||
16, // ASTC_2D_8X5 |
|||
32, // ASTC_2D_5X4 |
|||
32, // BGRA8_SRGB |
|||
64, // DXT1_SRGB |
|||
128, // DXT23_SRGB |
|||
128, // DXT45_SRGB |
|||
128, // BC7U |
|||
32, // ASTC_2D_4X4_SRGB |
|||
16, // ASTC_2D_8X8_SRGB |
|||
16, // ASTC_2D_8X5_SRGB |
|||
32, // ASTC_2D_5X4_SRGB |
|||
32, // Z32F |
|||
16, // Z16 |
|||
32, // Z24S8 |
|||
32, // S8Z24 |
|||
64, // Z32FS8 |
|||
}}; |
|||
|
|||
ASSERT(static_cast<std::size_t>(format) < bpp_table.size()); |
|||
return bpp_table[static_cast<std::size_t>(format)]; |
|||
} |
|||
|
|||
/// Returns the sizer in bytes of the specified pixel format |
|||
static constexpr u32 GetBytesPerPixel(PixelFormat pixel_format) { |
|||
if (pixel_format == PixelFormat::Invalid) { |
|||
return 0; |
|||
} |
|||
return GetFormatBpp(pixel_format) / CHAR_BIT; |
|||
} |
|||
|
|||
SurfaceTarget SurfaceTargetFromTextureType(Tegra::Texture::TextureType texture_type); |
|||
|
|||
bool SurfaceTargetIsLayered(SurfaceTarget target); |
|||
|
|||
PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format); |
|||
|
|||
PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format); |
|||
|
|||
PixelFormat PixelFormatFromTextureFormat(Tegra::Texture::TextureFormat format, |
|||
Tegra::Texture::ComponentType component_type, |
|||
bool is_srgb); |
|||
|
|||
ComponentType ComponentTypeFromTexture(Tegra::Texture::ComponentType type); |
|||
|
|||
ComponentType ComponentTypeFromRenderTarget(Tegra::RenderTargetFormat format); |
|||
|
|||
PixelFormat PixelFormatFromGPUPixelFormat(Tegra::FramebufferConfig::PixelFormat format); |
|||
|
|||
ComponentType ComponentTypeFromDepthFormat(Tegra::DepthFormat format); |
|||
|
|||
SurfaceType GetFormatType(PixelFormat pixel_format); |
|||
|
|||
bool IsPixelFormatASTC(PixelFormat format); |
|||
|
|||
std::pair<u32, u32> GetASTCBlockSize(PixelFormat format); |
|||
|
|||
/// Returns true if the specified PixelFormat is a BCn format, e.g. DXT or DXN |
|||
bool IsFormatBCn(PixelFormat format); |
|||
|
|||
} // namespace VideoCore::Surface |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue