use_docked_mode_texts_map = {
diff --git a/src/video_core/buffer_cache/buffer_cache.h b/src/video_core/buffer_cache/buffer_cache.h
index 94ef1a48df..eb18a4bd66 100644
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -792,6 +792,11 @@ void BufferCache::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
const u32 size = (std::min)(binding.size, (*channel_state->uniform_buffer_sizes)[stage][index]);
Buffer& buffer = slot_buffers[binding.buffer_id];
TouchBuffer(buffer, binding.buffer_id);
+ const bool sync_buffer = SynchronizeBuffer(buffer, device_addr, size);
+ if (sync_buffer) {
+ ++channel_state->uniform_cache_hits[0];
+ }
+ ++channel_state->uniform_cache_shots[0];
const bool use_fast_buffer = binding.buffer_id != NULL_BUFFER_ID &&
size <= channel_state->uniform_buffer_skip_cache_size &&
!memory_tracker.IsRegionGpuModified(device_addr, size);
@@ -822,12 +827,6 @@ void BufferCache
::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
device_memory.ReadBlockUnsafe(device_addr, span.data(), size);
return;
}
- // Classic cached path
- const bool sync_cached = SynchronizeBuffer(buffer, device_addr, size);
- if (sync_cached) {
- ++channel_state->uniform_cache_hits[0];
- }
- ++channel_state->uniform_cache_shots[0];
// Skip binding if it's not needed and if the bound buffer is not the fast version
// This exists to avoid instances where the fast buffer is bound and a GPU write happens
diff --git a/src/video_core/host_shaders/CMakeLists.txt b/src/video_core/host_shaders/CMakeLists.txt
index c14b44a45a..9f7b9edd5a 100644
--- a/src/video_core/host_shaders/CMakeLists.txt
+++ b/src/video_core/host_shaders/CMakeLists.txt
@@ -44,9 +44,13 @@ set(SHADER_FILES
pitch_unswizzle.comp
present_area.frag
present_bicubic.frag
+ present_zero_tangent.frag
+ present_bspline.frag
+ present_mitchell.frag
present_gaussian.frag
present_lanczos.frag
present_spline1.frag
+ present_mmpx.frag
queries_prefix_scan_sum.comp
queries_prefix_scan_sum_nosubgroups.comp
resolve_conditional_render.comp
diff --git a/src/video_core/host_shaders/present_bicubic.frag b/src/video_core/host_shaders/present_bicubic.frag
index a9d9d40a38..5347fd2ef7 100644
--- a/src/video_core/host_shaders/present_bicubic.frag
+++ b/src/video_core/host_shaders/present_bicubic.frag
@@ -1,56 +1,37 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
-
#version 460 core
-
-
layout (location = 0) in vec2 frag_tex_coord;
-
layout (location = 0) out vec4 color;
-
layout (binding = 0) uniform sampler2D color_texture;
-
-vec4 cubic(float v) {
- vec4 n = vec4(1.0, 2.0, 3.0, 4.0) - v;
- vec4 s = n * n * n;
- float x = s.x;
- float y = s.y - 4.0 * s.x;
- float z = s.z - 4.0 * s.y + 6.0 * s.x;
- float w = 6.0 - x - y - z;
- return vec4(x, y, z, w) * (1.0 / 6.0);
+vec4 cubic(float x) {
+ float x2 = x * x;
+ float x3 = x2 * x;
+ return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+ 0.0, 2.0, 0.0, 0.0,
+ -1.0, 0.0, 1.0, 0.0,
+ 2.0, -5.0, 4.0, -1.0,
+ -1.0, 3.0, -3.0, 1.0
+ ) * (1.0 / 2.0));
}
-
-vec4 textureBicubic( sampler2D textureSampler, vec2 texCoords ) {
-
- vec2 texSize = textureSize(textureSampler, 0);
- vec2 invTexSize = 1.0 / texSize;
-
- texCoords = texCoords * texSize - 0.5;
-
- vec2 fxy = fract(texCoords);
- texCoords -= fxy;
-
- vec4 xcubic = cubic(fxy.x);
- vec4 ycubic = cubic(fxy.y);
-
- vec4 c = texCoords.xxyy + vec2(-0.5, +1.5).xyxy;
-
- vec4 s = vec4(xcubic.xz + xcubic.yw, ycubic.xz + ycubic.yw);
- vec4 offset = c + vec4(xcubic.yw, ycubic.yw) / s;
-
- offset *= invTexSize.xxyy;
-
- vec4 sample0 = texture(textureSampler, offset.xz);
- vec4 sample1 = texture(textureSampler, offset.yz);
- vec4 sample2 = texture(textureSampler, offset.xw);
- vec4 sample3 = texture(textureSampler, offset.yw);
-
- float sx = s.x / (s.x + s.y);
- float sy = s.z / (s.z + s.w);
-
- return mix(mix(sample3, sample2, sx), mix(sample1, sample0, sx), sy);
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+ vec2 tex_size = vec2(textureSize(samp, 0));
+ vec2 cc_tex = uv * tex_size - 0.5f;
+ vec2 fex = cc_tex - floor(cc_tex);
+ vec4 xcubic = cubic(fex.x);
+ vec4 ycubic = cubic(fex.y);
+ vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+ vec4 z = vec4(xcubic.yw, ycubic.yw);
+ vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+ vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+ vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+ return mix(
+ mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+ mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+ n.y);
}
-
void main() {
color = textureBicubic(color_texture, frag_tex_coord);
}
diff --git a/src/video_core/host_shaders/present_bspline.frag b/src/video_core/host_shaders/present_bspline.frag
new file mode 100644
index 0000000000..f229de6030
--- /dev/null
+++ b/src/video_core/host_shaders/present_bspline.frag
@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#version 460 core
+layout (location = 0) in vec2 frag_tex_coord;
+layout (location = 0) out vec4 color;
+layout (binding = 0) uniform sampler2D color_texture;
+vec4 cubic(float x) {
+ float x2 = x * x;
+ float x3 = x2 * x;
+ return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+ 1.0, 4.0, 1.0, 0.0,
+ -3.0, 0.0, 3.0, 0.0,
+ 3.0, -6.0, 3.0, 0.0,
+ -1.0, 3.0, -3.0, 1.0
+ ) * (1.0 / 6.0));
+}
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+ vec2 tex_size = vec2(textureSize(samp, 0));
+ vec2 cc_tex = uv * tex_size - 0.5f;
+ vec2 fex = cc_tex - floor(cc_tex);
+ vec4 xcubic = cubic(fex.x);
+ vec4 ycubic = cubic(fex.y);
+ vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+ vec4 z = vec4(xcubic.yw, ycubic.yw);
+ vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+ vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+ vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+ return mix(
+ mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+ mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+ n.y);
+}
+void main() {
+ color = textureBicubic(color_texture, frag_tex_coord);
+}
diff --git a/src/video_core/host_shaders/present_mitchell.frag b/src/video_core/host_shaders/present_mitchell.frag
new file mode 100644
index 0000000000..4ca65cd6f0
--- /dev/null
+++ b/src/video_core/host_shaders/present_mitchell.frag
@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#version 460 core
+layout (location = 0) in vec2 frag_tex_coord;
+layout (location = 0) out vec4 color;
+layout (binding = 0) uniform sampler2D color_texture;
+vec4 cubic(float x) {
+ float x2 = x * x;
+ float x3 = x2 * x;
+ return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+ 1.0, 16.0, 1.0, 0.0,
+ -9.0, 0.0, 9.0, 0.0,
+ 15.0, -36.0, 27.0, -6.0,
+ -7.0, 21.0, -21.0, 7.0
+ ) * (1.0 / 18.0));
+}
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+ vec2 tex_size = vec2(textureSize(samp, 0));
+ vec2 cc_tex = uv * tex_size - 0.5f;
+ vec2 fex = cc_tex - floor(cc_tex);
+ vec4 xcubic = cubic(fex.x);
+ vec4 ycubic = cubic(fex.y);
+ vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+ vec4 z = vec4(xcubic.yw, ycubic.yw);
+ vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+ vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+ vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+ return mix(
+ mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+ mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+ n.y);
+}
+void main() {
+ color = textureBicubic(color_texture, frag_tex_coord);
+}
diff --git a/src/video_core/host_shaders/present_mmpx.frag b/src/video_core/host_shaders/present_mmpx.frag
new file mode 100644
index 0000000000..6c2c05a63a
--- /dev/null
+++ b/src/video_core/host_shaders/present_mmpx.frag
@@ -0,0 +1,131 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright 2023 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#version 460 core
+layout(location = 0) in vec2 tex_coord;
+layout(location = 0) out vec4 frag_color;
+layout(binding = 0) uniform sampler2D tex;
+
+#define src(x, y) texture(tex, coord + vec2(x, y) * 1.0 / source_size)
+
+float luma(vec4 col) {
+ return dot(col.rgb, vec3(0.2126, 0.7152, 0.0722)) * (1.0 - col.a);
+}
+
+bool same(vec4 B, vec4 A0) {
+ return all(equal(B, A0));
+}
+
+bool notsame(vec4 B, vec4 A0) {
+ return any(notEqual(B, A0));
+}
+
+bool all_eq2(vec4 B, vec4 A0, vec4 A1) {
+ return (same(B,A0) && same(B,A1));
+}
+
+bool all_eq3(vec4 B, vec4 A0, vec4 A1, vec4 A2) {
+ return (same(B,A0) && same(B,A1) && same(B,A2));
+}
+
+bool all_eq4(vec4 B, vec4 A0, vec4 A1, vec4 A2, vec4 A3) {
+ return (same(B,A0) && same(B,A1) && same(B,A2) && same(B,A3));
+}
+
+bool any_eq3(vec4 B, vec4 A0, vec4 A1, vec4 A2) {
+ return (same(B,A0) || same(B,A1) || same(B,A2));
+}
+
+bool none_eq2(vec4 B, vec4 A0, vec4 A1) {
+ return (notsame(B,A0) && notsame(B,A1));
+}
+
+bool none_eq4(vec4 B, vec4 A0, vec4 A1, vec4 A2, vec4 A3) {
+ return (notsame(B,A0) && notsame(B,A1) && notsame(B,A2) && notsame(B,A3));
+}
+
+void main()
+{
+ vec2 source_size = vec2(textureSize(tex, 0));
+ vec2 pos = fract(tex_coord * source_size) - vec2(0.5, 0.5);
+ vec2 coord = tex_coord - pos / source_size;
+
+ vec4 E = src(0.0,0.0);
+
+ vec4 A = src(-1.0,-1.0);
+ vec4 B = src(0.0,-1.0);
+ vec4 C = src(1.0,-1.0);
+
+ vec4 D = src(-1.0,0.0);
+ vec4 F = src(1.0,0.0);
+
+ vec4 G = src(-1.0,1.0);
+ vec4 H = src(0.0,1.0);
+ vec4 I = src(1.0,1.0);
+
+ vec4 J = E;
+ vec4 K = E;
+ vec4 L = E;
+ vec4 M = E;
+
+ frag_color = E;
+
+ if(same(E,A) && same(E,B) && same(E,C) && same(E,D) && same(E,F) && same(E,G) && same(E,H) && same(E,I)) return;
+
+ vec4 P = src(0.0,2.0);
+ vec4 Q = src(-2.0,0.0);
+ vec4 R = src(2.0,0.0);
+ vec4 S = src(0.0,2.0);
+
+ float Bl = luma(B);
+ float Dl = luma(D);
+ float El = luma(E);
+ float Fl = luma(F);
+ float Hl = luma(H);
+
+ if (((same(D,B) && notsame(D,H) && notsame(D,F))) && ((El>=Dl) || same(E,A)) && any_eq3(E,A,C,G) && ((El=Bl) || same(E,C)) && any_eq3(E,A,C,I) && ((El=Hl) || same(E,G)) && any_eq3(E,A,G,I) && ((El=Fl) || same(E,I)) && any_eq3(E,C,G,I) && ((El MakeBicubic(const Device& device) {
HostShaders::PRESENT_BICUBIC_FRAG);
}
+std::unique_ptr MakeMitchell(const Device& device) {
+ return std::make_unique(device, CreateBilinearSampler(),
+ HostShaders::PRESENT_MITCHELL_FRAG);
+}
+
+std::unique_ptr MakeZeroTangent(const Device& device) {
+ return std::make_unique(device, CreateBilinearSampler(),
+ HostShaders::PRESENT_ZERO_TANGENT_FRAG);
+}
+
+std::unique_ptr MakeBSpline(const Device& device) {
+ return std::make_unique(device, CreateBilinearSampler(),
+ HostShaders::PRESENT_BSPLINE_FRAG);
+}
+
std::unique_ptr MakeGaussian(const Device& device) {
return std::make_unique(device, CreateBilinearSampler(),
HostShaders::PRESENT_GAUSSIAN_FRAG);
@@ -60,4 +79,9 @@ std::unique_ptr MakeArea(const Device& device) {
HostShaders::PRESENT_AREA_FRAG);
}
+std::unique_ptr MakeMmpx(const Device& device) {
+ return std::make_unique(device, CreateNearestNeighborSampler(),
+ HostShaders::PRESENT_MMPX_FRAG);
+}
+
} // namespace OpenGL
diff --git a/src/video_core/renderer_opengl/present/filters.h b/src/video_core/renderer_opengl/present/filters.h
index 7b38ac56bc..187d0f1298 100644
--- a/src/video_core/renderer_opengl/present/filters.h
+++ b/src/video_core/renderer_opengl/present/filters.h
@@ -17,10 +17,14 @@ namespace OpenGL {
std::unique_ptr MakeNearestNeighbor(const Device& device);
std::unique_ptr MakeBilinear(const Device& device);
std::unique_ptr MakeBicubic(const Device& device);
+std::unique_ptr MakeZeroTangent(const Device& device);
+std::unique_ptr MakeMitchell(const Device& device);
+std::unique_ptr MakeBSpline(const Device& device);
std::unique_ptr MakeGaussian(const Device& device);
std::unique_ptr MakeSpline1(const Device& device);
std::unique_ptr MakeLanczos(const Device& device);
std::unique_ptr MakeScaleForce(const Device& device);
std::unique_ptr MakeArea(const Device& device);
+std::unique_ptr MakeMmpx(const Device& device);
} // namespace OpenGL
diff --git a/src/video_core/renderer_vulkan/present/filters.cpp b/src/video_core/renderer_vulkan/present/filters.cpp
index e0f2b26f84..0a28ea6349 100644
--- a/src/video_core/renderer_vulkan/present/filters.cpp
+++ b/src/video_core/renderer_vulkan/present/filters.cpp
@@ -7,6 +7,8 @@
// SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
+#include
+#include "common/assert.h"
#include "common/common_types.h"
#include "video_core/host_shaders/present_area_frag_spv.h"
@@ -14,6 +16,10 @@
#include "video_core/host_shaders/present_gaussian_frag_spv.h"
#include "video_core/host_shaders/present_lanczos_frag_spv.h"
#include "video_core/host_shaders/present_spline1_frag_spv.h"
+#include "video_core/host_shaders/present_mitchell_frag_spv.h"
+#include "video_core/host_shaders/present_bspline_frag_spv.h"
+#include "video_core/host_shaders/present_zero_tangent_frag_spv.h"
+#include "video_core/host_shaders/present_mmpx_frag_spv.h"
#include "video_core/host_shaders/vulkan_present_frag_spv.h"
#include "video_core/host_shaders/vulkan_present_scaleforce_fp16_frag_spv.h"
#include "video_core/host_shaders/vulkan_present_scaleforce_fp32_frag_spv.h"
@@ -52,13 +58,28 @@ std::unique_ptr MakeSpline1(const Device& device, VkFormat fram
BuildShader(device, PRESENT_SPLINE1_FRAG_SPV));
}
-std::unique_ptr MakeBicubic(const Device& device, VkFormat frame_format) {
+std::unique_ptr MakeBicubic(const Device& device, VkFormat frame_format, VkCubicFilterWeightsQCOM qcom_weights) {
// No need for handrolled shader -- if the VK impl can do it for us ;)
- if (device.IsExtFilterCubicSupported())
- return std::make_unique(device, frame_format, CreateCubicSampler(device),
- BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
- return std::make_unique(device, frame_format, CreateBilinearSampler(device),
- BuildShader(device, PRESENT_BICUBIC_FRAG_SPV));
+ // Catmull-Rom is default bicubic for all implementations...
+ if (device.IsExtFilterCubicSupported() && (device.IsQcomFilterCubicWeightsSupported() || qcom_weights == VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM)) {
+ return std::make_unique(device, frame_format, CreateCubicSampler(device,
+ qcom_weights), BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
+ } else {
+ return std::make_unique(device, frame_format, CreateBilinearSampler(device), [&](){
+ switch (qcom_weights) {
+ case VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM:
+ return BuildShader(device, PRESENT_BICUBIC_FRAG_SPV);
+ case VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM:
+ return BuildShader(device, PRESENT_ZERO_TANGENT_FRAG_SPV);
+ case VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM:
+ return BuildShader(device, PRESENT_BSPLINE_FRAG_SPV);
+ case VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM:
+ return BuildShader(device, PRESENT_MITCHELL_FRAG_SPV);
+ default:
+ UNREACHABLE();
+ }
+ }());
+ }
}
std::unique_ptr MakeGaussian(const Device& device, VkFormat frame_format) {
@@ -81,4 +102,9 @@ std::unique_ptr MakeArea(const Device& device, VkFormat frame_f
BuildShader(device, PRESENT_AREA_FRAG_SPV));
}
+std::unique_ptr MakeMmpx(const Device& device, VkFormat frame_format) {
+ return std::make_unique(device, frame_format, CreateNearestNeighborSampler(device),
+ BuildShader(device, PRESENT_MMPX_FRAG_SPV));
+}
+
} // namespace Vulkan
diff --git a/src/video_core/renderer_vulkan/present/filters.h b/src/video_core/renderer_vulkan/present/filters.h
index 015bffc8a5..afc3ba29a0 100644
--- a/src/video_core/renderer_vulkan/present/filters.h
+++ b/src/video_core/renderer_vulkan/present/filters.h
@@ -17,11 +17,12 @@ class MemoryAllocator;
std::unique_ptr MakeNearestNeighbor(const Device& device, VkFormat frame_format);
std::unique_ptr MakeBilinear(const Device& device, VkFormat frame_format);
-std::unique_ptr MakeBicubic(const Device& device, VkFormat frame_format);
+std::unique_ptr MakeBicubic(const Device& device, VkFormat frame_format, VkCubicFilterWeightsQCOM qcom_weights);
std::unique_ptr MakeSpline1(const Device& device, VkFormat frame_format);
std::unique_ptr MakeGaussian(const Device& device, VkFormat frame_format);
std::unique_ptr MakeLanczos(const Device& device, VkFormat frame_format);
std::unique_ptr MakeScaleForce(const Device& device, VkFormat frame_format);
std::unique_ptr MakeArea(const Device& device, VkFormat frame_format);
+std::unique_ptr MakeMmpx(const Device& device, VkFormat frame_format);
} // namespace Vulkan
diff --git a/src/video_core/renderer_vulkan/present/util.cpp b/src/video_core/renderer_vulkan/present/util.cpp
index 0b1a89eec0..29a1c34976 100644
--- a/src/video_core/renderer_vulkan/present/util.cpp
+++ b/src/video_core/renderer_vulkan/present/util.cpp
@@ -624,8 +624,8 @@ vk::Sampler CreateNearestNeighborSampler(const Device& device) {
return device.GetLogical().CreateSampler(ci_nn);
}
-vk::Sampler CreateCubicSampler(const Device& device) {
- const VkSamplerCreateInfo ci_nn{
+vk::Sampler CreateCubicSampler(const Device& device, VkCubicFilterWeightsQCOM qcom_weights) {
+ VkSamplerCreateInfo ci_nn{
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
.pNext = nullptr,
.flags = 0,
@@ -645,7 +645,14 @@ vk::Sampler CreateCubicSampler(const Device& device) {
.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
.unnormalizedCoordinates = VK_FALSE,
};
-
+ const VkSamplerCubicWeightsCreateInfoQCOM ci_qcom_nn{
+ .sType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM,
+ .pNext = nullptr,
+ .cubicWeights = qcom_weights
+ };
+ // If not specified, assume Catmull-Rom
+ if (qcom_weights != VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM)
+ ci_nn.pNext = &ci_qcom_nn;
return device.GetLogical().CreateSampler(ci_nn);
}
diff --git a/src/video_core/renderer_vulkan/present/util.h b/src/video_core/renderer_vulkan/present/util.h
index 11810352df..38cc6203c5 100644
--- a/src/video_core/renderer_vulkan/present/util.h
+++ b/src/video_core/renderer_vulkan/present/util.h
@@ -57,7 +57,7 @@ VkWriteDescriptorSet CreateWriteDescriptorSet(std::vector
VkDescriptorSet set, u32 binding);
vk::Sampler CreateBilinearSampler(const Device& device);
vk::Sampler CreateNearestNeighborSampler(const Device& device);
-vk::Sampler CreateCubicSampler(const Device& device);
+vk::Sampler CreateCubicSampler(const Device& device, VkCubicFilterWeightsQCOM qcom_weights);
void BeginRenderPass(vk::CommandBuffer& cmdbuf, VkRenderPass render_pass, VkFramebuffer framebuffer,
VkExtent2D extent);
diff --git a/src/video_core/renderer_vulkan/vk_blit_screen.cpp b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
index b720bcded3..0f54dd5ade 100644
--- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
@@ -7,6 +7,7 @@
// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
+#include
#include "video_core/framebuffer_config.h"
#include "video_core/present.h"
#include "video_core/renderer_vulkan/present/filters.h"
@@ -41,7 +42,16 @@ void BlitScreen::SetWindowAdaptPass() {
window_adapt = MakeNearestNeighbor(device, swapchain_view_format);
break;
case Settings::ScalingFilter::Bicubic:
- window_adapt = MakeBicubic(device, swapchain_view_format);
+ window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM);
+ break;
+ case Settings::ScalingFilter::ZeroTangent:
+ window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM);
+ break;
+ case Settings::ScalingFilter::BSpline:
+ window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM);
+ break;
+ case Settings::ScalingFilter::Mitchell:
+ window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM);
break;
case Settings::ScalingFilter::Spline1:
window_adapt = MakeSpline1(device, swapchain_view_format);
@@ -58,6 +68,9 @@ void BlitScreen::SetWindowAdaptPass() {
case Settings::ScalingFilter::Area:
window_adapt = MakeArea(device, swapchain_view_format);
break;
+ case Settings::ScalingFilter::Mmpx:
+ window_adapt = MakeMmpx(device, swapchain_view_format);
+ break;
case Settings::ScalingFilter::Fsr:
case Settings::ScalingFilter::Bilinear:
default:
diff --git a/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp b/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp
index 600003953d..3af9758a31 100644
--- a/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp
+++ b/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp
@@ -31,7 +31,7 @@ struct DescriptorBank {
bool DescriptorBankInfo::IsSuperset(const DescriptorBankInfo& subset) const noexcept {
return uniform_buffers >= subset.uniform_buffers && storage_buffers >= subset.storage_buffers &&
texture_buffers >= subset.texture_buffers && image_buffers >= subset.image_buffers &&
- textures >= subset.textures && images >= subset.image_buffers;
+ textures >= subset.textures && images >= subset.images;
}
template
diff --git a/src/video_core/vulkan_common/vulkan_device.h b/src/video_core/vulkan_common/vulkan_device.h
index bd54144480..cb13f28523 100644
--- a/src/video_core/vulkan_common/vulkan_device.h
+++ b/src/video_core/vulkan_common/vulkan_device.h
@@ -89,7 +89,8 @@ VK_DEFINE_HANDLE(VmaAllocator)
EXTENSION(NV, VIEWPORT_ARRAY2, viewport_array2) \
EXTENSION(NV, VIEWPORT_SWIZZLE, viewport_swizzle) \
EXTENSION(EXT, DESCRIPTOR_INDEXING, descriptor_indexing) \
- EXTENSION(EXT, FILTER_CUBIC, filter_cubic)
+ EXTENSION(EXT, FILTER_CUBIC, filter_cubic) \
+ EXTENSION(QCOM, FILTER_CUBIC_WEIGHTS, filter_cubic_weights)
// Define extensions which must be supported.
#define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME) \
@@ -558,6 +559,11 @@ public:
return extensions.filter_cubic;
}
+ /// Returns true if the device supports VK_QCOM_filter_cubic_weights
+ bool IsQcomFilterCubicWeightsSupported() const {
+ return extensions.filter_cubic_weights;
+ }
+
/// Returns true if the device supports VK_EXT_line_rasterization.
bool IsExtLineRasterizationSupported() const {
return extensions.line_rasterization;