ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #9236 from lioncash/log-backend 

VideoBackends: Migrate logging over to fmt
This commit is contained in:
Léo Lam 2020-11-12 14:51:28 +01:00 committed by GitHub
parent ec5313fe24 21dd7a8ebb
commit 8a621c2d5e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
31 changed files with 174 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Source/Core/VideoBackends/D3D/D3DBase.cpp
View File

@ -67,7 +67,7 @@ bool Create(u32 adapter_index, bool enable_debug_layer)
HRESULT hr = dxgi_factory->EnumAdapters(adapter_index, adapter.GetAddressOf()); HRESULT hr = dxgi_factory->EnumAdapters(adapter_index, adapter.GetAddressOf());
if (FAILED(hr)) if (FAILED(hr))
{ {
WARN_LOG(VIDEO, "Adapter %u not found, using default", adapter_index); WARN_LOG_FMT(VIDEO, "Adapter {} not found, using default", adapter_index);
adapter = nullptr; adapter = nullptr;
} }
@ -99,7 +99,7 @@ bool Create(u32 adapter_index, bool enable_debug_layer)
} }
else else
{ {
WARN_LOG(VIDEO, "Debug layer requested but not available."); WARN_LOG_FMT(VIDEO, "Debug layer requested but not available.");
} }
} }
@ -124,7 +124,7 @@ bool Create(u32 adapter_index, bool enable_debug_layer)
hr = device.As(&device1); hr = device.As(&device1);
if (FAILED(hr)) if (FAILED(hr))
{ {
WARN_LOG(VIDEO, "Missing Direct3D 11.1 support. Logical operations will not be supported."); WARN_LOG_FMT(VIDEO, "Missing Direct3D 11.1 support. Logical operations will not be supported.");
} }
stateman = std::make_unique<StateManager>(); stateman = std::make_unique<StateManager>();
@ -156,9 +156,9 @@ void Destroy()
} }
if (remaining_references) if (remaining_references)
ERROR_LOG(VIDEO, "Unreleased references: %i.", remaining_references); ERROR_LOG_FMT(VIDEO, "Unreleased references: {}.", remaining_references);
else else
NOTICE_LOG(VIDEO, "Successfully released all device references!"); NOTICE_LOG_FMT(VIDEO, "Successfully released all device references!");
dxgi_factory.Reset(); dxgi_factory.Reset();
D3DCommon::UnloadLibraries(); D3DCommon::UnloadLibraries();

2
Source/Core/VideoBackends/D3D/D3DState.cpp
View File

@ -386,7 +386,7 @@ ID3D11BlendState* StateCache::Get(BlendingState state)
{ {
return m_blend.emplace(state.hex, std::move(res)).first->second.Get(); return m_blend.emplace(state.hex, std::move(res)).first->second.Get();
} }
WARN_LOG(VIDEO, "Creating D3D blend state failed with an error: %x", hr); WARN_LOG_FMT(VIDEO, "Creating D3D blend state failed with an error: {:08X}", hr);
} }
D3D11_BLEND_DESC desc = {}; D3D11_BLEND_DESC desc = {};

2
Source/Core/VideoBackends/D3D/PerfQuery.cpp
View File

@ -35,7 +35,7 @@ void PerfQuery::EnableQuery(PerfQueryGroup type)
{ {
// TODO // TODO
FlushOne(); FlushOne();
ERROR_LOG(VIDEO, "Flushed query buffer early!"); ERROR_LOG_FMT(VIDEO, "Flushed query buffer early!");
} }
// start query // start query

2
Source/Core/VideoBackends/D3D12/BoundingBox.cpp
View File

@ -148,7 +148,7 @@ void BoundingBox::Flush()
const u32 copy_size = (end - start) * sizeof(ValueType); const u32 copy_size = (end - start) * sizeof(ValueType);
if (!m_upload_buffer.ReserveMemory(copy_size, sizeof(ValueType))) if (!m_upload_buffer.ReserveMemory(copy_size, sizeof(ValueType)))
{ {
WARN_LOG(VIDEO, "Executing command list while waiting for space in bbox stream buffer"); WARN_LOG_FMT(VIDEO, "Executing command list while waiting for space in bbox stream buffer");
Renderer::GetInstance()->ExecuteCommandList(false); Renderer::GetInstance()->ExecuteCommandList(false);
if (!m_upload_buffer.ReserveMemory(copy_size, sizeof(ValueType))) if (!m_upload_buffer.ReserveMemory(copy_size, sizeof(ValueType)))
{ {

4
Source/Core/VideoBackends/D3D12/DXContext.cpp
View File

@ -152,7 +152,7 @@ bool DXContext::CreateDevice(u32 adapter_index, bool enable_debug_layer)
HRESULT hr = m_dxgi_factory->EnumAdapters(adapter_index, &adapter); HRESULT hr = m_dxgi_factory->EnumAdapters(adapter_index, &adapter);
if (FAILED(hr)) if (FAILED(hr))
{ {
ERROR_LOG(VIDEO, "Adapter %u not found, using default", adapter_index); ERROR_LOG_FMT(VIDEO, "Adapter {} not found, using default", adapter_index);
adapter = nullptr; adapter = nullptr;
} }
@ -166,7 +166,7 @@ bool DXContext::CreateDevice(u32 adapter_index, bool enable_debug_layer)
} }
else else
{ {
ERROR_LOG(VIDEO, "Debug layer requested but not available."); ERROR_LOG_FMT(VIDEO, "Debug layer requested but not available.");
enable_debug_layer = false; enable_debug_layer = false;
} }
} }

4
Source/Core/VideoBackends/D3D12/DXPipeline.cpp
View File

@ -210,7 +210,7 @@ std::unique_ptr<DXPipeline> DXPipeline::Create(const AbstractPipelineConfig& con
HRESULT hr = g_dx_context->GetDevice()->CreateGraphicsPipelineState(&desc, IID_PPV_ARGS(&pso)); HRESULT hr = g_dx_context->GetDevice()->CreateGraphicsPipelineState(&desc, IID_PPV_ARGS(&pso));
if (FAILED(hr)) if (FAILED(hr))
{ {
WARN_LOG(VIDEO, "CreateGraphicsPipelineState() %sfailed with HRESULT %08X", WARN_LOG_FMT(VIDEO, "CreateGraphicsPipelineState() {}failed with HRESULT {:08X}",
cache_data ? "with cache data " : "", hr); cache_data ? "with cache data " : "", hr);
return nullptr; return nullptr;
} }
@ -227,7 +227,7 @@ AbstractPipeline::CacheData DXPipeline::GetCacheData() const
HRESULT hr = m_pipeline->GetCachedBlob(&blob); HRESULT hr = m_pipeline->GetCachedBlob(&blob);
if (FAILED(hr)) if (FAILED(hr))
{ {
WARN_LOG(VIDEO, "ID3D12Pipeline::GetCachedBlob() failed with HRESULT %08X", hr); WARN_LOG_FMT(VIDEO, "ID3D12Pipeline::GetCachedBlob() failed with HRESULT {:08X}", hr);
return {}; return {};
} }

3
Source/Core/VideoBackends/D3D12/DXTexture.cpp
View File

@ -239,7 +239,8 @@ void DXTexture::Load(u32 level, u32 width, u32 height, u32 row_length, const u8*
if (!g_dx_context->GetTextureUploadBuffer().ReserveMemory( if (!g_dx_context->GetTextureUploadBuffer().ReserveMemory(
upload_size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT)) upload_size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT))
{ {
WARN_LOG(VIDEO, "Executing command list while waiting for space in texture upload buffer"); WARN_LOG_FMT(VIDEO,
"Executing command list while waiting for space in texture upload buffer");
Renderer::GetInstance()->ExecuteCommandList(false); Renderer::GetInstance()->ExecuteCommandList(false);
if (!g_dx_context->GetTextureUploadBuffer().ReserveMemory( if (!g_dx_context->GetTextureUploadBuffer().ReserveMemory(
upload_size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT)) upload_size, D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT))

2
Source/Core/VideoBackends/D3D12/DescriptorHeapManager.cpp
View File

@ -148,7 +148,7 @@ bool SamplerHeapManager::Lookup(const SamplerState& ss, D3D12_CPU_DESCRIPTOR_HAN
{ {
// We can clear at any time because the descriptors are copied prior to execution. // We can clear at any time because the descriptors are copied prior to execution.
// It's still not free, since we have to recreate all our samplers again. // It's still not free, since we have to recreate all our samplers again.
WARN_LOG(VIDEO, "Out of samplers, resetting CPU heap"); WARN_LOG_FMT(VIDEO, "Out of samplers, resetting CPU heap");
Clear(); Clear();
} }

2
Source/Core/VideoBackends/D3D12/Renderer.cpp
View File

@ -653,7 +653,7 @@ void Renderer::UpdateDescriptorTables()
const bool uav_update_failed = (m_dirty_bits & DirtyState_PS_UAV) && !UpdateUAVDescriptorTable(); const bool uav_update_failed = (m_dirty_bits & DirtyState_PS_UAV) && !UpdateUAVDescriptorTable();
if (texture_update_failed || sampler_update_failed || uav_update_failed) if (texture_update_failed || sampler_update_failed || uav_update_failed)
{ {
WARN_LOG(VIDEO, "Executing command list while waiting for temporary %s", WARN_LOG_FMT(VIDEO, "Executing command list while waiting for temporary {}",
texture_update_failed ? "descriptors" : "samplers"); texture_update_failed ? "descriptors" : "samplers");
ExecuteCommandList(false); ExecuteCommandList(false);
SetRootSignatures(); SetRootSignatures();

10
Source/Core/VideoBackends/D3D12/VertexManager.cpp
View File

@ -80,7 +80,7 @@ void VertexManager::ResetBuffer(u32 vertex_stride)
if (!has_vbuffer_allocation || !has_ibuffer_allocation) if (!has_vbuffer_allocation || !has_ibuffer_allocation)
{ {
// Flush any pending commands first, so that we can wait on the fences // Flush any pending commands first, so that we can wait on the fences
WARN_LOG(VIDEO, "Executing command list while waiting for space in vertex/index buffer"); WARN_LOG_FMT(VIDEO, "Executing command list while waiting for space in vertex/index buffer");
Renderer::GetInstance()->ExecuteCommandList(false); Renderer::GetInstance()->ExecuteCommandList(false);
// Attempt to allocate again, this may cause a fence wait // Attempt to allocate again, this may cause a fence wait
@ -182,7 +182,7 @@ bool VertexManager::ReserveConstantStorage()
} }
// The only places that call constant updates are safe to have state restored. // The only places that call constant updates are safe to have state restored.
WARN_LOG(VIDEO, "Executing command list while waiting for space in uniform buffer"); WARN_LOG_FMT(VIDEO, "Executing command list while waiting for space in uniform buffer");
Renderer::GetInstance()->ExecuteCommandList(false); Renderer::GetInstance()->ExecuteCommandList(false);
// Since we are on a new command buffer, all constants have been invalidated, and we need // Since we are on a new command buffer, all constants have been invalidated, and we need
@ -244,7 +244,7 @@ void VertexManager::UploadUtilityUniforms(const void* data, u32 data_size)
if (!m_uniform_stream_buffer.ReserveMemory(data_size, if (!m_uniform_stream_buffer.ReserveMemory(data_size,
D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT)) D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT))
{ {
WARN_LOG(VIDEO, "Executing command buffer while waiting for ext space in uniform buffer"); WARN_LOG_FMT(VIDEO, "Executing command buffer while waiting for ext space in uniform buffer");
Renderer::GetInstance()->ExecuteCommandList(false); Renderer::GetInstance()->ExecuteCommandList(false);
} }
@ -266,7 +266,7 @@ bool VertexManager::UploadTexelBuffer(const void* data, u32 data_size, TexelBuff
if (!m_texel_stream_buffer.ReserveMemory(data_size, elem_size)) if (!m_texel_stream_buffer.ReserveMemory(data_size, elem_size))
{ {
// Try submitting cmdbuffer. // Try submitting cmdbuffer.
WARN_LOG(VIDEO, "Submitting command buffer while waiting for space in texel buffer"); WARN_LOG_FMT(VIDEO, "Submitting command buffer while waiting for space in texel buffer");
Renderer::GetInstance()->ExecuteCommandList(false); Renderer::GetInstance()->ExecuteCommandList(false);
if (!m_texel_stream_buffer.ReserveMemory(data_size, elem_size)) if (!m_texel_stream_buffer.ReserveMemory(data_size, elem_size))
{ {
@ -296,7 +296,7 @@ bool VertexManager::UploadTexelBuffer(const void* data, u32 data_size, TexelBuff
if (!m_texel_stream_buffer.ReserveMemory(reserve_size, elem_size)) if (!m_texel_stream_buffer.ReserveMemory(reserve_size, elem_size))
{ {
// Try submitting cmdbuffer. // Try submitting cmdbuffer.
WARN_LOG(VIDEO, "Submitting command buffer while waiting for space in texel buffer"); WARN_LOG_FMT(VIDEO, "Submitting command buffer while waiting for space in texel buffer");
Renderer::GetInstance()->ExecuteCommandList(false); Renderer::GetInstance()->ExecuteCommandList(false);
if (!m_texel_stream_buffer.ReserveMemory(reserve_size, elem_size)) if (!m_texel_stream_buffer.ReserveMemory(reserve_size, elem_size))
{ {

2
Source/Core/VideoBackends/D3DCommon/Shader.cpp
View File

@ -126,7 +126,7 @@ std::optional<Shader::BinaryData> Shader::CompileShader(D3D_FEATURE_LEVEL featur
if (errors && errors->GetBufferSize() > 0) if (errors && errors->GetBufferSize() > 0)
{ {
WARN_LOG(VIDEO, "%s compilation succeeded with warnings:\n%s", target, WARN_LOG_FMT(VIDEO, "{} compilation succeeded with warnings:\n{}", target,
static_cast<const char*>(errors->GetBufferPointer())); static_cast<const char*>(errors->GetBufferPointer()));
} }

6
Source/Core/VideoBackends/D3DCommon/SwapChain.cpp
View File

@ -134,7 +134,7 @@ bool SwapChain::CreateSwapChain(bool stereo)
hr = m_dxgi_factory->MakeWindowAssociation(static_cast<HWND>(m_wsi.render_surface), hr = m_dxgi_factory->MakeWindowAssociation(static_cast<HWND>(m_wsi.render_surface),
DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER); DXGI_MWA_NO_WINDOW_CHANGES | DXGI_MWA_NO_ALT_ENTER);
if (FAILED(hr)) if (FAILED(hr))
WARN_LOG(VIDEO, "MakeWindowAssociation() failed with HRESULT %08X", hr); WARN_LOG_FMT(VIDEO, "MakeWindowAssociation() failed with HRESULT {:08X}", hr);
m_stereo = stereo; m_stereo = stereo;
if (!CreateSwapChainBuffers()) if (!CreateSwapChainBuffers())
@ -167,7 +167,7 @@ bool SwapChain::ResizeSwapChain()
GetDXGIFormatForAbstractFormat(m_texture_format, false), GetDXGIFormatForAbstractFormat(m_texture_format, false),
GetSwapChainFlags()); GetSwapChainFlags());
if (FAILED(hr)) if (FAILED(hr))
WARN_LOG(VIDEO, "ResizeBuffers() failed with HRESULT %08X", hr); WARN_LOG_FMT(VIDEO, "ResizeBuffers() failed with HRESULT {:08X}", hr);
DXGI_SWAP_CHAIN_DESC desc; DXGI_SWAP_CHAIN_DESC desc;
if (SUCCEEDED(m_swap_chain->GetDesc(&desc))) if (SUCCEEDED(m_swap_chain->GetDesc(&desc)))
@ -237,7 +237,7 @@ bool SwapChain::Present()
HRESULT hr = m_swap_chain->Present(static_cast<UINT>(g_ActiveConfig.bVSyncActive), present_flags); HRESULT hr = m_swap_chain->Present(static_cast<UINT>(g_ActiveConfig.bVSyncActive), present_flags);
if (FAILED(hr)) if (FAILED(hr))
{ {
WARN_LOG(VIDEO, "Swap chain present failed with HRESULT %08X", hr); WARN_LOG_FMT(VIDEO, "Swap chain present failed with HRESULT {:08X}", hr);
return false; return false;
} }

4
Source/Core/VideoBackends/OGL/PerfQuery.cpp
View File

@ -104,7 +104,7 @@ void PerfQueryGL::EnableQuery(PerfQueryGroup type)
if (m_query_buffer.size() == m_query_count) if (m_query_buffer.size() == m_query_count)
{ {
FlushOne(); FlushOne();
// ERROR_LOG(VIDEO, "Flushed query buffer early!"); // ERROR_LOG_FMT(VIDEO, "Flushed query buffer early!");
} }
// start query // start query
@ -198,7 +198,7 @@ void PerfQueryGLESNV::EnableQuery(PerfQueryGroup type)
if (m_query_buffer.size() == m_query_count) if (m_query_buffer.size() == m_query_count)
{ {
FlushOne(); FlushOne();
// ERROR_LOG(VIDEO, "Flushed query buffer early!"); // ERROR_LOG_FMT(VIDEO, "Flushed query buffer early!");
} }
// start query // start query

10
Source/Core/VideoBackends/OGL/ProgramShaderCache.cpp
View File

@ -357,7 +357,7 @@ bool ProgramShaderCache::CheckShaderCompileResult(GLuint id, GLenum type, std::s
if (compileStatus != GL_TRUE) if (compileStatus != GL_TRUE)
{ {
ERROR_LOG(VIDEO, "%s failed compilation:\n%s", prefix, info_log.c_str()); ERROR_LOG_FMT(VIDEO, "{} failed compilation:\n{}", prefix, info_log);
std::string filename = VideoBackendBase::BadShaderFilename(prefix, num_failures++); std::string filename = VideoBackendBase::BadShaderFilename(prefix, num_failures++);
std::ofstream file; std::ofstream file;
@ -376,7 +376,7 @@ bool ProgramShaderCache::CheckShaderCompileResult(GLuint id, GLenum type, std::s
return false; return false;
} }
WARN_LOG(VIDEO, "%s compiled with warnings:\n%s", prefix, info_log.c_str()); WARN_LOG_FMT(VIDEO, "{} compiled with warnings:\n{}", prefix, info_log);
} }
return true; return true;
@ -396,7 +396,7 @@ bool ProgramShaderCache::CheckProgramLinkResult(GLuint id, std::string_view vcod
glGetProgramInfoLog(id, length, &length, &info_log[0]); glGetProgramInfoLog(id, length, &length, &info_log[0]);
if (linkStatus != GL_TRUE) if (linkStatus != GL_TRUE)
{ {
ERROR_LOG(VIDEO, "Program failed linking:\n%s", info_log.c_str()); ERROR_LOG_FMT(VIDEO, "Program failed linking:\n{}", info_log);
std::string filename = VideoBackendBase::BadShaderFilename("p", num_failures++); std::string filename = VideoBackendBase::BadShaderFilename("p", num_failures++);
std::ofstream file; std::ofstream file;
File::OpenFStream(file, filename, std::ios_base::out); File::OpenFStream(file, filename, std::ios_base::out);
@ -421,7 +421,7 @@ bool ProgramShaderCache::CheckProgramLinkResult(GLuint id, std::string_view vcod
return false; return false;
} }
WARN_LOG(VIDEO, "Program linked with warnings:\n%s", info_log.c_str()); WARN_LOG_FMT(VIDEO, "Program linked with warnings:\n{}", info_log);
} }
return true; return true;
@ -554,7 +554,7 @@ PipelineProgram* ProgramShaderCache::GetPipelineProgram(const GLVertexFormat* ve
glGetProgramiv(prog->shader.glprogid, GL_LINK_STATUS, &link_status); glGetProgramiv(prog->shader.glprogid, GL_LINK_STATUS, &link_status);
if (link_status != GL_TRUE) if (link_status != GL_TRUE)
{ {
WARN_LOG(VIDEO, "Failed to create GL program from program binary."); WARN_LOG_FMT(VIDEO, "Failed to create GL program from program binary.");
prog->shader.Destroy(); prog->shader.Destroy();
return nullptr; return nullptr;
} }

21
Source/Core/VideoBackends/OGL/Render.cpp
View File

@ -105,19 +105,19 @@ static void APIENTRY ErrorCallback(GLenum source, GLenum type, GLuint id, GLenum
switch (severity) switch (severity)
{ {
case GL_DEBUG_SEVERITY_HIGH_ARB: case GL_DEBUG_SEVERITY_HIGH_ARB:
ERROR_LOG(HOST_GPU, "id: %x, source: %s, type: %s - %s", id, s_source, s_type, message); ERROR_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
break; break;
case GL_DEBUG_SEVERITY_MEDIUM_ARB: case GL_DEBUG_SEVERITY_MEDIUM_ARB:
WARN_LOG(HOST_GPU, "id: %x, source: %s, type: %s - %s", id, s_source, s_type, message); WARN_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
break; break;
case GL_DEBUG_SEVERITY_LOW_ARB: case GL_DEBUG_SEVERITY_LOW_ARB:
DEBUG_LOG(HOST_GPU, "id: %x, source: %s, type: %s - %s", id, s_source, s_type, message); DEBUG_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
break; break;
case GL_DEBUG_SEVERITY_NOTIFICATION: case GL_DEBUG_SEVERITY_NOTIFICATION:
DEBUG_LOG(HOST_GPU, "id: %x, source: %s, type: %s - %s", id, s_source, s_type, message); DEBUG_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
break; break;
default: default:
ERROR_LOG(HOST_GPU, "id: %x, source: %s, type: %s - %s", id, s_source, s_type, message); ERROR_LOG_FMT(HOST_GPU, "id: {:x}, source: {}, type: {} - {}", id, s_source, s_type, message);
break; break;
} }
} }
@ -307,7 +307,7 @@ static void InitDriverInfo()
version = 100 * major + minor; version = 100 * major + minor;
if (change >= change_scale) if (change >= change_scale)
{ {
ERROR_LOG(VIDEO, "Version changeID overflow - change:%d scale:%f", change, change_scale); ERROR_LOG_FMT(VIDEO, "Version changeID overflow - change:{} scale:{}", change, change_scale);
} }
else else
{ {
@ -734,20 +734,20 @@ Renderer::Renderer(std::unique_ptr<GLContext> main_gl_context, float backbuffer_
g_Config.VerifyValidity(); g_Config.VerifyValidity();
UpdateActiveConfig(); UpdateActiveConfig();
OSD::AddMessage(StringFromFormat("Video Info: %s, %s, %s", g_ogl_config.gl_vendor, OSD::AddMessage(fmt::format("Video Info: {}, {}, {}", g_ogl_config.gl_vendor,
g_ogl_config.gl_renderer, g_ogl_config.gl_version), g_ogl_config.gl_renderer, g_ogl_config.gl_version),
5000); 5000);
if (!g_ogl_config.bSupportsGLBufferStorage && !g_ogl_config.bSupportsGLPinnedMemory) if (!g_ogl_config.bSupportsGLBufferStorage && !g_ogl_config.bSupportsGLPinnedMemory)
{ {
OSD::AddMessage(StringFromFormat("Your OpenGL driver does not support %s_buffer_storage.", OSD::AddMessage(fmt::format("Your OpenGL driver does not support {}_buffer_storage.",
m_main_gl_context->IsGLES() ? "EXT" : "ARB"), m_main_gl_context->IsGLES() ? "EXT" : "ARB"),
60000); 60000);
OSD::AddMessage("This device's performance will be terrible.", 60000); OSD::AddMessage("This device's performance will be terrible.", 60000);
OSD::AddMessage("Please ask your device vendor for an updated OpenGL driver.", 60000); OSD::AddMessage("Please ask your device vendor for an updated OpenGL driver.", 60000);
} }
WARN_LOG(VIDEO, "Missing OGL Extensions: %s%s%s%s%s%s%s%s%s%s%s%s%s%s", WARN_LOG_FMT(VIDEO, "Missing OGL Extensions: {}{}{}{}{}{}{}{}{}{}{}{}{}{}",
g_ActiveConfig.backend_info.bSupportsDualSourceBlend ? "" : "DualSourceBlend ", g_ActiveConfig.backend_info.bSupportsDualSourceBlend ? "" : "DualSourceBlend ",
g_ActiveConfig.backend_info.bSupportsPrimitiveRestart ? "" : "PrimitiveRestart ", g_ActiveConfig.backend_info.bSupportsPrimitiveRestart ? "" : "PrimitiveRestart ",
g_ActiveConfig.backend_info.bSupportsEarlyZ ? "" : "EarlyZ ", g_ActiveConfig.backend_info.bSupportsEarlyZ ? "" : "EarlyZ ",
@ -755,7 +755,8 @@ Renderer::Renderer(std::unique_ptr<GLContext> main_gl_context, float backbuffer_
supports_glsl_cache ? "" : "ShaderCache ", supports_glsl_cache ? "" : "ShaderCache ",
g_ogl_config.bSupportsGLBaseVertex ? "" : "BaseVertex ", g_ogl_config.bSupportsGLBaseVertex ? "" : "BaseVertex ",
g_ogl_config.bSupportsGLBufferStorage ? "" : "BufferStorage ", g_ogl_config.bSupportsGLBufferStorage ? "" : "BufferStorage ",
g_ogl_config.bSupportsGLSync ? "" : "Sync ", g_ogl_config.bSupportsMSAA ? "" : "MSAA ", g_ogl_config.bSupportsGLSync ? "" : "Sync ",
g_ogl_config.bSupportsMSAA ? "" : "MSAA ",
g_ActiveConfig.backend_info.bSupportsSSAA ? "" : "SSAA ", g_ActiveConfig.backend_info.bSupportsSSAA ? "" : "SSAA ",
g_ActiveConfig.backend_info.bSupportsGSInstancing ? "" : "GSInstancing ", g_ActiveConfig.backend_info.bSupportsGSInstancing ? "" : "GSInstancing ",
g_ActiveConfig.backend_info.bSupportsClipControl ? "" : "ClipControl ", g_ActiveConfig.backend_info.bSupportsClipControl ? "" : "ClipControl ",

40
Source/Core/VideoBackends/Software/EfbInterface.cpp
View File

@ -56,7 +56,9 @@ static void SetPixelAlphaOnly(u32 offset, u8 a)
} }
break; break;
default: default:
ERROR_LOG(VIDEO, "Unsupported pixel format: %i", static_cast<int>(bpmem.zcontrol.pixel_format)); ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}",
static_cast<int>(bpmem.zcontrol.pixel_format));
break;
} }
} }
@ -87,7 +89,7 @@ static void SetPixelColorOnly(u32 offset, u8* rgb)
break; break;
case PEControl::RGB565_Z16: case PEControl::RGB565_Z16:
{ {
INFO_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet"); INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet");
u32 src = *(u32*)rgb; u32 src = *(u32*)rgb;
u32* dst = (u32*)&efb[offset]; u32* dst = (u32*)&efb[offset];
u32 val = *dst & 0xff000000; u32 val = *dst & 0xff000000;
@ -96,7 +98,9 @@ static void SetPixelColorOnly(u32 offset, u8* rgb)
} }
break; break;
default: default:
ERROR_LOG(VIDEO, "Unsupported pixel format: %i", static_cast<int>(bpmem.zcontrol.pixel_format)); ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}",
static_cast<int>(bpmem.zcontrol.pixel_format));
break;
} }
} }
@ -128,7 +132,7 @@ static void SetPixelAlphaColor(u32 offset, u8* color)
break; break;
case PEControl::RGB565_Z16: case PEControl::RGB565_Z16:
{ {
INFO_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet"); INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet");
u32 src = *(u32*)color; u32 src = *(u32*)color;
u32* dst = (u32*)&efb[offset]; u32* dst = (u32*)&efb[offset];
u32 val = *dst & 0xff000000; u32 val = *dst & 0xff000000;
@ -137,7 +141,9 @@ static void SetPixelAlphaColor(u32 offset, u8* color)
} }
break; break;
default: default:
ERROR_LOG(VIDEO, "Unsupported pixel format: %i", static_cast<int>(bpmem.zcontrol.pixel_format)); ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}",
static_cast<int>(bpmem.zcontrol.pixel_format));
break;
} }
} }
@ -159,11 +165,12 @@ static u32 GetPixelColor(u32 offset)
Convert6To8((src >> 18) & 0x3f) << 24; // Red Convert6To8((src >> 18) & 0x3f) << 24; // Red
case PEControl::RGB565_Z16: case PEControl::RGB565_Z16:
INFO_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet"); INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet");
return 0xff | ((src & 0x00ffffff) << 8); return 0xff | ((src & 0x00ffffff) << 8);
default: default:
ERROR_LOG(VIDEO, "Unsupported pixel format: %i", static_cast<int>(bpmem.zcontrol.pixel_format)); ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}",
static_cast<int>(bpmem.zcontrol.pixel_format));
return 0; return 0;
} }
} }
@ -184,7 +191,7 @@ static void SetPixelDepth(u32 offset, u32 depth)
break; break;
case PEControl::RGB565_Z16: case PEControl::RGB565_Z16:
{ {
INFO_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet"); INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet");
u32* dst = (u32*)&efb[offset]; u32* dst = (u32*)&efb[offset];
u32 val = *dst & 0xff000000; u32 val = *dst & 0xff000000;
val |= depth & 0x00ffffff; val |= depth & 0x00ffffff;
@ -192,7 +199,9 @@ static void SetPixelDepth(u32 offset, u32 depth)
} }
break; break;
default: default:
ERROR_LOG(VIDEO, "Unsupported pixel format: %i", static_cast<int>(bpmem.zcontrol.pixel_format)); ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}",
static_cast<int>(bpmem.zcontrol.pixel_format));
break;
} }
} }
@ -211,12 +220,14 @@ static u32 GetPixelDepth(u32 offset)
break; break;
case PEControl::RGB565_Z16: case PEControl::RGB565_Z16:
{ {
INFO_LOG(VIDEO, "RGB565_Z16 is not supported correctly yet"); INFO_LOG_FMT(VIDEO, "RGB565_Z16 is not supported correctly yet");
depth = (*(u32*)&efb[offset]) & 0x00ffffff; depth = (*(u32*)&efb[offset]) & 0x00ffffff;
} }
break; break;
default: default:
ERROR_LOG(VIDEO, "Unsupported pixel format: %i", static_cast<int>(bpmem.zcontrol.pixel_format)); ERROR_LOG_FMT(VIDEO, "Unsupported pixel format: {}",
static_cast<int>(bpmem.zcontrol.pixel_format));
break;
} }
return depth; return depth;
@ -554,7 +565,7 @@ void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const MathUtil::Rectangle<int>
{ {
if (!xfb_in_ram) if (!xfb_in_ram)
{ {
WARN_LOG(VIDEO, "Tried to copy to invalid XFB address"); WARN_LOG_FMT(VIDEO, "Tried to copy to invalid XFB address");
return; return;
} }
@ -569,7 +580,7 @@ void EncodeXFB(u8* xfb_in_ram, u32 memory_stride, const MathUtil::Rectangle<int>
// copy always has an even width, which might not be true. // copy always has an even width, which might not be true.
if (left & 1 || right & 1) if (left & 1 || right & 1)
{ {
WARN_LOG(VIDEO, "Trying to copy XFB to from unaligned EFB source"); WARN_LOG_FMT(VIDEO, "Trying to copy XFB to from unaligned EFB source");
// this will show up as wrongly encoded // this will show up as wrongly encoded
} }
@ -677,7 +688,8 @@ bool ZCompare(u16 x, u16 y, u32 z)
break; break;
default: default:
pass = false; pass = false;
ERROR_LOG(VIDEO, "Bad Z compare mode %i", (int)bpmem.zmode.func); ERROR_LOG_FMT(VIDEO, "Bad Z compare mode {}", static_cast<int>(bpmem.zmode.func));
break;
} }
if (pass && bpmem.zmode.updateenable) if (pass && bpmem.zmode.updateenable)

4
Source/Core/VideoBackends/Software/SWOGLWindow.cpp
View File

@ -41,12 +41,12 @@ bool SWOGLWindow::Initialize(const WindowSystemInfo& wsi)
// Init extension support. // Init extension support.
if (!GLExtensions::Init(m_gl_context.get())) if (!GLExtensions::Init(m_gl_context.get()))
{ {
ERROR_LOG(VIDEO, "GLExtensions::Init failed!Does your video card support OpenGL 2.0?"); ERROR_LOG_FMT(VIDEO, "GLExtensions::Init failed!Does your video card support OpenGL 2.0?");
return false; return false;
} }
else if (GLExtensions::Version() < 310) else if (GLExtensions::Version() < 310)
{ {
ERROR_LOG(VIDEO, "OpenGL Version %d detected, but at least 3.1 is required.", ERROR_LOG_FMT(VIDEO, "OpenGL Version {} detected, but at least 3.1 is required.",
GLExtensions::Version()); GLExtensions::Version());
return false; return false;
} }

2
Source/Core/VideoBackends/Software/SWVertexLoader.cpp
View File

@ -110,7 +110,7 @@ void SWVertexLoader::SetFormat(u8 attributeIndex, u8 primitiveType)
xfmem.MatrixIndexB.Tex6MtxIdx != g_main_cp_state.matrix_index_b.Tex6MtxIdx || xfmem.MatrixIndexB.Tex6MtxIdx != g_main_cp_state.matrix_index_b.Tex6MtxIdx ||
xfmem.MatrixIndexB.Tex7MtxIdx != g_main_cp_state.matrix_index_b.Tex7MtxIdx) xfmem.MatrixIndexB.Tex7MtxIdx != g_main_cp_state.matrix_index_b.Tex7MtxIdx)
{ {
ERROR_LOG(VIDEO, "Matrix indices don't match"); ERROR_LOG_FMT(VIDEO, "Matrix indices don't match");
} }
m_vertex.posMtx = xfmem.MatrixIndexA.PosNormalMtxIdx; m_vertex.posMtx = xfmem.MatrixIndexA.PosNormalMtxIdx;

2
Source/Core/VideoBackends/Software/SetupUnit.cpp
View File

@ -37,7 +37,7 @@ void SetupUnit::SetupVertex()
SetupQuad(); SetupQuad();
break; break;
case OpcodeDecoder::GX_DRAW_QUADS_2: case OpcodeDecoder::GX_DRAW_QUADS_2:
WARN_LOG(VIDEO, "Non-standard primitive drawing command GL_DRAW_QUADS_2"); WARN_LOG_FMT(VIDEO, "Non-standard primitive drawing command GL_DRAW_QUADS_2");
SetupQuad(); SetupQuad();
break; break;
case OpcodeDecoder::GX_DRAW_TRIANGLES: case OpcodeDecoder::GX_DRAW_TRIANGLES:

3
Source/Core/VideoBackends/Software/TransformUnit.cpp
View File

@ -445,7 +445,8 @@ void TransformTexCoord(const InputVertexData* src, OutputVertexData* dst, bool s
dst->texCoords[coordNum].z = 1.0f; dst->texCoords[coordNum].z = 1.0f;
break; break;
default: default:
ERROR_LOG(VIDEO, "Bad tex gen type %i", texinfo.texgentype.Value()); ERROR_LOG_FMT(VIDEO, "Bad tex gen type {}", texinfo.texgentype.Value());
break;
} }
} }

2
Source/Core/VideoBackends/Vulkan/BoundingBox.cpp
View File

@ -34,7 +34,7 @@ bool BoundingBox::Initialize()
{ {
if (!g_ActiveConfig.backend_info.bSupportsBBox) if (!g_ActiveConfig.backend_info.bSupportsBBox)
{ {
WARN_LOG(VIDEO, "Vulkan: Bounding box is unsupported by your device."); WARN_LOG_FMT(VIDEO, "Vulkan: Bounding box is unsupported by your device.");
return true; return true;
} }

16
Source/Core/VideoBackends/Vulkan/ObjectCache.cpp
View File

@ -543,7 +543,7 @@ bool ObjectCache::ValidatePipelineCache(const u8* data, size_t data_length)
{ {
if (data_length < sizeof(VK_PIPELINE_CACHE_HEADER)) if (data_length < sizeof(VK_PIPELINE_CACHE_HEADER))
{ {
ERROR_LOG(VIDEO, "Pipeline cache failed validation: Invalid header"); ERROR_LOG_FMT(VIDEO, "Pipeline cache failed validation: Invalid header");
return false; return false;
} }
@ -551,28 +551,28 @@ bool ObjectCache::ValidatePipelineCache(const u8* data, size_t data_length)
std::memcpy(&header, data, sizeof(header)); std::memcpy(&header, data, sizeof(header));
if (header.header_length < sizeof(VK_PIPELINE_CACHE_HEADER)) if (header.header_length < sizeof(VK_PIPELINE_CACHE_HEADER))
{ {
ERROR_LOG(VIDEO, "Pipeline cache failed validation: Invalid header length"); ERROR_LOG_FMT(VIDEO, "Pipeline cache failed validation: Invalid header length");
return false; return false;
} }
if (header.header_version != VK_PIPELINE_CACHE_HEADER_VERSION_ONE) if (header.header_version != VK_PIPELINE_CACHE_HEADER_VERSION_ONE)
{ {
ERROR_LOG(VIDEO, "Pipeline cache failed validation: Invalid header version"); ERROR_LOG_FMT(VIDEO, "Pipeline cache failed validation: Invalid header version");
return false; return false;
} }
if (header.vendor_id != g_vulkan_context->GetDeviceProperties().vendorID) if (header.vendor_id != g_vulkan_context->GetDeviceProperties().vendorID)
{ {
ERROR_LOG(VIDEO, ERROR_LOG_FMT(
"Pipeline cache failed validation: Incorrect vendor ID (file: 0x%X, device: 0x%X)", VIDEO, "Pipeline cache failed validation: Incorrect vendor ID (file: {:#X}, device: {:#X})",
header.vendor_id, g_vulkan_context->GetDeviceProperties().vendorID); header.vendor_id, g_vulkan_context->GetDeviceProperties().vendorID);
return false; return false;
} }
if (header.device_id != g_vulkan_context->GetDeviceProperties().deviceID) if (header.device_id != g_vulkan_context->GetDeviceProperties().deviceID)
{ {
ERROR_LOG(VIDEO, ERROR_LOG_FMT(
"Pipeline cache failed validation: Incorrect device ID (file: 0x%X, device: 0x%X)", VIDEO, "Pipeline cache failed validation: Incorrect device ID (file: {:#X}, device: {:#X})",
header.device_id, g_vulkan_context->GetDeviceProperties().deviceID); header.device_id, g_vulkan_context->GetDeviceProperties().deviceID);
return false; return false;
} }
@ -580,7 +580,7 @@ bool ObjectCache::ValidatePipelineCache(const u8* data, size_t data_length)
if (std::memcmp(header.uuid, g_vulkan_context->GetDeviceProperties().pipelineCacheUUID, if (std::memcmp(header.uuid, g_vulkan_context->GetDeviceProperties().pipelineCacheUUID,
VK_UUID_SIZE) != 0) VK_UUID_SIZE) != 0)
{ {
ERROR_LOG(VIDEO, "Pipeline cache failed validation: Incorrect UUID"); ERROR_LOG_FMT(VIDEO, "Pipeline cache failed validation: Incorrect UUID");
return false; return false;
} }

12
Source/Core/VideoBackends/Vulkan/Renderer.cpp
View File

@ -300,17 +300,17 @@ void Renderer::BindBackbuffer(const ClearColor& clear_color)
if (res == VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT) if (res == VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT)
{ {
// The present keeps returning exclusive mode lost unless we re-create the swap chain. // The present keeps returning exclusive mode lost unless we re-create the swap chain.
INFO_LOG(VIDEO, "Lost exclusive fullscreen."); INFO_LOG_FMT(VIDEO, "Lost exclusive fullscreen.");
m_swap_chain->RecreateSwapChain(); m_swap_chain->RecreateSwapChain();
} }
else if (res == VK_SUBOPTIMAL_KHR || res == VK_ERROR_OUT_OF_DATE_KHR) else if (res == VK_SUBOPTIMAL_KHR || res == VK_ERROR_OUT_OF_DATE_KHR)
{ {
INFO_LOG(VIDEO, "Resizing swap chain due to suboptimal/out-of-date"); INFO_LOG_FMT(VIDEO, "Resizing swap chain due to suboptimal/out-of-date");
m_swap_chain->ResizeSwapChain(); m_swap_chain->ResizeSwapChain();
} }
else else
{ {
ERROR_LOG(VIDEO, "Unknown present error 0x%08X, please report.", res); ERROR_LOG_FMT(VIDEO, "Unknown present error {:#010X}, please report.", res);
m_swap_chain->RecreateSwapChain(); m_swap_chain->RecreateSwapChain();
} }
@ -401,7 +401,7 @@ void Renderer::CheckForSurfaceResize()
// CheckForSurfaceChange should handle this case. // CheckForSurfaceChange should handle this case.
if (!m_swap_chain) if (!m_swap_chain)
{ {
WARN_LOG(VIDEO, "Surface resize event received without active surface, ignoring"); WARN_LOG_FMT(VIDEO, "Surface resize event received without active surface, ignoring");
return; return;
} }
@ -527,7 +527,7 @@ void Renderer::SetTexture(u32 index, const AbstractTexture* texture)
{ {
if (StateTracker::GetInstance()->InRenderPass()) if (StateTracker::GetInstance()->InRenderPass())
{ {
WARN_LOG(VIDEO, "Transitioning image in render pass in Renderer::SetTexture()"); WARN_LOG_FMT(VIDEO, "Transitioning image in render pass in Renderer::SetTexture()");
StateTracker::GetInstance()->EndRenderPass(); StateTracker::GetInstance()->EndRenderPass();
} }
@ -553,7 +553,7 @@ void Renderer::SetSamplerState(u32 index, const SamplerState& state)
VkSampler sampler = g_object_cache->GetSampler(state); VkSampler sampler = g_object_cache->GetSampler(state);
if (sampler == VK_NULL_HANDLE) if (sampler == VK_NULL_HANDLE)
{ {
ERROR_LOG(VIDEO, "Failed to create sampler"); ERROR_LOG_FMT(VIDEO, "Failed to create sampler");
sampler = g_object_cache->GetPointSampler(); sampler = g_object_cache->GetPointSampler();
} }

12
Source/Core/VideoBackends/Vulkan/ShaderCompiler.cpp
View File

@ -203,16 +203,16 @@ static std::optional<SPIRVCodeVector> CompileShaderToSPV(EShLanguage stage,
// Temporary: skip if it contains "Warning, version 450 is not yet complete; most version-specific // Temporary: skip if it contains "Warning, version 450 is not yet complete; most version-specific
// features are present, but some are missing." // features are present, but some are missing."
if (strlen(shader->getInfoLog()) > 108) if (strlen(shader->getInfoLog()) > 108)
WARN_LOG(VIDEO, "Shader info log: %s", shader->getInfoLog()); WARN_LOG_FMT(VIDEO, "Shader info log: {}", shader->getInfoLog());
if (strlen(shader->getInfoDebugLog()) > 0) if (strlen(shader->getInfoDebugLog()) > 0)
WARN_LOG(VIDEO, "Shader debug info log: %s", shader->getInfoDebugLog()); WARN_LOG_FMT(VIDEO, "Shader debug info log: {}", shader->getInfoDebugLog());
if (strlen(program->getInfoLog()) > 25) if (strlen(program->getInfoLog()) > 25)
WARN_LOG(VIDEO, "Program info log: %s", program->getInfoLog()); WARN_LOG_FMT(VIDEO, "Program info log: {}", program->getInfoLog());
if (strlen(program->getInfoDebugLog()) > 0) if (strlen(program->getInfoDebugLog()) > 0)
WARN_LOG(VIDEO, "Program debug info log: %s", program->getInfoDebugLog()); WARN_LOG_FMT(VIDEO, "Program debug info log: {}", program->getInfoDebugLog());
std::string spv_messages = logger.getAllMessages(); const std::string spv_messages = logger.getAllMessages();
if (!spv_messages.empty()) if (!spv_messages.empty())
WARN_LOG(VIDEO, "SPIR-V conversion messages: %s", spv_messages.c_str()); WARN_LOG_FMT(VIDEO, "SPIR-V conversion messages: {}", spv_messages);
// Dump source code of shaders out to file if enabled. // Dump source code of shaders out to file if enabled.
if (g_ActiveConfig.iLog & CONF_SAVESHADERS) if (g_ActiveConfig.iLog & CONF_SAVESHADERS)

8
Source/Core/VideoBackends/Vulkan/StateTracker.cpp
View File

@ -351,12 +351,12 @@ bool StateTracker::Bind()
if (!UpdateDescriptorSet()) if (!UpdateDescriptorSet())
{ {
// We can fail to allocate descriptors if we exhaust the pool for this command buffer. // We can fail to allocate descriptors if we exhaust the pool for this command buffer.
WARN_LOG(VIDEO, "Failed to get a descriptor set, executing buffer"); WARN_LOG_FMT(VIDEO, "Failed to get a descriptor set, executing buffer");
Renderer::GetInstance()->ExecuteCommandBuffer(false, false); Renderer::GetInstance()->ExecuteCommandBuffer(false, false);
if (!UpdateDescriptorSet()) if (!UpdateDescriptorSet())
{ {
// Something strange going on. // Something strange going on.
ERROR_LOG(VIDEO, "Failed to get descriptor set, skipping draw"); ERROR_LOG_FMT(VIDEO, "Failed to get descriptor set, skipping draw");
return false; return false;
} }
} }
@ -405,12 +405,12 @@ bool StateTracker::BindCompute()
if (!UpdateComputeDescriptorSet()) if (!UpdateComputeDescriptorSet())
{ {
WARN_LOG(VIDEO, "Failed to get a compute descriptor set, executing buffer"); WARN_LOG_FMT(VIDEO, "Failed to get a compute descriptor set, executing buffer");
Renderer::GetInstance()->ExecuteCommandBuffer(false, false); Renderer::GetInstance()->ExecuteCommandBuffer(false, false);
if (!UpdateComputeDescriptorSet()) if (!UpdateComputeDescriptorSet())
{ {
// Something strange going on. // Something strange going on.
ERROR_LOG(VIDEO, "Failed to get descriptor set, skipping dispatch"); ERROR_LOG_FMT(VIDEO, "Failed to get descriptor set, skipping dispatch");
return false; return false;
} }
} }

8
Source/Core/VideoBackends/Vulkan/SwapChain.cpp
View File

@ -283,7 +283,7 @@ bool SwapChain::CreateSwapChain()
VkImageUsageFlags image_usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; VkImageUsageFlags image_usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
if (!(surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT)) if (!(surface_capabilities.supportedUsageFlags & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT))
{ {
ERROR_LOG(VIDEO, "Vulkan: Swap chain does not support usage as color attachment"); ERROR_LOG_FMT(VIDEO, "Vulkan: Swap chain does not support usage as color attachment");
return false; return false;
} }
@ -341,7 +341,7 @@ bool SwapChain::CreateSwapChain()
if (res != VK_SUCCESS) if (res != VK_SUCCESS)
{ {
// Try without exclusive fullscreen. // Try without exclusive fullscreen.
WARN_LOG(VIDEO, "Failed to create exclusive fullscreen swapchain, trying without."); WARN_LOG_FMT(VIDEO, "Failed to create exclusive fullscreen swapchain, trying without.");
swap_chain_info.pNext = nullptr; swap_chain_info.pNext = nullptr;
g_Config.backend_info.bSupportsExclusiveFullscreen = false; g_Config.backend_info.bSupportsExclusiveFullscreen = false;
g_ActiveConfig.backend_info.bSupportsExclusiveFullscreen = false; g_ActiveConfig.backend_info.bSupportsExclusiveFullscreen = false;
@ -514,7 +514,7 @@ bool SwapChain::SetFullscreenState(bool state)
return false; return false;
} }
INFO_LOG(VIDEO, "Exclusive fullscreen acquired."); INFO_LOG_FMT(VIDEO, "Exclusive fullscreen acquired.");
} }
else else
{ {
@ -522,7 +522,7 @@ bool SwapChain::SetFullscreenState(bool state)
if (res != VK_SUCCESS) if (res != VK_SUCCESS)
LOG_VULKAN_ERROR(res, "vkReleaseFullScreenExclusiveModeEXT failed:"); LOG_VULKAN_ERROR(res, "vkReleaseFullScreenExclusiveModeEXT failed:");
INFO_LOG(VIDEO, "Exclusive fullscreen released."); INFO_LOG_FMT(VIDEO, "Exclusive fullscreen released.");
} }
m_current_fullscreen_state = state; m_current_fullscreen_state = state;

3
Source/Core/VideoBackends/Vulkan/VKTexture.cpp
View File

@ -369,7 +369,8 @@ void VKTexture::Load(u32 level, u32 width, u32 height, u32 row_length, const u8*
if (!stream_buffer->ReserveMemory(upload_size, upload_alignment)) if (!stream_buffer->ReserveMemory(upload_size, upload_alignment))
{ {
// Execute the command buffer first. // Execute the command buffer first.
WARN_LOG(VIDEO, "Executing command list while waiting for space in texture upload buffer"); WARN_LOG_FMT(VIDEO,
"Executing command list while waiting for space in texture upload buffer");
Renderer::GetInstance()->ExecuteCommandBuffer(false); Renderer::GetInstance()->ExecuteCommandBuffer(false);
// Try allocating again. This may cause a fence wait. // Try allocating again. This may cause a fence wait.

10
Source/Core/VideoBackends/Vulkan/VertexManager.cpp
View File

@ -149,7 +149,7 @@ void VertexManager::ResetBuffer(u32 vertex_stride)
if (!has_vbuffer_allocation || !has_ibuffer_allocation) if (!has_vbuffer_allocation || !has_ibuffer_allocation)
{ {
// Flush any pending commands first, so that we can wait on the fences // Flush any pending commands first, so that we can wait on the fences
WARN_LOG(VIDEO, "Executing command list while waiting for space in vertex/index buffer"); WARN_LOG_FMT(VIDEO, "Executing command list while waiting for space in vertex/index buffer");
Renderer::GetInstance()->ExecuteCommandBuffer(false); Renderer::GetInstance()->ExecuteCommandBuffer(false);
// Attempt to allocate again, this may cause a fence wait // Attempt to allocate again, this may cause a fence wait
@ -253,7 +253,7 @@ bool VertexManager::ReserveConstantStorage()
} }
// The only places that call constant updates are safe to have state restored. // The only places that call constant updates are safe to have state restored.
WARN_LOG(VIDEO, "Executing command buffer while waiting for space in uniform buffer"); WARN_LOG_FMT(VIDEO, "Executing command buffer while waiting for space in uniform buffer");
Renderer::GetInstance()->ExecuteCommandBuffer(false); Renderer::GetInstance()->ExecuteCommandBuffer(false);
// Since we are on a new command buffer, all constants have been invalidated, and we need // Since we are on a new command buffer, all constants have been invalidated, and we need
@ -319,7 +319,7 @@ void VertexManager::UploadUtilityUniforms(const void* data, u32 data_size)
if (!m_uniform_stream_buffer->ReserveMemory(data_size, if (!m_uniform_stream_buffer->ReserveMemory(data_size,
g_vulkan_context->GetUniformBufferAlignment())) g_vulkan_context->GetUniformBufferAlignment()))
{ {
WARN_LOG(VIDEO, "Executing command buffer while waiting for ext space in uniform buffer"); WARN_LOG_FMT(VIDEO, "Executing command buffer while waiting for ext space in uniform buffer");
Renderer::GetInstance()->ExecuteCommandBuffer(false); Renderer::GetInstance()->ExecuteCommandBuffer(false);
} }
@ -340,7 +340,7 @@ bool VertexManager::UploadTexelBuffer(const void* data, u32 data_size, TexelBuff
if (!m_texel_stream_buffer->ReserveMemory(data_size, elem_size)) if (!m_texel_stream_buffer->ReserveMemory(data_size, elem_size))
{ {
// Try submitting cmdbuffer. // Try submitting cmdbuffer.
WARN_LOG(VIDEO, "Submitting command buffer while waiting for space in texel buffer"); WARN_LOG_FMT(VIDEO, "Submitting command buffer while waiting for space in texel buffer");
Renderer::GetInstance()->ExecuteCommandBuffer(false, false); Renderer::GetInstance()->ExecuteCommandBuffer(false, false);
if (!m_texel_stream_buffer->ReserveMemory(data_size, elem_size)) if (!m_texel_stream_buffer->ReserveMemory(data_size, elem_size))
{ {
@ -370,7 +370,7 @@ bool VertexManager::UploadTexelBuffer(const void* data, u32 data_size, TexelBuff
if (!m_texel_stream_buffer->ReserveMemory(reserve_size, elem_size)) if (!m_texel_stream_buffer->ReserveMemory(reserve_size, elem_size))
{ {
// Try submitting cmdbuffer. // Try submitting cmdbuffer.
WARN_LOG(VIDEO, "Submitting command buffer while waiting for space in texel buffer"); WARN_LOG_FMT(VIDEO, "Submitting command buffer while waiting for space in texel buffer");
Renderer::GetInstance()->ExecuteCommandBuffer(false, false); Renderer::GetInstance()->ExecuteCommandBuffer(false, false);
if (!m_texel_stream_buffer->ReserveMemory(reserve_size, elem_size)) if (!m_texel_stream_buffer->ReserveMemory(reserve_size, elem_size))
{ {

60
Source/Core/VideoBackends/Vulkan/VulkanContext.cpp
View File

@ -156,7 +156,7 @@ bool VulkanContext::SelectInstanceExtensions(std::vector<const char*>* extension
if (extension_count == 0) if (extension_count == 0)
{ {
ERROR_LOG(VIDEO, "Vulkan: No extensions supported by instance."); ERROR_LOG_FMT(VIDEO, "Vulkan: No extensions supported by instance.");
return false; return false;
} }
@ -166,7 +166,7 @@ bool VulkanContext::SelectInstanceExtensions(std::vector<const char*>* extension
ASSERT(res == VK_SUCCESS); ASSERT(res == VK_SUCCESS);
for (const auto& extension_properties : available_extension_list) for (const auto& extension_properties : available_extension_list)
INFO_LOG(VIDEO, "Available extension: %s", extension_properties.extensionName); INFO_LOG_FMT(VIDEO, "Available extension: {}", extension_properties.extensionName);
auto AddExtension = [&](const char* name, bool required) { auto AddExtension = [&](const char* name, bool required) {
if (std::find_if(available_extension_list.begin(), available_extension_list.end(), if (std::find_if(available_extension_list.begin(), available_extension_list.end(),
@ -174,13 +174,13 @@ bool VulkanContext::SelectInstanceExtensions(std::vector<const char*>* extension
return !strcmp(name, properties.extensionName); return !strcmp(name, properties.extensionName);
}) != available_extension_list.end()) }) != available_extension_list.end())
{ {
INFO_LOG(VIDEO, "Enabling extension: %s", name); INFO_LOG_FMT(VIDEO, "Enabling extension: {}", name);
extension_list->push_back(name); extension_list->push_back(name);
return true; return true;
} }
if (required) if (required)
ERROR_LOG(VIDEO, "Vulkan: Missing required extension %s.", name); ERROR_LOG_FMT(VIDEO, "Vulkan: Missing required extension {}.", name);
return false; return false;
}; };
@ -220,7 +220,7 @@ bool VulkanContext::SelectInstanceExtensions(std::vector<const char*>* extension
// VK_EXT_debug_report // VK_EXT_debug_report
if (enable_debug_report && !AddExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, false)) if (enable_debug_report && !AddExtension(VK_EXT_DEBUG_REPORT_EXTENSION_NAME, false))
WARN_LOG(VIDEO, "Vulkan: Debug report requested, but extension is not available."); WARN_LOG_FMT(VIDEO, "Vulkan: Debug report requested, but extension is not available.");
AddExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, false); AddExtension(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME, false);
AddExtension(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, false); AddExtension(VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME, false);
@ -437,7 +437,7 @@ bool VulkanContext::SelectDeviceExtensions(bool enable_surface)
if (extension_count == 0) if (extension_count == 0)
{ {
ERROR_LOG(VIDEO, "Vulkan: No extensions supported by device."); ERROR_LOG_FMT(VIDEO, "Vulkan: No extensions supported by device.");
return false; return false;
} }
@ -447,7 +447,7 @@ bool VulkanContext::SelectDeviceExtensions(bool enable_surface)
ASSERT(res == VK_SUCCESS); ASSERT(res == VK_SUCCESS);
for (const auto& extension_properties : available_extension_list) for (const auto& extension_properties : available_extension_list)
INFO_LOG(VIDEO, "Available extension: %s", extension_properties.extensionName); INFO_LOG_FMT(VIDEO, "Available extension: {}", extension_properties.extensionName);
auto AddExtension = [&](const char* name, bool required) { auto AddExtension = [&](const char* name, bool required) {
if (std::find_if(available_extension_list.begin(), available_extension_list.end(), if (std::find_if(available_extension_list.begin(), available_extension_list.end(),
@ -455,13 +455,13 @@ bool VulkanContext::SelectDeviceExtensions(bool enable_surface)
return !strcmp(name, properties.extensionName); return !strcmp(name, properties.extensionName);
}) != available_extension_list.end()) }) != available_extension_list.end())
{ {
INFO_LOG(VIDEO, "Enabling extension: %s", name); INFO_LOG_FMT(VIDEO, "Enabling extension: {}", name);
m_device_extensions.push_back(name); m_device_extensions.push_back(name);
return true; return true;
} }
if (required) if (required)
ERROR_LOG(VIDEO, "Vulkan: Missing required extension %s.", name); ERROR_LOG_FMT(VIDEO, "Vulkan: Missing required extension {}.", name);
return false; return false;
}; };
@ -472,7 +472,7 @@ bool VulkanContext::SelectDeviceExtensions(bool enable_surface)
#ifdef SUPPORTS_VULKAN_EXCLUSIVE_FULLSCREEN #ifdef SUPPORTS_VULKAN_EXCLUSIVE_FULLSCREEN
// VK_EXT_full_screen_exclusive // VK_EXT_full_screen_exclusive
if (AddExtension(VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME, true)) if (AddExtension(VK_EXT_FULL_SCREEN_EXCLUSIVE_EXTENSION_NAME, true))
INFO_LOG(VIDEO, "Using VK_EXT_full_screen_exclusive for exclusive fullscreen."); INFO_LOG_FMT(VIDEO, "Using VK_EXT_full_screen_exclusive for exclusive fullscreen.");
#endif #endif
return true; return true;
@ -488,12 +488,14 @@ bool VulkanContext::SelectDeviceFeatures()
// Not having geometry shaders or wide lines will cause issues with rendering. // Not having geometry shaders or wide lines will cause issues with rendering.
if (!available_features.geometryShader && !available_features.wideLines) if (!available_features.geometryShader && !available_features.wideLines)
WARN_LOG(VIDEO, "Vulkan: Missing both geometryShader and wideLines features."); WARN_LOG_FMT(VIDEO, "Vulkan: Missing both geometryShader and wideLines features.");
if (!available_features.largePoints) if (!available_features.largePoints)
WARN_LOG(VIDEO, "Vulkan: Missing large points feature. CPU EFB writes will be slower."); WARN_LOG_FMT(VIDEO, "Vulkan: Missing large points feature. CPU EFB writes will be slower.");
if (!available_features.occlusionQueryPrecise) if (!available_features.occlusionQueryPrecise)
WARN_LOG(VIDEO, "Vulkan: Missing precise occlusion queries. Perf queries will be inaccurate."); {
WARN_LOG_FMT(VIDEO,
"Vulkan: Missing precise occlusion queries. Perf queries will be inaccurate.");
}
// Enable the features we use. // Enable the features we use.
m_device_features.dualSrcBlend = available_features.dualSrcBlend; m_device_features.dualSrcBlend = available_features.dualSrcBlend;
m_device_features.geometryShader = available_features.geometryShader; m_device_features.geometryShader = available_features.geometryShader;
@ -519,14 +521,14 @@ bool VulkanContext::CreateDevice(VkSurfaceKHR surface, bool enable_validation_la
vkGetPhysicalDeviceQueueFamilyProperties(m_physical_device, &queue_family_count, nullptr); vkGetPhysicalDeviceQueueFamilyProperties(m_physical_device, &queue_family_count, nullptr);
if (queue_family_count == 0) if (queue_family_count == 0)
{ {
ERROR_LOG(VIDEO, "No queue families found on specified vulkan physical device."); ERROR_LOG_FMT(VIDEO, "No queue families found on specified vulkan physical device.");
return false; return false;
} }
std::vector<VkQueueFamilyProperties> queue_family_properties(queue_family_count); std::vector<VkQueueFamilyProperties> queue_family_properties(queue_family_count);
vkGetPhysicalDeviceQueueFamilyProperties(m_physical_device, &queue_family_count, vkGetPhysicalDeviceQueueFamilyProperties(m_physical_device, &queue_family_count,
queue_family_properties.data()); queue_family_properties.data());
INFO_LOG(VIDEO, "%u vulkan queue families", queue_family_count); INFO_LOG_FMT(VIDEO, "{} vulkan queue families", queue_family_count);
// Find graphics and present queues. // Find graphics and present queues.
m_graphics_queue_family_index = queue_family_count; m_graphics_queue_family_index = queue_family_count;
@ -569,12 +571,12 @@ bool VulkanContext::CreateDevice(VkSurfaceKHR surface, bool enable_validation_la
} }
if (m_graphics_queue_family_index == queue_family_count) if (m_graphics_queue_family_index == queue_family_count)
{ {
ERROR_LOG(VIDEO, "Vulkan: Failed to find an acceptable graphics queue."); ERROR_LOG_FMT(VIDEO, "Vulkan: Failed to find an acceptable graphics queue.");
return false; return false;
} }
if (surface && m_present_queue_family_index == queue_family_count) if (surface && m_present_queue_family_index == queue_family_count)
{ {
ERROR_LOG(VIDEO, "Vulkan: Failed to find an acceptable present queue."); ERROR_LOG_FMT(VIDEO, "Vulkan: Failed to find an acceptable present queue.");
return false; return false;
} }
@ -666,16 +668,16 @@ static VKAPI_ATTR VkBool32 VKAPI_CALL DebugReportCallback(VkDebugReportFlagsEXT
const char* pLayerPrefix, const char* pLayerPrefix,
const char* pMessage, void* pUserData) const char* pMessage, void* pUserData)
{ {
std::string log_message = const std::string log_message =
StringFromFormat("Vulkan debug report: (%s) %s", pLayerPrefix ? pLayerPrefix : "", pMessage); fmt::format("Vulkan debug report: ({}) {}", pLayerPrefix ? pLayerPrefix : "", pMessage);
if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT)
GENERIC_LOG(Common::Log::HOST_GPU, Common::Log::LERROR, "%s", log_message.c_str()); GENERIC_LOG_FMT(Common::Log::HOST_GPU, Common::Log::LERROR, "{}", log_message);
else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT)) else if (flags & (VK_DEBUG_REPORT_WARNING_BIT_EXT | VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT))
GENERIC_LOG(Common::Log::HOST_GPU, Common::Log::LWARNING, "%s", log_message.c_str()); GENERIC_LOG_FMT(Common::Log::HOST_GPU, Common::Log::LWARNING, "{}", log_message);
else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) else if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT)
GENERIC_LOG(Common::Log::HOST_GPU, Common::Log::LINFO, "%s", log_message.c_str()); GENERIC_LOG_FMT(Common::Log::HOST_GPU, Common::Log::LINFO, "{}", log_message);
else else
GENERIC_LOG(Common::Log::HOST_GPU, Common::Log::LDEBUG, "%s", log_message.c_str()); GENERIC_LOG_FMT(Common::Log::HOST_GPU, Common::Log::LDEBUG, "{}", log_message);
return VK_FALSE; return VK_FALSE;
} }
@ -763,13 +765,13 @@ u32 VulkanContext::GetUploadMemoryType(u32 bits, bool* is_coherent)
type_index = GetMemoryType(bits, COHERENT_FLAGS, false, is_coherent); type_index = GetMemoryType(bits, COHERENT_FLAGS, false, is_coherent);
if (type_index) if (type_index)
{ {
WARN_LOG(VIDEO, WARN_LOG_FMT(VIDEO,
"Strict check for upload memory properties failed, this may affect performance"); "Strict check for upload memory properties failed, this may affect performance");
return type_index.value(); return type_index.value();
} }
// Fall back to non-coherent memory. // Fall back to non-coherent memory.
WARN_LOG( WARN_LOG_FMT(
VIDEO, VIDEO,
"Vulkan: Failed to find a coherent memory type for uploads, this will affect performance."); "Vulkan: Failed to find a coherent memory type for uploads, this will affect performance.");
type_index = GetMemoryType(bits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, false, is_coherent); type_index = GetMemoryType(bits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, false, is_coherent);
@ -811,7 +813,7 @@ u32 VulkanContext::GetReadbackMemoryType(u32 bits, bool* is_coherent)
if (type_index) if (type_index)
return type_index.value(); return type_index.value();
WARN_LOG(VIDEO, "Vulkan: Failed to find a cached memory type for readbacks, this will affect " WARN_LOG_FMT(VIDEO, "Vulkan: Failed to find a cached memory type for readbacks, this will affect "
"performance."); "performance.");
type_index = GetMemoryType(bits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, false, is_coherent); type_index = GetMemoryType(bits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, false, is_coherent);
*is_coherent = false; *is_coherent = false;
@ -896,8 +898,8 @@ void VulkanContext::InitDriverDetails()
} }
else else
{ {
WARN_LOG(VIDEO, "Unknown Vulkan driver vendor, please report it to us."); WARN_LOG_FMT(VIDEO, "Unknown Vulkan driver vendor, please report it to us.");
WARN_LOG(VIDEO, "Vendor ID: 0x%X, Device Name: %s", vendor_id, device_name.c_str()); WARN_LOG_FMT(VIDEO, "Vendor ID: {:#X}, Device Name: {}", vendor_id, device_name);
vendor = DriverDetails::VENDOR_UNKNOWN; vendor = DriverDetails::VENDOR_UNKNOWN;
driver = DriverDetails::DRIVER_UNKNOWN; driver = DriverDetails::DRIVER_UNKNOWN;
} }

13
Source/Core/VideoBackends/Vulkan/VulkanLoader.cpp
View File

@ -67,7 +67,7 @@ bool LoadVulkanLibrary()
#define VULKAN_MODULE_ENTRY_POINT(name, required) \ #define VULKAN_MODULE_ENTRY_POINT(name, required) \
if (!s_vulkan_module.GetSymbol(#name, &name) && required) \ if (!s_vulkan_module.GetSymbol(#name, &name) && required) \
{ \ { \
ERROR_LOG(VIDEO, "Vulkan: Failed to load required module function %s", #name); \ ERROR_LOG_FMT(VIDEO, "Vulkan: Failed to load required module function {}", #name); \
ResetVulkanLibraryFunctionPointers(); \ ResetVulkanLibraryFunctionPointers(); \
s_vulkan_module.Close(); \ s_vulkan_module.Close(); \
return false; \ return false; \
@ -92,7 +92,7 @@ bool LoadVulkanInstanceFunctions(VkInstance instance)
*func_ptr = vkGetInstanceProcAddr(instance, name); *func_ptr = vkGetInstanceProcAddr(instance, name);
if (!(*func_ptr) && is_required) if (!(*func_ptr) && is_required)
{ {
ERROR_LOG(VIDEO, "Vulkan: Failed to load required instance function %s", name); ERROR_LOG_FMT(VIDEO, "Vulkan: Failed to load required instance function {}", name);
required_functions_missing = true; required_functions_missing = true;
} }
}; };
@ -112,7 +112,7 @@ bool LoadVulkanDeviceFunctions(VkDevice device)
*func_ptr = vkGetDeviceProcAddr(device, name); *func_ptr = vkGetDeviceProcAddr(device, name);
if (!(*func_ptr) && is_required) if (!(*func_ptr) && is_required)
{ {
ERROR_LOG(VIDEO, "Vulkan: Failed to load required device function %s", name); ERROR_LOG_FMT(VIDEO, "Vulkan: Failed to load required device function {}", name);
required_functions_missing = true; required_functions_missing = true;
} }
}; };
@ -213,11 +213,10 @@ void LogVulkanResult(int level, const char* func_name, VkResult res, const char*
std::string real_msg = StringFromFormatV(msg, ap); std::string real_msg = StringFromFormatV(msg, ap);
va_end(ap); va_end(ap);
real_msg = StringFromFormat("(%s) %s (%d: %s)", func_name, real_msg.c_str(), real_msg = fmt::format("({}) {} ({}: {})", func_name, real_msg, static_cast<int>(res),
static_cast<int>(res), VkResultToString(res)); VkResultToString(res));
GENERIC_LOG(Common::Log::VIDEO, static_cast<Common::Log::LOG_LEVELS>(level), "%s", GENERIC_LOG_FMT(Common::Log::VIDEO, static_cast<Common::Log::LOG_LEVELS>(level), "{}", real_msg);
real_msg.c_str());
} }
} // namespace Vulkan } // namespace Vulkan

8
Source/Core/VideoBackends/Vulkan/main.cpp
View File

@ -106,7 +106,7 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
bool enable_validation_layer = g_Config.bEnableValidationLayer; bool enable_validation_layer = g_Config.bEnableValidationLayer;
if (enable_validation_layer && !VulkanContext::CheckValidationLayerAvailablility()) if (enable_validation_layer && !VulkanContext::CheckValidationLayerAvailablility())
{ {
WARN_LOG(VIDEO, "Validation layer requested but not available, disabling."); WARN_LOG_FMT(VIDEO, "Validation layer requested but not available, disabling.");
enable_validation_layer = false; enable_validation_layer = false;
} }
@ -166,7 +166,7 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
size_t selected_adapter_index = static_cast<size_t>(g_Config.iAdapter); size_t selected_adapter_index = static_cast<size_t>(g_Config.iAdapter);
if (selected_adapter_index >= gpu_list.size()) if (selected_adapter_index >= gpu_list.size())
{ {
WARN_LOG(VIDEO, "Vulkan adapter index out of range, selecting first adapter."); WARN_LOG_FMT(VIDEO, "Vulkan adapter index out of range, selecting first adapter.");
selected_adapter_index = 0; selected_adapter_index = 0;
} }
@ -312,7 +312,7 @@ void VideoBackend::PrepareWindow(WindowSystemInfo& wsi)
Class clsCAMetalLayer = objc_getClass("CAMetalLayer"); Class clsCAMetalLayer = objc_getClass("CAMetalLayer");
if (!clsCAMetalLayer) if (!clsCAMetalLayer)
{ {
ERROR_LOG(VIDEO, "Failed to get CAMetalLayer class."); ERROR_LOG_FMT(VIDEO, "Failed to get CAMetalLayer class.");
return; return;
} }
@ -321,7 +321,7 @@ void VideoBackend::PrepareWindow(WindowSystemInfo& wsi)
sel_getUid("layer")); sel_getUid("layer"));
if (!layer) if (!layer)
{ {
ERROR_LOG(VIDEO, "Failed to create Metal layer."); ERROR_LOG_FMT(VIDEO, "Failed to create Metal layer.");
return; return;
} }