mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-18 20:36:04 +00:00
fix: upscale game buffers before native-resolution composition (#1367)
* fix: upscale game buffers before native-resolution composition * fix: drop an added code comment from the effects source draw * fix: effects source keeps pillarboxed games and near-full source rectangles * fix: a larger opaque draw above keeps the full composition path --------- Co-authored-by: maxjivi05 <maxjividen@gmail.com>
This commit is contained in:
1 parent
7c5bf77f17
commit
e879375ca4
6 files changed
+786
-19
No files matched your search
@@ -1,5 +1,6 @@
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
#include "effects_chain.h"
|
||||
#include "blend_pass.h"
|
||||
#include "vk_loader.h"
|
||||
#include "vk_present.h"
|
||||
#include <pthread.h>
|
||||
@@ -146,6 +147,16 @@ int vkp_effects_active(void) {
|
||||
return spatial_mode(g_cur.scaling) || effect_count(&g_cur) > 0;
|
||||
}
|
||||
|
||||
int vkp_effects_upscaling(void) {
|
||||
vkp_effects_sync();
|
||||
return spatial_mode(g_cur.scaling) && g_cur.scaling != 6;
|
||||
}
|
||||
|
||||
int vkp_effects_postprocessing(void) {
|
||||
vkp_effects_sync();
|
||||
return effect_count(&g_cur) > 0;
|
||||
}
|
||||
|
||||
VkFilter vkp_effects_blit_filter(void) {
|
||||
vkp_effects_sync();
|
||||
return g_cur.scaling == 2 ? VK_FILTER_NEAREST : VK_FILTER_LINEAR;
|
||||
@@ -233,6 +244,7 @@ static VkImageView make_view(VkImage img, VkFormat fmt) {
|
||||
}
|
||||
|
||||
static void target_destroy(struct fx_target *t) {
|
||||
if (t->img) blendp_forget_image(t->img);
|
||||
if (t->ds) g_vk.FreeDescriptorSets(g_dev, g_dpool, 1, &t->ds);
|
||||
if (t->fb) g_vk.DestroyFramebuffer(g_dev, t->fb, NULL);
|
||||
if (t->view) g_vk.DestroyImageView(g_dev, t->view, NULL);
|
||||
|
||||
@@ -10,6 +10,9 @@ int vkp_effects_sync(void);
|
||||
|
||||
int vkp_effects_active(void);
|
||||
|
||||
int vkp_effects_upscaling(void);
|
||||
int vkp_effects_postprocessing(void);
|
||||
|
||||
VkFilter vkp_effects_blit_filter(void);
|
||||
|
||||
VkImage vkp_effects_run(VkCommandBuffer cmd, VkImage scene, int scene_w, int scene_h,
|
||||
|
||||
@@ -1271,6 +1271,57 @@ static int draw_to_scene_blit(const struct vkp_draw *d, int scene_w, int scene_h
|
||||
return map_draw(d, 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, (float)scene_w, (float)scene_h, blit);
|
||||
}
|
||||
|
||||
static int effects_source_draw(int scene_w, int scene_h, const struct vkp_draw *draws, int n,
|
||||
struct vkp_draw *out) {
|
||||
if (!draws) return 0;
|
||||
int opaque_above = 0;
|
||||
for (int i = n - 1; i >= 0; i--) {
|
||||
const struct vkp_draw *d = &draws[i];
|
||||
const struct vkp_image *im = d->img;
|
||||
if (!im || d->blend || d->dx != 0 || d->dy != 0 || d->dw != scene_w || d->dh != scene_h) {
|
||||
if (im && !d->blend && d->dw * d->dh > opaque_above) opaque_above = d->dw * d->dh;
|
||||
continue;
|
||||
}
|
||||
if (opaque_above > im->w * im->h) return 0;
|
||||
if (d->sx != 0 || d->sy != 0 || d->sw <= im->w - 1.0f || d->sw >= im->w + 1.0f ||
|
||||
d->sh <= im->h - 1.0f || d->sh >= im->h + 1.0f ||
|
||||
im->w <= 0 || im->h <= 0 || im->w > scene_w || im->h > scene_h ||
|
||||
(im->w == scene_w && im->h == scene_h) ||
|
||||
(i + 1 < n && vkp_effects_postprocessing())) return 0;
|
||||
*out = *d;
|
||||
out->dw = im->w;
|
||||
out->dh = im->h;
|
||||
return i + 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void effects_source_note(int scene_w, int scene_h, const struct vkp_draw *draws, int n,
|
||||
int input_w, int input_h, int output_w, int output_h) {
|
||||
static uint64_t previous;
|
||||
uint64_t key = 14695981039346656037ULL;
|
||||
const int sizes[] = {scene_w, scene_h, n, input_w, input_h, output_w, output_h};
|
||||
for (unsigned i = 0; i < sizeof(sizes) / sizeof(sizes[0]); i++)
|
||||
key = (key ^ (uint32_t)sizes[i]) * 1099511628211ULL;
|
||||
for (int i = 0; i < n; i++) {
|
||||
const struct vkp_draw *d = &draws[i];
|
||||
const int values[] = {d->img ? d->img->w : 0, d->img ? d->img->h : 0, d->dw, d->dh, d->blend,
|
||||
d->sx != 0 || d->sy != 0 || !d->img || d->sw != d->img->w || d->sh != d->img->h};
|
||||
for (unsigned j = 0; j < sizeof(values) / sizeof(values[0]); j++)
|
||||
key = (key ^ (uint32_t)values[j]) * 1099511628211ULL;
|
||||
}
|
||||
if (key == previous) return;
|
||||
previous = key;
|
||||
droiddeck_log("effects", "input %dx%d -> %dx%d, logical scene %dx%d, %d draws",
|
||||
input_w, input_h, output_w, output_h, scene_w, scene_h, n);
|
||||
for (int i = 0; i < n && i < 8; i++) {
|
||||
const struct vkp_draw *d = &draws[i];
|
||||
droiddeck_log("effects", "draw %d: buffer %dx%d, source %.1f,%.1f %.1fx%.1f -> scene %d,%d %dx%d, blend %d",
|
||||
i, d->img ? d->img->w : 0, d->img ? d->img->h : 0,
|
||||
d->sx, d->sy, d->sw, d->sh, d->dx, d->dy, d->dw, d->dh, d->blend);
|
||||
}
|
||||
}
|
||||
|
||||
static void record_draw(VkCommandBuffer cmd, const struct vkp_draw *d, const VkImageBlit *blit, VkImage target,
|
||||
VkFormat target_fmt, int target_w, int target_h, VkFilter filter) {
|
||||
const struct vkp_image *im = d->img;
|
||||
@@ -1282,6 +1333,34 @@ static void record_draw(VkCommandBuffer cmd, const struct vkp_draw *d, const VkI
|
||||
target, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, blit, filter);
|
||||
}
|
||||
|
||||
static void effects_overlay_draws(VkCommandBuffer cmd, VkImage result, int result_w, int result_h,
|
||||
int scene_w, int scene_h, const struct vkp_draw *draws, int n) {
|
||||
if (n <= 0) return;
|
||||
VkImageMemoryBarrier b = {
|
||||
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
|
||||
.newLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||||
.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED, .dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
|
||||
.image = result, .subresourceRange = {VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1},
|
||||
.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
|
||||
.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT | VK_ACCESS_COLOR_ATTACHMENT_READ_BIT |
|
||||
VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT};
|
||||
g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
|
||||
VK_PIPELINE_STAGE_TRANSFER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
|
||||
0, 0, NULL, 0, NULL, 1, &b);
|
||||
for (int i = 0; i < n; i++) {
|
||||
VkImageBlit blit;
|
||||
if (!draws[i].img || !map_draw(&draws[i], (float)result_w / scene_w, (float)result_h / scene_h,
|
||||
0, 0, 0, 0, (float)result_w, (float)result_h, &blit)) continue;
|
||||
record_draw(cmd, &draws[i], &blit, result, SCENE_FMT, result_w, result_h, VK_FILTER_LINEAR);
|
||||
}
|
||||
b.oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL;
|
||||
b.newLayout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
|
||||
b.srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT;
|
||||
b.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
|
||||
g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||||
0, 0, NULL, 0, NULL, 1, &b);
|
||||
}
|
||||
|
||||
static void destroy_scene_image(void) {
|
||||
if (g_scene.img) vkp_effects_forget_image(g_scene.img);
|
||||
if (g_scene.img) hdrc_forget_image(g_scene.img);
|
||||
@@ -1673,6 +1752,20 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
|
||||
cb = 0;
|
||||
}
|
||||
vkp_cardboard_begin_frame();
|
||||
int input_w = scene_w, input_h = scene_h;
|
||||
int pass_n = n;
|
||||
int overlay_start = n;
|
||||
struct vkp_draw source_draw;
|
||||
const struct vkp_draw *pass_draws = draws;
|
||||
const int source_end = fx && !hf && vkp_effects_upscaling()
|
||||
? effects_source_draw(scene_w, scene_h, draws, n, &source_draw) : 0;
|
||||
if (source_end) {
|
||||
input_w = source_draw.dw;
|
||||
input_h = source_draw.dh;
|
||||
pass_draws = &source_draw;
|
||||
pass_n = 1;
|
||||
overlay_start = source_end;
|
||||
}
|
||||
const int deep = hf && n > 0 && fg && g_swap_is_hdr && !hf->tonemap && vkp_framegen_format_ok(FG_HDR_FMT) &&
|
||||
ensure_img(&g_fgscene, scene_w, scene_h, FG_HDR_FMT,
|
||||
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
|
||||
@@ -1692,7 +1785,11 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
|
||||
"into the HDR10 swapchain (%s): banding possible in smooth gradients", sw);
|
||||
}
|
||||
}
|
||||
const int pass = deep || ((fx || fg || cb || (hf && n > 0)) && ensure_scene_image(scene_w, scene_h) == 0);
|
||||
const int pass = deep || ((fx || fg || cb || (hf && n > 0)) && ensure_scene_image(input_w, input_h) == 0);
|
||||
const int draw_n = pass ? pass_n : n;
|
||||
if (pass && fx && !hf && vkp_effects_upscaling())
|
||||
effects_source_note(scene_w, scene_h, draws, n, input_w, input_h,
|
||||
(int)(scene_w * g_map.kx + 0.5f), (int)(scene_h * g_map.ky + 0.5f));
|
||||
VkImage scene_img = deep ? g_fgscene.img : g_scene.img;
|
||||
const VkFormat scene_fmt = deep ? FG_HDR_FMT : SCENE_FMT;
|
||||
const VkFilter blit_filter = vkp_effects_blit_filter();
|
||||
@@ -1743,11 +1840,12 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
|
||||
int covered = 0;
|
||||
VkImageBlit cover_blit;
|
||||
if (!(hf && pass)) {
|
||||
for (int i = n - 1; i >= 0 && !covered; i--) {
|
||||
const struct vkp_draw *d = &draws[i];
|
||||
if (!d->img || d->blend || d->dx > 0 || d->dy > 0 || d->dx + d->dw < scene_w ||
|
||||
d->dy + d->dh < scene_h) continue;
|
||||
covered = pass ? draw_to_scene_blit(d, scene_w, scene_h, &cover_blit) : draw_to_blit(d, &cover_blit);
|
||||
for (int i = draw_n - 1; i >= 0 && !covered; i--) {
|
||||
const struct vkp_draw *d = pass ? &pass_draws[i] : &draws[i];
|
||||
const int target_w = pass ? input_w : scene_w, target_h = pass ? input_h : scene_h;
|
||||
if (!d->img || d->blend || d->dx > 0 || d->dy > 0 || d->dx + d->dw < target_w ||
|
||||
d->dy + d->dh < target_h) continue;
|
||||
covered = pass ? draw_to_scene_blit(d, input_w, input_h, &cover_blit) : draw_to_blit(d, &cover_blit);
|
||||
}
|
||||
}
|
||||
const int cleared = covered && (pass || record_bars_clear(cmd, target, &cover_blit));
|
||||
@@ -1771,12 +1869,13 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
|
||||
hdr_how = g_swap_is_hdr ? 1 : 2;
|
||||
drawn = n;
|
||||
}
|
||||
for (int i = 0; i < n && !hdr_how; i++) {
|
||||
for (int i = 0; i < draw_n && !hdr_how; i++) {
|
||||
VkImageBlit blit;
|
||||
if (!draws[i].img) continue;
|
||||
if (pass ? !draw_to_scene_blit(&draws[i], scene_w, scene_h, &blit) : !draw_to_blit(&draws[i], &blit)) continue;
|
||||
record_draw(cmd, &draws[i], &blit, target, pass ? scene_fmt : g_swap_fmt,
|
||||
pass ? scene_w : (int)g_extent.width, pass ? scene_h : (int)g_extent.height,
|
||||
const struct vkp_draw *d = pass ? &pass_draws[i] : &draws[i];
|
||||
if (!d->img) continue;
|
||||
if (pass ? !draw_to_scene_blit(d, input_w, input_h, &blit) : !draw_to_blit(d, &blit)) continue;
|
||||
record_draw(cmd, d, &blit, target, pass ? scene_fmt : g_swap_fmt,
|
||||
pass ? input_w : (int)g_extent.width, pass ? input_h : (int)g_extent.height,
|
||||
pass ? VK_FILTER_LINEAR : blit_filter);
|
||||
drawn++;
|
||||
}
|
||||
@@ -1784,7 +1883,7 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
|
||||
int ngen = 0;
|
||||
VkImage gens[VKP_FG_MAX_GENERATIONS] = {VK_NULL_HANDLE};
|
||||
VkImage result = scene_img;
|
||||
int rw = scene_w, rh = scene_h;
|
||||
int rw = input_w, rh = input_h;
|
||||
if (!pass) {
|
||||
VkImageMemoryBarrier b_present = {
|
||||
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, .oldLayout = VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||||
@@ -1799,7 +1898,9 @@ static int render_impl(int scene_w, int scene_h, const struct vkp_draw *draws, i
|
||||
int mapped_w = (int)(scene_w * g_map.kx + 0.5f), mapped_h = (int)(scene_h * g_map.ky + 0.5f);
|
||||
if (fg) { mapped_w = scene_w; mapped_h = scene_h; }
|
||||
vkp_effects_set_formats(scene_fmt, scene_fmt);
|
||||
result = vkp_effects_run(cmd, scene_img, scene_w, scene_h, mapped_w, mapped_h, &rw, &rh);
|
||||
result = vkp_effects_run(cmd, scene_img, input_w, input_h, mapped_w, mapped_h, &rw, &rh);
|
||||
effects_overlay_draws(cmd, result, rw, rh, scene_w, scene_h,
|
||||
draws ? draws + overlay_start : NULL, n - overlay_start);
|
||||
result_layout = VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL;
|
||||
}
|
||||
VkImageMemoryBarrier b_general = {
|
||||
@@ -2158,13 +2259,31 @@ static int pass_begin_impl(int scene_w, int scene_h, const struct vkp_draw *draw
|
||||
const struct vkp_hdr_frame *hf, int *rw, int *rh) {
|
||||
if (g_pass.active) vkp_pass_abort();
|
||||
if (vkp_update_map(scene_w, scene_h) != 0) return -1;
|
||||
int input_w = scene_w, input_h = scene_h;
|
||||
int pass_n = n, overlay_start = n;
|
||||
struct vkp_draw source_draw;
|
||||
const struct vkp_draw *pass_draws = draws;
|
||||
const int source_end = !hf && vkp_effects_upscaling()
|
||||
? effects_source_draw(scene_w, scene_h, draws, n, &source_draw) : 0;
|
||||
if (source_end) {
|
||||
input_w = source_draw.dw;
|
||||
input_h = source_draw.dh;
|
||||
effects_source_note(scene_w, scene_h, draws, n, input_w, input_h,
|
||||
(int)(scene_w * g_map.kx + 0.5f), (int)(scene_h * g_map.ky + 0.5f));
|
||||
pass_draws = &source_draw;
|
||||
pass_n = 1;
|
||||
overlay_start = source_end;
|
||||
} else if (!hf && vkp_effects_upscaling()) {
|
||||
effects_source_note(scene_w, scene_h, draws, n, input_w, input_h,
|
||||
(int)(scene_w * g_map.kx + 0.5f), (int)(scene_h * g_map.ky + 0.5f));
|
||||
}
|
||||
if (hf) {
|
||||
if (ensure_img(&g_hdrscene, scene_w, scene_h, HDR_FMT,
|
||||
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_SAMPLED_BIT |
|
||||
VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT,
|
||||
"HDR composition (picture)") != 0)
|
||||
return -1;
|
||||
} else if (ensure_scene_image(scene_w, scene_h) != 0) return -1;
|
||||
} else if (ensure_scene_image(input_w, input_h) != 0) return -1;
|
||||
|
||||
VkCommandBuffer cmd = g_cmds[0];
|
||||
g_vk.ResetCommandBuffer(cmd, 0);
|
||||
@@ -2224,19 +2343,21 @@ static int pass_begin_impl(int scene_w, int scene_h, const struct vkp_draw *draw
|
||||
.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT};
|
||||
g_vk.CmdPipelineBarrier(cmd, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||||
0, 1, &mb, 0, NULL, 0, NULL);
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int i = 0; i < pass_n; i++) {
|
||||
VkImageBlit blit;
|
||||
if (!draws[i].img || !draw_to_scene_blit(&draws[i], scene_w, scene_h, &blit)) continue;
|
||||
record_draw(cmd, &draws[i], &blit, g_scene.img, SCENE_FMT, scene_w, scene_h,
|
||||
if (!pass_draws[i].img || !draw_to_scene_blit(&pass_draws[i], input_w, input_h, &blit)) continue;
|
||||
record_draw(cmd, &pass_draws[i], &blit, g_scene.img, SCENE_FMT, input_w, input_h,
|
||||
VK_FILTER_LINEAR);
|
||||
}
|
||||
if (vkp_effects_active()) vkp_effects_set_formats(VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM);
|
||||
}
|
||||
|
||||
int mapped_w = (int)(scene_w * g_map.kx + 0.5f), mapped_h = (int)(scene_h * g_map.ky + 0.5f);
|
||||
g_pass.rw = scene_w; g_pass.rh = scene_h;
|
||||
g_pass.result = vkp_effects_run(cmd, scene_img, scene_w, scene_h, mapped_w, mapped_h,
|
||||
g_pass.rw = input_w; g_pass.rh = input_h;
|
||||
g_pass.result = vkp_effects_run(cmd, scene_img, input_w, input_h, mapped_w, mapped_h,
|
||||
&g_pass.rw, &g_pass.rh);
|
||||
effects_overlay_draws(cmd, g_pass.result, g_pass.rw, g_pass.rh, scene_w, scene_h,
|
||||
draws ? draws + overlay_start : NULL, n - overlay_start);
|
||||
g_pass.active = 1;
|
||||
if (rw) *rw = g_pass.rw;
|
||||
if (rh) *rh = g_pass.rh;
|
||||
|
||||
Reference in new issue
Block a user