piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-11-14 21:37:52 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity

VideoBackends:Metal: Cache pipelines

Browse Source 
Metal pipelines hold less stuff than Dolphin pipelines, so duplicates will appear
This commit is contained in:
TellowKrinkle 2022-06-13 02:24:33 -05:00
parent e32213d031
commit 5742ccf8de
11 changed files with 555 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Source/Core/VideoBackends/Metal/CMakeLists.txt
View File

@ -11,6 +11,7 @@ add_library(videometal
MTLPipeline.h
MTLRenderer.mm
MTLRenderer.h
MTLShader.mm
MTLShader.h
MTLStateTracker.mm
MTLStateTracker.h
@ -18,6 +19,8 @@ add_library(videometal
MTLTexture.h
MTLUtil.mm
MTLUtil.h
MTLVertexFormat.mm
MTLVertexFormat.h
MTLVertexManager.mm
MTLVertexManager.h
VideoBackend.h

9
Source/Core/VideoBackends/Metal/MTLObjectCache.h
View File

@ -10,8 +10,12 @@
#include "VideoCommon/RenderState.h"
struct AbstractPipelineConfig;
class AbstractPipeline;
namespace Metal
{
class Shader;
extern MRCOwned<id<MTLDevice>> g_device;
extern MRCOwned<id<MTLCommandQueue>> g_queue;
@ -87,7 +91,12 @@ public:
void ReloadSamplers();
std::unique_ptr<AbstractPipeline> CreatePipeline(const AbstractPipelineConfig& config);
void ShaderDestroyed(const Shader* shader);
private:
class Internal;
std::unique_ptr<Internal> m_internal;
MRCOwned<id<MTLSamplerState>> CreateSampler(SamplerSelector sel);
MRCOwned<id<MTLDepthStencilState>> m_dss[DepthStencilSelector::N_VALUES];
MRCOwned<id<MTLSamplerState>> m_samplers[SamplerSelector::N_VALUES];

326
Source/Core/VideoBackends/Metal/MTLObjectCache.mm
View File

@ -3,6 +3,20 @@
#include "VideoBackends/Metal/MTLObjectCache.h"
#include <map>
#include <mutex>
#include <optional>
#include "Common/Assert.h"
#include "Common/MsgHandler.h"
#include "VideoBackends/Metal/MTLPipeline.h"
#include "VideoBackends/Metal/MTLUtil.h"
#include "VideoBackends/Metal/MTLVertexFormat.h"
#include "VideoCommon/AbstractPipeline.h"
#include "VideoCommon/NativeVertexFormat.h"
#include "VideoCommon/VertexShaderGen.h"
#include "VideoCommon/VideoConfig.h"
MRCOwned<id<MTLDevice>> Metal::g_device;
@ -14,6 +28,7 @@ static void SetupDepthStencil(
Metal::ObjectCache::ObjectCache()
{
m_internal = std::make_unique<Internal>();
SetupDepthStencil(m_dss);
}
@ -170,3 +185,314 @@ void Metal::ObjectCache::ReloadSamplers()
for (auto& sampler : m_samplers)
sampler = nullptr;
}
// MARK: Pipelines
static MTLPrimitiveTopologyClass GetClass(PrimitiveType prim)
{
switch (prim)
{
case PrimitiveType::Points:
return MTLPrimitiveTopologyClassPoint;
case PrimitiveType::Lines:
return MTLPrimitiveTopologyClassLine;
case PrimitiveType::Triangles:
case PrimitiveType::TriangleStrip:
return MTLPrimitiveTopologyClassTriangle;
}
}
static MTLPrimitiveType Convert(PrimitiveType prim)
{
// clang-format off
switch (prim)
{
case PrimitiveType::Points: return MTLPrimitiveTypePoint;
case PrimitiveType::Lines: return MTLPrimitiveTypeLine;
case PrimitiveType::Triangles: return MTLPrimitiveTypeTriangle;
case PrimitiveType::TriangleStrip: return MTLPrimitiveTypeTriangleStrip;
}
// clang-format on
}
static MTLCullMode Convert(CullMode cull)
{
switch (cull)
{
case CullMode::None:
case CullMode::All: // Handled by disabling rasterization
return MTLCullModeNone;
case CullMode::Front:
return MTLCullModeFront;
case CullMode::Back:
return MTLCullModeBack;
}
}
static MTLBlendFactor Convert(DstBlendFactor factor, bool usedualsrc)
{
// clang-format off
switch (factor)
{
case DstBlendFactor::Zero: return MTLBlendFactorZero;
case DstBlendFactor::One: return MTLBlendFactorOne;
case DstBlendFactor::SrcClr: return MTLBlendFactorSourceColor;
case DstBlendFactor::InvSrcClr: return MTLBlendFactorOneMinusSourceColor;
case DstBlendFactor::SrcAlpha: return usedualsrc ? MTLBlendFactorSource1Alpha
: MTLBlendFactorSourceAlpha;
case DstBlendFactor::InvSrcAlpha: return usedualsrc ? MTLBlendFactorOneMinusSource1Alpha
: MTLBlendFactorOneMinusSourceAlpha;
case DstBlendFactor::DstAlpha: return MTLBlendFactorDestinationAlpha;
case DstBlendFactor::InvDstAlpha: return MTLBlendFactorOneMinusDestinationAlpha;
}
// clang-format on
}
static MTLBlendFactor Convert(SrcBlendFactor factor, bool usedualsrc)
{
// clang-format off
switch (factor)
{
case SrcBlendFactor::Zero: return MTLBlendFactorZero;
case SrcBlendFactor::One: return MTLBlendFactorOne;
case SrcBlendFactor::DstClr: return MTLBlendFactorDestinationColor;
case SrcBlendFactor::InvDstClr: return MTLBlendFactorOneMinusDestinationColor;
case SrcBlendFactor::SrcAlpha: return usedualsrc ? MTLBlendFactorSource1Alpha
: MTLBlendFactorSourceAlpha;
case SrcBlendFactor::InvSrcAlpha: return usedualsrc ? MTLBlendFactorOneMinusSource1Alpha
: MTLBlendFactorOneMinusSourceAlpha;
case SrcBlendFactor::DstAlpha: return MTLBlendFactorDestinationAlpha;
case SrcBlendFactor::InvDstAlpha: return MTLBlendFactorOneMinusDestinationAlpha;
}
// clang-format on
}
class Metal::ObjectCache::Internal
{
public:
using StoredPipeline = std::pair<MRCOwned<id<MTLRenderPipelineState>>, PipelineReflection>;
/// Holds only the things that are actually used in a Metal pipeline
struct PipelineID
{
struct VertexAttribute
{
// Just hold the things that might differ while using the same shader
// (Really only a thing for ubershaders)
u8 offset : 6;
u8 components : 2;
VertexAttribute() = default;
explicit VertexAttribute(AttributeFormat format)
: offset(format.offset), components(format.components - 1)
{
if (!format.enable)
offset = 0x3F; // Set it to something unlikely
}
};
template <size_t N>
static void CopyAll(std::array<VertexAttribute, N>& output, const AttributeFormat (&input)[N])
{
for (size_t i = 0; i < N; ++i)
output[i] = VertexAttribute(input[i]);
}
PipelineID(const AbstractPipelineConfig& cfg)
{
memset(this, 0, sizeof(*this));
if (const NativeVertexFormat* v = cfg.vertex_format)
{
const PortableVertexDeclaration& decl = v->GetVertexDeclaration();
v_stride = v->GetVertexStride();
v_position = VertexAttribute(decl.position);
CopyAll(v_normals, decl.normals);
CopyAll(v_colors, decl.colors);
CopyAll(v_texcoords, decl.texcoords);
v_posmtx = VertexAttribute(decl.posmtx);
}
vertex_shader = static_cast<const Shader*>(cfg.vertex_shader);
fragment_shader = static_cast<const Shader*>(cfg.pixel_shader);
framebuffer.color_texture_format = cfg.framebuffer_state.color_texture_format.Value();
framebuffer.depth_texture_format = cfg.framebuffer_state.depth_texture_format.Value();
blend.colorupdate = cfg.blending_state.colorupdate.Value();
blend.alphaupdate = cfg.blending_state.alphaupdate.Value();
if (cfg.blending_state.blendenable)
{
// clang-format off
blend.blendenable = true;
blend.usedualsrc = cfg.blending_state.usedualsrc.Value();
blend.srcfactor = cfg.blending_state.srcfactor.Value();
blend.dstfactor = cfg.blending_state.dstfactor.Value();
blend.srcfactoralpha = cfg.blending_state.srcfactoralpha.Value();
blend.dstfactoralpha = cfg.blending_state.dstfactoralpha.Value();
blend.subtract = cfg.blending_state.subtract.Value();
blend.subtractAlpha = cfg.blending_state.subtractAlpha.Value();
// clang-format on
}
// Throw extras in bits we don't otherwise use
if (cfg.rasterization_state.cullmode == CullMode::All)
blend.hex |= 1 << 29;
if (cfg.rasterization_state.primitive == PrimitiveType::Points)
blend.hex |= 1 << 30;
else if (cfg.rasterization_state.primitive == PrimitiveType::Lines)
blend.hex |= 1 << 31;
}
PipelineID() { memset(this, 0, sizeof(*this)); }
PipelineID(const PipelineID& other) { memcpy(this, &other, sizeof(*this)); }
PipelineID& operator=(const PipelineID& other)
{
memcpy(this, &other, sizeof(*this));
return *this;
}
bool operator<(const PipelineID& other) const
{
return memcmp(this, &other, sizeof(*this)) < 0;
}
bool operator==(const PipelineID& other) const
{
return memcmp(this, &other, sizeof(*this)) == 0;
}
u8 v_stride;
VertexAttribute v_position;
std::array<VertexAttribute, 3> v_normals;
std::array<VertexAttribute, 2> v_colors;
std::array<VertexAttribute, 8> v_texcoords;
VertexAttribute v_posmtx;
const Shader* vertex_shader;
const Shader* fragment_shader;
BlendingState blend;
FramebufferState framebuffer;
};
std::mutex m_mtx;
std::condition_variable m_cv;
std::map<PipelineID, StoredPipeline> m_pipelines;
std::map<const Shader*, std::vector<PipelineID>> m_shaders;
std::array<u32, 3> m_pipeline_counter;
StoredPipeline CreatePipeline(const AbstractPipelineConfig& config)
{
@autoreleasepool
{
ASSERT(!config.geometry_shader);
auto desc = MRCTransfer([MTLRenderPipelineDescriptor new]);
[desc setVertexFunction:static_cast<const Shader*>(config.vertex_shader)->GetShader()];
[desc setFragmentFunction:static_cast<const Shader*>(config.pixel_shader)->GetShader()];
if (config.usage == AbstractPipelineUsage::GX)
{
if ([[[desc vertexFunction] label] containsString:@"Uber"])
[desc
setLabel:[NSString stringWithFormat:@"GX Uber Pipeline %d", m_pipeline_counter[0]++]];
else
[desc setLabel:[NSString stringWithFormat:@"GX Pipeline %d", m_pipeline_counter[1]++]];
}
else
{
[desc setLabel:[NSString stringWithFormat:@"Utility Pipeline %d", m_pipeline_counter[2]++]];
}
if (config.vertex_format)
[desc setVertexDescriptor:static_cast<const VertexFormat*>(config.vertex_format)->Get()];
RasterizationState rs = config.rasterization_state;
[desc setInputPrimitiveTopology:GetClass(rs.primitive)];
if (rs.cullmode == CullMode::All)
[desc setRasterizationEnabled:NO];
MTLRenderPipelineColorAttachmentDescriptor* color0 =
[[desc colorAttachments] objectAtIndexedSubscript:0];
BlendingState bs = config.blending_state;
MTLColorWriteMask mask = MTLColorWriteMaskNone;
if (bs.colorupdate)
mask |= MTLColorWriteMaskRed | MTLColorWriteMaskGreen | MTLColorWriteMaskBlue;
if (bs.alphaupdate)
mask |= MTLColorWriteMaskAlpha;
[color0 setWriteMask:mask];
if (bs.blendenable)
{
// clang-format off
[color0 setBlendingEnabled:YES];
[color0 setSourceRGBBlendFactor: Convert(bs.srcfactor, bs.usedualsrc)];
[color0 setSourceAlphaBlendFactor: Convert(bs.srcfactoralpha, bs.usedualsrc)];
[color0 setDestinationRGBBlendFactor: Convert(bs.dstfactor, bs.usedualsrc)];
[color0 setDestinationAlphaBlendFactor:Convert(bs.dstfactoralpha, bs.usedualsrc)];
[color0 setRgbBlendOperation: bs.subtract ? MTLBlendOperationReverseSubtract : MTLBlendOperationAdd];
[color0 setAlphaBlendOperation:bs.subtractAlpha ? MTLBlendOperationReverseSubtract : MTLBlendOperationAdd];
// clang-format on
}
FramebufferState fs = config.framebuffer_state;
[color0 setPixelFormat:Util::FromAbstract(fs.color_texture_format)];
[desc setDepthAttachmentPixelFormat:Util::FromAbstract(fs.depth_texture_format)];
if (Util::HasStencil(fs.depth_texture_format))
[desc setStencilAttachmentPixelFormat:Util::FromAbstract(fs.depth_texture_format)];
NSError* err = nullptr;
MTLRenderPipelineReflection* reflection = nullptr;
id<MTLRenderPipelineState> pipe =
[g_device newRenderPipelineStateWithDescriptor:desc
options:MTLPipelineOptionArgumentInfo
reflection:&reflection
error:&err];
if (err)
{
PanicAlertFmt("Failed to compile pipeline for {} and {}: {}",
[[[desc vertexFunction] label] UTF8String],
[[[desc fragmentFunction] label] UTF8String],
[[err localizedDescription] UTF8String]);
return std::make_pair(nullptr, PipelineReflection());
}
return std::make_pair(MRCTransfer(pipe), PipelineReflection(reflection));
}
}
StoredPipeline GetOrCreatePipeline(const AbstractPipelineConfig& config)
{
std::unique_lock<std::mutex> lock(m_mtx);
PipelineID pid(config);
auto it = m_pipelines.find(pid);
if (it != m_pipelines.end())
{
while (!it->second.first && !it->second.second.textures)
m_cv.wait(lock); // Wait for whoever's already compiling this
return it->second;
}
// Reserve the spot now, so other threads know we're making it
it = m_pipelines.insert({pid, {nullptr, PipelineReflection()}}).first;
lock.unlock();
StoredPipeline pipe = CreatePipeline(config);
lock.lock();
if (pipe.first)
it->second = pipe;
else
it->second.second.textures = 1; // Abuse this as a "failed to create pipeline" flag
m_shaders[pid.vertex_shader].push_back(pid);
m_shaders[pid.fragment_shader].push_back(pid);
lock.unlock();
m_cv.notify_all(); // Wake up anyone who might be waiting
return pipe;
}
void ShaderDestroyed(const Shader* shader)
{
std::lock_guard<std::mutex> lock(m_mtx);
auto it = m_shaders.find(shader);
if (it == m_shaders.end())
return;
// It's unlikely, but if a shader is destroyed, a new one could be made with the same address
// (Also, we know it won't be used anymore, so there's no reason to keep these around)
for (const PipelineID& pid : it->second)
m_pipelines.erase(pid);
m_shaders.erase(it);
}
};
std::unique_ptr<AbstractPipeline>
Metal::ObjectCache::CreatePipeline(const AbstractPipelineConfig& config)
{
Internal::StoredPipeline pipeline = m_internal->GetOrCreatePipeline(config);
if (!pipeline.first)
return nullptr;
return std::make_unique<Pipeline>(
std::move(pipeline.first), pipeline.second, Convert(config.rasterization_state.primitive),
Convert(config.rasterization_state.cullmode), config.depth_state, config.usage);
}
void Metal::ObjectCache::ShaderDestroyed(const Shader* shader)
{
m_internal->ShaderDestroyed(shader);
}

31
Source/Core/VideoBackends/Metal/MTLPipeline.h
View File

@ -14,24 +14,34 @@
namespace Metal
{
struct PipelineReflection
{
u32 textures = 0;
u32 samplers = 0;
u32 vertex_buffers = 0;
u32 fragment_buffers = 0;
PipelineReflection() = default;
explicit PipelineReflection(MTLRenderPipelineReflection* reflection);
};
class Pipeline final : public AbstractPipeline
{
public:
explicit Pipeline(MRCOwned<id<MTLRenderPipelineState>> pipeline,
MTLRenderPipelineReflection* reflection, MTLPrimitiveType prim,
MTLCullMode cull, DepthState depth, AbstractPipelineUsage usage);
const PipelineReflection& reflection, MTLPrimitiveType prim, MTLCullMode cull,
DepthState depth, AbstractPipelineUsage usage);
id<MTLRenderPipelineState> Get() const { return m_pipeline; }
MTLPrimitiveType Prim() const { return m_prim; }
MTLCullMode Cull() const { return m_cull; }
DepthStencilSelector DepthStencil() const { return m_depth_stencil; }
AbstractPipelineUsage Usage() const { return m_usage; }
u32 GetTextures() const { return m_textures; }
u32 GetSamplers() const { return m_samplers; }
u32 GetVertexBuffers() const { return m_vertex_buffers; }
u32 GetFragmentBuffers() const { return m_fragment_buffers; }
bool UsesVertexBuffer(u32 index) const { return m_vertex_buffers & (1 << index); }
bool UsesFragmentBuffer(u32 index) const { return m_fragment_buffers & (1 << index); }
u32 GetTextures() const { return m_reflection.textures; }
u32 GetSamplers() const { return m_reflection.samplers; }
u32 GetVertexBuffers() const { return m_reflection.vertex_buffers; }
u32 GetFragmentBuffers() const { return m_reflection.fragment_buffers; }
bool UsesVertexBuffer(u32 index) const { return m_reflection.vertex_buffers & (1 << index); }
bool UsesFragmentBuffer(u32 index) const { return m_reflection.fragment_buffers & (1 << index); }
private:
MRCOwned<id<MTLRenderPipelineState>> m_pipeline;
@ -39,10 +49,7 @@ private:
MTLCullMode m_cull;
DepthStencilSelector m_depth_stencil;
AbstractPipelineUsage m_usage;
u32 m_textures = 0;
u32 m_samplers = 0;
u32 m_vertex_buffers = 0;
u32 m_fragment_buffers = 0;
PipelineReflection m_reflection;
};
class ComputePipeline : public Shader

12
Source/Core/VideoBackends/Metal/MTLPipeline.mm
View File

@ -47,14 +47,18 @@ static void GetArguments(NSArray<MTLArgument*>* arguments, u32* textures, u32* s
}
}
Metal::PipelineReflection::PipelineReflection(MTLRenderPipelineReflection* reflection)
{
GetArguments([reflection vertexArguments], nullptr, nullptr, &vertex_buffers);
GetArguments([reflection fragmentArguments], &textures, &samplers, &fragment_buffers);
}
Metal::Pipeline::Pipeline(MRCOwned<id<MTLRenderPipelineState>> pipeline,
MTLRenderPipelineReflection* reflection, MTLPrimitiveType prim,
const PipelineReflection& reflection, MTLPrimitiveType prim,
MTLCullMode cull, DepthState depth, AbstractPipelineUsage usage)
: m_pipeline(std::move(pipeline)), m_prim(prim), m_cull(cull), m_depth_stencil(depth),
m_usage(usage)
m_usage(usage), m_reflection(reflection)
{
GetArguments([reflection vertexArguments], nullptr, nullptr, &m_vertex_buffers);
GetArguments([reflection fragmentArguments], &m_textures, &m_samplers, &m_fragment_buffers);
}
Metal::ComputePipeline::ComputePipeline(ShaderStage stage, MTLComputePipelineReflection* reflection,

1
Source/Core/VideoBackends/Metal/MTLRenderer.h
View File

@ -82,7 +82,6 @@ private:
u32 m_texture_counter = 0;
u32 m_staging_texture_counter = 0;
std::array<u32, 4> m_shader_counter = {};
u32 m_pipeline_counter = 0;
void CheckForSurfaceChange();
void CheckForSurfaceResize();

211
Source/Core/VideoBackends/Metal/MTLRenderer.mm
View File

@ -9,11 +9,10 @@
#include "VideoBackends/Metal/MTLStateTracker.h"
#include "VideoBackends/Metal/MTLTexture.h"
#include "VideoBackends/Metal/MTLUtil.h"
#include "VideoBackends/Metal/MTLVertexFormat.h"
#include "VideoBackends/Metal/MTLVertexManager.h"
#include "VideoCommon/FramebufferManager.h"
#include "VideoCommon/NativeVertexFormat.h"
#include "VideoCommon/VertexShaderGen.h"
#include "VideoCommon/VideoBackendBase.h"
Metal::Renderer::Renderer(MRCOwned<CAMetalLayer*> layer, int width, int height, float layer_scale)
@ -110,66 +109,6 @@ Metal::Renderer::CreateFramebuffer(AbstractTexture* color_attachment,
// MARK: Pipeline Creation
namespace Metal
{
class VertexFormat : public NativeVertexFormat
{
public:
VertexFormat(const PortableVertexDeclaration& vtx_decl)
: NativeVertexFormat(vtx_decl), m_desc(MRCTransfer([MTLVertexDescriptor new]))
{
[[[m_desc layouts] objectAtIndexedSubscript:0] setStride:vtx_decl.stride];
SetAttribute(SHADER_POSITION_ATTRIB, vtx_decl.position);
SetAttributes(SHADER_NORMAL_ATTRIB, vtx_decl.normals);
SetAttributes(SHADER_COLOR0_ATTRIB, vtx_decl.colors);
SetAttributes(SHADER_TEXTURE0_ATTRIB, vtx_decl.texcoords);
SetAttribute(SHADER_POSMTX_ATTRIB, vtx_decl.posmtx);
}
MTLVertexDescriptor* Get() const { return m_desc; }
private:
template <size_t N>
void SetAttributes(u32 attribute, const AttributeFormat (&format)[N])
{
for (size_t i = 0; i < N; i++)
SetAttribute(attribute + i, format[i]);
}
void SetAttribute(u32 attribute, const AttributeFormat& format)
{
if (!format.enable)
return;
MTLVertexAttributeDescriptor* desc = [[m_desc attributes] objectAtIndexedSubscript:attribute];
[desc setFormat:ConvertFormat(format.type, format.components, format.integer)];
[desc setOffset:format.offset];
[desc setBufferIndex:0];
}
static MTLVertexFormat ConvertFormat(ComponentFormat format, int count, bool int_format)
{
static constexpr MTLVertexFormat formats[2][5][4] = {
[false] = {
[static_cast<int>(ComponentFormat::UByte)] = { MTLVertexFormatUCharNormalized, MTLVertexFormatUChar2Normalized, MTLVertexFormatUChar3Normalized, MTLVertexFormatUChar4Normalized },
[static_cast<int>(ComponentFormat::Byte)] = { MTLVertexFormatCharNormalized, MTLVertexFormatChar2Normalized, MTLVertexFormatChar3Normalized, MTLVertexFormatChar4Normalized },
[static_cast<int>(ComponentFormat::UShort)] = { MTLVertexFormatUShortNormalized, MTLVertexFormatUShort2Normalized, MTLVertexFormatUShort3Normalized, MTLVertexFormatUShort4Normalized },
[static_cast<int>(ComponentFormat::Short)] = { MTLVertexFormatShortNormalized, MTLVertexFormatShort2Normalized, MTLVertexFormatShort3Normalized, MTLVertexFormatShort4Normalized },
[static_cast<int>(ComponentFormat::Float)] = { MTLVertexFormatFloat, MTLVertexFormatFloat2, MTLVertexFormatFloat3, MTLVertexFormatFloat4 },
},
[true] = {
[static_cast<int>(ComponentFormat::UByte)] = { MTLVertexFormatUChar, MTLVertexFormatUChar2, MTLVertexFormatUChar3, MTLVertexFormatUChar4 },
[static_cast<int>(ComponentFormat::Byte)] = { MTLVertexFormatChar, MTLVertexFormatChar2, MTLVertexFormatChar3, MTLVertexFormatChar4 },
[static_cast<int>(ComponentFormat::UShort)] = { MTLVertexFormatUShort, MTLVertexFormatUShort2, MTLVertexFormatUShort3, MTLVertexFormatUShort4 },
[static_cast<int>(ComponentFormat::Short)] = { MTLVertexFormatShort, MTLVertexFormatShort2, MTLVertexFormatShort3, MTLVertexFormatShort4 },
[static_cast<int>(ComponentFormat::Float)] = { MTLVertexFormatFloat, MTLVertexFormatFloat2, MTLVertexFormatFloat3, MTLVertexFormatFloat4 },
},
};
return formats[int_format][static_cast<int>(format)][count - 1];
}
MRCOwned<MTLVertexDescriptor*> m_desc;
};
} // namespace Metal
std::unique_ptr<AbstractShader> Metal::Renderer::CreateShaderFromSource(ShaderStage stage,
std::string_view source,
std::string_view name)
@ -311,157 +250,11 @@ Metal::Renderer::CreateNativeVertexFormat(const PortableVertexDeclaration& vtx_d
}
}
static MTLPrimitiveTopologyClass GetClass(PrimitiveType prim)
{
switch (prim)
{
case PrimitiveType::Points:
return MTLPrimitiveTopologyClassPoint;
case PrimitiveType::Lines:
return MTLPrimitiveTopologyClassLine;
case PrimitiveType::Triangles:
case PrimitiveType::TriangleStrip:
return MTLPrimitiveTopologyClassTriangle;
}
}
static MTLPrimitiveType Convert(PrimitiveType prim)
{
switch (prim)
{
case PrimitiveType::Points: return MTLPrimitiveTypePoint;
case PrimitiveType::Lines: return MTLPrimitiveTypeLine;
case PrimitiveType::Triangles: return MTLPrimitiveTypeTriangle;
case PrimitiveType::TriangleStrip: return MTLPrimitiveTypeTriangleStrip;
}
}
static MTLCullMode Convert(CullMode cull)
{
switch (cull)
{
case CullMode::None:
case CullMode::All: // Handled by disabling rasterization
return MTLCullModeNone;
case CullMode::Front:
return MTLCullModeFront;
case CullMode::Back:
return MTLCullModeBack;
}
}
static MTLBlendFactor Convert(DstBlendFactor factor, bool src1)
{
static constexpr MTLBlendFactor factors[2][8] = {
[false] = {
[static_cast<int>(DstBlendFactor::Zero)] = MTLBlendFactorZero,
[static_cast<int>(DstBlendFactor::One)] = MTLBlendFactorOne,
[static_cast<int>(DstBlendFactor::SrcClr)] = MTLBlendFactorSourceColor,
[static_cast<int>(DstBlendFactor::InvSrcClr)] = MTLBlendFactorOneMinusSourceColor,
[static_cast<int>(DstBlendFactor::SrcAlpha)] = MTLBlendFactorSourceAlpha,
[static_cast<int>(DstBlendFactor::InvSrcAlpha)] = MTLBlendFactorOneMinusSourceAlpha,
[static_cast<int>(DstBlendFactor::DstAlpha)] = MTLBlendFactorDestinationAlpha,
[static_cast<int>(DstBlendFactor::InvDstAlpha)] = MTLBlendFactorOneMinusDestinationAlpha,
},
[true] = {
[static_cast<int>(DstBlendFactor::Zero)] = MTLBlendFactorZero,
[static_cast<int>(DstBlendFactor::One)] = MTLBlendFactorOne,
[static_cast<int>(DstBlendFactor::SrcClr)] = MTLBlendFactorSourceColor,
[static_cast<int>(DstBlendFactor::InvSrcClr)] = MTLBlendFactorOneMinusSource1Color,
[static_cast<int>(DstBlendFactor::SrcAlpha)] = MTLBlendFactorSource1Alpha,
[static_cast<int>(DstBlendFactor::InvSrcAlpha)] = MTLBlendFactorOneMinusSource1Alpha,
[static_cast<int>(DstBlendFactor::DstAlpha)] = MTLBlendFactorDestinationAlpha,
[static_cast<int>(DstBlendFactor::InvDstAlpha)] = MTLBlendFactorOneMinusDestinationAlpha,
},
};
return factors[src1][static_cast<int>(factor)];
}
static MTLBlendFactor Convert(SrcBlendFactor factor, bool src1)
{
static constexpr MTLBlendFactor factors[2][8] = {
[false] = {
[static_cast<int>(SrcBlendFactor::Zero)] = MTLBlendFactorZero,
[static_cast<int>(SrcBlendFactor::One)] = MTLBlendFactorOne,
[static_cast<int>(SrcBlendFactor::DstClr)] = MTLBlendFactorDestinationColor,
[static_cast<int>(SrcBlendFactor::InvDstClr)] = MTLBlendFactorOneMinusDestinationColor,
[static_cast<int>(SrcBlendFactor::SrcAlpha)] = MTLBlendFactorSourceAlpha,
[static_cast<int>(SrcBlendFactor::InvSrcAlpha)] = MTLBlendFactorOneMinusSourceAlpha,
[static_cast<int>(SrcBlendFactor::DstAlpha)] = MTLBlendFactorDestinationAlpha,
[static_cast<int>(SrcBlendFactor::InvDstAlpha)] = MTLBlendFactorOneMinusDestinationAlpha,
},
[true] = {
[static_cast<int>(SrcBlendFactor::Zero)] = MTLBlendFactorZero,
[static_cast<int>(SrcBlendFactor::One)] = MTLBlendFactorOne,
[static_cast<int>(SrcBlendFactor::DstClr)] = MTLBlendFactorDestinationColor,
[static_cast<int>(SrcBlendFactor::InvDstClr)] = MTLBlendFactorOneMinusDestinationColor,
[static_cast<int>(SrcBlendFactor::SrcAlpha)] = MTLBlendFactorSource1Alpha,
[static_cast<int>(SrcBlendFactor::InvSrcAlpha)] = MTLBlendFactorOneMinusSource1Alpha,
[static_cast<int>(SrcBlendFactor::DstAlpha)] = MTLBlendFactorDestinationAlpha,
[static_cast<int>(SrcBlendFactor::InvDstAlpha)] = MTLBlendFactorOneMinusDestinationAlpha,
},
};
return factors[src1][static_cast<int>(factor)];
}
std::unique_ptr<AbstractPipeline>
Metal::Renderer::CreatePipeline(const AbstractPipelineConfig& config, const void* cache_data,
size_t cache_data_length)
{
@autoreleasepool
{
assert(!config.geometry_shader);
auto desc = MRCTransfer([MTLRenderPipelineDescriptor new]);
[desc setLabel:[NSString stringWithFormat:@"Pipeline %d", m_pipeline_counter++]];
[desc setVertexFunction:static_cast<const Shader*>(config.vertex_shader)->GetShader()];
[desc setFragmentFunction:static_cast<const Shader*>(config.pixel_shader)->GetShader()];
if (config.vertex_format)
[desc setVertexDescriptor:static_cast<const VertexFormat*>(config.vertex_format)->Get()];
RasterizationState rs = config.rasterization_state;
[desc setInputPrimitiveTopology:GetClass(rs.primitive)];
if (rs.cullmode == CullMode::All)
[desc setRasterizationEnabled:NO];
MTLRenderPipelineColorAttachmentDescriptor* color0 = [desc colorAttachments][0];
BlendingState bs = config.blending_state;
MTLColorWriteMask mask = MTLColorWriteMaskNone;
if (bs.colorupdate)
mask |= MTLColorWriteMaskRed | MTLColorWriteMaskGreen | MTLColorWriteMaskBlue;
if (bs.alphaupdate)
mask |= MTLColorWriteMaskAlpha;
[color0 setWriteMask:mask];
if (bs.blendenable)
{
[color0 setBlendingEnabled:YES];
[color0 setSourceRGBBlendFactor: Convert(bs.srcfactor, bs.usedualsrc)];
[color0 setSourceAlphaBlendFactor: Convert(bs.srcfactoralpha, bs.usedualsrc)];
[color0 setDestinationRGBBlendFactor: Convert(bs.dstfactor, bs.usedualsrc)];
[color0 setDestinationAlphaBlendFactor:Convert(bs.dstfactoralpha, bs.usedualsrc)];
[color0 setRgbBlendOperation: bs.subtract ? MTLBlendOperationReverseSubtract : MTLBlendOperationAdd];
[color0 setAlphaBlendOperation:bs.subtractAlpha ? MTLBlendOperationReverseSubtract : MTLBlendOperationAdd];
}
FramebufferState fs = config.framebuffer_state;
[color0 setPixelFormat:Util::FromAbstract(fs.color_texture_format)];
[desc setDepthAttachmentPixelFormat:Util::FromAbstract(fs.depth_texture_format)];
if (Util::HasStencil(fs.depth_texture_format))
[desc setStencilAttachmentPixelFormat:Util::FromAbstract(fs.depth_texture_format)];
NSError* err = nullptr;
MTLRenderPipelineReflection* reflection = nullptr;
id<MTLRenderPipelineState> pipe =
[g_device newRenderPipelineStateWithDescriptor:desc
options:MTLPipelineOptionArgumentInfo
reflection:&reflection
error:&err];
if (err)
{
PanicAlertFmt("Failed to compile pipeline for {} and {}: {}",
[[[desc vertexFunction] label] UTF8String],
[[[desc fragmentFunction] label] UTF8String],
[[err localizedDescription] UTF8String]);
return nullptr;
}
return std::make_unique<Pipeline>(MRCTransfer(pipe), reflection, Convert(rs.primitive),
Convert(rs.cullmode), config.depth_state, config.usage);
}
return g_object_cache->CreatePipeline(config);
}
void Metal::Renderer::Flush()

8
Source/Core/VideoBackends/Metal/MTLShader.h
View File

@ -15,13 +15,11 @@ namespace Metal
class Shader : public AbstractShader
{
public:
explicit Shader(ShaderStage stage, std::string msl, MRCOwned<id<MTLFunction>> shader)
: AbstractShader(stage), m_msl(std::move(msl)), m_shader(std::move(shader))
{
}
explicit Shader(ShaderStage stage, std::string msl, MRCOwned<id<MTLFunction>> shader);
~Shader();
id<MTLFunction> GetShader() const { return m_shader; }
BinaryData GetBinary() const override { return BinaryData(m_msl.begin(), m_msl.end()); }
BinaryData GetBinary() const override;
private:
std::string m_msl;

19
Source/Core/VideoBackends/Metal/MTLShader.mm Normal file
View File

@ -0,0 +1,19 @@
#include "VideoBackends/Metal/MTLShader.h"
#include "VideoBackends/Metal/MTLObjectCache.h"
Metal::Shader::Shader(ShaderStage stage, std::string msl, MRCOwned<id<MTLFunction>> shader)
: AbstractShader(stage), m_msl(std::move(msl)), m_shader(std::move(shader))
{
}
Metal::Shader::~Shader()
{
g_object_cache->ShaderDestroyed(this);
}
AbstractShader::BinaryData Metal::Shader::GetBinary() const
{
return BinaryData(m_msl.begin(), m_msl.end());
}

23
Source/Core/VideoBackends/Metal/MTLVertexFormat.h Normal file
View File

@ -0,0 +1,23 @@
// Copyright 2022 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <Metal/Metal.h>
#include "VideoBackends/Metal/MRCHelpers.h"
#include "VideoCommon/NativeVertexFormat.h"
namespace Metal
{
class VertexFormat : public NativeVertexFormat
{
public:
VertexFormat(const PortableVertexDeclaration& vtx_decl);
MTLVertexDescriptor* Get() const { return m_desc; }
MRCOwned<MTLVertexDescriptor*> m_desc;
};
} // namespace Metal

143
Source/Core/VideoBackends/Metal/MTLVertexFormat.mm Normal file
View File

@ -0,0 +1,143 @@
// Copyright 2022 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "VideoBackends/Metal/MTLVertexFormat.h"
#include "VideoCommon/VertexShaderGen.h"
static MTLVertexFormat ConvertFormat(ComponentFormat format, int count, bool int_format)
{
// clang-format off
if (int_format)
{
switch (format)
{
case ComponentFormat::UByte:
switch (count)
{
case 1: return MTLVertexFormatUChar;
case 2: return MTLVertexFormatUChar2;
case 3: return MTLVertexFormatUChar3;
case 4: return MTLVertexFormatUChar4;
default: return MTLVertexFormatInvalid;
}
case ComponentFormat::Byte:
switch (count)
{
case 1: return MTLVertexFormatChar;
case 2: return MTLVertexFormatChar2;
case 3: return MTLVertexFormatChar3;
case 4: return MTLVertexFormatChar4;
default: return MTLVertexFormatInvalid;
}
case ComponentFormat::UShort:
switch (count)
{
case 1: return MTLVertexFormatUShort;
case 2: return MTLVertexFormatUShort2;
case 3: return MTLVertexFormatUShort3;
case 4: return MTLVertexFormatUShort4;
default: return MTLVertexFormatInvalid;
}
case ComponentFormat::Short:
switch (count)
{
case 1: return MTLVertexFormatShort;
case 2: return MTLVertexFormatShort2;
case 3: return MTLVertexFormatShort3;
case 4: return MTLVertexFormatShort4;
default: return MTLVertexFormatInvalid;
}
case ComponentFormat::Float:
switch (count)
{
case 1: return MTLVertexFormatFloat;
case 2: return MTLVertexFormatFloat2;
case 3: return MTLVertexFormatFloat3;
case 4: return MTLVertexFormatFloat4;
default: return MTLVertexFormatInvalid;
}
}
}
else
{
switch (format)
{
case ComponentFormat::UByte:
switch (count)
{
case 1: return MTLVertexFormatUCharNormalized;
case 2: return MTLVertexFormatUChar2Normalized;
case 3: return MTLVertexFormatUChar3Normalized;
case 4: return MTLVertexFormatUChar4Normalized;
default: return MTLVertexFormatInvalid;
}
case ComponentFormat::Byte:
switch (count)
{
case 1: return MTLVertexFormatCharNormalized;
case 2: return MTLVertexFormatChar2Normalized;
case 3: return MTLVertexFormatChar3Normalized;
case 4: return MTLVertexFormatChar4Normalized;
default: return MTLVertexFormatInvalid;
}
case ComponentFormat::UShort:
switch (count)
{
case 1: return MTLVertexFormatUShortNormalized;
case 2: return MTLVertexFormatUShort2Normalized;
case 3: return MTLVertexFormatUShort3Normalized;
case 4: return MTLVertexFormatUShort4Normalized;
default: return MTLVertexFormatInvalid;
}
case ComponentFormat::Short:
switch (count)
{
case 1: return MTLVertexFormatShortNormalized;
case 2: return MTLVertexFormatShort2Normalized;
case 3: return MTLVertexFormatShort3Normalized;
case 4: return MTLVertexFormatShort4Normalized;
default: return MTLVertexFormatInvalid;
}
case ComponentFormat::Float:
switch (count)
{
case 1: return MTLVertexFormatFloat;
case 2: return MTLVertexFormatFloat2;
case 3: return MTLVertexFormatFloat3;
case 4: return MTLVertexFormatFloat4;
default: return MTLVertexFormatInvalid;
}
}
}
// clang-format on
}
static void SetAttribute(MTLVertexDescriptor* desc, u32 attribute, const AttributeFormat& format)
{
if (!format.enable)
return;
MTLVertexAttributeDescriptor* attr_desc = [[desc attributes] objectAtIndexedSubscript:attribute];
[attr_desc setFormat:ConvertFormat(format.type, format.components, format.integer)];
[attr_desc setOffset:format.offset];
[attr_desc setBufferIndex:0];
}
template <size_t N>
static void SetAttributes(MTLVertexDescriptor* desc, u32 attribute,
const AttributeFormat (&format)[N])
{
for (size_t i = 0; i < N; ++i)
SetAttribute(desc, attribute + i, format[i]);
}
Metal::VertexFormat::VertexFormat(const PortableVertexDeclaration& vtx_decl)
: NativeVertexFormat(vtx_decl), m_desc(MRCTransfer([MTLVertexDescriptor new]))
{
[[[m_desc layouts] objectAtIndexedSubscript:0] setStride:vtx_decl.stride];
SetAttribute(m_desc, SHADER_POSITION_ATTRIB, vtx_decl.position);
SetAttributes(m_desc, SHADER_NORMAL_ATTRIB, vtx_decl.normals);
SetAttributes(m_desc, SHADER_COLOR0_ATTRIB, vtx_decl.colors);
SetAttributes(m_desc, SHADER_TEXTURE0_ATTRIB, vtx_decl.texcoords);
SetAttribute(m_desc, SHADER_POSMTX_ATTRIB, vtx_decl.posmtx);
}