lvella/suyu
1
0
Fork 0
forked from suyu/suyu
Code Pull requests Activity

copy_params: Use constructor instead of C-like initialization

Browse source
This commit is contained in:
ReinUsesLisp 2019-05-07 21:28:31 -03:00
parent 1af4414861
commit 03d10ea3b4
3 changed files with 39 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
src/video_core/texture_cache/copy_params.h
View file

@ -9,6 +9,16 @@
namespace VideoCommon { namespace VideoCommon {
struct CopyParams { struct CopyParams {
CopyParams(u32 source_x, u32 source_y, u32 source_z, u32 dest_x, u32 dest_y, u32 dest_z,
u32 source_level, u32 dest_level, u32 width, u32 height, u32 depth)
: source_x{source_x}, source_y{source_y}, source_z{source_z}, dest_x{dest_x},
dest_y{dest_y}, dest_z{dest_z}, source_level{source_level},
dest_level{dest_level}, width{width}, height{height}, depth{depth} {}
CopyParams(u32 width, u32 height, u32 depth, u32 level)
: source_x{}, source_y{}, source_z{}, dest_x{}, dest_y{}, dest_z{}, source_level{level},
dest_level{level}, width{width}, height{height}, depth{depth} {}
u32 source_x; u32 source_x;
u32 source_y; u32 source_y;
u32 source_z; u32 source_z;

53
src/video_core/texture_cache/surface_base.h
View file

@ -149,45 +149,32 @@ public:
} }
std::vector<CopyParams> BreakDown(const SurfaceParams& in_params) const { std::vector<CopyParams> BreakDown(const SurfaceParams& in_params) const {
auto set_up_copy = [](CopyParams& cp, const u32 width, const u32 height, const u32 depth, std::vector<CopyParams> result;
const u32 level) { const u32 layers{params.depth};
cp.source_x = 0; const u32 mipmaps{params.num_levels};
cp.source_y = 0;
cp.source_z = 0;
cp.dest_x = 0;
cp.dest_y = 0;
cp.dest_z = 0;
cp.source_level = level;
cp.dest_level = level;
cp.width = width;
cp.height = height;
cp.depth = depth;
};
const u32 layers = params.depth;
const u32 mipmaps = params.num_levels;
if (params.is_layered) { if (params.is_layered) {
std::vector<CopyParams> result{layers * mipmaps}; result.reserve(static_cast<std::size_t>(layers) * static_cast<std::size_t>(mipmaps));
for (std::size_t layer = 0; layer < layers; layer++) { for (u32 layer = 0; layer < layers; layer++) {
const u32 layer_offset = layer * mipmaps; const u32 layer_offset{layer * mipmaps};
for (std::size_t level = 0; level < mipmaps; level++) { for (u32 level = 0; level < mipmaps; level++) {
CopyParams& cp = result[layer_offset + level]; const u32 width{
const u32 width = std::min(params.GetMipWidth(level), in_params.GetMipWidth(level))};
std::min(params.GetMipWidth(level), in_params.GetMipWidth(level)); const u32 height{
const u32 height = std::min(params.GetMipHeight(level), in_params.GetMipHeight(level))};
std::min(params.GetMipHeight(level), in_params.GetMipHeight(level)); result.emplace_back(width, height, layer, level);
set_up_copy(cp, width, height, layer, level);
} }
} }
return result; return result;
} else { } else {
std::vector<CopyParams> result{mipmaps}; result.reserve(mipmaps);
for (std::size_t level = 0; level < mipmaps; level++) { for (std::size_t level = 0; level < mipmaps; level++) {
CopyParams& cp = result[level]; const u32 width{std::min(params.GetMipWidth(level), in_params.GetMipWidth(level))};
const u32 width = std::min(params.GetMipWidth(level), in_params.GetMipWidth(level)); const u32 height{
const u32 height = std::min(params.GetMipHeight(level), in_params.GetMipHeight(level))};
std::min(params.GetMipHeight(level), in_params.GetMipHeight(level)); const u32 depth{std::min(params.GetMipDepth(level), in_params.GetMipDepth(level))};
const u32 depth = std::min(params.GetMipDepth(level), in_params.GetMipDepth(level)); result.emplace_back(width, height, depth, level);
set_up_copy(cp, width, height, depth, level);
} }
return result; return result;
} }

23
src/video_core/texture_cache/texture_cache.h
View file

@ -283,7 +283,7 @@ private:
} }
std::pair<TSurface, TView> RebuildSurface(TSurface current_surface, std::pair<TSurface, TView> RebuildSurface(TSurface current_surface,
const SurfaceParams& params) { const SurfaceParams& params) {
const auto gpu_addr = current_surface->GetGpuAddr(); const auto gpu_addr = current_surface->GetGpuAddr();
TSurface new_surface = GetUncachedSurface(gpu_addr, params); TSurface new_surface = GetUncachedSurface(gpu_addr, params);
std::vector<CopyParams> bricks = current_surface->BreakDown(params); std::vector<CopyParams> bricks = current_surface->BreakDown(params);
@ -323,26 +323,21 @@ private:
return {}; return {};
} }
const std::size_t candidate_size = src_params.GetGuestSizeInBytes(); const std::size_t candidate_size = src_params.GetGuestSizeInBytes();
auto mipmap_layer = new_surface->GetLayerMipmap(surface->GetGpuAddr()); auto mipmap_layer{new_surface->GetLayerMipmap(surface->GetGpuAddr())};
if (!mipmap_layer) { if (!mipmap_layer) {
return {}; return {};
} }
const u32 layer = (*mipmap_layer).first; const u32 layer{mipmap_layer->first};
const u32 mipmap = (*mipmap_layer).second; const u32 mipmap{mipmap_layer->second};
if (new_surface->GetMipmapSize(mipmap) != candidate_size) { if (new_surface->GetMipmapSize(mipmap) != candidate_size) {
return {}; return {};
} }
// Now we got all the data set up // Now we got all the data set up
CopyParams copy_params{}; const u32 dst_width{params.GetMipWidth(mipmap)};
const u32 dst_width = params.GetMipWidth(mipmap); const u32 dst_height{params.GetMipHeight(mipmap)};
const u32 dst_height = params.GetMipHeight(mipmap); const CopyParams copy_params(0, 0, 0, 0, 0, layer, 0, mipmap,
copy_params.width = std::min(src_params.width, dst_width); std::min(src_params.width, dst_width),
copy_params.height = std::min(src_params.height, dst_height); std::min(src_params.height, dst_height), 1);
copy_params.depth = 1;
copy_params.source_level = 0;
copy_params.dest_level = mipmap;
copy_params.source_z = 0;
copy_params.dest_z = layer;
ImageCopy(surface, new_surface, copy_params); ImageCopy(surface, new_surface, copy_params);
} }
for (auto surface : overlaps) { for (auto surface : overlaps) {