octo/citra
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rasterizer_cache: Separate texture swizzling to utils

Browse Source
This commit is contained in:
emufan4568
2022-09-07 15:32:02 +03:00
committed by GPUCode
parent cf8bc35d46
commit 06bacfbd72
6 changed files with 122 additions and 45 deletions
Download Patch File Download Diff File Expand all files Collapse all files

70
src/video_core/rasterizer_cache/cached_surface.cpp
View File

@ -33,12 +33,17 @@ void CachedSurface::LoadGLBuffer(PAddr load_start, PAddr load_end) {
const bool need_swap =
GLES && (pixel_format == PixelFormat::RGBA8 || pixel_format == PixelFormat::RGB8);
const u8* const texture_src_data = VideoCore::g_memory->GetPhysicalPointer(addr);
if (texture_src_data == nullptr)
const u8* texture_ptr = VideoCore::g_memory->GetPhysicalPointer(addr);
if (texture_ptr == nullptr) {
return;
}
const u32 byte_size = width * height * GetBytesPerPixel(pixel_format);
const auto texture_data = std::span<const std::byte>{reinterpret_cast<const std::byte*>(texture_ptr),
byte_size};
if (gl_buffer.empty()) {
gl_buffer.resize(width * height * GetBytesPerPixel(pixel_format));
gl_buffer.resize(byte_size);
}
// TODO: Should probably be done in ::Memory:: and check for other regions too
@ -60,48 +65,26 @@ void CachedSurface::LoadGLBuffer(PAddr load_start, PAddr load_end) {
// cannot fully test this
if (pixel_format == PixelFormat::RGBA8) {
for (std::size_t i = start_offset; i < load_end - addr; i += 4) {
gl_buffer[i] = texture_src_data[i + 3];
gl_buffer[i + 1] = texture_src_data[i + 2];
gl_buffer[i + 2] = texture_src_data[i + 1];
gl_buffer[i + 3] = texture_src_data[i];
gl_buffer[i] = texture_ptr[i + 3];
gl_buffer[i + 1] = texture_ptr[i + 2];
gl_buffer[i + 2] = texture_ptr[i + 1];
gl_buffer[i + 3] = texture_ptr[i];
}
} else if (pixel_format == PixelFormat::RGB8) {
for (std::size_t i = start_offset; i < load_end - addr; i += 3) {
gl_buffer[i] = texture_src_data[i + 2];
gl_buffer[i + 1] = texture_src_data[i + 1];
gl_buffer[i + 2] = texture_src_data[i];
gl_buffer[i] = texture_ptr[i + 2];
gl_buffer[i + 1] = texture_ptr[i + 1];
gl_buffer[i + 2] = texture_ptr[i];
}
}
} else {
std::memcpy(&gl_buffer[start_offset], texture_src_data + start_offset,
std::memcpy(&gl_buffer[start_offset], texture_ptr + start_offset,
load_end - load_start);
}
} else {
if (type == SurfaceType::Texture) {
Pica::Texture::TextureInfo tex_info{};
tex_info.width = width;
tex_info.height = height;
tex_info.format = static_cast<Pica::TexturingRegs::TextureFormat>(pixel_format);
tex_info.SetDefaultStride();
tex_info.physical_address = addr;
const SurfaceInterval load_interval(load_start, load_end);
const auto rect = GetSubRect(FromInterval(load_interval));
ASSERT(FromInterval(load_interval).GetInterval() == load_interval);
for (unsigned y = rect.bottom; y < rect.top; ++y) {
for (unsigned x = rect.left; x < rect.right; ++x) {
auto vec4 =
Pica::Texture::LookupTexture(texture_src_data, x, height - 1 - y, tex_info);
const std::size_t offset = (x + (width * y)) * 4;
std::memcpy(&gl_buffer[offset], vec4.AsArray(), 4);
}
}
} else {
const u32 func_index = static_cast<u32>(pixel_format);
const MortonFunc func = UNSWIZZLE_TABLE[func_index];
func(stride, height, &gl_buffer[0], addr, load_start, load_end);
}
const auto dest_data = std::span<std::byte>{reinterpret_cast<std::byte*>(gl_buffer.data()),
byte_size};
UnswizzleTexture(*this, load_start, load_end, texture_data, dest_data);
}
}
@ -109,10 +92,12 @@ MICROPROFILE_DEFINE(RasterizerCache_SurfaceFlush, "RasterizerCache", "Surface Fl
MP_RGB(128, 192, 64));
void CachedSurface::FlushGLBuffer(PAddr flush_start, PAddr flush_end) {
u8* const dst_buffer = VideoCore::g_memory->GetPhysicalPointer(addr);
if (dst_buffer == nullptr)
if (dst_buffer == nullptr) {
return;
}
ASSERT(gl_buffer.size() == width * height * GetBytesPerPixel(pixel_format));
const u32 byte_size = width * height * GetBytesPerPixel(pixel_format);
DEBUG_ASSERT(gl_buffer.size() == byte_size);
// TODO: Should probably be done in ::Memory:: and check for other regions too
// same as loadglbuffer()
@ -132,8 +117,9 @@ void CachedSurface::FlushGLBuffer(PAddr flush_start, PAddr flush_end) {
const u32 coarse_start_offset = start_offset - (start_offset % fill_size);
const u32 backup_bytes = start_offset % fill_size;
std::array<u8, 4> backup_data;
if (backup_bytes)
if (backup_bytes) {
std::memcpy(&backup_data[0], &dst_buffer[coarse_start_offset], backup_bytes);
}
for (u32 offset = coarse_start_offset; offset < end_offset; offset += fill_size) {
std::memcpy(&dst_buffer[offset], &fill_data[0],
@ -162,9 +148,9 @@ void CachedSurface::FlushGLBuffer(PAddr flush_start, PAddr flush_end) {
flush_end - flush_start);
}
} else {
const u32 func_index = static_cast<u32>(pixel_format);
const MortonFunc func = SWIZZLE_TABLE[func_index];
func(stride, height, &gl_buffer[0], addr, flush_start, flush_end);
const auto source_data = std::span<std::byte>{reinterpret_cast<std::byte*>(gl_buffer.data()),
byte_size};
SwizzleTexture(*this, flush_start, flush_end, source_data, {});
}
}

3
src/video_core/rasterizer_cache/rasterizer_cache.cpp
View File

@ -451,7 +451,8 @@ Surface RasterizerCache::GetTextureSurface(const Pica::Texture::TextureInfo& inf
const Subresource dst_subresource = {
.aspect = aspect,
.region = surface_params.GetScaledRect()
.region = surface_params.GetScaledRect(),
.level = level
};
runtime.BlitTextures(level_surface->texture, src_subresource,

45
src/video_core/rasterizer_cache/utils.cpp
View File

@ -5,6 +5,8 @@
#pragma once
#include <glad/glad.h>
#include "video_core/texture/texture_decode.h"
#include "video_core/rasterizer_cache/morton_swizzle.h"
#include "video_core/rasterizer_cache/surface_params.h"
#include "video_core/rasterizer_cache/utils.h"
#include "video_core/renderer_opengl/gl_vars.h"
@ -54,6 +56,49 @@ const FormatTuple& GetFormatTuple(PixelFormat pixel_format) {
return tex_tuple;
}
void SwizzleTexture(const SurfaceParams& params, u32 flush_start, u32 flush_end,
std::span<std::byte> source, std::span<std::byte> dest) {
const u32 func_index = static_cast<u32>(params.pixel_format);
const MortonFunc swizzle = SWIZZLE_TABLE[func_index];
u8* source_data = reinterpret_cast<u8*>(source.data());
// TODO: Move memory access out of the morton function
swizzle(params.stride, params.height, source_data, params.addr, flush_start, flush_end);
}
void UnswizzleTexture(const SurfaceParams& params, u32 load_start, u32 load_end,
std::span<const std::byte> source, std::span<std::byte> dest) {
// TODO: Integrate this to UNSWIZZLE_TABLE
if (params.type == SurfaceType::Texture) {
Pica::Texture::TextureInfo tex_info{};
tex_info.width = params.width;
tex_info.height = params.height;
tex_info.format = static_cast<Pica::TexturingRegs::TextureFormat>(params.pixel_format);
tex_info.SetDefaultStride();
tex_info.physical_address = params.addr;
const SurfaceInterval load_interval(load_start, load_end);
const auto rect = params.GetSubRect(params.FromInterval(load_interval));
DEBUG_ASSERT(params.FromInterval(load_interval).GetInterval() == load_interval);
const u8* source_data = reinterpret_cast<const u8*>(source.data());
for (u32 y = rect.bottom; y < rect.top; y++) {
for (u32 x = rect.left; x < rect.right; x++) {
auto vec4 =
Pica::Texture::LookupTexture(source_data, x, params.height - 1 - y, tex_info);
const std::size_t offset = (x + (params.width * y)) * 4;
std::memcpy(dest.data() + offset, vec4.AsArray(), 4);
}
}
} else {
const u32 func_index = static_cast<u32>(params.pixel_format);
const MortonFunc deswizzle = UNSWIZZLE_TABLE[func_index];
u8* dest_data = reinterpret_cast<u8*>(dest.data());
deswizzle(params.stride, params.height, dest_data, params.addr, load_start, load_end);
}
}
ClearValue MakeClearValue(Aspect aspect, PixelFormat format, const u8* fill_data) {
ClearValue result{};
switch (aspect) {

9
src/video_core/rasterizer_cache/utils.h
View File

@ -4,6 +4,7 @@
#pragma once
#include <functional>
#include <span>
#include "common/hash.h"
#include "video_core/rasterizer_cache/pixel_format.h"
#include "video_core/rasterizer_cache/types.h"
@ -47,6 +48,14 @@ struct TextureCubeConfig {
}
};
class SurfaceParams;
void SwizzleTexture(const SurfaceParams& params, u32 flush_start, u32 flush_end,
std::span<std::byte> source, std::span<std::byte> dest);
void UnswizzleTexture(const SurfaceParams& params, u32 load_start, u32 load_end,
std::span<const std::byte> source, std::span<std::byte> dest);
[[nodiscard]] ClearValue MakeClearValue(Aspect aspect, PixelFormat format, const u8* fill_data);
[[nodiscard]] Aspect ToAspect(SurfaceType type);

21
src/video_core/texture/texture_decode.cpp
View File

@ -2,10 +2,10 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
#include <bit>
#include "common/assert.h"
#include "common/color.h"
#include "common/logging/log.h"
#include "common/math_util.h"
#include "common/swap.h"
#include "common/vector_math.h"
#include "video_core/regs_texturing.h"
@ -223,4 +223,23 @@ TextureInfo TextureInfo::FromPicaRegister(const TexturingRegs::TextureConfig& co
return info;
}
void ConvertBGRToRGBA(std::span<const std::byte> source, std::span<std::byte> dest) {
u32 j = 0;
for (u32 i = 0; i < source.size(); i += 3) {
dest[j] = source[i + 2];
dest[j + 1] = source[i + 1];
dest[j + 2] = source[i];
dest[j + 3] = std::byte{0xFF};
j += 4;
}
}
void ConvertABGRToRGBA(std::span<const std::byte> source, std::span<std::byte> dest) {
for (u32 i = 0; i < source.size(); i += 4) {
const u32 abgr = *reinterpret_cast<const u32*>(source.data() + i);
const u32 rgba = std::byteswap(abgr);
std::memcpy(dest.data() + i, &rgba, 4);
}
}
} // namespace Pica::Texture

19
src/video_core/texture/texture_decode.h
View File

@ -3,7 +3,7 @@
// Refer to the license.txt file included.
#pragma once
#include <span>
#include "common/common_types.h"
#include "common/vector_math.h"
#include "video_core/regs_texturing.h"
@ -55,4 +55,21 @@ Common::Vec4<u8> LookupTexture(const u8* source, unsigned int x, unsigned int y,
Common::Vec4<u8> LookupTexelInTile(const u8* source, unsigned int x, unsigned int y,
const TextureInfo& info, bool disable_alpha);
/**
* Converts pixel data encoded in BGR format to RGBA
*
* @param source Span to the source pixel data
* @param dest Span to the destination pixel data
*/
void ConvertBGRToRGBA(std::span<const std::byte> source, std::span<std::byte> dest);
/**
* Converts pixel data encoded in ABGR format to RGBA
*
* @param source Span to the source pixel data
* @param dest Span to the destination pixel data
*/
void ConvertABGRToRGBA(std::span<const std::byte> source, std::span<std::byte> dest);
} // namespace Pica::Texture