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

code: Run clang format

Browse Source
This commit is contained in:
GPUCode
2023-01-11 16:13:39 +02:00
parent 10a7b60b12
commit 2335b47f4b
24 changed files with 263 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/android/app/src/main/jni/emu_window/emu_window_gl.cpp
View File

@ -41,9 +41,11 @@ static constexpr std::array<EGLint, 4> egl_context_attribs{EGL_CONTEXT_CLIENT_VE
class SharedContext_Android : public Frontend::GraphicsContext {
public:
SharedContext_Android(EGLDisplay egl_display, EGLConfig egl_config,
EGLContext egl_share_context) : egl_display{egl_display},
egl_surface{eglCreatePbufferSurface(egl_display, egl_config, egl_empty_attribs.data())},
egl_context{eglCreateContext(egl_display, egl_config, egl_share_context, egl_context_attribs.data())} {
EGLContext egl_share_context)
: egl_display{egl_display}, egl_surface{eglCreatePbufferSurface(egl_display, egl_config,
egl_empty_attribs.data())},
egl_context{eglCreateContext(egl_display, egl_config, egl_share_context,
egl_context_attribs.data())} {
ASSERT_MSG(egl_surface, "eglCreatePbufferSurface() failed!");
ASSERT_MSG(egl_context, "eglCreateContext() failed!");
}
@ -72,7 +74,8 @@ private:
EGLContext egl_context{};
};
EmuWindow_Android_OpenGL::EmuWindow_Android_OpenGL(ANativeWindow* surface) : EmuWindow_Android{surface} {
EmuWindow_Android_OpenGL::EmuWindow_Android_OpenGL(ANativeWindow* surface)
: EmuWindow_Android{surface} {
if (egl_display = eglGetDisplay(EGL_DEFAULT_DISPLAY); egl_display == EGL_NO_DISPLAY) {
LOG_CRITICAL(Frontend, "eglGetDisplay() failed");
return;

3
src/android/app/src/main/jni/emu_window/emu_window_vk.cpp
View File

@ -19,7 +19,8 @@
class SharedContext_Android : public Frontend::GraphicsContext {};
EmuWindow_Android_Vulkan::EmuWindow_Android_Vulkan(ANativeWindow* surface) : EmuWindow_Android{surface} {
EmuWindow_Android_Vulkan::EmuWindow_Android_Vulkan(ANativeWindow* surface)
: EmuWindow_Android{surface} {
CreateWindowSurface();
if (core_context = CreateSharedContext(); !core_context) {

2
src/android/app/src/main/jni/native.cpp
View File

@ -32,8 +32,8 @@
#include "jni/camera/ndk_camera.h"
#include "jni/camera/still_image_camera.h"
#include "jni/config.h"
#include "jni/emu_window/emu_window_vk.h"
#include "jni/emu_window/emu_window_gl.h"
#include "jni/emu_window/emu_window_vk.h"
#include "jni/game_info.h"
#include "jni/game_settings.h"
#include "jni/id_cache.h"

3
src/common/error.cpp
View File

@ -30,7 +30,8 @@ std::string NativeErrorToString(int e) {
return ret;
#else
char err_str[255];
#if (defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))) || defined(ANDROID)
#if (defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))) || \
defined(ANDROID)
// Thread safe (GNU-specific)
const char* str = strerror_r(e, err_str, sizeof(err_str));
return std::string(str);

12
src/video_core/renderer_opengl/gl_shader_gen.cpp
View File

@ -262,7 +262,8 @@ static std::string SampleTexture(const PicaFSConfig& config, unsigned texture_un
// Only unit 0 respects the texturing type
switch (state.texture0_type) {
case TexturingRegs::TextureConfig::Texture2D:
return "textureLod(tex0, texcoord0, getLod(texcoord0 * vec2(textureSize(tex0, 0))) + tex_lod_bias[0])";
return "textureLod(tex0, texcoord0, getLod(texcoord0 * vec2(textureSize(tex0, 0))) + "
"tex_lod_bias[0])";
case TexturingRegs::TextureConfig::Projection2D:
// TODO (wwylele): find the exact LOD formula for projection texture
return "textureProj(tex0, vec3(texcoord0, texcoord0_w))";
@ -280,12 +281,15 @@ static std::string SampleTexture(const PicaFSConfig& config, unsigned texture_un
return "texture(tex0, texcoord0)";
}
case 1:
return "textureLod(tex1, texcoord1, getLod(texcoord1 * vec2(textureSize(tex1, 0))) + tex_lod_bias[1])";
return "textureLod(tex1, texcoord1, getLod(texcoord1 * vec2(textureSize(tex1, 0))) + "
"tex_lod_bias[1])";
case 2:
if (state.texture2_use_coord1)
return "textureLod(tex2, texcoord1, getLod(texcoord1 * vec2(textureSize(tex2, 0))) + tex_lod_bias[2])";
return "textureLod(tex2, texcoord1, getLod(texcoord1 * vec2(textureSize(tex2, 0))) + "
"tex_lod_bias[2])";
else
return "textureLod(tex2, texcoord2, getLod(texcoord2 * vec2(textureSize(tex2, 0))) + tex_lod_bias[2])";
return "textureLod(tex2, texcoord2, getLod(texcoord2 * vec2(textureSize(tex2, 0))) + "
"tex_lod_bias[2])";
case 3:
if (state.proctex.enable) {
return "ProcTex()";

9
src/video_core/renderer_opengl/gl_texture_runtime.cpp
View File

@ -222,11 +222,10 @@ bool TextureRuntime::ClearTexture(Surface& surface, const VideoCore::TextureClea
bool TextureRuntime::CopyTextures(Surface& source, Surface& dest,
const VideoCore::TextureCopy& copy) {
glCopyImageSubData(source.texture.handle, GL_TEXTURE_2D,
copy.src_level, copy.src_offset.x, copy.src_offset.y, 0,
dest.texture.handle, GL_TEXTURE_2D,
copy.dst_level, copy.dst_offset.x, copy.dst_offset.y, 0,
copy.extent.width, copy.extent.height, 1);
glCopyImageSubData(source.texture.handle, GL_TEXTURE_2D, copy.src_level, copy.src_offset.x,
copy.src_offset.y, 0, dest.texture.handle, GL_TEXTURE_2D, copy.dst_level,
copy.dst_offset.x, copy.dst_offset.y, 0, copy.extent.width,
copy.extent.height, 1);
return true;
}

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

@ -208,11 +208,10 @@ void RendererVulkan::BeginRendering() {
device.updateDescriptorSetWithTemplate(set, present_update_template, present_textures[0]);
scheduler.Record([this, set, pipeline_index = current_pipeline](vk::CommandBuffer cmdbuf) {
cmdbuf.bindPipeline(vk::PipelineBindPoint::eGraphics,
present_pipelines[pipeline_index]);
cmdbuf.bindPipeline(vk::PipelineBindPoint::eGraphics, present_pipelines[pipeline_index]);
cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, present_pipeline_layout,
0, set, {});
cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, present_pipeline_layout, 0, set,
{});
});
const RenderpassState renderpass_info = {
@ -564,8 +563,7 @@ void RendererVulkan::LoadColorToActiveVkTexture(u8 color_r, u8 color_g, u8 color
vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier);
cmdbuf.clearColorImage(image, vk::ImageLayout::eTransferDstOptimal, clear_color,
range);
cmdbuf.clearColorImage(image, vk::ImageLayout::eTransferDstOptimal, clear_color, range);
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
vk::PipelineStageFlagBits::eFragmentShader,
@ -626,8 +624,7 @@ void RendererVulkan::DrawSingleScreenRotated(u32 screen_id, float x, float y, fl
scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer cmdbuf) {
cmdbuf.pushConstants(present_pipeline_layout,
vk::ShaderStageFlagBits::eFragment |
vk::ShaderStageFlagBits::eVertex,
vk::ShaderStageFlagBits::eFragment | vk::ShaderStageFlagBits::eVertex,
0, sizeof(info), &info);
cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0});
@ -664,8 +661,7 @@ void RendererVulkan::DrawSingleScreen(u32 screen_id, float x, float y, float w,
scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer cmdbuf) {
cmdbuf.pushConstants(present_pipeline_layout,
vk::ShaderStageFlagBits::eFragment |
vk::ShaderStageFlagBits::eVertex,
vk::ShaderStageFlagBits::eFragment | vk::ShaderStageFlagBits::eVertex,
0, sizeof(info), &info);
cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0});
@ -703,8 +699,7 @@ void RendererVulkan::DrawSingleScreenStereoRotated(u32 screen_id_l, u32 screen_i
scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer cmdbuf) {
cmdbuf.pushConstants(present_pipeline_layout,
vk::ShaderStageFlagBits::eFragment |
vk::ShaderStageFlagBits::eVertex,
vk::ShaderStageFlagBits::eFragment | vk::ShaderStageFlagBits::eVertex,
0, sizeof(info), &info);
cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0});
@ -744,8 +739,7 @@ void RendererVulkan::DrawSingleScreenStereo(u32 screen_id_l, u32 screen_id_r, fl
scheduler.Record([this, offset = offset, info = draw_info](vk::CommandBuffer cmdbuf) {
cmdbuf.pushConstants(present_pipeline_layout,
vk::ShaderStageFlagBits::eFragment |
vk::ShaderStageFlagBits::eVertex,
vk::ShaderStageFlagBits::eFragment | vk::ShaderStageFlagBits::eVertex,
0, sizeof(info), &info);
cmdbuf.bindVertexBuffers(0, vertex_buffer.Handle(), {0});

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

@ -14,8 +14,7 @@
namespace Vulkan {
BlitHelper::BlitHelper(const Instance& instance, Scheduler& scheduler,
DescriptorManager& desc_manager,
RenderpassCache& renderpass_cache)
DescriptorManager& desc_manager, RenderpassCache& renderpass_cache)
: scheduler{scheduler}, desc_manager{desc_manager},
renderpass_cache{renderpass_cache}, device{instance.GetDevice()} {
constexpr std::string_view cs_source = R"(
@ -246,8 +245,8 @@ void BlitHelper::BlitD24S8ToR32(Surface& source, Surface& dest,
vk::PipelineStageFlagBits::eComputeShader,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barriers);
cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, compute_pipeline_layout,
0, set, {});
cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, compute_pipeline_layout, 0, set,
{});
cmdbuf.bindPipeline(vk::PipelineBindPoint::eCompute, compute_pipeline);
const auto src_offset = Common::MakeVec(blit.src_rect.left, blit.src_rect.bottom);

3
src/video_core/renderer_vulkan/vk_blit_helper.h
View File

@ -20,8 +20,7 @@ class Surface;
class BlitHelper {
public:
BlitHelper(const Instance& instance, Scheduler& scheduler,
DescriptorManager& desc_manager,
BlitHelper(const Instance& instance, Scheduler& scheduler, DescriptorManager& desc_manager,
RenderpassCache& renderpass_cache);
~BlitHelper();

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

@ -137,8 +137,8 @@ void DescriptorManager::BindDescriptorSets() {
}
scheduler.Record([this, bound_sets](vk::CommandBuffer cmdbuf) {
cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline_layout, 0,
bound_sets, {});
cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline_layout, 0, bound_sets,
{});
});
descriptor_set_dirty.fill(false);

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

@ -176,7 +176,8 @@ void D24S8toRGBA8::Reinterpret(Surface& source, VideoCore::Rect2D src_rect, Surf
.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED,
.image = src_image,
.subresourceRange{
.aspectMask = vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil,
.aspectMask =
vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil,
.baseMipLevel = 0,
.levelCount = VK_REMAINING_MIP_LEVELS,
.baseArrayLayer = 0,
@ -198,8 +199,7 @@ void D24S8toRGBA8::Reinterpret(Surface& source, VideoCore::Rect2D src_rect, Surf
.baseArrayLayer = 0,
.layerCount = VK_REMAINING_ARRAY_LAYERS,
},
}
};
}};
const std::array post_barriers = {
vk::ImageMemoryBarrier{
.srcAccessMask = vk::AccessFlagBits::eShaderRead,
@ -242,8 +242,8 @@ void D24S8toRGBA8::Reinterpret(Surface& source, VideoCore::Rect2D src_rect, Surf
vk::PipelineStageFlagBits::eComputeShader,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barriers);
cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, compute_pipeline_layout,
0, set, {});
cmdbuf.bindDescriptorSets(vk::PipelineBindPoint::eCompute, compute_pipeline_layout, 0, set,
{});
cmdbuf.bindPipeline(vk::PipelineBindPoint::eCompute, compute_pipeline);
const auto src_offset = Common::MakeVec(src_rect.left, src_rect.bottom);

6
src/video_core/renderer_vulkan/vk_instance.cpp
View File

@ -107,7 +107,8 @@ Instance::Instance(bool validation, bool dump_command_buffers)
VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr);
// Enable the instance extensions the platform requires
const std::vector extensions = GetInstanceExtensions(Frontend::WindowSystemType::Headless, false);
const std::vector extensions =
GetInstanceExtensions(Frontend::WindowSystemType::Headless, false);
const vk::ApplicationInfo application_info = {
.pApplicationName = "Citra",
@ -218,7 +219,8 @@ Instance::Instance(Frontend::EmuWindow& window, u32 physical_device_index)
// If validation is enabled attempt to also enable debug messenger
if (enable_validation) {
const auto it = std::find_if(extensions.begin(), extensions.end(), [](const char* extension) {
const auto it =
std::find_if(extensions.begin(), extensions.end(), [](const char* extension) {
return std::strcmp(extension, VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0;
});

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

@ -247,8 +247,7 @@ bool PipelineCache::UseProgrammableVertexShader(const Pica::Regs& regs,
return false;
}
scheduler.Record(
[this, handle = handle, hash = config.Hash()](vk::CommandBuffer) {
scheduler.Record([this, handle = handle, hash = config.Hash()](vk::CommandBuffer) {
current_shaders[ProgramType::VS] = handle;
shader_hashes[ProgramType::VS] = hash;
});
@ -354,16 +353,12 @@ void PipelineCache::BindSampler(u32 binding, vk::Sampler sampler) {
void PipelineCache::SetViewport(float x, float y, float width, float height) {
const vk::Viewport viewport{x, y, width, height, 0.f, 1.f};
scheduler.Record([viewport](vk::CommandBuffer cmdbuf) {
cmdbuf.setViewport(0, viewport);
});
scheduler.Record([viewport](vk::CommandBuffer cmdbuf) { cmdbuf.setViewport(0, viewport); });
}
void PipelineCache::SetScissor(s32 x, s32 y, u32 width, u32 height) {
const vk::Rect2D scissor{{x, y}, {width, height}};
scheduler.Record([scissor](vk::CommandBuffer cmdbuf) {
cmdbuf.setScissor(0, scissor);
});
scheduler.Record([scissor](vk::CommandBuffer cmdbuf) { cmdbuf.setScissor(0, scissor); });
}
void PipelineCache::ApplyDynamic(const PipelineInfo& info) {

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

@ -151,8 +151,8 @@ std::vector<const char*> GetInstanceExtensions(Frontend::WindowSystemType window
});
if (it == properties.end()) {
LOG_WARNING(Render_Vulkan,
"Required instance extension {} is not available", extension);
LOG_WARNING(Render_Vulkan, "Required instance extension {} is not available",
extension);
return true;
}
return false;

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

@ -269,10 +269,9 @@ void RasterizerVulkan::SetupVertexArray(u32 vs_input_size, u32 vs_input_index_mi
SetupFixedAttribs();
// Bind the generated bindings
scheduler.Record([this, binding_count = layout.binding_count, vertex_offsets = binding_offsets]
(vk::CommandBuffer cmdbuf) {
cmdbuf.bindVertexBuffers(0, binding_count, vertex_buffers.data(),
vertex_offsets.data());
scheduler.Record([this, binding_count = layout.binding_count,
vertex_offsets = binding_offsets](vk::CommandBuffer cmdbuf) {
cmdbuf.bindVertexBuffers(0, binding_count, vertex_buffers.data(), vertex_offsets.data());
});
}
@ -442,8 +441,8 @@ void RasterizerVulkan::SetupIndexArray() {
stream_buffer.Commit(index_buffer_size);
scheduler.Record([this, index_offset = index_offset,
index_type = index_type](vk::CommandBuffer cmdbuf) {
scheduler.Record(
[this, index_offset = index_offset, index_type = index_type](vk::CommandBuffer cmdbuf) {
cmdbuf.bindIndexBuffer(stream_buffer.Handle(), index_offset, index_type);
});
}
@ -555,16 +554,14 @@ bool RasterizerVulkan::Draw(bool accelerate, bool is_indexed) {
// nothing. Always sample from the base level until mipmaps for texture cubes are
// implemented
const bool skip_mipmap = config.type == Pica::TexturingRegs::TextureConfig::TextureCube;
info = SamplerInfo{
.mag_filter = config.mag_filter,
info = SamplerInfo{.mag_filter = config.mag_filter,
.min_filter = config.min_filter,
.mip_filter = config.mip_filter,
.wrap_s = config.wrap_s,
.wrap_t = config.wrap_t,
.border_color = config.border_color.raw,
.lod_min = skip_mipmap ? 0.f : static_cast<float>(config.lod.min_level),
.lod_max = skip_mipmap ? 0.f : static_cast<float>(config.lod.max_level)
};
.lod_max = skip_mipmap ? 0.f : static_cast<float>(config.lod.max_level)};
// Search the cache and bind the appropriate sampler
if (auto it = samplers.find(info); it != samplers.end()) {
@ -762,8 +759,8 @@ bool RasterizerVulkan::Draw(bool accelerate, bool is_indexed) {
std::memcpy(array_ptr, vertex_batch.data() + base_vertex, vertex_size);
stream_buffer.Commit(vertex_size);
scheduler.Record([this, vertices, base_vertex,
offset = offset](vk::CommandBuffer cmdbuf) {
scheduler.Record(
[this, vertices, base_vertex, offset = offset](vk::CommandBuffer cmdbuf) {
cmdbuf.bindVertexBuffers(0, stream_buffer.Handle(), offset);
cmdbuf.draw(vertices, 1, base_vertex, 0);
});

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

@ -94,8 +94,8 @@ void RenderpassCache::EnterRenderpass(const RenderpassState& state) {
return;
}
scheduler.Record([should_end = bool(current_state.renderpass),
state](vk::CommandBuffer cmdbuf) {
scheduler.Record(
[should_end = bool(current_state.renderpass), state](vk::CommandBuffer cmdbuf) {
if (should_end) {
cmdbuf.endRenderPass();
}

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

@ -27,8 +27,8 @@ void Scheduler::CommandChunk::ExecuteAll(vk::CommandBuffer cmdbuf) {
Scheduler::Scheduler(const Instance& instance, RenderpassCache& renderpass_cache)
: instance{instance}, renderpass_cache{renderpass_cache}, master_semaphore{instance},
command_pool{instance, master_semaphore},
use_worker_thread{Settings::values.async_command_recording} {
command_pool{instance, master_semaphore}, use_worker_thread{
Settings::values.async_command_recording} {
AllocateWorkerCommandBuffers();
if (use_worker_thread) {
AcquireNewChunk();
@ -119,8 +119,8 @@ void Scheduler::SubmitExecution(vk::Semaphore signal_semaphore, vk::Semaphore wa
state = StateFlags::AllDirty;
renderpass_cache.ExitRenderpass();
Record([signal_semaphore, wait_semaphore, handle, signal_value,
this](vk::CommandBuffer cmdbuf) {
Record(
[signal_semaphore, wait_semaphore, handle, signal_value, this](vk::CommandBuffer cmdbuf) {
MICROPROFILE_SCOPE(Vulkan_Submit);
cmdbuf.end();

3
src/video_core/renderer_vulkan/vk_shader_gen_spv.cpp
View File

@ -975,7 +975,8 @@ void FragmentModule::DefineProcTexSampler() {
const Id proctex_alpha_map_offset{GetShaderDataMember(i32_id, ConstS32(13))};
const Id final_alpha{AppendProcTexCombineAndMap(config.state.proctex.alpha_combiner, u, v,
proctex_alpha_map_offset)};
const Id final_color_xyz{OpVectorShuffle(vec_ids.Get(3), final_color, final_color, 0, 1, 2)};
const Id final_color_xyz{
OpVectorShuffle(vec_ids.Get(3), final_color, final_color, 0, 1, 2)};
final_color = OpCompositeConstruct(vec_ids.Get(4), final_color_xyz, final_alpha);
}

1
src/video_core/renderer_vulkan/vk_swapchain.h
View File

@ -16,6 +16,7 @@ class RenderpassCache;
class Swapchain {
static constexpr u32 PREFERRED_IMAGE_COUNT = 3;
public:
Swapchain(const Instance& instance, Scheduler& scheduler, RenderpassCache& renderpass_cache);
~Swapchain();

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

@ -460,15 +460,13 @@ bool TextureRuntime::ClearTexture(Surface& surface, const VideoCore::TextureClea
},
};
cmdbuf.pipelineBarrier(params.pipeline_flags,
vk::PipelineStageFlagBits::eTransfer,
cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barrier);
const bool is_color =
static_cast<bool>(params.aspect & vk::ImageAspectFlagBits::eColor);
if (is_color) {
cmdbuf.clearColorImage(params.src_image,
vk::ImageLayout::eTransferDstOptimal,
cmdbuf.clearColorImage(params.src_image, vk::ImageLayout::eTransferDstOptimal,
MakeClearColorValue(value), range);
} else {
cmdbuf.clearDepthStencilImage(params.src_image,
@ -476,9 +474,8 @@ bool TextureRuntime::ClearTexture(Surface& surface, const VideoCore::TextureClea
MakeClearDepthStencilValue(value), range);
}
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
params.pipeline_flags, vk::DependencyFlagBits::eByRegion,
{}, {}, post_barrier);
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags,
vk::DependencyFlagBits::eByRegion, {}, {}, post_barrier);
});
return true;
}
@ -494,8 +491,8 @@ void TextureRuntime::ClearTextureWithRenderpass(Surface& surface,
surface.type != VideoCore::SurfaceType::DepthStencil;
const vk::AccessFlags access_flag =
is_color ? vk::AccessFlagBits::eColorAttachmentRead |
vk::AccessFlagBits::eColorAttachmentWrite
is_color
? vk::AccessFlagBits::eColorAttachmentRead | vk::AccessFlagBits::eColorAttachmentWrite
: vk::AccessFlagBits::eDepthStencilAttachmentRead |
vk::AccessFlagBits::eDepthStencilAttachmentWrite;
@ -700,8 +697,8 @@ bool TextureRuntime::CopyTextures(Surface& source, Surface& dest,
cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, pre_barriers);
cmdbuf.copyImage(params.src_image, vk::ImageLayout::eTransferSrcOptimal,
params.dst_image, vk::ImageLayout::eTransferDstOptimal, image_copy);
cmdbuf.copyImage(params.src_image, vk::ImageLayout::eTransferSrcOptimal, params.dst_image,
vk::ImageLayout::eTransferDstOptimal, image_copy);
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags,
vk::DependencyFlagBits::eByRegion, {}, {}, post_barriers);
@ -828,9 +825,8 @@ bool TextureRuntime::BlitTextures(Surface& source, Surface& dest,
cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, read_barriers);
cmdbuf.blitImage(params.src_image, vk::ImageLayout::eTransferSrcOptimal,
params.dst_image, vk::ImageLayout::eTransferDstOptimal, blit_area,
params.filter);
cmdbuf.blitImage(params.src_image, vk::ImageLayout::eTransferSrcOptimal, params.dst_image,
vk::ImageLayout::eTransferDstOptimal, blit_area, params.filter);
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags,
vk::DependencyFlagBits::eByRegion, {}, {}, write_barriers);
@ -839,8 +835,7 @@ bool TextureRuntime::BlitTextures(Surface& source, Surface& dest,
return true;
}
void TextureRuntime::GenerateMipmaps(Surface& surface, u32 max_level) {
}
void TextureRuntime::GenerateMipmaps(Surface& surface, u32 max_level) {}
const ReinterpreterList& TextureRuntime::GetPossibleReinterpretations(
VideoCore::PixelFormat dest_format) const {
@ -914,8 +909,8 @@ void Surface::Upload(const VideoCore::BufferTextureCopy& upload, const StagingDa
.src_image = alloc.image,
};
scheduler.Record([format = alloc.format, params, staging,
upload](vk::CommandBuffer cmdbuf) {
scheduler.Record(
[format = alloc.format, params, staging, upload](vk::CommandBuffer cmdbuf) {
u32 num_copies = 1;
std::array<vk::BufferImageCopy, 2> buffer_image_copies;
@ -977,17 +972,15 @@ void Surface::Upload(const VideoCore::BufferTextureCopy& upload, const StagingDa
},
};
cmdbuf.pipelineBarrier(params.pipeline_flags,
vk::PipelineStageFlagBits::eTransfer,
cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, read_barrier);
cmdbuf.copyBufferToImage(staging.buffer, params.src_image,
vk::ImageLayout::eTransferDstOptimal, num_copies,
buffer_image_copies.data());
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
params.pipeline_flags, vk::DependencyFlagBits::eByRegion,
{}, {}, write_barrier);
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags,
vk::DependencyFlagBits::eByRegion, {}, {}, write_barrier);
});
runtime.upload_buffer.Commit(staging.size);
@ -1073,16 +1066,15 @@ void Surface::Download(const VideoCore::BufferTextureCopy& download, const Stagi
.dstAccessMask = vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite,
};
cmdbuf.pipelineBarrier(params.pipeline_flags,
vk::PipelineStageFlagBits::eTransfer,
cmdbuf.pipelineBarrier(params.pipeline_flags, vk::PipelineStageFlagBits::eTransfer,
vk::DependencyFlagBits::eByRegion, {}, {}, read_barrier);
cmdbuf.copyImageToBuffer(params.src_image, vk::ImageLayout::eTransferSrcOptimal,
staging.buffer, buffer_image_copy);
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
params.pipeline_flags, vk::DependencyFlagBits::eByRegion,
memory_write_barrier, {}, image_write_barrier);
cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, params.pipeline_flags,
vk::DependencyFlagBits::eByRegion, memory_write_barrier, {},
image_write_barrier);
});
runtime.download_buffer.Commit(staging.size);
}