archive/Cemu
1
0
Fork 0
mirror of https://github.com/cemu-project/Cemu.git synced 2025-07-03 13:31:18 +12:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

latte: rename metal specific options

Browse source
This commit is contained in:
Samuliak 2025-05-20 18:26:52 +02:00
parent feba1aa7ba
commit 4311a41f34
No known key found for this signature in database
11 changed files with 57 additions and 53 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/Cafe/CafeSystem.cpp
View file

@ -259,7 +259,7 @@ void InfoLog_PrintActiveSettings()
{ {
cemuLog_log(LogType::Force, "Async compile: {}", GetConfig().async_compile.GetValue() ? "true" : "false"); cemuLog_log(LogType::Force, "Async compile: {}", GetConfig().async_compile.GetValue() ? "true" : "false");
cemuLog_log(LogType::Force, "Force mesh shaders: {}", GetConfig().force_mesh_shaders.GetValue() ? "true" : "false"); cemuLog_log(LogType::Force, "Force mesh shaders: {}", GetConfig().force_mesh_shaders.GetValue() ? "true" : "false");
cemuLog_log(LogType::Force, "Fast math: {}", g_current_game_profile->GetFastMath() ? "true" : "false"); cemuLog_log(LogType::Force, "Fast math: {}", g_current_game_profile->GetShaderFastMath() ? "true" : "false");
cemuLog_log(LogType::Force, "Buffer cache type: {}", g_current_game_profile->GetBufferCacheMode()); cemuLog_log(LogType::Force, "Buffer cache type: {}", g_current_game_profile->GetBufferCacheMode());
cemuLog_log(LogType::Force, "Position invariance: {}", g_current_game_profile->GetPositionInvariance()); cemuLog_log(LogType::Force, "Position invariance: {}", g_current_game_profile->GetPositionInvariance());
if (!GetConfig().vk_accurate_barriers.GetValue()) if (!GetConfig().vk_accurate_barriers.GetValue())

16
src/Cafe/GameProfile/GameProfile.cpp
View file

@ -226,8 +226,8 @@ bool GameProfile::Load(uint64_t title_id)
m_graphics_api = (GraphicAPI)graphicsApi.value; m_graphics_api = (GraphicAPI)graphicsApi.value;
gameProfile_loadEnumOption(iniParser, "accurateShaderMul", m_accurateShaderMul); gameProfile_loadEnumOption(iniParser, "accurateShaderMul", m_accurateShaderMul);
gameProfile_loadBooleanOption2(iniParser, "fastMath", m_fastMath); gameProfile_loadBooleanOption2(iniParser, "shaderFastMath", m_shaderFastMath);
gameProfile_loadEnumOption(iniParser, "bufferCacheMode2", m_bufferCacheMode); gameProfile_loadEnumOption(iniParser, "metalBufferCacheMode2", m_metalBufferCacheMode);
gameProfile_loadEnumOption(iniParser, "positionInvariance2", m_positionInvariance); gameProfile_loadEnumOption(iniParser, "positionInvariance2", m_positionInvariance);
// legacy support // legacy support
@ -309,8 +309,8 @@ void GameProfile::Save(uint64_t title_id)
fs->writeLine("[Graphics]"); fs->writeLine("[Graphics]");
WRITE_ENTRY(accurateShaderMul); WRITE_ENTRY(accurateShaderMul);
WRITE_ENTRY(fastMath); WRITE_ENTRY(shaderFastMath);
WRITE_ENTRY_NUMBERED(bufferCacheMode, 2); WRITE_ENTRY_NUMBERED(metalBufferCacheMode, 2);
WRITE_ENTRY_NUMBERED(positionInvariance, 2); WRITE_ENTRY_NUMBERED(positionInvariance, 2);
WRITE_OPTIONAL_ENTRY(precompiledShaders); WRITE_OPTIONAL_ENTRY(precompiledShaders);
WRITE_OPTIONAL_ENTRY(graphics_api); WRITE_OPTIONAL_ENTRY(graphics_api);
@ -342,8 +342,8 @@ void GameProfile::ResetOptional()
// graphic settings // graphic settings
m_accurateShaderMul = AccurateShaderMulOption::True; m_accurateShaderMul = AccurateShaderMulOption::True;
m_fastMath = true; m_shaderFastMath = true;
m_bufferCacheMode = BufferCacheMode::Auto; m_metalBufferCacheMode = MetalBufferCacheMode::Auto;
m_positionInvariance = PositionInvariance::Auto; m_positionInvariance = PositionInvariance::Auto;
// cpu settings // cpu settings
m_threadQuantum = kThreadQuantumDefault; m_threadQuantum = kThreadQuantumDefault;
@ -365,8 +365,8 @@ void GameProfile::Reset()
// graphic settings // graphic settings
m_accurateShaderMul = AccurateShaderMulOption::True; m_accurateShaderMul = AccurateShaderMulOption::True;
m_fastMath = true; m_shaderFastMath = true;
m_bufferCacheMode = BufferCacheMode::Auto; m_metalBufferCacheMode = MetalBufferCacheMode::Auto;
m_positionInvariance = PositionInvariance::Auto; m_positionInvariance = PositionInvariance::Auto;
m_precompiledShaders = PrecompiledShaderOption::Auto; m_precompiledShaders = PrecompiledShaderOption::Auto;
// cpu settings // cpu settings

8
src/Cafe/GameProfile/GameProfile.h
View file

@ -31,8 +31,8 @@ public:
[[nodiscard]] const std::optional<GraphicAPI>& GetGraphicsAPI() const { return m_graphics_api; } [[nodiscard]] const std::optional<GraphicAPI>& GetGraphicsAPI() const { return m_graphics_api; }
[[nodiscard]] const AccurateShaderMulOption& GetAccurateShaderMul() const { return m_accurateShaderMul; } [[nodiscard]] const AccurateShaderMulOption& GetAccurateShaderMul() const { return m_accurateShaderMul; }
[[nodiscard]] bool GetFastMath() const { return m_fastMath; } [[nodiscard]] bool GetShaderFastMath() const { return m_shaderFastMath; }
[[nodiscard]] BufferCacheMode GetBufferCacheMode() const { return m_bufferCacheMode; } [[nodiscard]] MetalBufferCacheMode GetBufferCacheMode() const { return m_metalBufferCacheMode; }
[[nodiscard]] PositionInvariance GetPositionInvariance() const { return m_positionInvariance; } [[nodiscard]] PositionInvariance GetPositionInvariance() const { return m_positionInvariance; }
[[nodiscard]] const std::optional<PrecompiledShaderOption>& GetPrecompiledShadersState() const { return m_precompiledShaders; } [[nodiscard]] const std::optional<PrecompiledShaderOption>& GetPrecompiledShadersState() const { return m_precompiledShaders; }
@ -57,8 +57,8 @@ private:
// graphic settings // graphic settings
std::optional<GraphicAPI> m_graphics_api{}; std::optional<GraphicAPI> m_graphics_api{};
AccurateShaderMulOption m_accurateShaderMul = AccurateShaderMulOption::True; AccurateShaderMulOption m_accurateShaderMul = AccurateShaderMulOption::True;
bool m_fastMath = true; bool m_shaderFastMath = true;
BufferCacheMode m_bufferCacheMode = BufferCacheMode::Auto; MetalBufferCacheMode m_metalBufferCacheMode = MetalBufferCacheMode::Auto;
PositionInvariance m_positionInvariance = PositionInvariance::Auto; PositionInvariance m_positionInvariance = PositionInvariance::Auto;
std::optional<PrecompiledShaderOption> m_precompiledShaders{}; std::optional<PrecompiledShaderOption> m_precompiledShaders{};
// cpu settings // cpu settings

2
src/Cafe/HW/Latte/LegacyShaderDecompiler/LatteDecompilerAnalyzer.cpp
View file

@ -559,6 +559,7 @@ namespace LatteDecompiler
{ {
decompilerContext->hasUniformVarBlock = true; // uf_verticesPerInstance and uf_streamoutBufferBase* decompilerContext->hasUniformVarBlock = true; // uf_verticesPerInstance and uf_streamoutBufferBase*
} }
#if ENABLE_METAL
if (g_renderer->GetType() == RendererAPI::Metal) if (g_renderer->GetType() == RendererAPI::Metal)
{ {
bool usesGeometryShader = UseGeometryShader(*decompilerContext->contextRegistersNew, decompilerContext->options->usesGeometryShader); bool usesGeometryShader = UseGeometryShader(*decompilerContext->contextRegistersNew, decompilerContext->options->usesGeometryShader);
@ -566,6 +567,7 @@ namespace LatteDecompiler
if (decompilerContext->shaderType == LatteConst::ShaderType::Vertex && usesGeometryShader) if (decompilerContext->shaderType == LatteConst::ShaderType::Vertex && usesGeometryShader)
decompilerContext->hasUniformVarBlock = true; // uf_verticesPerInstance decompilerContext->hasUniformVarBlock = true; // uf_verticesPerInstance
} }
#endif
} }
void _initUniformBindingPoints(LatteDecompilerShaderContext* decompilerContext) void _initUniformBindingPoints(LatteDecompilerShaderContext* decompilerContext)

26
src/Cafe/HW/Latte/Renderer/Metal/MetalMemoryManager.cpp
View file

@ -36,9 +36,9 @@ void MetalMemoryManager::InitBufferCache(size_t size)
{ {
cemu_assert_debug(!m_bufferCache); cemu_assert_debug(!m_bufferCache);
m_bufferCacheMode = g_current_game_profile->GetBufferCacheMode(); m_metalBufferCacheMode = g_current_game_profile->GetBufferCacheMode();
if (m_bufferCacheMode == BufferCacheMode::Auto) if (m_metalBufferCacheMode == MetalBufferCacheMode::Auto)
{ {
// TODO: do this for all unified memory systems? // TODO: do this for all unified memory systems?
if (m_mtlr->IsAppleGPU()) if (m_mtlr->IsAppleGPU())
@ -50,21 +50,21 @@ void MetalMemoryManager::InitBufferCache(size_t size)
case 0x0005000010143500: // USA case 0x0005000010143500: // USA
case 0x0005000010143400: // JPN case 0x0005000010143400: // JPN
// TODO: use host instead? // TODO: use host instead?
m_bufferCacheMode = BufferCacheMode::DeviceShared; m_metalBufferCacheMode = MetalBufferCacheMode::DeviceShared;
break; break;
default: default:
m_bufferCacheMode = BufferCacheMode::DevicePrivate; m_metalBufferCacheMode = MetalBufferCacheMode::DevicePrivate;
break; break;
} }
} }
else else
{ {
m_bufferCacheMode = BufferCacheMode::DevicePrivate; m_metalBufferCacheMode = MetalBufferCacheMode::DevicePrivate;
} }
} }
// First, try to import the host memory as a buffer // First, try to import the host memory as a buffer
if (m_bufferCacheMode == BufferCacheMode::Host) if (m_metalBufferCacheMode == MetalBufferCacheMode::Host)
{ {
if (m_mtlr->HasUnifiedMemory()) if (m_mtlr->HasUnifiedMemory())
{ {
@ -74,18 +74,18 @@ void MetalMemoryManager::InitBufferCache(size_t size)
if (!m_bufferCache) if (!m_bufferCache)
{ {
cemuLog_log(LogType::Force, "Failed to import host memory as a buffer, using device shared mode instead"); cemuLog_log(LogType::Force, "Failed to import host memory as a buffer, using device shared mode instead");
m_bufferCacheMode = BufferCacheMode::DeviceShared; m_metalBufferCacheMode = MetalBufferCacheMode::DeviceShared;
} }
} }
else else
{ {
cemuLog_log(LogType::Force, "Host buffer cache mode is only available on unified memory systems, using device shared mode instead"); cemuLog_log(LogType::Force, "Host buffer cache mode is only available on unified memory systems, using device shared mode instead");
m_bufferCacheMode = BufferCacheMode::DeviceShared; m_metalBufferCacheMode = MetalBufferCacheMode::DeviceShared;
} }
} }
if (!m_bufferCache) if (!m_bufferCache)
m_bufferCache = m_mtlr->GetDevice()->newBuffer(size, (m_bufferCacheMode == BufferCacheMode::DevicePrivate ? MTL::ResourceStorageModePrivate : MTL::ResourceStorageModeShared)); m_bufferCache = m_mtlr->GetDevice()->newBuffer(size, (m_metalBufferCacheMode == MetalBufferCacheMode::DevicePrivate ? MTL::ResourceStorageModePrivate : MTL::ResourceStorageModeShared));
#ifdef CEMU_DEBUG_ASSERT #ifdef CEMU_DEBUG_ASSERT
m_bufferCache->setLabel(GetLabel("Buffer cache", m_bufferCache)); m_bufferCache->setLabel(GetLabel("Buffer cache", m_bufferCache));
@ -94,11 +94,11 @@ void MetalMemoryManager::InitBufferCache(size_t size)
void MetalMemoryManager::UploadToBufferCache(const void* data, size_t offset, size_t size) void MetalMemoryManager::UploadToBufferCache(const void* data, size_t offset, size_t size)
{ {
cemu_assert_debug(m_bufferCacheMode != BufferCacheMode::Host); cemu_assert_debug(m_metalBufferCacheMode != MetalBufferCacheMode::Host);
cemu_assert_debug(m_bufferCache); cemu_assert_debug(m_bufferCache);
cemu_assert_debug((offset + size) <= m_bufferCache->length()); cemu_assert_debug((offset + size) <= m_bufferCache->length());
if (m_bufferCacheMode == BufferCacheMode::DevicePrivate) if (m_metalBufferCacheMode == MetalBufferCacheMode::DevicePrivate)
{ {
auto blitCommandEncoder = m_mtlr->GetBlitCommandEncoder(); auto blitCommandEncoder = m_mtlr->GetBlitCommandEncoder();
@ -118,10 +118,10 @@ void MetalMemoryManager::UploadToBufferCache(const void* data, size_t offset, si
void MetalMemoryManager::CopyBufferCache(size_t srcOffset, size_t dstOffset, size_t size) void MetalMemoryManager::CopyBufferCache(size_t srcOffset, size_t dstOffset, size_t size)
{ {
cemu_assert_debug(m_bufferCacheMode != BufferCacheMode::Host); cemu_assert_debug(m_metalBufferCacheMode != MetalBufferCacheMode::Host);
cemu_assert_debug(m_bufferCache); cemu_assert_debug(m_bufferCache);
if (m_bufferCacheMode == BufferCacheMode::DevicePrivate) if (m_metalBufferCacheMode == MetalBufferCacheMode::DevicePrivate)
m_mtlr->CopyBufferToBuffer(m_bufferCache, srcOffset, m_bufferCache, dstOffset, size, ALL_MTL_RENDER_STAGES, ALL_MTL_RENDER_STAGES); m_mtlr->CopyBufferToBuffer(m_bufferCache, srcOffset, m_bufferCache, dstOffset, size, ALL_MTL_RENDER_STAGES, ALL_MTL_RENDER_STAGES);
else else
memcpy((uint8*)m_bufferCache->contents() + dstOffset, (uint8*)m_bufferCache->contents() + srcOffset, size); memcpy((uint8*)m_bufferCache->contents() + dstOffset, (uint8*)m_bufferCache->contents() + srcOffset, size);

6
src/Cafe/HW/Latte/Renderer/Metal/MetalMemoryManager.h
View file

@ -43,12 +43,12 @@ public:
// Getters // Getters
bool UseHostMemoryForCache() const bool UseHostMemoryForCache() const
{ {
return (m_bufferCacheMode == BufferCacheMode::Host); return (m_metalBufferCacheMode == MetalBufferCacheMode::Host);
} }
bool NeedsReducedLatency() const bool NeedsReducedLatency() const
{ {
return (m_bufferCacheMode == BufferCacheMode::DeviceShared || m_bufferCacheMode == BufferCacheMode::Host); return (m_metalBufferCacheMode == MetalBufferCacheMode::DeviceShared || m_metalBufferCacheMode == MetalBufferCacheMode::Host);
} }
MPTR GetImportedMemBaseAddress() const MPTR GetImportedMemBaseAddress() const
@ -70,7 +70,7 @@ private:
MetalSynchronizedHeapAllocator m_indexAllocator; MetalSynchronizedHeapAllocator m_indexAllocator;
MTL::Buffer* m_bufferCache = nullptr; MTL::Buffer* m_bufferCache = nullptr;
BufferCacheMode m_bufferCacheMode; MetalBufferCacheMode m_metalBufferCacheMode;
MPTR m_importedMemBaseAddress; MPTR m_importedMemBaseAddress;
size_t m_hostAllocationSize = 0; size_t m_hostAllocationSize = 0;
}; };

2
src/Cafe/HW/Latte/Renderer/Metal/RendererShaderMtl.cpp
View file

@ -277,7 +277,7 @@ MTL::Library* RendererShaderMtl::LibraryFromSource()
{ {
// Compile from source // Compile from source
NS_STACK_SCOPED MTL::CompileOptions* options = MTL::CompileOptions::alloc()->init(); NS_STACK_SCOPED MTL::CompileOptions* options = MTL::CompileOptions::alloc()->init();
if (g_current_game_profile->GetFastMath()) if (g_current_game_profile->GetShaderFastMath())
options->setFastMathEnabled(true); options->setFastMathEnabled(true);
if (m_mtlr->GetPositionInvariance()) if (m_mtlr->GetPositionInvariance())

16
src/config/CemuConfig.h
View file

@ -124,14 +124,14 @@ enum class AccurateShaderMulOption
}; };
ENABLE_ENUM_ITERATORS(AccurateShaderMulOption, AccurateShaderMulOption::False, AccurateShaderMulOption::True); ENABLE_ENUM_ITERATORS(AccurateShaderMulOption, AccurateShaderMulOption::False, AccurateShaderMulOption::True);
enum class BufferCacheMode enum class MetalBufferCacheMode
{ {
Auto, Auto,
DevicePrivate, DevicePrivate,
DeviceShared, DeviceShared,
Host, Host,
}; };
ENABLE_ENUM_ITERATORS(BufferCacheMode, BufferCacheMode::Auto, BufferCacheMode::Host); ENABLE_ENUM_ITERATORS(MetalBufferCacheMode, MetalBufferCacheMode::Auto, MetalBufferCacheMode::Host);
enum class PositionInvariance enum class PositionInvariance
{ {
@ -239,16 +239,16 @@ struct fmt::formatter<AccurateShaderMulOption> : formatter<string_view> {
} }
}; };
template <> template <>
struct fmt::formatter<BufferCacheMode> : formatter<string_view> { struct fmt::formatter<MetalBufferCacheMode> : formatter<string_view> {
template <typename FormatContext> template <typename FormatContext>
auto format(const BufferCacheMode c, FormatContext &ctx) const { auto format(const MetalBufferCacheMode c, FormatContext &ctx) const {
string_view name; string_view name;
switch (c) switch (c)
{ {
case BufferCacheMode::Auto: name = "auto"; break; case MetalBufferCacheMode::Auto: name = "auto"; break;
case BufferCacheMode::DevicePrivate: name = "device private"; break; case MetalBufferCacheMode::DevicePrivate: name = "device private"; break;
case BufferCacheMode::DeviceShared: name = "device shared"; break; case MetalBufferCacheMode::DeviceShared: name = "device shared"; break;
case BufferCacheMode::Host: name = "host"; break; case MetalBufferCacheMode::Host: name = "host"; break;
default: name = "unknown"; break; default: name = "unknown"; break;
} }
return formatter<string_view>::format(name, ctx); return formatter<string_view>::format(name, ctx);

24
src/gui/GameProfileWindow.cpp
View file

@ -128,19 +128,19 @@ GameProfileWindow::GameProfileWindow(wxWindow* parent, uint64_t title_id)
m_shader_mul_accuracy->SetToolTip(_("EXPERT OPTION\nControls the accuracy of floating point multiplication in shaders.\n\nRecommended: true")); m_shader_mul_accuracy->SetToolTip(_("EXPERT OPTION\nControls the accuracy of floating point multiplication in shaders.\n\nRecommended: true"));
first_row->Add(m_shader_mul_accuracy, 0, wxALL, 5); first_row->Add(m_shader_mul_accuracy, 0, wxALL, 5);
first_row->Add(new wxStaticText(panel, wxID_ANY, _("Fast math")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); first_row->Add(new wxStaticText(panel, wxID_ANY, _("Shader fast math")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
wxString math_values[] = { _("false"), _("true") }; wxString math_values[] = { _("false"), _("true") };
m_fast_math = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, (int)std::size(math_values), math_values); m_shader_fast_math = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, (int)std::size(math_values), math_values);
m_fast_math->SetToolTip(_("EXPERT OPTION\nEnables fast math for all shaders. May (rarely) cause graphical bugs.\n\nMetal only\n\nRecommended: true")); m_shader_fast_math->SetToolTip(_("EXPERT OPTION\nEnables fast math for all shaders. May (rarely) cause graphical bugs.\n\nMetal only\n\nRecommended: true"));
first_row->Add(m_fast_math, 0, wxALL, 5); first_row->Add(m_shader_fast_math, 0, wxALL, 5);
first_row->Add(new wxStaticText(panel, wxID_ANY, _("Buffer cache mode")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); first_row->Add(new wxStaticText(panel, wxID_ANY, _("Metal buffer cache mode")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
wxString cache_values[] = { _("auto"), _("device private"), _("device shared"), _("host") }; wxString cache_values[] = { _("auto"), _("device private"), _("device shared"), _("host") };
m_buffer_cache_mode = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, (int)std::size(cache_values), cache_values); m_metal_buffer_cache_mode = new wxChoice(panel, wxID_ANY, wxDefaultPosition, wxDefaultSize, (int)std::size(cache_values), cache_values);
m_buffer_cache_mode->SetToolTip(_("EXPERT OPTION\nDecides how the buffer cache memory will be managed.\n\nMetal only\n\nRecommended: auto")); m_metal_buffer_cache_mode->SetToolTip(_("EXPERT OPTION\nDecides how the buffer cache memory will be managed.\n\nMetal only\n\nRecommended: auto"));
first_row->Add(m_buffer_cache_mode, 0, wxALL, 5); first_row->Add(m_metal_buffer_cache_mode, 0, wxALL, 5);
first_row->Add(new wxStaticText(panel, wxID_ANY, _("Position invariance")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5); first_row->Add(new wxStaticText(panel, wxID_ANY, _("Position invariance")), 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
@ -295,8 +295,8 @@ void GameProfileWindow::ApplyProfile()
else else
m_graphic_api->SetSelection(1 + m_game_profile.m_graphics_api.value()); // "", OpenGL, Vulkan, Metal m_graphic_api->SetSelection(1 + m_game_profile.m_graphics_api.value()); // "", OpenGL, Vulkan, Metal
m_shader_mul_accuracy->SetSelection((int)m_game_profile.m_accurateShaderMul); m_shader_mul_accuracy->SetSelection((int)m_game_profile.m_accurateShaderMul);
m_fast_math->SetSelection((int)m_game_profile.m_fastMath); m_shader_fast_math->SetSelection((int)m_game_profile.m_shaderFastMath);
m_buffer_cache_mode->SetSelection((int)m_game_profile.m_bufferCacheMode); m_metal_buffer_cache_mode->SetSelection((int)m_game_profile.m_metalBufferCacheMode);
m_position_invariance->SetSelection((int)m_game_profile.m_positionInvariance); m_position_invariance->SetSelection((int)m_game_profile.m_positionInvariance);
//// audio //// audio
@ -359,8 +359,8 @@ void GameProfileWindow::SaveProfile()
m_game_profile.m_accurateShaderMul = (AccurateShaderMulOption)m_shader_mul_accuracy->GetSelection(); m_game_profile.m_accurateShaderMul = (AccurateShaderMulOption)m_shader_mul_accuracy->GetSelection();
if (m_game_profile.m_accurateShaderMul != AccurateShaderMulOption::False && m_game_profile.m_accurateShaderMul != AccurateShaderMulOption::True) if (m_game_profile.m_accurateShaderMul != AccurateShaderMulOption::False && m_game_profile.m_accurateShaderMul != AccurateShaderMulOption::True)
m_game_profile.m_accurateShaderMul = AccurateShaderMulOption::True; // force a legal value m_game_profile.m_accurateShaderMul = AccurateShaderMulOption::True; // force a legal value
m_game_profile.m_fastMath = (bool)m_fast_math->GetSelection(); m_game_profile.m_shaderFastMath = (bool)m_shader_fast_math->GetSelection();
m_game_profile.m_bufferCacheMode = (BufferCacheMode)m_buffer_cache_mode->GetSelection(); m_game_profile.m_metalBufferCacheMode = (MetalBufferCacheMode)m_metal_buffer_cache_mode->GetSelection();
m_game_profile.m_positionInvariance = (PositionInvariance)m_position_invariance->GetSelection(); m_game_profile.m_positionInvariance = (PositionInvariance)m_position_invariance->GetSelection();
if (m_graphic_api->GetSelection() == 0) if (m_graphic_api->GetSelection() == 0)

4
src/gui/GameProfileWindow.h
View file

@ -40,8 +40,8 @@ private:
wxChoice* m_graphic_api; wxChoice* m_graphic_api;
wxChoice* m_shader_mul_accuracy; wxChoice* m_shader_mul_accuracy;
wxChoice* m_fast_math; wxChoice* m_shader_fast_math;
wxChoice* m_buffer_cache_mode; wxChoice* m_metal_buffer_cache_mode;
wxChoice* m_position_invariance; wxChoice* m_position_invariance;
//wxChoice* m_cache_accuracy; //wxChoice* m_cache_accuracy;

4
src/gui/GeneralSettings2.cpp
View file

@ -1091,11 +1091,13 @@ void GeneralSettings2::StoreConfig()
{ {
if (selection != wxNOT_FOUND) if (selection != wxNOT_FOUND)
{ {
#if ENABLE_METAL
const auto* info = (wxMetalUUID*)m_graphic_device->GetClientObject(selection); const auto* info = (wxMetalUUID*)m_graphic_device->GetClientObject(selection);
if (info) if (info)
config.mtl_graphic_device_uuid = info->GetDeviceInfo().uuid; config.mtl_graphic_device_uuid = info->GetDeviceInfo().uuid;
else else
config.mtl_graphic_device_uuid = {}; config.mtl_graphic_device_uuid = {};
#endif
} }
else else
config.mtl_graphic_device_uuid = {}; config.mtl_graphic_device_uuid = {};
@ -1638,9 +1640,9 @@ void GeneralSettings2::HandleGraphicsApiSelection()
m_vsync->Select(selection); m_vsync->Select(selection);
m_graphic_device->Enable(); m_graphic_device->Enable();
auto devices = MetalRenderer::GetDevices();
m_graphic_device->Clear(); m_graphic_device->Clear();
#if ENABLE_METAL #if ENABLE_METAL
auto devices = MetalRenderer::GetDevices();
if(!devices.empty()) if(!devices.empty())
{ {
for (const auto& device : devices) for (const auto& device : devices)