|
|
|
@ -4,7 +4,14 @@
|
|
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
|
|
#include <condition_variable>
|
|
|
|
|
#include <memory>
|
|
|
|
|
#include <optional>
|
|
|
|
|
#include <stack>
|
|
|
|
|
#include <thread>
|
|
|
|
|
#include <utility>
|
|
|
|
|
#include "common/common_types.h"
|
|
|
|
|
#include "common/threadsafe_queue.h"
|
|
|
|
|
#include "video_core/renderer_vulkan/declarations.h"
|
|
|
|
|
|
|
|
|
|
namespace Vulkan {
|
|
|
|
@ -30,23 +37,6 @@ private:
|
|
|
|
|
VKFence* const& fence;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class VKCommandBufferView {
|
|
|
|
|
public:
|
|
|
|
|
VKCommandBufferView() = default;
|
|
|
|
|
VKCommandBufferView(const vk::CommandBuffer& cmdbuf) : cmdbuf{cmdbuf} {}
|
|
|
|
|
|
|
|
|
|
const vk::CommandBuffer* operator->() const noexcept {
|
|
|
|
|
return &cmdbuf;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
operator vk::CommandBuffer() const noexcept {
|
|
|
|
|
return cmdbuf;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
const vk::CommandBuffer& cmdbuf;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/// The scheduler abstracts command buffer and fence management with an interface that's able to do
|
|
|
|
|
/// OpenGL-like operations on Vulkan command buffers.
|
|
|
|
|
class VKScheduler {
|
|
|
|
@ -54,32 +44,190 @@ public:
|
|
|
|
|
explicit VKScheduler(const VKDevice& device, VKResourceManager& resource_manager);
|
|
|
|
|
~VKScheduler();
|
|
|
|
|
|
|
|
|
|
/// Gets a reference to the current fence.
|
|
|
|
|
VKFenceView GetFence() const {
|
|
|
|
|
return current_fence;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Gets a reference to the current command buffer.
|
|
|
|
|
VKCommandBufferView GetCommandBuffer() const {
|
|
|
|
|
return current_cmdbuf;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Sends the current execution context to the GPU.
|
|
|
|
|
void Flush(bool release_fence = true, vk::Semaphore semaphore = nullptr);
|
|
|
|
|
|
|
|
|
|
/// Sends the current execution context to the GPU and waits for it to complete.
|
|
|
|
|
void Finish(bool release_fence = true, vk::Semaphore semaphore = nullptr);
|
|
|
|
|
|
|
|
|
|
/// Waits for the worker thread to finish executing everything. After this function returns it's
|
|
|
|
|
/// safe to touch worker resources.
|
|
|
|
|
void WaitWorker();
|
|
|
|
|
|
|
|
|
|
/// Sends currently recorded work to the worker thread.
|
|
|
|
|
void DispatchWork();
|
|
|
|
|
|
|
|
|
|
/// Requests to begin a renderpass.
|
|
|
|
|
void RequestRenderpass(const vk::RenderPassBeginInfo& renderpass_bi);
|
|
|
|
|
|
|
|
|
|
/// Requests the current executino context to be able to execute operations only allowed outside
|
|
|
|
|
/// of a renderpass.
|
|
|
|
|
void RequestOutsideRenderPassOperationContext();
|
|
|
|
|
|
|
|
|
|
/// Binds a pipeline to the current execution context.
|
|
|
|
|
void BindGraphicsPipeline(vk::Pipeline pipeline);
|
|
|
|
|
|
|
|
|
|
/// Returns true when viewports have been set in the current command buffer.
|
|
|
|
|
bool TouchViewports() {
|
|
|
|
|
return std::exchange(state.viewports, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Returns true when scissors have been set in the current command buffer.
|
|
|
|
|
bool TouchScissors() {
|
|
|
|
|
return std::exchange(state.scissors, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Returns true when depth bias have been set in the current command buffer.
|
|
|
|
|
bool TouchDepthBias() {
|
|
|
|
|
return std::exchange(state.depth_bias, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Returns true when blend constants have been set in the current command buffer.
|
|
|
|
|
bool TouchBlendConstants() {
|
|
|
|
|
return std::exchange(state.blend_constants, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Returns true when depth bounds have been set in the current command buffer.
|
|
|
|
|
bool TouchDepthBounds() {
|
|
|
|
|
return std::exchange(state.depth_bounds, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Returns true when stencil values have been set in the current command buffer.
|
|
|
|
|
bool TouchStencilValues() {
|
|
|
|
|
return std::exchange(state.stencil_values, true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Send work to a separate thread.
|
|
|
|
|
template <typename T>
|
|
|
|
|
void Record(T&& command) {
|
|
|
|
|
if (chunk->Record(command)) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
DispatchWork();
|
|
|
|
|
(void)chunk->Record(command);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Gets a reference to the current fence.
|
|
|
|
|
VKFenceView GetFence() const {
|
|
|
|
|
return current_fence;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
class Command {
|
|
|
|
|
public:
|
|
|
|
|
virtual ~Command() = default;
|
|
|
|
|
|
|
|
|
|
virtual void Execute(vk::CommandBuffer cmdbuf,
|
|
|
|
|
const vk::DispatchLoaderDynamic& dld) const = 0;
|
|
|
|
|
|
|
|
|
|
Command* GetNext() const {
|
|
|
|
|
return next;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void SetNext(Command* next_) {
|
|
|
|
|
next = next_;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
Command* next = nullptr;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
|
class TypedCommand final : public Command {
|
|
|
|
|
public:
|
|
|
|
|
explicit TypedCommand(T&& command) : command{std::move(command)} {}
|
|
|
|
|
~TypedCommand() override = default;
|
|
|
|
|
|
|
|
|
|
TypedCommand(TypedCommand&&) = delete;
|
|
|
|
|
TypedCommand& operator=(TypedCommand&&) = delete;
|
|
|
|
|
|
|
|
|
|
void Execute(vk::CommandBuffer cmdbuf,
|
|
|
|
|
const vk::DispatchLoaderDynamic& dld) const override {
|
|
|
|
|
command(cmdbuf, dld);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
T command;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class CommandChunk final {
|
|
|
|
|
public:
|
|
|
|
|
void ExecuteAll(vk::CommandBuffer cmdbuf, const vk::DispatchLoaderDynamic& dld);
|
|
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
|
bool Record(T& command) {
|
|
|
|
|
using FuncType = TypedCommand<T>;
|
|
|
|
|
static_assert(sizeof(FuncType) < sizeof(data), "Lambda is too large");
|
|
|
|
|
|
|
|
|
|
if (command_offset > sizeof(data) - sizeof(FuncType)) {
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Command* current_last = last;
|
|
|
|
|
|
|
|
|
|
last = new (data.data() + command_offset) FuncType(std::move(command));
|
|
|
|
|
|
|
|
|
|
if (current_last) {
|
|
|
|
|
current_last->SetNext(last);
|
|
|
|
|
} else {
|
|
|
|
|
first = last;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
command_offset += sizeof(FuncType);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool Empty() const {
|
|
|
|
|
return command_offset == 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
Command* first = nullptr;
|
|
|
|
|
Command* last = nullptr;
|
|
|
|
|
|
|
|
|
|
std::size_t command_offset = 0;
|
|
|
|
|
std::array<u8, 0x8000> data{};
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
void WorkerThread();
|
|
|
|
|
|
|
|
|
|
void SubmitExecution(vk::Semaphore semaphore);
|
|
|
|
|
|
|
|
|
|
void AllocateNewContext();
|
|
|
|
|
|
|
|
|
|
void InvalidateState();
|
|
|
|
|
|
|
|
|
|
void EndPendingOperations();
|
|
|
|
|
|
|
|
|
|
void EndRenderPass();
|
|
|
|
|
|
|
|
|
|
void AcquireNewChunk();
|
|
|
|
|
|
|
|
|
|
const VKDevice& device;
|
|
|
|
|
VKResourceManager& resource_manager;
|
|
|
|
|
vk::CommandBuffer current_cmdbuf;
|
|
|
|
|
VKFence* current_fence = nullptr;
|
|
|
|
|
VKFence* next_fence = nullptr;
|
|
|
|
|
|
|
|
|
|
struct State {
|
|
|
|
|
std::optional<vk::RenderPassBeginInfo> renderpass;
|
|
|
|
|
vk::Pipeline graphics_pipeline;
|
|
|
|
|
bool viewports = false;
|
|
|
|
|
bool scissors = false;
|
|
|
|
|
bool depth_bias = false;
|
|
|
|
|
bool blend_constants = false;
|
|
|
|
|
bool depth_bounds = false;
|
|
|
|
|
bool stencil_values = false;
|
|
|
|
|
} state;
|
|
|
|
|
|
|
|
|
|
std::unique_ptr<CommandChunk> chunk;
|
|
|
|
|
std::thread worker_thread;
|
|
|
|
|
|
|
|
|
|
Common::SPSCQueue<std::unique_ptr<CommandChunk>> chunk_queue;
|
|
|
|
|
Common::SPSCQueue<std::unique_ptr<CommandChunk>> chunk_reserve;
|
|
|
|
|
std::mutex mutex;
|
|
|
|
|
std::condition_variable cv;
|
|
|
|
|
bool quit = false;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
} // namespace Vulkan
|
|
|
|
|