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

renderer_vulkan: Remove upload_cmdbuf

Browse Source 
* No longer needed with the new stream buffer
This commit is contained in:
GPUCode
2022-12-31 17:44:15 +02:00
parent 2c34f41747
commit b1a02e1710
11 changed files with 127 additions and 151 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
src/video_core/renderer_vulkan/renderer_vulkan.cpp
View File

@@ -206,12 +206,11 @@ void RendererVulkan::BeginRendering() {
vk::DescriptorSet set = desc_manager.AllocateSet(present_descriptor_layout); vk::DescriptorSet set = desc_manager.AllocateSet(present_descriptor_layout);
device.updateDescriptorSetWithTemplate(set, present_update_template, present_textures[0]); device.updateDescriptorSetWithTemplate(set, present_update_template, present_textures[0]);
scheduler.Record([this, set, pipeline_index = current_pipeline](vk::CommandBuffer render_cmdbuf, scheduler.Record([this, set, pipeline_index = current_pipeline](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) { cmdbuf.bindPipeline(vk::PipelineBindPoint::eGraphics,
render_cmdbuf.bindPipeline(vk::PipelineBindPoint::eGraphics,
present_pipelines[pipeline_index]); present_pipelines[pipeline_index]);
render_cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, present_pipeline_layout, cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, present_pipeline_layout,
0, set, {}); 0, set, {});
}); });
@@ -529,8 +528,7 @@ void RendererVulkan::LoadColorToActiveVkTexture(u8 color_r, u8 color_g, u8 color
}; };
renderpass_cache.ExitRenderpass(); renderpass_cache.ExitRenderpass();
scheduler.Record([image = texture.alloc.image, clear_color](vk::CommandBuffer render_cmdbuf, scheduler.Record([image = texture.alloc.image, clear_color](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) {
const vk::ImageSubresourceRange range = { const vk::ImageSubresourceRange range = {
.aspectMask = vk::ImageAspectFlagBits::eColor, .aspectMask = vk::ImageAspectFlagBits::eColor,
.baseMipLevel = 0, .baseMipLevel = 0,
@@ -561,14 +559,14 @@ void RendererVulkan::LoadColorToActiveVkTexture(u8 color_r, u8 color_g, u8 color
.subresourceRange = range, .subresourceRange = range,
}; };
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eFragmentShader, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eFragmentShader,
vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier); vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier);
render_cmdbuf.clearColorImage(image, vk::ImageLayout::eTransferDstOptimal, clear_color, cmdbuf.clearColorImage(image, vk::ImageLayout::eTransferDstOptimal, clear_color,
range); range);
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eFragmentShader, vk::PipelineStageFlagBits::eFragmentShader,
vk::DependencyFlagBits::eByRegion, {}, {}, post_barrier); vk::DependencyFlagBits::eByRegion, {}, {}, post_barrier);
}); });
@@ -625,15 +623,14 @@ void RendererVulkan::DrawSingleScreenRotated(u32 screen_id, float x, float y, fl
draw_info.o_resolution = Common::Vec4f{h, w, 1.0f / h, 1.0f / w}; draw_info.o_resolution = Common::Vec4f{h, w, 1.0f / h, 1.0f / w};
draw_info.screen_id_l = screen_id; draw_info.screen_id_l = screen_id;
scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer render_cmdbuf, scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) { cmdbuf.pushConstants(present_pipeline_layout,
render_cmdbuf.pushConstants(present_pipeline_layout,
vk::ShaderStageFlagBits::eFragment | vk::ShaderStageFlagBits::eFragment |
vk::ShaderStageFlagBits::eVertex, vk::ShaderStageFlagBits::eVertex,
0, sizeof(info), &info); 0, sizeof(info), &info);
render_cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0}); cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0});
render_cmdbuf.draw(4, 1, offset / sizeof(ScreenRectVertex), 0); cmdbuf.draw(4, 1, offset / sizeof(ScreenRectVertex), 0);
}); });
} }
@@ -664,15 +661,14 @@ void RendererVulkan::DrawSingleScreen(u32 screen_id, float x, float y, float w,
draw_info.o_resolution = Common::Vec4f{h, w, 1.0f / h, 1.0f / w}; draw_info.o_resolution = Common::Vec4f{h, w, 1.0f / h, 1.0f / w};
draw_info.screen_id_l = screen_id; draw_info.screen_id_l = screen_id;
scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer render_cmdbuf, scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) { cmdbuf.pushConstants(present_pipeline_layout,
render_cmdbuf.pushConstants(present_pipeline_layout,
vk::ShaderStageFlagBits::eFragment | vk::ShaderStageFlagBits::eFragment |
vk::ShaderStageFlagBits::eVertex, vk::ShaderStageFlagBits::eVertex,
0, sizeof(info), &info); 0, sizeof(info), &info);
render_cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0}); cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0});
render_cmdbuf.draw(4, 1, offset / sizeof(ScreenRectVertex), 0); cmdbuf.draw(4, 1, offset / sizeof(ScreenRectVertex), 0);
}); });
} }
@@ -704,15 +700,14 @@ void RendererVulkan::DrawSingleScreenStereoRotated(u32 screen_id_l, u32 screen_i
draw_info.screen_id_l = screen_id_l; draw_info.screen_id_l = screen_id_l;
draw_info.screen_id_r = screen_id_r; draw_info.screen_id_r = screen_id_r;
scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer render_cmdbuf, scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) { cmdbuf.pushConstants(present_pipeline_layout,
render_cmdbuf.pushConstants(present_pipeline_layout,
vk::ShaderStageFlagBits::eFragment | vk::ShaderStageFlagBits::eFragment |
vk::ShaderStageFlagBits::eVertex, vk::ShaderStageFlagBits::eVertex,
0, sizeof(info), &info); 0, sizeof(info), &info);
render_cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0}); cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0});
render_cmdbuf.draw(4, 1, offset / sizeof(ScreenRectVertex), 0); cmdbuf.draw(4, 1, offset / sizeof(ScreenRectVertex), 0);
}); });
} }
@@ -746,15 +741,14 @@ void RendererVulkan::DrawSingleScreenStereo(u32 screen_id_l, u32 screen_id_r, fl
draw_info.screen_id_l = screen_id_l; draw_info.screen_id_l = screen_id_l;
draw_info.screen_id_r = screen_id_r; draw_info.screen_id_r = screen_id_r;
scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer render_cmdbuf, scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) { cmdbuf.pushConstants(present_pipeline_layout,
render_cmdbuf.pushConstants(present_pipeline_layout,
vk::ShaderStageFlagBits::eFragment | vk::ShaderStageFlagBits::eFragment |
vk::ShaderStageFlagBits::eVertex, vk::ShaderStageFlagBits::eVertex,
0, sizeof(info), &info); 0, sizeof(info), &info);
render_cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0}); cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0});
render_cmdbuf.draw(4, 1, offset / sizeof(ScreenRectVertex), 0); cmdbuf.draw(4, 1, offset / sizeof(ScreenRectVertex), 0);
}); });
} }
@@ -925,7 +919,7 @@ void RendererVulkan::SwapBuffers() {
swapchain.AcquireNextImage(); swapchain.AcquireNextImage();
} while (swapchain.NeedsRecreation()); } while (swapchain.NeedsRecreation());
scheduler.Record([layout](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { scheduler.Record([layout](vk::CommandBuffer cmdbuf) {
const vk::Viewport viewport = { const vk::Viewport viewport = {
.x = 0.0f, .x = 0.0f,
.y = 0.0f, .y = 0.0f,
@@ -940,8 +934,8 @@ void RendererVulkan::SwapBuffers() {
.extent = {layout.width, layout.height}, .extent = {layout.width, layout.height},
}; };
render_cmdbuf.setViewport(0, viewport); cmdbuf.setViewport(0, viewport);
render_cmdbuf.setScissor(0, scissor); cmdbuf.setScissor(0, scissor);
}); });
DrawScreens(layout, false); DrawScreens(layout, false);

15
src/video_core/renderer_vulkan/vk_blit_helper.cpp
View File

@@ -167,8 +167,7 @@ void BlitHelper::BlitD24S8ToR32(Surface& source, Surface& dest,
device.updateDescriptorSetWithTemplate(set, update_template, textures[0]); device.updateDescriptorSetWithTemplate(set, update_template, textures[0]);
scheduler.Record([this, set, blit, src_image = source.alloc.image, scheduler.Record([this, set, blit, src_image = source.alloc.image,
dst_image = dest.alloc.image](vk::CommandBuffer render_cmdbuf, dst_image = dest.alloc.image](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) {
const std::array pre_barriers = { const std::array pre_barriers = {
vk::ImageMemoryBarrier{ vk::ImageMemoryBarrier{
.srcAccessMask = vk::AccessFlagBits::eShaderWrite | .srcAccessMask = vk::AccessFlagBits::eShaderWrite |
@@ -240,21 +239,21 @@ void BlitHelper::BlitD24S8ToR32(Surface& source, Surface& dest,
.layerCount = VK_REMAINING_ARRAY_LAYERS, .layerCount = VK_REMAINING_ARRAY_LAYERS,
}, },
}}; }};
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eAllCommands, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eAllCommands,
vk::PipelineStageFlagBits::eComputeShader, vk::PipelineStageFlagBits::eComputeShader,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barriers); vk::DependencyFlagBits::eByRegion, {}, {}, pre_barriers);
render_cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, compute_pipeline_layout, cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, compute_pipeline_layout,
0, set, {}); 0, set, {});
render_cmdbuf.bindPipeline(vk::PipelineBindPoint::eCompute, compute_pipeline); cmdbuf.bindPipeline(vk::PipelineBindPoint::eCompute, compute_pipeline);
const auto src_offset = Common::MakeVec(blit.src_rect.left, blit.src_rect.bottom); const auto src_offset = Common::MakeVec(blit.src_rect.left, blit.src_rect.bottom);
render_cmdbuf.pushConstants(compute_pipeline_layout, vk::ShaderStageFlagBits::eCompute, 0, cmdbuf.pushConstants(compute_pipeline_layout, vk::ShaderStageFlagBits::eCompute, 0,
sizeof(Common::Vec2i), src_offset.AsArray()); sizeof(Common::Vec2i), src_offset.AsArray());
render_cmdbuf.dispatch(blit.src_rect.GetWidth() / 8, blit.src_rect.GetHeight() / 8, 1); cmdbuf.dispatch(blit.src_rect.GetWidth() / 8, blit.src_rect.GetHeight() / 8, 1);
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eComputeShader, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eComputeShader,
vk::PipelineStageFlagBits::eAllCommands, vk::PipelineStageFlagBits::eAllCommands,
vk::DependencyFlagBits::eByRegion, {}, {}, post_barriers); vk::DependencyFlagBits::eByRegion, {}, {}, post_barriers);
}); });

4
src/video_core/renderer_vulkan/vk_descriptor_manager.cpp
View File

@@ -132,8 +132,8 @@ void DescriptorManager::BindDescriptorSets() {
bound_sets[i] = descriptor_sets[i]; bound_sets[i] = descriptor_sets[i];
} }
scheduler.Record([this, bound_sets](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { scheduler.Record([this, bound_sets](vk::CommandBuffer cmdbuf) {
render_cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline_layout, 0, cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline_layout, 0,
bound_sets, {}); bound_sets, {});
}); });

15
src/video_core/renderer_vulkan/vk_format_reinterpreter.cpp
View File

@@ -165,8 +165,7 @@ void D24S8toRGBA8::Reinterpret(Surface& source, VideoCore::Rect2D src_rect, Surf
runtime.GetRenderpassCache().ExitRenderpass(); runtime.GetRenderpassCache().ExitRenderpass();
scheduler.Record([this, set, src_rect, src_image = source.alloc.image, scheduler.Record([this, set, src_rect, src_image = source.alloc.image,
dst_image = dest.alloc.image](vk::CommandBuffer render_cmdbuf, dst_image = dest.alloc.image](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) {
const vk::ImageMemoryBarrier pre_barrier = { const vk::ImageMemoryBarrier pre_barrier = {
.srcAccessMask = vk::AccessFlagBits::eShaderWrite | .srcAccessMask = vk::AccessFlagBits::eShaderWrite |
vk::AccessFlagBits::eDepthStencilAttachmentWrite | vk::AccessFlagBits::eDepthStencilAttachmentWrite |
@@ -221,21 +220,21 @@ void D24S8toRGBA8::Reinterpret(Surface& source, VideoCore::Rect2D src_rect, Surf
}, },
}}; }};
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eAllCommands, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eAllCommands,
vk::PipelineStageFlagBits::eComputeShader, vk::PipelineStageFlagBits::eComputeShader,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier); vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier);
render_cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, compute_pipeline_layout, cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, compute_pipeline_layout,
0, set, {}); 0, set, {});
render_cmdbuf.bindPipeline(vk::PipelineBindPoint::eCompute, compute_pipeline); cmdbuf.bindPipeline(vk::PipelineBindPoint::eCompute, compute_pipeline);
const auto src_offset = Common::MakeVec(src_rect.left, src_rect.bottom); const auto src_offset = Common::MakeVec(src_rect.left, src_rect.bottom);
render_cmdbuf.pushConstants(compute_pipeline_layout, vk::ShaderStageFlagBits::eCompute, 0, cmdbuf.pushConstants(compute_pipeline_layout, vk::ShaderStageFlagBits::eCompute, 0,
sizeof(Common::Vec2i), src_offset.AsArray()); sizeof(Common::Vec2i), src_offset.AsArray());
render_cmdbuf.dispatch(src_rect.GetWidth() / 8, src_rect.GetHeight() / 8, 1); cmdbuf.dispatch(src_rect.GetWidth() / 8, src_rect.GetHeight() / 8, 1);
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eComputeShader, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eComputeShader,
vk::PipelineStageFlagBits::eAllCommands, vk::PipelineStageFlagBits::eAllCommands,
vk::DependencyFlagBits::eByRegion, {}, {}, post_barriers); vk::DependencyFlagBits::eByRegion, {}, {}, post_barriers);
}); });

49
src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
View File

@@ -197,7 +197,7 @@ void PipelineCache::SaveDiskCache() {
void PipelineCache::BindPipeline(const PipelineInfo& info) { void PipelineCache::BindPipeline(const PipelineInfo& info) {
ApplyDynamic(info); ApplyDynamic(info);
scheduler.Record([this, info](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { scheduler.Record([this, info](vk::CommandBuffer cmdbuf) {
std::size_t shader_hash = 0; std::size_t shader_hash = 0;
for (u32 i = 0; i < MAX_SHADER_STAGES; i++) { for (u32 i = 0; i < MAX_SHADER_STAGES; i++) {
shader_hash = Common::HashCombine(shader_hash, shader_hashes[i]); shader_hash = Common::HashCombine(shader_hash, shader_hashes[i]);
@@ -215,7 +215,7 @@ void PipelineCache::BindPipeline(const PipelineInfo& info) {
it->second = BuildPipeline(info); it->second = BuildPipeline(info);
} }
render_cmdbuf.bindPipeline(vk::PipelineBindPoint::eGraphics, it->second); cmdbuf.bindPipeline(vk::PipelineBindPoint::eGraphics, it->second);
current_pipeline = it->second; current_pipeline = it->second;
}); });
@@ -248,7 +248,7 @@ bool PipelineCache::UseProgrammableVertexShader(const Pica::Regs& regs,
} }
scheduler.Record( scheduler.Record(
[this, handle = handle, hash = config.Hash()](vk::CommandBuffer, vk::CommandBuffer) { [this, handle = handle, hash = config.Hash()](vk::CommandBuffer) {
current_shaders[ProgramType::VS] = handle; current_shaders[ProgramType::VS] = handle;
shader_hashes[ProgramType::VS] = hash; shader_hashes[ProgramType::VS] = hash;
}); });
@@ -257,7 +257,7 @@ bool PipelineCache::UseProgrammableVertexShader(const Pica::Regs& regs,
} }
void PipelineCache::UseTrivialVertexShader() { void PipelineCache::UseTrivialVertexShader() {
scheduler.Record([this](vk::CommandBuffer, vk::CommandBuffer) { scheduler.Record([this](vk::CommandBuffer) {
current_shaders[ProgramType::VS] = trivial_vertex_shader; current_shaders[ProgramType::VS] = trivial_vertex_shader;
shader_hashes[ProgramType::VS] = 0; shader_hashes[ProgramType::VS] = 0;
}); });
@@ -273,14 +273,14 @@ void PipelineCache::UseFixedGeometryShader(const Pica::Regs& regs) {
fixed_geometry_shaders.Get(gs_config, vk::ShaderStageFlagBits::eGeometry, fixed_geometry_shaders.Get(gs_config, vk::ShaderStageFlagBits::eGeometry,
instance.GetDevice(), ShaderOptimization::Debug); instance.GetDevice(), ShaderOptimization::Debug);
scheduler.Record([this, handle, hash = gs_config.Hash()](vk::CommandBuffer, vk::CommandBuffer) { scheduler.Record([this, handle, hash = gs_config.Hash()](vk::CommandBuffer) {
current_shaders[ProgramType::GS] = handle; current_shaders[ProgramType::GS] = handle;
shader_hashes[ProgramType::GS] = hash; shader_hashes[ProgramType::GS] = hash;
}); });
} }
void PipelineCache::UseTrivialGeometryShader() { void PipelineCache::UseTrivialGeometryShader() {
scheduler.Record([this](vk::CommandBuffer, vk::CommandBuffer) { scheduler.Record([this](vk::CommandBuffer) {
current_shaders[ProgramType::GS] = VK_NULL_HANDLE; current_shaders[ProgramType::GS] = VK_NULL_HANDLE;
shader_hashes[ProgramType::GS] = 0; shader_hashes[ProgramType::GS] = 0;
}); });
@@ -291,7 +291,7 @@ MICROPROFILE_DEFINE(Vulkan_FragmentGeneration, "Vulkan", "Fragment Shader Compil
void PipelineCache::UseFragmentShader(const Pica::Regs& regs) { void PipelineCache::UseFragmentShader(const Pica::Regs& regs) {
const PicaFSConfig config{regs, instance}; const PicaFSConfig config{regs, instance};
scheduler.Record([this, config](vk::CommandBuffer, vk::CommandBuffer) { scheduler.Record([this, config](vk::CommandBuffer) {
MICROPROFILE_SCOPE(Vulkan_FragmentGeneration); MICROPROFILE_SCOPE(Vulkan_FragmentGeneration);
vk::ShaderModule handle{}; vk::ShaderModule handle{};
@@ -354,15 +354,15 @@ void PipelineCache::BindSampler(u32 binding, vk::Sampler sampler) {
void PipelineCache::SetViewport(float x, float y, float width, float height) { void PipelineCache::SetViewport(float x, float y, float width, float height) {
const vk::Viewport viewport{x, y, width, height, 0.f, 1.f}; const vk::Viewport viewport{x, y, width, height, 0.f, 1.f};
scheduler.Record([viewport](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { scheduler.Record([viewport](vk::CommandBuffer cmdbuf) {
render_cmdbuf.setViewport(0, viewport); cmdbuf.setViewport(0, viewport);
}); });
} }
void PipelineCache::SetScissor(s32 x, s32 y, u32 width, u32 height) { void PipelineCache::SetScissor(s32 x, s32 y, u32 width, u32 height) {
const vk::Rect2D scissor{{x, y}, {width, height}}; const vk::Rect2D scissor{{x, y}, {width, height}};
scheduler.Record([scissor](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { scheduler.Record([scissor](vk::CommandBuffer cmdbuf) {
render_cmdbuf.setScissor(0, scissor); cmdbuf.setScissor(0, scissor);
}); });
} }
@@ -370,59 +370,58 @@ void PipelineCache::ApplyDynamic(const PipelineInfo& info) {
const bool is_dirty = scheduler.IsStateDirty(StateFlags::Pipeline); const bool is_dirty = scheduler.IsStateDirty(StateFlags::Pipeline);
PipelineInfo current = current_info; PipelineInfo current = current_info;
scheduler.Record([this, info, is_dirty, current](vk::CommandBuffer render_cmdbuf, scheduler.Record([this, info, is_dirty, current](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) {
if (info.dynamic.stencil_compare_mask != current.dynamic.stencil_compare_mask || is_dirty) { if (info.dynamic.stencil_compare_mask != current.dynamic.stencil_compare_mask || is_dirty) {
render_cmdbuf.setStencilCompareMask(vk::StencilFaceFlagBits::eFrontAndBack, cmdbuf.setStencilCompareMask(vk::StencilFaceFlagBits::eFrontAndBack,
info.dynamic.stencil_compare_mask); info.dynamic.stencil_compare_mask);
} }
if (info.dynamic.stencil_write_mask != current.dynamic.stencil_write_mask || is_dirty) { if (info.dynamic.stencil_write_mask != current.dynamic.stencil_write_mask || is_dirty) {
render_cmdbuf.setStencilWriteMask(vk::StencilFaceFlagBits::eFrontAndBack, cmdbuf.setStencilWriteMask(vk::StencilFaceFlagBits::eFrontAndBack,
info.dynamic.stencil_write_mask); info.dynamic.stencil_write_mask);
} }
if (info.dynamic.stencil_reference != current.dynamic.stencil_reference || is_dirty) { if (info.dynamic.stencil_reference != current.dynamic.stencil_reference || is_dirty) {
render_cmdbuf.setStencilReference(vk::StencilFaceFlagBits::eFrontAndBack, cmdbuf.setStencilReference(vk::StencilFaceFlagBits::eFrontAndBack,
info.dynamic.stencil_reference); info.dynamic.stencil_reference);
} }
if (info.dynamic.blend_color != current.dynamic.blend_color || is_dirty) { if (info.dynamic.blend_color != current.dynamic.blend_color || is_dirty) {
const Common::Vec4f color = PicaToVK::ColorRGBA8(info.dynamic.blend_color); const Common::Vec4f color = PicaToVK::ColorRGBA8(info.dynamic.blend_color);
render_cmdbuf.setBlendConstants(color.AsArray()); cmdbuf.setBlendConstants(color.AsArray());
} }
if (instance.IsExtendedDynamicStateSupported()) { if (instance.IsExtendedDynamicStateSupported()) {
if (info.rasterization.cull_mode != current.rasterization.cull_mode || is_dirty) { if (info.rasterization.cull_mode != current.rasterization.cull_mode || is_dirty) {
render_cmdbuf.setCullModeEXT(PicaToVK::CullMode(info.rasterization.cull_mode)); cmdbuf.setCullModeEXT(PicaToVK::CullMode(info.rasterization.cull_mode));
render_cmdbuf.setFrontFaceEXT(PicaToVK::FrontFace(info.rasterization.cull_mode)); cmdbuf.setFrontFaceEXT(PicaToVK::FrontFace(info.rasterization.cull_mode));
} }
if (info.depth_stencil.depth_compare_op != current.depth_stencil.depth_compare_op || if (info.depth_stencil.depth_compare_op != current.depth_stencil.depth_compare_op ||
is_dirty) { is_dirty) {
render_cmdbuf.setDepthCompareOpEXT( cmdbuf.setDepthCompareOpEXT(
PicaToVK::CompareFunc(info.depth_stencil.depth_compare_op)); PicaToVK::CompareFunc(info.depth_stencil.depth_compare_op));
} }
if (info.depth_stencil.depth_test_enable != current.depth_stencil.depth_test_enable || if (info.depth_stencil.depth_test_enable != current.depth_stencil.depth_test_enable ||
is_dirty) { is_dirty) {
render_cmdbuf.setDepthTestEnableEXT(info.depth_stencil.depth_test_enable); cmdbuf.setDepthTestEnableEXT(info.depth_stencil.depth_test_enable);
} }
if (info.depth_stencil.depth_write_enable != current.depth_stencil.depth_write_enable || if (info.depth_stencil.depth_write_enable != current.depth_stencil.depth_write_enable ||
is_dirty) { is_dirty) {
render_cmdbuf.setDepthWriteEnableEXT(info.depth_stencil.depth_write_enable); cmdbuf.setDepthWriteEnableEXT(info.depth_stencil.depth_write_enable);
} }
if (info.rasterization.topology != current.rasterization.topology || is_dirty) { if (info.rasterization.topology != current.rasterization.topology || is_dirty) {
render_cmdbuf.setPrimitiveTopologyEXT( cmdbuf.setPrimitiveTopologyEXT(
PicaToVK::PrimitiveTopology(info.rasterization.topology)); PicaToVK::PrimitiveTopology(info.rasterization.topology));
} }
if (info.depth_stencil.stencil_test_enable != if (info.depth_stencil.stencil_test_enable !=
current.depth_stencil.stencil_test_enable || current.depth_stencil.stencil_test_enable ||
is_dirty) { is_dirty) {
render_cmdbuf.setStencilTestEnableEXT(info.depth_stencil.stencil_test_enable); cmdbuf.setStencilTestEnableEXT(info.depth_stencil.stencil_test_enable);
} }
if (info.depth_stencil.stencil_fail_op != current.depth_stencil.stencil_fail_op || if (info.depth_stencil.stencil_fail_op != current.depth_stencil.stencil_fail_op ||
@@ -431,7 +430,7 @@ void PipelineCache::ApplyDynamic(const PipelineInfo& info) {
current.depth_stencil.stencil_depth_fail_op || current.depth_stencil.stencil_depth_fail_op ||
info.depth_stencil.stencil_compare_op != current.depth_stencil.stencil_compare_op || info.depth_stencil.stencil_compare_op != current.depth_stencil.stencil_compare_op ||
is_dirty) { is_dirty) {
render_cmdbuf.setStencilOpEXT( cmdbuf.setStencilOpEXT(
vk::StencilFaceFlagBits::eFrontAndBack, vk::StencilFaceFlagBits::eFrontAndBack,
PicaToVK::StencilOp(info.depth_stencil.stencil_fail_op), PicaToVK::StencilOp(info.depth_stencil.stencil_fail_op),
PicaToVK::StencilOp(info.depth_stencil.stencil_pass_op), PicaToVK::StencilOp(info.depth_stencil.stencil_pass_op),

22
src/video_core/renderer_vulkan/vk_rasterizer.cpp
View File

@@ -285,9 +285,9 @@ void RasterizerVulkan::SetupVertexArray(u32 vs_input_size, u32 vs_input_index_mi
SetupFixedAttribs(); SetupFixedAttribs();
// Bind the generated bindings // Bind the generated bindings
scheduler.Record([this, binding_count = layout.binding_count, vertex_offsets = binding_offsets]( scheduler.Record([this, binding_count = layout.binding_count, vertex_offsets = binding_offsets]
vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { (vk::CommandBuffer cmdbuf) {
render_cmdbuf.bindVertexBuffers(0, binding_count, vertex_buffers.data(), cmdbuf.bindVertexBuffers(0, binding_count, vertex_buffers.data(),
vertex_offsets.data()); vertex_offsets.data());
}); });
} }
@@ -423,11 +423,11 @@ bool RasterizerVulkan::AccelerateDrawBatchInternal(bool is_indexed) {
.is_indexed = is_indexed, .is_indexed = is_indexed,
}; };
scheduler.Record([params](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { scheduler.Record([params](vk::CommandBuffer cmdbuf) {
if (params.is_indexed) { if (params.is_indexed) {
render_cmdbuf.drawIndexed(params.vertex_count, 1, 0, params.vertex_offset, 0); cmdbuf.drawIndexed(params.vertex_count, 1, 0, params.vertex_offset, 0);
} else { } else {
render_cmdbuf.draw(params.vertex_count, 1, 0, 0); cmdbuf.draw(params.vertex_count, 1, 0, 0);
} }
}); });
@@ -459,8 +459,8 @@ void RasterizerVulkan::SetupIndexArray() {
stream_buffer.Commit(index_buffer_size); stream_buffer.Commit(index_buffer_size);
scheduler.Record([this, index_offset = index_offset, scheduler.Record([this, index_offset = index_offset,
index_type = index_type](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { index_type = index_type](vk::CommandBuffer cmdbuf) {
render_cmdbuf.bindIndexBuffer(stream_buffer.Handle(), index_offset, index_type); cmdbuf.bindIndexBuffer(stream_buffer.Handle(), index_offset, index_type);
}); });
} }
@@ -780,9 +780,9 @@ bool RasterizerVulkan::Draw(bool accelerate, bool is_indexed) {
stream_buffer.Commit(vertex_size); stream_buffer.Commit(vertex_size);
scheduler.Record([this, vertices, base_vertex, scheduler.Record([this, vertices, base_vertex,
offset = offset](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { offset = offset](vk::CommandBuffer cmdbuf) {
render_cmdbuf.bindVertexBuffers(0, stream_buffer.Handle(), offset); cmdbuf.bindVertexBuffers(0, stream_buffer.Handle(), offset);
render_cmdbuf.draw(vertices, 1, base_vertex, 0); cmdbuf.draw(vertices, 1, base_vertex, 0);
}); });
} }
} }

10
src/video_core/renderer_vulkan/vk_renderpass_cache.cpp
View File

@@ -95,9 +95,9 @@ void RenderpassCache::EnterRenderpass(const RenderpassState& state) {
} }
scheduler.Record([should_end = bool(current_state.renderpass), scheduler.Record([should_end = bool(current_state.renderpass),
state](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { state](vk::CommandBuffer cmdbuf) {
if (should_end) { if (should_end) {
render_cmdbuf.endRenderPass(); cmdbuf.endRenderPass();
} }
const vk::RenderPassBeginInfo renderpass_begin_info = { const vk::RenderPassBeginInfo renderpass_begin_info = {
@@ -108,7 +108,7 @@ void RenderpassCache::EnterRenderpass(const RenderpassState& state) {
.pClearValues = &state.clear, .pClearValues = &state.clear,
}; };
render_cmdbuf.beginRenderPass(renderpass_begin_info, vk::SubpassContents::eInline); cmdbuf.beginRenderPass(renderpass_begin_info, vk::SubpassContents::eInline);
}); });
if (is_dirty) { if (is_dirty) {
@@ -123,9 +123,7 @@ void RenderpassCache::ExitRenderpass() {
return; return;
} }
scheduler.Record( scheduler.Record([](vk::CommandBuffer cmdbuf) { cmdbuf.endRenderPass(); });
[](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { render_cmdbuf.endRenderPass(); });
current_state = {}; current_state = {};
} }

29
src/video_core/renderer_vulkan/vk_scheduler.cpp
View File

@@ -5,18 +5,17 @@
#include <utility> #include <utility>
#include "common/microprofile.h" #include "common/microprofile.h"
#include "common/settings.h" #include "common/settings.h"
#include "video_core/renderer_vulkan/renderer_vulkan.h"
#include "video_core/renderer_vulkan/vk_instance.h" #include "video_core/renderer_vulkan/vk_instance.h"
#include "video_core/renderer_vulkan/vk_renderpass_cache.h"
#include "video_core/renderer_vulkan/vk_scheduler.h" #include "video_core/renderer_vulkan/vk_scheduler.h"
namespace Vulkan { namespace Vulkan {
void Scheduler::CommandChunk::ExecuteAll(vk::CommandBuffer render_cmdbuf, void Scheduler::CommandChunk::ExecuteAll(vk::CommandBuffer cmdbuf) {
vk::CommandBuffer upload_cmdbuf) {
auto command = first; auto command = first;
while (command != nullptr) { while (command != nullptr) {
auto next = command->GetNext(); auto next = command->GetNext();
command->Execute(render_cmdbuf, upload_cmdbuf); command->Execute(cmdbuf);
command->~Command(); command->~Command();
command = next; command = next;
} }
@@ -109,7 +108,7 @@ void Scheduler::WorkerThread() {
work_queue.pop(); work_queue.pop();
has_submit = work->HasSubmit(); has_submit = work->HasSubmit();
work->ExecuteAll(render_cmdbuf, upload_cmdbuf); work->ExecuteAll(current_cmdbuf);
} }
if (has_submit) { if (has_submit) {
AllocateWorkerCommandBuffers(); AllocateWorkerCommandBuffers();
@@ -121,13 +120,11 @@ void Scheduler::WorkerThread() {
void Scheduler::AllocateWorkerCommandBuffers() { void Scheduler::AllocateWorkerCommandBuffers() {
const vk::CommandBufferBeginInfo begin_info = { const vk::CommandBufferBeginInfo begin_info = {
.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit}; .flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit,
};
upload_cmdbuf = command_pool.Commit(); current_cmdbuf = command_pool.Commit();
upload_cmdbuf.begin(begin_info); current_cmdbuf.begin(begin_info);
render_cmdbuf = command_pool.Commit();
render_cmdbuf.begin(begin_info);
} }
MICROPROFILE_DEFINE(Vulkan_Submit, "Vulkan", "Submit Exectution", MP_RGB(255, 192, 255)); MICROPROFILE_DEFINE(Vulkan_Submit, "Vulkan", "Submit Exectution", MP_RGB(255, 192, 255));
@@ -138,10 +135,9 @@ void Scheduler::SubmitExecution(vk::Semaphore signal_semaphore, vk::Semaphore wa
renderpass_cache.ExitRenderpass(); renderpass_cache.ExitRenderpass();
Record([signal_semaphore, wait_semaphore, handle, signal_value, Record([signal_semaphore, wait_semaphore, handle, signal_value,
this](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer upload_cmdbuf) { this](vk::CommandBuffer cmdbuf) {
MICROPROFILE_SCOPE(Vulkan_Submit); MICROPROFILE_SCOPE(Vulkan_Submit);
upload_cmdbuf.end(); cmdbuf.end();
render_cmdbuf.end();
const u32 num_signal_semaphores = signal_semaphore ? 2U : 1U; const u32 num_signal_semaphores = signal_semaphore ? 2U : 1U;
const std::array signal_values{signal_value, u64(0)}; const std::array signal_values{signal_value, u64(0)};
@@ -163,14 +159,13 @@ void Scheduler::SubmitExecution(vk::Semaphore signal_semaphore, vk::Semaphore wa
.pSignalSemaphoreValues = signal_values.data(), .pSignalSemaphoreValues = signal_values.data(),
}; };
const std::array cmdbuffers = {upload_cmdbuf, render_cmdbuf};
const vk::SubmitInfo submit_info = { const vk::SubmitInfo submit_info = {
.pNext = &timeline_si, .pNext = &timeline_si,
.waitSemaphoreCount = num_wait_semaphores, .waitSemaphoreCount = num_wait_semaphores,
.pWaitSemaphores = wait_semaphores.data(), .pWaitSemaphores = wait_semaphores.data(),
.pWaitDstStageMask = wait_stage_masks.data(), .pWaitDstStageMask = wait_stage_masks.data(),
.commandBufferCount = static_cast<u32>(cmdbuffers.size()), .commandBufferCount = 1u,
.pCommandBuffers = cmdbuffers.data(), .pCommandBuffers = &cmdbuf,
.signalSemaphoreCount = num_signal_semaphores, .signalSemaphoreCount = num_signal_semaphores,
.pSignalSemaphores = signal_semaphores.data(), .pSignalSemaphores = signal_semaphores.data(),
}; };

15
src/video_core/renderer_vulkan/vk_scheduler.h
View File

@@ -53,7 +53,7 @@ public:
template <typename T> template <typename T>
void Record(T&& command) { void Record(T&& command) {
if (!use_worker_thread) { if (!use_worker_thread) {
command(render_cmdbuf, upload_cmdbuf); command(current_cmdbuf);
return; return;
} }
@@ -103,8 +103,7 @@ private:
public: public:
virtual ~Command() = default; virtual ~Command() = default;
virtual void Execute(vk::CommandBuffer render_cmdbuf, virtual void Execute(vk::CommandBuffer cmdbuf) const = 0;
vk::CommandBuffer upload_cmdbuf) const = 0;
Command* GetNext() const { Command* GetNext() const {
return next; return next;
@@ -127,9 +126,8 @@ private:
TypedCommand(TypedCommand&&) = delete; TypedCommand(TypedCommand&&) = delete;
TypedCommand& operator=(TypedCommand&&) = delete; TypedCommand& operator=(TypedCommand&&) = delete;
void Execute(vk::CommandBuffer render_cmdbuf, void Execute(vk::CommandBuffer cmdbuf) const override {
vk::CommandBuffer upload_cmdbuf) const override { command(cmdbuf);
command(render_cmdbuf, upload_cmdbuf);
} }
private: private:
@@ -138,7 +136,7 @@ private:
class CommandChunk final { class CommandChunk final {
public: public:
void ExecuteAll(vk::CommandBuffer render_cmdbuf, vk::CommandBuffer upload_cmdbuf); void ExecuteAll(vk::CommandBuffer cmdbuf);
template <typename T> template <typename T>
bool Record(T& command) { bool Record(T& command) {
@@ -201,8 +199,7 @@ private:
std::unique_ptr<CommandChunk> chunk; std::unique_ptr<CommandChunk> chunk;
std::queue<std::unique_ptr<CommandChunk>> work_queue; std::queue<std::unique_ptr<CommandChunk>> work_queue;
std::vector<std::unique_ptr<CommandChunk>> chunk_reserve; std::vector<std::unique_ptr<CommandChunk>> chunk_reserve;
vk::CommandBuffer render_cmdbuf; vk::CommandBuffer current_cmdbuf;
vk::CommandBuffer upload_cmdbuf;
StateFlags state{}; StateFlags state{};
std::mutex reserve_mutex; std::mutex reserve_mutex;
std::mutex work_mutex; std::mutex work_mutex;

2
src/video_core/renderer_vulkan/vk_swapchain.cpp
View File

@@ -111,7 +111,7 @@ void Swapchain::AcquireNextImage() {
MICROPROFILE_DEFINE(Vulkan_Present, "Vulkan", "Swapchain Present", MP_RGB(66, 185, 245)); MICROPROFILE_DEFINE(Vulkan_Present, "Vulkan", "Swapchain Present", MP_RGB(66, 185, 245));
void Swapchain::Present() { void Swapchain::Present() {
scheduler.Record([this, index = image_index](vk::CommandBuffer, vk::CommandBuffer) { scheduler.Record([this, index = image_index](vk::CommandBuffer) {
const vk::PresentInfoKHR present_info = { const vk::PresentInfoKHR present_info = {
.waitSemaphoreCount = 1, .waitSemaphoreCount = 1,
.pWaitSemaphores = &present_ready[index], .pWaitSemaphores = &present_ready[index],

59
src/video_core/renderer_vulkan/vk_texture_runtime.cpp
View File

@@ -327,8 +327,7 @@ ImageAlloc TextureRuntime::Allocate(u32 width, u32 height, VideoCore::PixelForma
alloc.storage_view = device.createImageView(storage_view_info); alloc.storage_view = device.createImageView(storage_view_info);
} }
scheduler.Record([image = alloc.image, aspect = alloc.aspect](vk::CommandBuffer, scheduler.Record([image = alloc.image, aspect = alloc.aspect](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer upload_cmdbuf) {
const vk::ImageMemoryBarrier init_barrier = { const vk::ImageMemoryBarrier init_barrier = {
.srcAccessMask = vk::AccessFlagBits::eNone, .srcAccessMask = vk::AccessFlagBits::eNone,
.dstAccessMask = vk::AccessFlagBits::eNone, .dstAccessMask = vk::AccessFlagBits::eNone,
@@ -346,7 +345,7 @@ ImageAlloc TextureRuntime::Allocate(u32 width, u32 height, VideoCore::PixelForma
}, },
}; };
upload_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTopOfPipe,
vk::PipelineStageFlagBits::eTopOfPipe, vk::PipelineStageFlagBits::eTopOfPipe,
vk::DependencyFlagBits::eByRegion, {}, {}, init_barrier); vk::DependencyFlagBits::eByRegion, {}, {}, init_barrier);
}); });
@@ -406,8 +405,7 @@ bool TextureRuntime::ClearTexture(Surface& surface, const VideoCore::TextureClea
}; };
if (clear.texture_rect == surface.GetScaledRect()) { if (clear.texture_rect == surface.GetScaledRect()) {
scheduler.Record([params, clear, value](vk::CommandBuffer render_cmdbuf, scheduler.Record([params, clear, value](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) {
const vk::ImageSubresourceRange range = { const vk::ImageSubresourceRange range = {
.aspectMask = params.aspect, .aspectMask = params.aspect,
.baseMipLevel = clear.texture_level, .baseMipLevel = clear.texture_level,
@@ -450,23 +448,23 @@ bool TextureRuntime::ClearTexture(Surface& surface, const VideoCore::TextureClea
}, },
}; };
render_cmdbuf.pipelineBarrier(params.pipeline_flags, cmdbuf.pipelineBarrier(params.pipeline_flags,
vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier); vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier);
const bool is_color = const bool is_color =
static_cast<bool>(params.aspect & vk::ImageAspectFlagBits::eColor); static_cast<bool>(params.aspect & vk::ImageAspectFlagBits::eColor);
if (is_color) { if (is_color) {
render_cmdbuf.clearColorImage(params.src_image, cmdbuf.clearColorImage(params.src_image,
vk::ImageLayout::eTransferDstOptimal, vk::ImageLayout::eTransferDstOptimal,
MakeClearColorValue(value), range); MakeClearColorValue(value), range);
} else { } else {
render_cmdbuf.clearDepthStencilImage(params.src_image, cmdbuf.clearDepthStencilImage(params.src_image,
vk::ImageLayout::eTransferDstOptimal, vk::ImageLayout::eTransferDstOptimal,
MakeClearDepthStencilValue(value), range); MakeClearDepthStencilValue(value), range);
} }
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
params.pipeline_flags, vk::DependencyFlagBits::eByRegion, params.pipeline_flags, vk::DependencyFlagBits::eByRegion,
{}, {}, post_barrier); {}, {}, post_barrier);
}); });
@@ -525,8 +523,7 @@ void TextureRuntime::ClearTextureWithRenderpass(Surface& surface,
.src_image = surface.alloc.image, .src_image = surface.alloc.image,
}; };
scheduler.Record([params, level = clear.texture_level](vk::CommandBuffer render_cmdbuf, scheduler.Record([params, level = clear.texture_level](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) {
const vk::ImageMemoryBarrier pre_barrier = { const vk::ImageMemoryBarrier pre_barrier = {
.srcAccessMask = params.src_access, .srcAccessMask = params.src_access,
.dstAccessMask = vk::AccessFlagBits::eTransferWrite, .dstAccessMask = vk::AccessFlagBits::eTransferWrite,
@@ -544,15 +541,14 @@ void TextureRuntime::ClearTextureWithRenderpass(Surface& surface,
}, },
}; };
render_cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer, cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier); vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier);
}); });
renderpass_cache.EnterRenderpass(clear_info); renderpass_cache.EnterRenderpass(clear_info);
renderpass_cache.ExitRenderpass(); renderpass_cache.ExitRenderpass();
scheduler.Record([params, level = clear.texture_level](vk::CommandBuffer render_cmdbuf, scheduler.Record([params, level = clear.texture_level](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) {
const vk::ImageMemoryBarrier post_barrier = { const vk::ImageMemoryBarrier post_barrier = {
.srcAccessMask = vk::AccessFlagBits::eTransferWrite, .srcAccessMask = vk::AccessFlagBits::eTransferWrite,
.dstAccessMask = params.src_access, .dstAccessMask = params.src_access,
@@ -570,7 +566,7 @@ void TextureRuntime::ClearTextureWithRenderpass(Surface& surface,
}, },
}; };
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags,
vk::DependencyFlagBits::eByRegion, {}, {}, post_barrier); vk::DependencyFlagBits::eByRegion, {}, {}, post_barrier);
}); });
} }
@@ -589,7 +585,7 @@ bool TextureRuntime::CopyTextures(Surface& source, Surface& dest,
.dst_image = dest.alloc.image, .dst_image = dest.alloc.image,
}; };
scheduler.Record([params, copy](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { scheduler.Record([params, copy](vk::CommandBuffer cmdbuf) {
const vk::ImageCopy image_copy = { const vk::ImageCopy image_copy = {
.srcSubresource{ .srcSubresource{
.aspectMask = params.aspect, .aspectMask = params.aspect,
@@ -679,13 +675,13 @@ bool TextureRuntime::CopyTextures(Surface& source, Surface& dest,
}, },
}; };
render_cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer, cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barriers); vk::DependencyFlagBits::eByRegion, {}, {}, pre_barriers);
render_cmdbuf.copyImage(params.src_image, vk::ImageLayout::eTransferSrcOptimal, cmdbuf.copyImage(params.src_image, vk::ImageLayout::eTransferSrcOptimal,
params.dst_image, vk::ImageLayout::eTransferDstOptimal, image_copy); params.dst_image, vk::ImageLayout::eTransferDstOptimal, image_copy);
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags,
vk::DependencyFlagBits::eByRegion, {}, {}, post_barriers); vk::DependencyFlagBits::eByRegion, {}, {}, post_barriers);
}); });
@@ -706,7 +702,7 @@ bool TextureRuntime::BlitTextures(Surface& source, Surface& dest,
.dst_image = dest.alloc.image, .dst_image = dest.alloc.image,
}; };
scheduler.Record([params, blit](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { scheduler.Record([params, blit](vk::CommandBuffer cmdbuf) {
const std::array source_offsets = { const std::array source_offsets = {
vk::Offset3D{static_cast<s32>(blit.src_rect.left), vk::Offset3D{static_cast<s32>(blit.src_rect.left),
static_cast<s32>(blit.src_rect.bottom), 0}, static_cast<s32>(blit.src_rect.bottom), 0},
@@ -807,14 +803,14 @@ bool TextureRuntime::BlitTextures(Surface& source, Surface& dest,
}, },
}; };
render_cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer, cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, read_barriers); vk::DependencyFlagBits::eByRegion, {}, {}, read_barriers);
render_cmdbuf.blitImage(params.src_image, vk::ImageLayout::eTransferSrcOptimal, cmdbuf.blitImage(params.src_image, vk::ImageLayout::eTransferSrcOptimal,
params.dst_image, vk::ImageLayout::eTransferDstOptimal, blit_area, params.dst_image, vk::ImageLayout::eTransferDstOptimal, blit_area,
params.filter); params.filter);
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags,
vk::DependencyFlagBits::eByRegion, {}, {}, write_barriers); vk::DependencyFlagBits::eByRegion, {}, {}, write_barriers);
}); });
@@ -932,7 +928,7 @@ void Surface::Upload(const VideoCore::BufferTextureCopy& upload, const StagingDa
}; };
scheduler.Record([format = alloc.format, params, staging, scheduler.Record([format = alloc.format, params, staging,
upload](vk::CommandBuffer render_cmdbuf, vk::CommandBuffer) { upload](vk::CommandBuffer cmdbuf) {
u32 num_copies = 1; u32 num_copies = 1;
std::array<vk::BufferImageCopy, 2> buffer_image_copies; std::array<vk::BufferImageCopy, 2> buffer_image_copies;
@@ -994,15 +990,15 @@ void Surface::Upload(const VideoCore::BufferTextureCopy& upload, const StagingDa
}, },
}; };
render_cmdbuf.pipelineBarrier(params.pipeline_flags, cmdbuf.pipelineBarrier(params.pipeline_flags,
vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, read_barrier); vk::DependencyFlagBits::eByRegion, {}, {}, read_barrier);
render_cmdbuf.copyBufferToImage(staging.buffer, params.src_image, cmdbuf.copyBufferToImage(staging.buffer, params.src_image,
vk::ImageLayout::eTransferDstOptimal, num_copies, vk::ImageLayout::eTransferDstOptimal, num_copies,
buffer_image_copies.data()); buffer_image_copies.data());
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
params.pipeline_flags, vk::DependencyFlagBits::eByRegion, params.pipeline_flags, vk::DependencyFlagBits::eByRegion,
{}, {}, write_barrier); {}, {}, write_barrier);
}); });
@@ -1037,8 +1033,7 @@ void Surface::Download(const VideoCore::BufferTextureCopy& download, const Stagi
.src_image = alloc.image, .src_image = alloc.image,
}; };
scheduler.Record([params, staging, download](vk::CommandBuffer render_cmdbuf, scheduler.Record([params, staging, download](vk::CommandBuffer cmdbuf) {
vk::CommandBuffer) {
const VideoCore::Rect2D rect = download.texture_rect; const VideoCore::Rect2D rect = download.texture_rect;
const vk::BufferImageCopy buffer_image_copy = { const vk::BufferImageCopy buffer_image_copy = {
.bufferOffset = staging.buffer_offset + download.buffer_offset, .bufferOffset = staging.buffer_offset + download.buffer_offset,
@@ -1091,14 +1086,14 @@ void Surface::Download(const VideoCore::BufferTextureCopy& download, const Stagi
.dstAccessMask = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite, .dstAccessMask = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite,
}; };
render_cmdbuf.pipelineBarrier(params.pipeline_flags, cmdbuf.pipelineBarrier(params.pipeline_flags,
vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, read_barrier); vk::DependencyFlagBits::eByRegion, {}, {}, read_barrier);
render_cmdbuf.copyImageToBuffer(params.src_image, vk::ImageLayout::eTransferSrcOptimal, cmdbuf.copyImageToBuffer(params.src_image, vk::ImageLayout::eTransferSrcOptimal,
staging.buffer, buffer_image_copy); staging.buffer, buffer_image_copy);
render_cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
params.pipeline_flags, vk::DependencyFlagBits::eByRegion, params.pipeline_flags, vk::DependencyFlagBits::eByRegion,
memory_write_barrier, {}, image_write_barrier); memory_write_barrier, {}, image_write_barrier);
}); });