Mirrors/yuzu-fork
1
0
Fork 0
mirror of https://github.com/yuzu-mirror/yuzu.git synced 2024-11-03 10:40:00 +00:00
Code Issues Projects Releases Packages Wiki Activity

video_core: Refactor resolution scale function

Browse source
This commit is contained in:
ameerj 2021-10-12 00:35:01 -04:00 committed by Fernando Sahmkow
parent b14f2c7c82
commit abd07e4158
4 changed files with 34 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
src/common/settings.h
View file

@ -72,6 +72,20 @@ struct ResolutionScalingInfo {
f32 up_factor{1.0f}; f32 up_factor{1.0f};
f32 down_factor{1.0f}; f32 down_factor{1.0f};
bool active{}; bool active{};
s32 ScaleUp(s32 value) const {
if (value == 0) {
return 0;
}
return std::max((value * static_cast<s32>(up_scale)) >> static_cast<s32>(down_shift), 1);
}
u32 ScaleUp(u32 value) const {
if (value == 0U) {
return 0U;
}
return std::max((value * up_scale) >> down_shift, 1U);
}
}; };
/** The BasicSetting class is a simple resource manager. It defines a label and default value /** The BasicSetting class is a simple resource manager. It defines a label and default value

8
src/video_core/renderer_opengl/gl_texture_cache.cpp
View file

@ -924,12 +924,8 @@ bool Image::Scale() {
const GLenum filter = linear_color_format ? GL_LINEAR : GL_NEAREST; const GLenum filter = linear_color_format ? GL_LINEAR : GL_NEAREST;
const auto& resolution = runtime->resolution; const auto& resolution = runtime->resolution;
const u32 up = resolution.up_scale; const u32 scaled_width = resolution.ScaleUp(info.size.width);
const u32 down = resolution.down_shift; const u32 scaled_height = is_2d ? resolution.ScaleUp(info.size.height) : info.size.height;
const auto scale = [&](u32 value) { return std::max<u32>((value * up) >> down, 1U); };
const u32 scaled_width = scale(info.size.width);
const u32 scaled_height = is_2d ? scale(info.size.height) : info.size.height;
const u32 original_width = info.size.width; const u32 original_width = info.size.width;
const u32 original_height = info.size.height; const u32 original_height = info.size.height;

19
src/video_core/renderer_vulkan/vk_texture_cache.cpp
View file

@ -607,16 +607,13 @@ void BlitScale(VKScheduler& scheduler, VkImage src_image, VkImage dst_image, con
scheduler.RequestOutsideRenderPassOperationContext(); scheduler.RequestOutsideRenderPassOperationContext();
scheduler.Record([dst_image, src_image, extent, resources, aspect_mask, resolution, type, scheduler.Record([dst_image, src_image, extent, resources, aspect_mask, resolution, type,
scaling, vk_filter](vk::CommandBuffer cmdbuf) { scaling, vk_filter](vk::CommandBuffer cmdbuf) {
const auto scale_up = [&](u32 value) {
return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
};
const VkOffset2D src_size{ const VkOffset2D src_size{
.x = static_cast<s32>(scaling ? extent.width : scale_up(extent.width)), .x = static_cast<s32>(scaling ? extent.width : resolution.ScaleUp(extent.width)),
.y = static_cast<s32>(scaling ? extent.height : scale_up(extent.height)), .y = static_cast<s32>(scaling ? extent.height : resolution.ScaleUp(extent.height)),
}; };
const VkOffset2D dst_size{ const VkOffset2D dst_size{
.x = static_cast<s32>(scaling ? scale_up(extent.width) : extent.width), .x = static_cast<s32>(scaling ? resolution.ScaleUp(extent.width) : extent.width),
.y = static_cast<s32>(scaling ? scale_up(extent.height) : extent.height), .y = static_cast<s32>(scaling ? resolution.ScaleUp(extent.height) : extent.height),
}; };
boost::container::small_vector<VkImageBlit, 4> regions; boost::container::small_vector<VkImageBlit, 4> regions;
regions.reserve(resources.levels); regions.reserve(resources.levels);
@ -1144,13 +1141,9 @@ bool Image::ScaleUp() {
return false; return false;
} }
if (!scaled_image) { if (!scaled_image) {
const u32 up = resolution.up_scale;
const u32 down = resolution.down_shift;
const auto scale = [&](u32 value) { return std::max<u32>((value * up) >> down, 1U); };
const bool is_2d = info.type == ImageType::e2D; const bool is_2d = info.type == ImageType::e2D;
const u32 scaled_width = scale(info.size.width); const u32 scaled_width = resolution.ScaleUp(info.size.width);
const u32 scaled_height = is_2d ? scale(info.size.height) : info.size.height; const u32 scaled_height = is_2d ? resolution.ScaleUp(info.size.height) : info.size.height;
auto scaled_info = info; auto scaled_info = info;
scaled_info.size.width = scaled_width; scaled_info.size.width = scaled_width;
scaled_info.size.height = scaled_height; scaled_info.size.height = scaled_height;

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

@ -504,17 +504,11 @@ void TextureCache<P>::BlitImage(const Tegra::Engines::Fermi2D::Surface& dst,
is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled); is_dst_rescaled = True(dst_image.flags & ImageFlagBits::Rescaled);
} }
const auto& resolution = Settings::values.resolution_info; const auto& resolution = Settings::values.resolution_info;
const auto scale_up = [&](u32 value) -> u32 {
if (value == 0) {
return 0U;
}
return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
};
const auto scale_region = [&](Region2D& region) { const auto scale_region = [&](Region2D& region) {
region.start.x = scale_up(region.start.x); region.start.x = resolution.ScaleUp(region.start.x);
region.start.y = scale_up(region.start.y); region.start.y = resolution.ScaleUp(region.start.y);
region.end.x = scale_up(region.end.x); region.end.x = resolution.ScaleUp(region.end.x);
region.end.y = scale_up(region.end.y); region.end.y = resolution.ScaleUp(region.end.y);
}; };
// TODO: Deduplicate // TODO: Deduplicate
@ -1721,20 +1715,14 @@ void TextureCache<P>::CopyImage(ImageId dst_id, ImageId src_id, std::vector<Imag
ASSERT(True(dst.flags & ImageFlagBits::Rescaled)); ASSERT(True(dst.flags & ImageFlagBits::Rescaled));
const bool both_2d{src.info.type == ImageType::e2D && dst.info.type == ImageType::e2D}; const bool both_2d{src.info.type == ImageType::e2D && dst.info.type == ImageType::e2D};
const auto& resolution = Settings::values.resolution_info; const auto& resolution = Settings::values.resolution_info;
const auto scale_up = [&](u32 value) -> u32 {
if (value == 0) {
return 0U;
}
return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
};
for (auto& copy : copies) { for (auto& copy : copies) {
copy.src_offset.x = scale_up(copy.src_offset.x); copy.src_offset.x = resolution.ScaleUp(copy.src_offset.x);
copy.dst_offset.x = scale_up(copy.dst_offset.x); copy.dst_offset.x = resolution.ScaleUp(copy.dst_offset.x);
copy.extent.width = scale_up(copy.extent.width); copy.extent.width = resolution.ScaleUp(copy.extent.width);
if (both_2d) { if (both_2d) {
copy.src_offset.y = scale_up(copy.src_offset.y); copy.src_offset.y = resolution.ScaleUp(copy.src_offset.y);
copy.dst_offset.y = scale_up(copy.dst_offset.y); copy.dst_offset.y = resolution.ScaleUp(copy.dst_offset.y);
copy.extent.height = scale_up(copy.extent.height); copy.extent.height = resolution.ScaleUp(copy.extent.height);
} }
} }
} }
@ -1812,12 +1800,9 @@ std::pair<FramebufferId, ImageViewId> TextureCache<P>::RenderTargetFromImage(
Extent3D extent = MipSize(image.info.size, view_info.range.base.level); Extent3D extent = MipSize(image.info.size, view_info.range.base.level);
if (is_rescaled) { if (is_rescaled) {
const auto& resolution = Settings::values.resolution_info; const auto& resolution = Settings::values.resolution_info;
const auto scale_up = [&](u32 value) { extent.width = resolution.ScaleUp(extent.width);
return std::max<u32>((value * resolution.up_scale) >> resolution.down_shift, 1U);
};
extent.width = scale_up(extent.width);
if (image.info.type == ImageType::e2D) { if (image.info.type == ImageType::e2D) {
extent.height = scale_up(extent.height); extent.height = resolution.ScaleUp(extent.height);
} }
} }
const u32 num_samples = image.info.num_samples; const u32 num_samples = image.info.num_samples;