forked from suyu/suyu
513 lines
24 KiB
C++
513 lines
24 KiB
C++
// Copyright 2019 yuzu Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include "common/assert.h"
|
|
#include "common/common_types.h"
|
|
#include "common/microprofile.h"
|
|
#include "common/scope_exit.h"
|
|
#include "core/core.h"
|
|
#include "video_core/morton.h"
|
|
#include "video_core/renderer_opengl/gl_resource_manager.h"
|
|
#include "video_core/renderer_opengl/gl_state.h"
|
|
#include "video_core/renderer_opengl/gl_texture_cache.h"
|
|
#include "video_core/renderer_opengl/utils.h"
|
|
#include "video_core/texture_cache/texture_cache.h"
|
|
#include "video_core/textures/convert.h"
|
|
#include "video_core/textures/texture.h"
|
|
|
|
namespace OpenGL {
|
|
|
|
using Tegra::Texture::SwizzleSource;
|
|
using VideoCore::MortonSwizzleMode;
|
|
|
|
using VideoCore::Surface::ComponentType;
|
|
using VideoCore::Surface::PixelFormat;
|
|
using VideoCore::Surface::SurfaceTarget;
|
|
using VideoCore::Surface::SurfaceType;
|
|
|
|
MICROPROFILE_DEFINE(OpenGL_Texture_Upload, "OpenGL", "Texture Upload", MP_RGB(128, 192, 128));
|
|
MICROPROFILE_DEFINE(OpenGL_Texture_Download, "OpenGL", "Texture Download", MP_RGB(128, 192, 128));
|
|
|
|
namespace {
|
|
|
|
struct FormatTuple {
|
|
GLint internal_format;
|
|
GLenum format;
|
|
GLenum type;
|
|
ComponentType component_type;
|
|
bool compressed;
|
|
};
|
|
|
|
constexpr std::array<FormatTuple, VideoCore::Surface::MaxPixelFormat> tex_format_tuples = {{
|
|
{GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // ABGR8U
|
|
{GL_RGBA8, GL_RGBA, GL_BYTE, ComponentType::SNorm, false}, // ABGR8S
|
|
{GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE, ComponentType::UInt, false}, // ABGR8UI
|
|
{GL_RGB565, GL_RGB, GL_UNSIGNED_SHORT_5_6_5_REV, ComponentType::UNorm, false}, // B5G6R5U
|
|
{GL_RGB10_A2, GL_RGBA, GL_UNSIGNED_INT_2_10_10_10_REV, ComponentType::UNorm,
|
|
false}, // A2B10G10R10U
|
|
{GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_1_5_5_5_REV, ComponentType::UNorm, false}, // A1B5G5R5U
|
|
{GL_R8, GL_RED, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // R8U
|
|
{GL_R8UI, GL_RED_INTEGER, GL_UNSIGNED_BYTE, ComponentType::UInt, false}, // R8UI
|
|
{GL_RGBA16F, GL_RGBA, GL_HALF_FLOAT, ComponentType::Float, false}, // RGBA16F
|
|
{GL_RGBA16, GL_RGBA, GL_UNSIGNED_SHORT, ComponentType::UNorm, false}, // RGBA16U
|
|
{GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, ComponentType::UInt, false}, // RGBA16UI
|
|
{GL_R11F_G11F_B10F, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV, ComponentType::Float,
|
|
false}, // R11FG11FB10F
|
|
{GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false}, // RGBA32UI
|
|
{GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
|
|
true}, // DXT1
|
|
{GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
|
|
true}, // DXT23
|
|
{GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
|
|
true}, // DXT45
|
|
{GL_COMPRESSED_RED_RGTC1, GL_RED, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm, true}, // DXN1
|
|
{GL_COMPRESSED_RG_RGTC2, GL_RG, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
|
|
true}, // DXN2UNORM
|
|
{GL_COMPRESSED_SIGNED_RG_RGTC2, GL_RG, GL_INT, ComponentType::SNorm, true}, // DXN2SNORM
|
|
{GL_COMPRESSED_RGBA_BPTC_UNORM, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
|
|
true}, // BC7U
|
|
{GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::Float,
|
|
true}, // BC6H_UF16
|
|
{GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, GL_RGB, GL_UNSIGNED_INT_8_8_8_8, ComponentType::Float,
|
|
true}, // BC6H_SF16
|
|
{GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4
|
|
{GL_RGBA8, GL_BGRA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // BGRA8
|
|
{GL_RGBA32F, GL_RGBA, GL_FLOAT, ComponentType::Float, false}, // RGBA32F
|
|
{GL_RG32F, GL_RG, GL_FLOAT, ComponentType::Float, false}, // RG32F
|
|
{GL_R32F, GL_RED, GL_FLOAT, ComponentType::Float, false}, // R32F
|
|
{GL_R16F, GL_RED, GL_HALF_FLOAT, ComponentType::Float, false}, // R16F
|
|
{GL_R16, GL_RED, GL_UNSIGNED_SHORT, ComponentType::UNorm, false}, // R16U
|
|
{GL_R16_SNORM, GL_RED, GL_SHORT, ComponentType::SNorm, false}, // R16S
|
|
{GL_R16UI, GL_RED_INTEGER, GL_UNSIGNED_SHORT, ComponentType::UInt, false}, // R16UI
|
|
{GL_R16I, GL_RED_INTEGER, GL_SHORT, ComponentType::SInt, false}, // R16I
|
|
{GL_RG16, GL_RG, GL_UNSIGNED_SHORT, ComponentType::UNorm, false}, // RG16
|
|
{GL_RG16F, GL_RG, GL_HALF_FLOAT, ComponentType::Float, false}, // RG16F
|
|
{GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT, ComponentType::UInt, false}, // RG16UI
|
|
{GL_RG16I, GL_RG_INTEGER, GL_SHORT, ComponentType::SInt, false}, // RG16I
|
|
{GL_RG16_SNORM, GL_RG, GL_SHORT, ComponentType::SNorm, false}, // RG16S
|
|
{GL_RGB32F, GL_RGB, GL_FLOAT, ComponentType::Float, false}, // RGB32F
|
|
{GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm,
|
|
false}, // RGBA8_SRGB
|
|
{GL_RG8, GL_RG, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // RG8U
|
|
{GL_RG8, GL_RG, GL_BYTE, ComponentType::SNorm, false}, // RG8S
|
|
{GL_RG32UI, GL_RG_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false}, // RG32UI
|
|
{GL_R32UI, GL_RED_INTEGER, GL_UNSIGNED_INT, ComponentType::UInt, false}, // R32UI
|
|
{GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X8
|
|
{GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X5
|
|
{GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X4
|
|
{GL_SRGB8_ALPHA8, GL_BGRA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // BGRA8
|
|
// Compressed sRGB formats
|
|
{GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
|
|
true}, // DXT1_SRGB
|
|
{GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
|
|
true}, // DXT23_SRGB
|
|
{GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
|
|
true}, // DXT45_SRGB
|
|
{GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, ComponentType::UNorm,
|
|
true}, // BC7U_SRGB
|
|
{GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_4X4_SRGB
|
|
{GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X8_SRGB
|
|
{GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_8X5_SRGB
|
|
{GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X4_SRGB
|
|
{GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X5
|
|
{GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_5X5_SRGB
|
|
{GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_10X8
|
|
{GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, ComponentType::UNorm, false}, // ASTC_2D_10X8_SRGB
|
|
|
|
// Depth formats
|
|
{GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT, ComponentType::Float, false}, // Z32F
|
|
{GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, ComponentType::UNorm,
|
|
false}, // Z16
|
|
|
|
// DepthStencil formats
|
|
{GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
|
|
false}, // Z24S8
|
|
{GL_DEPTH24_STENCIL8, GL_DEPTH_STENCIL, GL_UNSIGNED_INT_24_8, ComponentType::UNorm,
|
|
false}, // S8Z24
|
|
{GL_DEPTH32F_STENCIL8, GL_DEPTH_STENCIL, GL_FLOAT_32_UNSIGNED_INT_24_8_REV,
|
|
ComponentType::Float, false}, // Z32FS8
|
|
}};
|
|
|
|
const FormatTuple& GetFormatTuple(PixelFormat pixel_format, ComponentType component_type) {
|
|
ASSERT(static_cast<std::size_t>(pixel_format) < tex_format_tuples.size());
|
|
const auto& format{tex_format_tuples[static_cast<std::size_t>(pixel_format)]};
|
|
ASSERT(component_type == format.component_type);
|
|
return format;
|
|
}
|
|
|
|
GLenum GetTextureTarget(const SurfaceTarget& target) {
|
|
switch (target) {
|
|
case SurfaceTarget::Texture1D:
|
|
return GL_TEXTURE_1D;
|
|
case SurfaceTarget::Texture2D:
|
|
return GL_TEXTURE_2D;
|
|
case SurfaceTarget::Texture3D:
|
|
return GL_TEXTURE_3D;
|
|
case SurfaceTarget::Texture1DArray:
|
|
return GL_TEXTURE_1D_ARRAY;
|
|
case SurfaceTarget::Texture2DArray:
|
|
return GL_TEXTURE_2D_ARRAY;
|
|
case SurfaceTarget::TextureCubemap:
|
|
return GL_TEXTURE_CUBE_MAP;
|
|
case SurfaceTarget::TextureCubeArray:
|
|
return GL_TEXTURE_CUBE_MAP_ARRAY;
|
|
}
|
|
UNREACHABLE();
|
|
return {};
|
|
}
|
|
|
|
GLint GetSwizzleSource(SwizzleSource source) {
|
|
switch (source) {
|
|
case SwizzleSource::Zero:
|
|
return GL_ZERO;
|
|
case SwizzleSource::R:
|
|
return GL_RED;
|
|
case SwizzleSource::G:
|
|
return GL_GREEN;
|
|
case SwizzleSource::B:
|
|
return GL_BLUE;
|
|
case SwizzleSource::A:
|
|
return GL_ALPHA;
|
|
case SwizzleSource::OneInt:
|
|
case SwizzleSource::OneFloat:
|
|
return GL_ONE;
|
|
}
|
|
UNREACHABLE();
|
|
return GL_NONE;
|
|
}
|
|
|
|
void ApplyTextureDefaults(const SurfaceParams& params, GLuint texture) {
|
|
glTextureParameteri(texture, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTextureParameteri(texture, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glTextureParameteri(texture, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
|
glTextureParameteri(texture, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
|
glTextureParameteri(texture, GL_TEXTURE_MAX_LEVEL, params.num_levels - 1);
|
|
if (params.num_levels == 1) {
|
|
glTextureParameterf(texture, GL_TEXTURE_LOD_BIAS, 1000.0f);
|
|
}
|
|
}
|
|
|
|
OGLTexture CreateTexture(const SurfaceParams& params, GLenum target, GLenum internal_format) {
|
|
OGLTexture texture;
|
|
texture.Create(target);
|
|
|
|
switch (params.target) {
|
|
case SurfaceTarget::Texture1D:
|
|
glTextureStorage1D(texture.handle, params.num_levels, internal_format, params.width);
|
|
break;
|
|
case SurfaceTarget::Texture2D:
|
|
case SurfaceTarget::TextureCubemap:
|
|
glTextureStorage2D(texture.handle, params.num_levels, internal_format, params.width,
|
|
params.height);
|
|
break;
|
|
case SurfaceTarget::Texture3D:
|
|
case SurfaceTarget::Texture2DArray:
|
|
case SurfaceTarget::TextureCubeArray:
|
|
glTextureStorage3D(texture.handle, params.num_levels, internal_format, params.width,
|
|
params.height, params.depth);
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
|
|
ApplyTextureDefaults(params, texture.handle);
|
|
|
|
return texture;
|
|
}
|
|
|
|
} // Anonymous namespace
|
|
|
|
CachedSurface::CachedSurface(const GPUVAddr gpu_addr, const SurfaceParams& params)
|
|
: VideoCommon::SurfaceBase<View>(gpu_addr, params) {
|
|
const auto& tuple{GetFormatTuple(params.pixel_format, params.component_type)};
|
|
internal_format = tuple.internal_format;
|
|
format = tuple.format;
|
|
type = tuple.type;
|
|
is_compressed = tuple.compressed;
|
|
target = GetTextureTarget(params.target);
|
|
texture = CreateTexture(params, target, internal_format);
|
|
DecorateSurfaceName();
|
|
main_view = CreateView(
|
|
ViewParams(params.target, 0, params.is_layered ? params.depth : 1, 0, params.num_levels));
|
|
main_view->DecorateViewName(gpu_addr,
|
|
params.TargetName() + "V:" + std::to_string(view_count++));
|
|
}
|
|
|
|
CachedSurface::~CachedSurface() {
|
|
views.clear();
|
|
main_view = nullptr;
|
|
}
|
|
|
|
void CachedSurface::DownloadTexture(std::vector<u8>& staging_buffer) {
|
|
MICROPROFILE_SCOPE(OpenGL_Texture_Download);
|
|
|
|
// TODO(Rodrigo): Optimize alignment
|
|
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
|
SCOPE_EXIT({ glPixelStorei(GL_PACK_ROW_LENGTH, 0); });
|
|
|
|
for (u32 level = 0; level < params.num_levels; ++level) {
|
|
glPixelStorei(GL_PACK_ROW_LENGTH, static_cast<GLint>(params.GetMipWidth(level)));
|
|
const std::size_t mip_offset = params.GetHostMipmapLevelOffset(level);
|
|
if (is_compressed) {
|
|
glGetCompressedTextureImage(texture.handle, level,
|
|
static_cast<GLsizei>(params.GetHostMipmapSize(level)),
|
|
staging_buffer.data() + mip_offset);
|
|
} else {
|
|
glGetTextureImage(texture.handle, level, format, type,
|
|
static_cast<GLsizei>(params.GetHostMipmapSize(level)),
|
|
staging_buffer.data() + mip_offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CachedSurface::UploadTexture(std::vector<u8>& staging_buffer) {
|
|
MICROPROFILE_SCOPE(OpenGL_Texture_Upload);
|
|
SCOPE_EXIT({ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); });
|
|
for (u32 level = 0; level < params.num_levels; ++level) {
|
|
UploadTextureMipmap(level, staging_buffer);
|
|
}
|
|
}
|
|
|
|
void CachedSurface::UploadTextureMipmap(u32 level, std::vector<u8>& staging_buffer) {
|
|
// TODO(Rodrigo): Optimize alignment
|
|
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, static_cast<GLint>(params.GetMipWidth(level)));
|
|
|
|
const std::size_t mip_offset = params.GetHostMipmapLevelOffset(level);
|
|
u8* buffer{staging_buffer.data() + mip_offset};
|
|
if (is_compressed) {
|
|
const auto image_size{static_cast<GLsizei>(params.GetHostMipmapSize(level))};
|
|
switch (params.target) {
|
|
case SurfaceTarget::Texture2D:
|
|
glCompressedTextureSubImage2D(texture.handle, level, 0, 0,
|
|
static_cast<GLsizei>(params.GetMipWidth(level)),
|
|
static_cast<GLsizei>(params.GetMipHeight(level)),
|
|
internal_format, image_size, buffer);
|
|
break;
|
|
case SurfaceTarget::Texture3D:
|
|
case SurfaceTarget::Texture2DArray:
|
|
case SurfaceTarget::TextureCubeArray:
|
|
glCompressedTextureSubImage3D(texture.handle, level, 0, 0, 0,
|
|
static_cast<GLsizei>(params.GetMipWidth(level)),
|
|
static_cast<GLsizei>(params.GetMipHeight(level)),
|
|
static_cast<GLsizei>(params.GetMipDepth(level)),
|
|
internal_format, image_size, buffer);
|
|
break;
|
|
case SurfaceTarget::TextureCubemap: {
|
|
const std::size_t layer_size{params.GetHostLayerSize(level)};
|
|
for (std::size_t face = 0; face < params.depth; ++face) {
|
|
glCompressedTextureSubImage3D(texture.handle, level, 0, 0, static_cast<GLint>(face),
|
|
static_cast<GLsizei>(params.GetMipWidth(level)),
|
|
static_cast<GLsizei>(params.GetMipHeight(level)), 1,
|
|
internal_format, static_cast<GLsizei>(layer_size),
|
|
buffer);
|
|
buffer += layer_size;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
} else {
|
|
switch (params.target) {
|
|
case SurfaceTarget::Texture1D:
|
|
glTextureSubImage1D(texture.handle, level, 0, params.GetMipWidth(level), format, type,
|
|
buffer);
|
|
break;
|
|
case SurfaceTarget::Texture1DArray:
|
|
case SurfaceTarget::Texture2D:
|
|
glTextureSubImage2D(texture.handle, level, 0, 0, params.GetMipWidth(level),
|
|
params.GetMipHeight(level), format, type, buffer);
|
|
break;
|
|
case SurfaceTarget::Texture3D:
|
|
case SurfaceTarget::Texture2DArray:
|
|
case SurfaceTarget::TextureCubeArray:
|
|
glTextureSubImage3D(
|
|
texture.handle, level, 0, 0, 0, static_cast<GLsizei>(params.GetMipWidth(level)),
|
|
static_cast<GLsizei>(params.GetMipHeight(level)),
|
|
static_cast<GLsizei>(params.GetMipDepth(level)), format, type, buffer);
|
|
break;
|
|
case SurfaceTarget::TextureCubemap:
|
|
for (std::size_t face = 0; face < params.depth; ++face) {
|
|
glTextureSubImage3D(texture.handle, level, 0, 0, static_cast<GLint>(face),
|
|
params.GetMipWidth(level), params.GetMipHeight(level), 1,
|
|
format, type, buffer);
|
|
buffer += params.GetHostLayerSize(level);
|
|
}
|
|
break;
|
|
default:
|
|
UNREACHABLE();
|
|
}
|
|
}
|
|
}
|
|
|
|
void CachedSurface::DecorateSurfaceName() {
|
|
LabelGLObject(GL_TEXTURE, texture.handle, GetGpuAddr(), params.TargetName());
|
|
}
|
|
|
|
void CachedSurfaceView::DecorateViewName(GPUVAddr gpu_addr, std::string prefix) {
|
|
LabelGLObject(GL_TEXTURE, texture_view.handle, gpu_addr, prefix);
|
|
}
|
|
|
|
View CachedSurface::CreateView(const ViewParams& view_key) {
|
|
auto view = std::make_shared<CachedSurfaceView>(*this, view_key);
|
|
views[view_key] = view;
|
|
view->DecorateViewName(gpu_addr, params.TargetName() + "V:" + std::to_string(view_count++));
|
|
return view;
|
|
}
|
|
|
|
CachedSurfaceView::CachedSurfaceView(CachedSurface& surface, const ViewParams& params)
|
|
: VideoCommon::ViewBase(params), surface{surface} {
|
|
target = GetTextureTarget(params.target);
|
|
texture_view = CreateTextureView();
|
|
swizzle = EncodeSwizzle(SwizzleSource::R, SwizzleSource::G, SwizzleSource::B, SwizzleSource::A);
|
|
}
|
|
|
|
CachedSurfaceView::~CachedSurfaceView() = default;
|
|
|
|
void CachedSurfaceView::Attach(GLenum attachment) const {
|
|
ASSERT(params.num_layers == 1 && params.num_levels == 1);
|
|
|
|
const auto& owner_params = surface.GetSurfaceParams();
|
|
|
|
switch (owner_params.target) {
|
|
case SurfaceTarget::Texture1D:
|
|
glFramebufferTexture1D(GL_DRAW_FRAMEBUFFER, attachment, surface.GetTarget(),
|
|
surface.GetTexture(), params.base_level);
|
|
break;
|
|
case SurfaceTarget::Texture2D:
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, attachment, surface.GetTarget(),
|
|
surface.GetTexture(), params.base_level);
|
|
break;
|
|
case SurfaceTarget::Texture1DArray:
|
|
case SurfaceTarget::Texture2DArray:
|
|
case SurfaceTarget::TextureCubemap:
|
|
case SurfaceTarget::TextureCubeArray:
|
|
glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER, attachment, surface.GetTexture(),
|
|
params.base_level, params.base_layer);
|
|
break;
|
|
default:
|
|
UNIMPLEMENTED();
|
|
}
|
|
}
|
|
|
|
void CachedSurfaceView::ApplySwizzle(SwizzleSource x_source, SwizzleSource y_source,
|
|
SwizzleSource z_source, SwizzleSource w_source) {
|
|
u32 new_swizzle = EncodeSwizzle(x_source, y_source, z_source, w_source);
|
|
if (new_swizzle == swizzle)
|
|
return;
|
|
swizzle = new_swizzle;
|
|
const std::array<GLint, 4> gl_swizzle = {GetSwizzleSource(x_source), GetSwizzleSource(y_source),
|
|
GetSwizzleSource(z_source),
|
|
GetSwizzleSource(w_source)};
|
|
glTextureParameteriv(texture_view.handle, GL_TEXTURE_SWIZZLE_RGBA, gl_swizzle.data());
|
|
}
|
|
|
|
OGLTextureView CachedSurfaceView::CreateTextureView() const {
|
|
const auto& owner_params = surface.GetSurfaceParams();
|
|
OGLTextureView tv;
|
|
tv.Create();
|
|
|
|
const GLuint handle{tv.handle};
|
|
const FormatTuple& tuple{
|
|
GetFormatTuple(owner_params.pixel_format, owner_params.component_type)};
|
|
|
|
glTextureView(handle, target, surface.texture.handle, tuple.internal_format, params.base_level,
|
|
params.num_levels, params.base_layer, params.num_layers);
|
|
|
|
ApplyTextureDefaults(owner_params, handle);
|
|
|
|
return tv;
|
|
}
|
|
|
|
TextureCacheOpenGL::TextureCacheOpenGL(Core::System& system,
|
|
VideoCore::RasterizerInterface& rasterizer)
|
|
: TextureCacheBase{system, rasterizer} {
|
|
src_framebuffer.Create();
|
|
dst_framebuffer.Create();
|
|
}
|
|
|
|
TextureCacheOpenGL::~TextureCacheOpenGL() = default;
|
|
|
|
Surface TextureCacheOpenGL::CreateSurface(GPUVAddr gpu_addr, const SurfaceParams& params) {
|
|
return std::make_shared<CachedSurface>(gpu_addr, params);
|
|
}
|
|
|
|
void TextureCacheOpenGL::ImageCopy(Surface src_surface, Surface dst_surface,
|
|
const VideoCommon::CopyParams& copy_params) {
|
|
const auto src_handle = src_surface->GetTexture();
|
|
const auto src_target = src_surface->GetTarget();
|
|
const auto dst_handle = dst_surface->GetTexture();
|
|
const auto dst_target = dst_surface->GetTarget();
|
|
glCopyImageSubData(src_handle, src_target, copy_params.source_level, copy_params.source_x,
|
|
copy_params.source_y, copy_params.source_z, dst_handle, dst_target,
|
|
copy_params.dest_level, copy_params.dest_x, copy_params.dest_y,
|
|
copy_params.dest_z, copy_params.width, copy_params.height,
|
|
copy_params.depth);
|
|
}
|
|
|
|
void TextureCacheOpenGL::ImageBlit(Surface src_surface, Surface dst_surface,
|
|
const Common::Rectangle<u32>& src_rect,
|
|
const Common::Rectangle<u32>& dst_rect) {
|
|
const auto& src_params{src_surface->GetSurfaceParams()};
|
|
const auto& dst_params{dst_surface->GetSurfaceParams()};
|
|
|
|
OpenGLState prev_state{OpenGLState::GetCurState()};
|
|
SCOPE_EXIT({ prev_state.Apply(); });
|
|
|
|
OpenGLState state;
|
|
state.draw.read_framebuffer = src_framebuffer.handle;
|
|
state.draw.draw_framebuffer = dst_framebuffer.handle;
|
|
state.ApplyFramebufferState();
|
|
|
|
u32 buffers{};
|
|
|
|
UNIMPLEMENTED_IF(src_params.target != SurfaceTarget::Texture2D);
|
|
UNIMPLEMENTED_IF(dst_params.target != SurfaceTarget::Texture2D);
|
|
|
|
const GLuint src_texture{src_surface->GetTexture()};
|
|
const GLuint dst_texture{dst_surface->GetTexture()};
|
|
|
|
if (src_params.type == SurfaceType::ColorTexture) {
|
|
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
|
|
src_texture, 0);
|
|
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0,
|
|
0);
|
|
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
|
|
dst_texture, 0);
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0,
|
|
0);
|
|
|
|
buffers = GL_COLOR_BUFFER_BIT;
|
|
} else if (src_params.type == SurfaceType::Depth) {
|
|
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
|
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, src_texture,
|
|
0);
|
|
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
|
|
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, dst_texture,
|
|
0);
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_TEXTURE_2D, 0, 0);
|
|
|
|
buffers = GL_DEPTH_BUFFER_BIT;
|
|
} else if (src_params.type == SurfaceType::DepthStencil) {
|
|
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
|
glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
|
|
src_texture, 0);
|
|
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
|
|
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_TEXTURE_2D,
|
|
dst_texture, 0);
|
|
|
|
buffers = GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT;
|
|
}
|
|
|
|
glBlitFramebuffer(src_rect.left, src_rect.top, src_rect.right, src_rect.bottom, dst_rect.left,
|
|
dst_rect.top, dst_rect.right, dst_rect.bottom, buffers,
|
|
buffers == GL_COLOR_BUFFER_BIT ? GL_LINEAR : GL_NEAREST);
|
|
}
|
|
|
|
} // namespace OpenGL
|