mirror of
https://github.com/dolphin-emu/dolphin
synced 2024-11-04 20:43:44 -05:00
296 lines
9.7 KiB
C++
296 lines
9.7 KiB
C++
// Copyright 2022 Dolphin Emulator Project
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
#pragma once
|
|
|
|
#include <Metal/Metal.h>
|
|
#include <atomic>
|
|
#include <memory>
|
|
#include <vector>
|
|
|
|
#include "Common/Assert.h"
|
|
#include "Common/CommonTypes.h"
|
|
#include "Common/MathUtil.h"
|
|
|
|
#include "VideoBackends/Metal/MRCHelpers.h"
|
|
#include "VideoBackends/Metal/MTLObjectCache.h"
|
|
#include "VideoBackends/Metal/MTLTexture.h"
|
|
#include "VideoBackends/Metal/MTLUtil.h"
|
|
|
|
#include "VideoCommon/Constants.h"
|
|
#include "VideoCommon/FramebufferManager.h"
|
|
#include "VideoCommon/PerfQueryBase.h"
|
|
|
|
namespace Metal
|
|
{
|
|
class Pipeline;
|
|
class ComputePipeline;
|
|
|
|
class StateTracker
|
|
{
|
|
public:
|
|
enum class UploadBuffer
|
|
{
|
|
Other,
|
|
Uniform,
|
|
Vertex,
|
|
Index,
|
|
Texels,
|
|
Last = Texels
|
|
};
|
|
|
|
struct Map
|
|
{
|
|
id<MTLBuffer> gpu_buffer;
|
|
size_t gpu_offset;
|
|
void* cpu_buffer;
|
|
};
|
|
|
|
enum class AlignMask : size_t
|
|
{
|
|
None = 0,
|
|
Other = 15,
|
|
Uniform = 255,
|
|
};
|
|
|
|
StateTracker(StateTracker&&) = delete;
|
|
explicit StateTracker();
|
|
~StateTracker();
|
|
|
|
Framebuffer* GetCurrentFramebuffer() { return m_current_framebuffer; };
|
|
void SetCurrentFramebuffer(Framebuffer* framebuffer);
|
|
void BeginClearRenderPass(MTLClearColor color, float depth);
|
|
void BeginRenderPass(MTLLoadAction load_action);
|
|
void BeginRenderPass(MTLRenderPassDescriptor* descriptor);
|
|
void BeginComputePass();
|
|
MTLRenderPassDescriptor* GetRenderPassDescriptor(Framebuffer* framebuffer,
|
|
MTLLoadAction load_action);
|
|
|
|
void EndRenderPass();
|
|
void FlushEncoders();
|
|
void WaitForFlushedEncoders();
|
|
bool HasUnflushedData() { return static_cast<bool>(m_current_render_cmdbuf); }
|
|
bool GPUBusy()
|
|
{
|
|
return m_current_draw != 1 + m_last_finished_draw.load(std::memory_order_acquire);
|
|
}
|
|
void ReloadSamplers();
|
|
void NotifyOfCPUGPUSync()
|
|
{
|
|
if (!g_features.manual_buffer_upload || !m_manual_buffer_upload)
|
|
return;
|
|
if (m_upload_cmdbuf || m_current_render_cmdbuf)
|
|
return;
|
|
SetManualBufferUpload(false);
|
|
}
|
|
|
|
void SetPipeline(const Pipeline* pipe);
|
|
void SetPipeline(const ComputePipeline* pipe);
|
|
void SetScissor(const MathUtil::Rectangle<int>& rect);
|
|
void SetViewport(float x, float y, float width, float height, float near_depth, float far_depth);
|
|
void SetTexture(u32 idx, id<MTLTexture> texture);
|
|
void SetSampler(u32 idx, const SamplerState& sampler);
|
|
void InvalidateUniforms(bool vertex, bool geometry, bool fragment);
|
|
void SetUtilityUniform(const void* buffer, size_t size);
|
|
void SetTexelBuffer(id<MTLBuffer> buffer, u32 offset0, u32 offset1);
|
|
void SetVerticesAndIndices(id<MTLBuffer> vertices, id<MTLBuffer> indices);
|
|
void SetBBoxBuffer(id<MTLBuffer> bbox, id<MTLFence> upload, id<MTLFence> download);
|
|
void SetVertexBufferNow(u32 idx, id<MTLBuffer> buffer, u32 offset);
|
|
void SetFragmentBufferNow(u32 idx, id<MTLBuffer> buffer, u32 offset);
|
|
/// Use around utility draws that are commonly used immediately before gx draws to the same buffer
|
|
void EnableEncoderLabel(bool enabled) { m_flags.should_apply_label = enabled; }
|
|
void EnablePerfQuery(PerfQueryGroup group, u32 query_id);
|
|
void DisablePerfQuery();
|
|
void UnbindTexture(id<MTLTexture> texture);
|
|
|
|
void Draw(u32 base_vertex, u32 num_vertices);
|
|
void DrawIndexed(u32 base_index, u32 num_indices, u32 base_vertex);
|
|
void DispatchComputeShader(u32 groupsize_x, u32 groupsize_y, u32 groupsize_z, u32 groups_x,
|
|
u32 groups_y, u32 groups_z);
|
|
void ResolveTexture(id<MTLTexture> src, id<MTLTexture> dst, u32 layer, u32 level);
|
|
|
|
size_t Align(size_t amt, AlignMask align)
|
|
{
|
|
return (amt + static_cast<size_t>(align)) & ~static_cast<size_t>(align);
|
|
}
|
|
Map AllocateForTextureUpload(size_t amt);
|
|
Map Allocate(UploadBuffer buffer_idx, size_t amt, AlignMask align)
|
|
{
|
|
Preallocate(buffer_idx, amt);
|
|
return CommitPreallocation(buffer_idx, amt, align);
|
|
}
|
|
std::pair<void*, size_t> Preallocate(UploadBuffer buffer_idx, size_t amt);
|
|
/// Must follow a call to Preallocate where amt is >= to the one provided here
|
|
Map CommitPreallocation(UploadBuffer buffer_idx, size_t amt, AlignMask align)
|
|
{
|
|
DEBUG_ASSERT((m_upload_buffers[static_cast<int>(buffer_idx)].usage.Pos() &
|
|
static_cast<size_t>(align)) == 0);
|
|
return CommitPreallocation(buffer_idx, Align(amt, align));
|
|
}
|
|
id<MTLBlitCommandEncoder> GetUploadEncoder();
|
|
id<MTLBlitCommandEncoder> GetTextureUploadEncoder();
|
|
id<MTLCommandBuffer> GetRenderCmdBuf();
|
|
|
|
private:
|
|
class UsageTracker
|
|
{
|
|
struct UsageEntry
|
|
{
|
|
u64 drawno;
|
|
size_t pos;
|
|
};
|
|
std::vector<UsageEntry> m_usage;
|
|
size_t m_size = 0;
|
|
size_t m_pos = 0;
|
|
|
|
public:
|
|
size_t Size() { return m_size; }
|
|
size_t Pos() { return m_pos; }
|
|
bool PrepareForAllocation(u64 last_draw, size_t amt);
|
|
size_t Allocate(u64 current_draw, size_t amt);
|
|
void Reset(size_t new_size);
|
|
};
|
|
|
|
struct CPUBuffer
|
|
{
|
|
UsageTracker usage;
|
|
MRCOwned<id<MTLBuffer>> mtlbuffer;
|
|
void* buffer = nullptr;
|
|
};
|
|
|
|
struct BufferPair
|
|
{
|
|
UsageTracker usage;
|
|
MRCOwned<id<MTLBuffer>> cpubuffer;
|
|
MRCOwned<id<MTLBuffer>> gpubuffer;
|
|
void* buffer = nullptr;
|
|
size_t last_upload = 0;
|
|
};
|
|
|
|
struct Backref;
|
|
struct PerfQueryTracker;
|
|
|
|
std::shared_ptr<Backref> m_backref;
|
|
std::vector<std::shared_ptr<PerfQueryTracker>> m_perf_query_tracker_cache;
|
|
MRCOwned<id<MTLFence>> m_fence;
|
|
MRCOwned<id<MTLCommandBuffer>> m_upload_cmdbuf;
|
|
MRCOwned<id<MTLBlitCommandEncoder>> m_upload_encoder;
|
|
MRCOwned<id<MTLCommandBuffer>> m_texture_upload_cmdbuf;
|
|
MRCOwned<id<MTLBlitCommandEncoder>> m_texture_upload_encoder;
|
|
MRCOwned<id<MTLCommandBuffer>> m_current_render_cmdbuf;
|
|
MRCOwned<id<MTLCommandBuffer>> m_last_render_cmdbuf;
|
|
MRCOwned<id<MTLRenderCommandEncoder>> m_current_render_encoder;
|
|
MRCOwned<id<MTLComputeCommandEncoder>> m_current_compute_encoder;
|
|
MRCOwned<MTLRenderPassDescriptor*> m_resolve_pass_desc;
|
|
Framebuffer* m_current_framebuffer;
|
|
CPUBuffer m_texture_upload_buffer;
|
|
BufferPair m_upload_buffers[static_cast<int>(UploadBuffer::Last) + 1];
|
|
u64 m_current_draw = 1;
|
|
std::atomic<u64> m_last_finished_draw{0};
|
|
|
|
MRCOwned<id<MTLTexture>> m_dummy_texture;
|
|
|
|
// Compute has a set of samplers and a set of writable images
|
|
static constexpr u32 MAX_COMPUTE_TEXTURES = VideoCommon::MAX_COMPUTE_SHADER_SAMPLERS * 2;
|
|
static constexpr u32 MAX_PIXEL_TEXTURES = VideoCommon::MAX_PIXEL_SHADER_SAMPLERS;
|
|
static constexpr u32 MAX_TEXTURES = std::max(MAX_PIXEL_TEXTURES, MAX_COMPUTE_TEXTURES);
|
|
static constexpr u32 MAX_SAMPLERS =
|
|
std::max(VideoCommon::MAX_PIXEL_SHADER_SAMPLERS, VideoCommon::MAX_COMPUTE_SHADER_SAMPLERS);
|
|
|
|
// MARK: State
|
|
u16 m_dirty_textures;
|
|
u16 m_dirty_samplers;
|
|
static_assert(sizeof(m_dirty_textures) * 8 >= MAX_TEXTURES, "Make this bigger");
|
|
static_assert(sizeof(m_dirty_samplers) * 8 >= MAX_SAMPLERS, "Make this bigger");
|
|
union Flags
|
|
{
|
|
struct
|
|
{
|
|
// clang-format off
|
|
bool has_gx_vs_uniform : 1;
|
|
bool has_gx_gs_uniform : 1;
|
|
bool has_gx_ps_uniform : 1;
|
|
bool has_utility_vs_uniform : 1;
|
|
bool has_utility_ps_uniform : 1;
|
|
bool has_pipeline : 1;
|
|
bool has_scissor : 1;
|
|
bool has_viewport : 1;
|
|
bool has_vertices : 1;
|
|
bool has_texel_buffer : 1;
|
|
bool bbox_fence : 1;
|
|
bool should_apply_label : 1;
|
|
// clang-format on
|
|
};
|
|
u16 bits = 0;
|
|
void NewEncoder()
|
|
{
|
|
Flags reset_mask;
|
|
// Set the flags you *don't* want to reset
|
|
reset_mask.should_apply_label = true;
|
|
bits &= reset_mask.bits;
|
|
}
|
|
} m_flags;
|
|
|
|
/// Things that represent the state of the encoder
|
|
struct Current
|
|
{
|
|
NSString* label;
|
|
id<MTLRenderPipelineState> pipeline;
|
|
std::array<id<MTLBuffer>, 2> vertex_buffers;
|
|
std::array<id<MTLBuffer>, 3> fragment_buffers;
|
|
u32 width;
|
|
u32 height;
|
|
MathUtil::Rectangle<int> scissor_rect;
|
|
Util::Viewport viewport;
|
|
MTLDepthClipMode depth_clip_mode;
|
|
MTLCullMode cull_mode;
|
|
DepthStencilSelector depth_stencil;
|
|
PerfQueryGroup perf_query_group;
|
|
} m_current;
|
|
std::shared_ptr<PerfQueryTracker> m_current_perf_query;
|
|
|
|
/// Things that represent what we'd *like* to have on the encoder for the next draw
|
|
struct State
|
|
{
|
|
MathUtil::Rectangle<int> scissor_rect;
|
|
Util::Viewport viewport;
|
|
const Pipeline* render_pipeline = nullptr;
|
|
const ComputePipeline* compute_pipeline = nullptr;
|
|
std::array<id<MTLTexture>, MAX_TEXTURES> textures = {};
|
|
std::array<id<MTLSamplerState>, MAX_SAMPLERS> samplers = {};
|
|
std::array<float, MAX_SAMPLERS> sampler_min_lod;
|
|
std::array<float, MAX_SAMPLERS> sampler_max_lod;
|
|
std::array<SamplerState, MAX_SAMPLERS> sampler_states;
|
|
const Texture* compute_texture = nullptr;
|
|
std::unique_ptr<u8[]> utility_uniform;
|
|
u32 utility_uniform_size = 0;
|
|
u32 utility_uniform_capacity = 0;
|
|
id<MTLBuffer> bbox = nullptr;
|
|
id<MTLFence> bbox_upload_fence = nullptr;
|
|
id<MTLFence> bbox_download_fence = nullptr;
|
|
id<MTLBuffer> vertices = nullptr;
|
|
id<MTLBuffer> indices = nullptr;
|
|
id<MTLBuffer> texels = nullptr;
|
|
u32 texel_buffer_offset0;
|
|
u32 texel_buffer_offset1;
|
|
PerfQueryGroup perf_query_group = static_cast<PerfQueryGroup>(-1);
|
|
u32 perf_query_id;
|
|
} m_state;
|
|
|
|
u32 m_perf_query_tracker_counter = 0;
|
|
bool m_manual_buffer_upload = false;
|
|
|
|
void SetManualBufferUpload(bool enable);
|
|
std::shared_ptr<PerfQueryTracker> NewPerfQueryTracker();
|
|
void SetSamplerForce(u32 idx, const SamplerState& sampler);
|
|
void Sync(BufferPair& buffer);
|
|
Map CommitPreallocation(UploadBuffer buffer_idx, size_t actual_amt);
|
|
void CheckViewport();
|
|
void CheckScissor();
|
|
void PrepareRender();
|
|
void PrepareCompute();
|
|
};
|
|
|
|
extern std::unique_ptr<StateTracker> g_state_tracker;
|
|
} // namespace Metal
|