mirror/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-01-31 18:32:43 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #9248 from lioncash/video-fmt

Browse Source 
VideoCommon: Migrate over to fmt
This commit is contained in:
Léo Lam 2020-11-18 11:10:48 +01:00 committed by GitHub
commit 4eecb8fd11
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
32 changed files with 310 additions and 281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Source/Core/VideoCommon/AbstractTexture.cpp
View File

@ -126,7 +126,7 @@ u32 AbstractTexture::CalculateStrideForFormat(AbstractTextureFormat format, u32
case AbstractTextureFormat::D32F_S8: case AbstractTextureFormat::D32F_S8:
return static_cast<size_t>(row_length) * 8; return static_cast<size_t>(row_length) * 8;
default: default:
PanicAlert("Unhandled texture format."); PanicAlertFmt("Unhandled texture format.");
return 0; return 0;
} }
} }
@ -153,7 +153,7 @@ u32 AbstractTexture::GetTexelSizeForFormat(AbstractTextureFormat format)
case AbstractTextureFormat::D32F_S8: case AbstractTextureFormat::D32F_S8:
return 8; return 8;
default: default:
PanicAlert("Unhandled texture format."); PanicAlertFmt("Unhandled texture format.");
return 0; return 0;
} }
} }

6
Source/Core/VideoCommon/AsyncShaderCompiler.cpp
View File

@ -122,7 +122,7 @@ bool AsyncShaderCompiler::StartWorkerThreads(u32 num_worker_threads)
void* thread_param = nullptr; void* thread_param = nullptr;
if (!WorkerThreadInitMainThread(&thread_param)) if (!WorkerThreadInitMainThread(&thread_param))
{ {
WARN_LOG(VIDEO, "Failed to initialize shader compiler worker thread."); WARN_LOG_FMT(VIDEO, "Failed to initialize shader compiler worker thread.");
break; break;
} }
@ -133,7 +133,7 @@ bool AsyncShaderCompiler::StartWorkerThreads(u32 num_worker_threads)
if (!m_worker_thread_start_result.load()) if (!m_worker_thread_start_result.load())
{ {
WARN_LOG(VIDEO, "Failed to start shader compiler worker thread."); WARN_LOG_FMT(VIDEO, "Failed to start shader compiler worker thread.");
thr.join(); thr.join();
break; break;
} }
@ -198,7 +198,7 @@ void AsyncShaderCompiler::WorkerThreadEntryPoint(void* param)
// Initialize worker thread with backend-specific method. // Initialize worker thread with backend-specific method.
if (!WorkerThreadInitWorkerThread(param)) if (!WorkerThreadInitWorkerThread(param))
{ {
WARN_LOG(VIDEO, "Failed to initialize shader compiler worker."); WARN_LOG_FMT(VIDEO, "Failed to initialize shader compiler worker.");
m_worker_thread_start_result.store(false); m_worker_thread_start_result.store(false);
m_init_event.Set(); m_init_event.Set();
return; return;

27
Source/Core/VideoCommon/BPFunctions.cpp
View File

@ -5,6 +5,7 @@
#include "VideoCommon/BPFunctions.h" #include "VideoCommon/BPFunctions.h"
#include <algorithm> #include <algorithm>
#include <string_view>
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "Common/Logging/Log.h" #include "Common/Logging/Log.h"
@ -223,12 +224,12 @@ void OnPixelFormatChange()
if (!g_ActiveConfig.bEFBEmulateFormatChanges) if (!g_ActiveConfig.bEFBEmulateFormatChanges)
return; return;
auto old_format = g_renderer->GetPrevPixelFormat(); const auto old_format = g_renderer->GetPrevPixelFormat();
auto new_format = bpmem.zcontrol.pixel_format; const auto new_format = bpmem.zcontrol.pixel_format;
g_renderer->StorePixelFormat(new_format); g_renderer->StorePixelFormat(new_format);
DEBUG_LOG(VIDEO, "pixelfmt: pixel=%d, zc=%d", static_cast<int>(new_format), DEBUG_LOG_FMT(VIDEO, "pixelfmt: pixel={}, zc={}", static_cast<int>(new_format),
static_cast<int>(bpmem.zcontrol.zformat)); static_cast<int>(bpmem.zcontrol.zformat));
// no need to reinterpret pixel data in these cases // no need to reinterpret pixel data in these cases
if (new_format == old_format || old_format == PEControl::INVALID_FMT) if (new_format == old_format || old_format == PEControl::INVALID_FMT)
@ -291,8 +292,8 @@ void OnPixelFormatChange()
break; break;
} }
ERROR_LOG(VIDEO, "Unhandled EFB format change: %d to %d", static_cast<int>(old_format), ERROR_LOG_FMT(VIDEO, "Unhandled EFB format change: {} to {}", static_cast<int>(old_format),
static_cast<int>(new_format)); static_cast<int>(new_format));
} }
void SetInterlacingMode(const BPCmd& bp) void SetInterlacingMode(const BPCmd& bp)
@ -304,21 +305,21 @@ void SetInterlacingMode(const BPCmd& bp)
{ {
// SDK always sets bpmem.lineptwidth.lineaspect via BPMEM_LINEPTWIDTH // SDK always sets bpmem.lineptwidth.lineaspect via BPMEM_LINEPTWIDTH
// just before this cmd // just before this cmd
const char* action[] = {"don't adjust", "adjust"}; static constexpr std::string_view action[] = {"don't adjust", "adjust"};
DEBUG_LOG(VIDEO, "BPMEM_FIELDMODE texLOD:%s lineaspect:%s", action[bpmem.fieldmode.texLOD], DEBUG_LOG_FMT(VIDEO, "BPMEM_FIELDMODE texLOD:{} lineaspect:{}", action[bpmem.fieldmode.texLOD],
action[bpmem.lineptwidth.lineaspect]); action[bpmem.lineptwidth.lineaspect]);
} }
break; break;
case BPMEM_FIELDMASK: case BPMEM_FIELDMASK:
{ {
// Determines if fields will be written to EFB (always computed) // Determines if fields will be written to EFB (always computed)
const char* action[] = {"skip", "write"}; static constexpr std::string_view action[] = {"skip", "write"};
DEBUG_LOG(VIDEO, "BPMEM_FIELDMASK even:%s odd:%s", action[bpmem.fieldmask.even], DEBUG_LOG_FMT(VIDEO, "BPMEM_FIELDMASK even:{} odd:{}", action[bpmem.fieldmask.even],
action[bpmem.fieldmask.odd]); action[bpmem.fieldmask.odd]);
} }
break; break;
default: default:
ERROR_LOG(VIDEO, "SetInterlacingMode default"); ERROR_LOG_FMT(VIDEO, "SetInterlacingMode default");
break; break;
} }
} }

56
Source/Core/VideoCommon/BPStructs.cpp
View File

@ -90,11 +90,11 @@ static void BPWritten(const BPCmd& bp)
switch (bp.address) switch (bp.address)
{ {
case BPMEM_GENMODE: // Set the Generation Mode case BPMEM_GENMODE: // Set the Generation Mode
PRIM_LOG("genmode: texgen=%d, col=%d, multisampling=%d, tev=%d, cullmode=%d, ind=%d, zfeeze=%d", PRIM_LOG("genmode: texgen={}, col={}, multisampling={}, tev={}, cullmode={}, ind={}, zfeeze={}",
(u32)bpmem.genMode.numtexgens, (u32)bpmem.genMode.numcolchans, bpmem.genMode.numtexgens.Value(), bpmem.genMode.numcolchans.Value(),
(u32)bpmem.genMode.multisampling, (u32)bpmem.genMode.numtevstages + 1, bpmem.genMode.multisampling.Value(), bpmem.genMode.numtevstages.Value() + 1,
(u32)bpmem.genMode.cullmode, (u32)bpmem.genMode.numindstages, static_cast<u32>(bpmem.genMode.cullmode), bpmem.genMode.numindstages.Value(),
(u32)bpmem.genMode.zfreeze); bpmem.genMode.zfreeze.Value());
if (bp.changes) if (bp.changes)
PixelShaderManager::SetGenModeChanged(); PixelShaderManager::SetGenModeChanged();
@ -138,7 +138,7 @@ static void BPWritten(const BPCmd& bp)
GeometryShaderManager::SetLinePtWidthChanged(); GeometryShaderManager::SetLinePtWidthChanged();
return; return;
case BPMEM_ZMODE: // Depth Control case BPMEM_ZMODE: // Depth Control
PRIM_LOG("zmode: test=%u, func=%u, upd=%u", bpmem.zmode.testenable.Value(), PRIM_LOG("zmode: test={}, func={}, upd={}", bpmem.zmode.testenable.Value(),
bpmem.zmode.func.Value(), bpmem.zmode.updateenable.Value()); bpmem.zmode.func.Value(), bpmem.zmode.updateenable.Value());
SetDepthMode(); SetDepthMode();
PixelShaderManager::SetZModeControl(); PixelShaderManager::SetZModeControl();
@ -146,7 +146,7 @@ static void BPWritten(const BPCmd& bp)
case BPMEM_BLENDMODE: // Blending Control case BPMEM_BLENDMODE: // Blending Control
if (bp.changes & 0xFFFF) if (bp.changes & 0xFFFF)
{ {
PRIM_LOG("blendmode: en=%u, open=%u, colupd=%u, alphaupd=%u, dst=%u, src=%u, sub=%u, mode=%u", PRIM_LOG("blendmode: en={}, open={}, colupd={}, alphaupd={}, dst={}, src={}, sub={}, mode={}",
bpmem.blendmode.blendenable.Value(), bpmem.blendmode.logicopenable.Value(), bpmem.blendmode.blendenable.Value(), bpmem.blendmode.logicopenable.Value(),
bpmem.blendmode.colorupdate.Value(), bpmem.blendmode.alphaupdate.Value(), bpmem.blendmode.colorupdate.Value(), bpmem.blendmode.alphaupdate.Value(),
bpmem.blendmode.dstfactor.Value(), bpmem.blendmode.srcfactor.Value(), bpmem.blendmode.dstfactor.Value(), bpmem.blendmode.srcfactor.Value(),
@ -158,7 +158,7 @@ static void BPWritten(const BPCmd& bp)
} }
return; return;
case BPMEM_CONSTANTALPHA: // Set Destination Alpha case BPMEM_CONSTANTALPHA: // Set Destination Alpha
PRIM_LOG("constalpha: alp=%d, en=%d", bpmem.dstalpha.alpha.Value(), PRIM_LOG("constalpha: alp={}, en={}", bpmem.dstalpha.alpha.Value(),
bpmem.dstalpha.enable.Value()); bpmem.dstalpha.enable.Value());
if (bp.changes) if (bp.changes)
{ {
@ -181,11 +181,11 @@ static void BPWritten(const BPCmd& bp)
g_framebuffer_manager->InvalidatePeekCache(false); g_framebuffer_manager->InvalidatePeekCache(false);
if (!Fifo::UseDeterministicGPUThread()) if (!Fifo::UseDeterministicGPUThread())
PixelEngine::SetFinish(); // may generate interrupt PixelEngine::SetFinish(); // may generate interrupt
DEBUG_LOG(VIDEO, "GXSetDrawDone SetPEFinish (value: 0x%02X)", (bp.newvalue & 0xFFFF)); DEBUG_LOG_FMT(VIDEO, "GXSetDrawDone SetPEFinish (value: {:#04X})", bp.newvalue & 0xFFFF);
return; return;
default: default:
WARN_LOG(VIDEO, "GXSetDrawDone ??? (value 0x%02X)", (bp.newvalue & 0xFFFF)); WARN_LOG_FMT(VIDEO, "GXSetDrawDone ??? (value {:#04X})", bp.newvalue & 0xFFFF);
return; return;
} }
return; return;
@ -194,14 +194,14 @@ static void BPWritten(const BPCmd& bp)
g_framebuffer_manager->InvalidatePeekCache(false); g_framebuffer_manager->InvalidatePeekCache(false);
if (!Fifo::UseDeterministicGPUThread()) if (!Fifo::UseDeterministicGPUThread())
PixelEngine::SetToken(static_cast<u16>(bp.newvalue & 0xFFFF), false); PixelEngine::SetToken(static_cast<u16>(bp.newvalue & 0xFFFF), false);
DEBUG_LOG(VIDEO, "SetPEToken 0x%04x", (bp.newvalue & 0xFFFF)); DEBUG_LOG_FMT(VIDEO, "SetPEToken {:#06X}", bp.newvalue & 0xFFFF);
return; return;
case BPMEM_PE_TOKEN_INT_ID: // Pixel Engine Interrupt Token ID case BPMEM_PE_TOKEN_INT_ID: // Pixel Engine Interrupt Token ID
g_texture_cache->FlushEFBCopies(); g_texture_cache->FlushEFBCopies();
g_framebuffer_manager->InvalidatePeekCache(false); g_framebuffer_manager->InvalidatePeekCache(false);
if (!Fifo::UseDeterministicGPUThread()) if (!Fifo::UseDeterministicGPUThread())
PixelEngine::SetToken(static_cast<u16>(bp.newvalue & 0xFFFF), true); PixelEngine::SetToken(static_cast<u16>(bp.newvalue & 0xFFFF), true);
DEBUG_LOG(VIDEO, "SetPEToken + INT 0x%04x", (bp.newvalue & 0xFFFF)); DEBUG_LOG_FMT(VIDEO, "SetPEToken + INT {:#06X}", bp.newvalue & 0xFFFF);
return; return;
// ------------------------ // ------------------------
@ -243,8 +243,8 @@ static void BPWritten(const BPCmd& bp)
int copy_height = srcRect.GetHeight(); int copy_height = srcRect.GetHeight();
if (srcRect.right > s32(EFB_WIDTH) || srcRect.bottom > s32(EFB_HEIGHT)) if (srcRect.right > s32(EFB_WIDTH) || srcRect.bottom > s32(EFB_HEIGHT))
{ {
WARN_LOG(VIDEO, "Oversized EFB copy: %dx%d (offset %d,%d stride %u)", copy_width, copy_height, WARN_LOG_FMT(VIDEO, "Oversized EFB copy: {}x{} (offset {},{} stride {})", copy_width,
srcRect.left, srcRect.top, destStride); copy_height, srcRect.left, srcRect.top, destStride);
// Adjust the copy size to fit within the EFB. So that we don't end up with a stretched image, // Adjust the copy size to fit within the EFB. So that we don't end up with a stretched image,
// instead of clamping the source rectangle, we reduce it by the over-sized amount. // instead of clamping the source rectangle, we reduce it by the over-sized amount.
@ -291,11 +291,11 @@ static void BPWritten(const BPCmd& bp)
u32 height = static_cast<u32>(num_xfb_lines); u32 height = static_cast<u32>(num_xfb_lines);
DEBUG_LOG(VIDEO, DEBUG_LOG_FMT(VIDEO,
"RenderToXFB: destAddr: %08x | srcRect {%d %d %d %d} | fbWidth: %u | " "RenderToXFB: destAddr: {:08x} | srcRect [{} {} {} {}] | fbWidth: {} | "
"fbStride: %u | fbHeight: %u | yScale: %f", "fbStride: {} | fbHeight: {} | yScale: {}",
destAddr, srcRect.left, srcRect.top, srcRect.right, srcRect.bottom, destAddr, srcRect.left, srcRect.top, srcRect.right, srcRect.bottom,
bpmem.copyTexSrcWH.x + 1, destStride, height, yScale); bpmem.copyTexSrcWH.x + 1, destStride, height, yScale);
bool is_depth_copy = bpmem.zcontrol.pixel_format == PEControl::Z24; bool is_depth_copy = bpmem.zcontrol.pixel_format == PEControl::Z24;
g_texture_cache->CopyRenderTargetToTexture( g_texture_cache->CopyRenderTargetToTexture(
@ -370,9 +370,10 @@ static void BPWritten(const BPCmd& bp)
PixelShaderManager::SetFogColorChanged(); PixelShaderManager::SetFogColorChanged();
return; return;
case BPMEM_ALPHACOMPARE: // Compare Alpha Values case BPMEM_ALPHACOMPARE: // Compare Alpha Values
PRIM_LOG("alphacmp: ref0=%d, ref1=%d, comp0=%d, comp1=%d, logic=%d", (int)bpmem.alpha_test.ref0, PRIM_LOG("alphacmp: ref0={}, ref1={}, comp0={}, comp1={}, logic={}",
(int)bpmem.alpha_test.ref1, (int)bpmem.alpha_test.comp0, (int)bpmem.alpha_test.comp1, bpmem.alpha_test.ref0.Value(), bpmem.alpha_test.ref1.Value(),
(int)bpmem.alpha_test.logic); static_cast<int>(bpmem.alpha_test.comp0), static_cast<int>(bpmem.alpha_test.comp1),
static_cast<int>(bpmem.alpha_test.logic));
if (bp.changes & 0xFFFF) if (bp.changes & 0xFFFF)
PixelShaderManager::SetAlpha(); PixelShaderManager::SetAlpha();
if (bp.changes) if (bp.changes)
@ -382,7 +383,7 @@ static void BPWritten(const BPCmd& bp)
} }
return; return;
case BPMEM_BIAS: // BIAS case BPMEM_BIAS: // BIAS
PRIM_LOG("ztex bias=0x%x", bpmem.ztex1.bias.Value()); PRIM_LOG("ztex bias={:#x}", bpmem.ztex1.bias.Value());
if (bp.changes) if (bp.changes)
PixelShaderManager::SetZTextureBias(); PixelShaderManager::SetZTextureBias();
return; return;
@ -393,9 +394,9 @@ static void BPWritten(const BPCmd& bp)
if (bp.changes & 12) if (bp.changes & 12)
PixelShaderManager::SetZTextureOpChanged(); PixelShaderManager::SetZTextureOpChanged();
#if defined(_DEBUG) || defined(DEBUGFAST) #if defined(_DEBUG) || defined(DEBUGFAST)
const char* pzop[] = {"DISABLE", "ADD", "REPLACE", "?"}; static constexpr std::string_view pzop[] = {"DISABLE", "ADD", "REPLACE", "?"};
const char* pztype[] = {"Z8", "Z16", "Z24", "?"}; static constexpr std::string_view pztype[] = {"Z8", "Z16", "Z24", "?"};
PRIM_LOG("ztex op=%s, type=%s", pzop[bpmem.ztex2.op], pztype[bpmem.ztex2.type]); PRIM_LOG("ztex op={}, type={}", pzop[bpmem.ztex2.op], pztype[bpmem.ztex2.type]);
#endif #endif
} }
return; return;
@ -711,7 +712,8 @@ static void BPWritten(const BPCmd& bp)
break; break;
} }
WARN_LOG(VIDEO, "Unknown BP opcode: address = 0x%08x value = 0x%08x", bp.address, bp.newvalue); WARN_LOG_FMT(VIDEO, "Unknown BP opcode: address = {:#010x} value = {:#010x}", bp.address,
bp.newvalue);
} }
// Call browser: OpcodeDecoding.cpp ExecuteDisplayList > Decode() > LoadBPReg() // Call browser: OpcodeDecoding.cpp ExecuteDisplayList > Decode() > LoadBPReg()

91
Source/Core/VideoCommon/CommandProcessor.cpp
View File

@ -361,13 +361,13 @@ void UpdateInterrupts(u64 userdata)
if (userdata) if (userdata)
{ {
s_interrupt_set.Set(); s_interrupt_set.Set();
DEBUG_LOG(COMMANDPROCESSOR, "Interrupt set"); DEBUG_LOG_FMT(COMMANDPROCESSOR, "Interrupt set");
ProcessorInterface::SetInterrupt(INT_CAUSE_CP, true); ProcessorInterface::SetInterrupt(INT_CAUSE_CP, true);
} }
else else
{ {
s_interrupt_set.Clear(); s_interrupt_set.Clear();
DEBUG_LOG(COMMANDPROCESSOR, "Interrupt cleared"); DEBUG_LOG_FMT(COMMANDPROCESSOR, "Interrupt cleared");
ProcessorInterface::SetInterrupt(INT_CAUSE_CP, false); ProcessorInterface::SetInterrupt(INT_CAUSE_CP, false);
} }
CoreTiming::ForceExceptionCheck(0); CoreTiming::ForceExceptionCheck(0);
@ -395,21 +395,21 @@ void SetCPStatusFromGPU()
{ {
if (!fifo.bFF_Breakpoint) if (!fifo.bFF_Breakpoint)
{ {
DEBUG_LOG(COMMANDPROCESSOR, "Hit breakpoint at %i", fifo.CPReadPointer); DEBUG_LOG_FMT(COMMANDPROCESSOR, "Hit breakpoint at {}", fifo.CPReadPointer);
fifo.bFF_Breakpoint = true; fifo.bFF_Breakpoint = true;
} }
} }
else else
{ {
if (fifo.bFF_Breakpoint) if (fifo.bFF_Breakpoint)
DEBUG_LOG(COMMANDPROCESSOR, "Cleared breakpoint at %i", fifo.CPReadPointer); DEBUG_LOG_FMT(COMMANDPROCESSOR, "Cleared breakpoint at {}", fifo.CPReadPointer);
fifo.bFF_Breakpoint = false; fifo.bFF_Breakpoint = false;
} }
} }
else else
{ {
if (fifo.bFF_Breakpoint) if (fifo.bFF_Breakpoint)
DEBUG_LOG(COMMANDPROCESSOR, "Cleared breakpoint at %i", fifo.CPReadPointer); DEBUG_LOG_FMT(COMMANDPROCESSOR, "Cleared breakpoint at {}", fifo.CPReadPointer);
fifo.bFF_Breakpoint = false; fifo.bFF_Breakpoint = false;
} }
@ -462,7 +462,7 @@ void SetCPStatusFromCPU()
if (!interrupt || bpInt || undfInt || ovfInt) if (!interrupt || bpInt || undfInt || ovfInt)
{ {
s_interrupt_set.Set(interrupt); s_interrupt_set.Set(interrupt);
DEBUG_LOG(COMMANDPROCESSOR, "Interrupt set"); DEBUG_LOG_FMT(COMMANDPROCESSOR, "Interrupt set");
ProcessorInterface::SetInterrupt(INT_CAUSE_CP, interrupt); ProcessorInterface::SetInterrupt(INT_CAUSE_CP, interrupt);
} }
} }
@ -483,9 +483,9 @@ void SetCpStatusRegister()
m_CPStatusReg.UnderflowLoWatermark = fifo.bFF_LoWatermark; m_CPStatusReg.UnderflowLoWatermark = fifo.bFF_LoWatermark;
m_CPStatusReg.OverflowHiWatermark = fifo.bFF_HiWatermark; m_CPStatusReg.OverflowHiWatermark = fifo.bFF_HiWatermark;
DEBUG_LOG(COMMANDPROCESSOR, "\t Read from STATUS_REGISTER : %04x", m_CPStatusReg.Hex); DEBUG_LOG_FMT(COMMANDPROCESSOR, "\t Read from STATUS_REGISTER : {:04x}", m_CPStatusReg.Hex);
DEBUG_LOG( DEBUG_LOG_FMT(
COMMANDPROCESSOR, "(r) status: iBP %s | fReadIdle %s | fCmdIdle %s | iOvF %s | iUndF %s", COMMANDPROCESSOR, "(r) status: iBP {} | fReadIdle {} | fCmdIdle {} | iOvF {} | iUndF {}",
m_CPStatusReg.Breakpoint ? "ON" : "OFF", m_CPStatusReg.ReadIdle ? "ON" : "OFF", m_CPStatusReg.Breakpoint ? "ON" : "OFF", m_CPStatusReg.ReadIdle ? "ON" : "OFF",
m_CPStatusReg.CommandIdle ? "ON" : "OFF", m_CPStatusReg.OverflowHiWatermark ? "ON" : "OFF", m_CPStatusReg.CommandIdle ? "ON" : "OFF", m_CPStatusReg.OverflowHiWatermark ? "ON" : "OFF",
m_CPStatusReg.UnderflowLoWatermark ? "ON" : "OFF"); m_CPStatusReg.UnderflowLoWatermark ? "ON" : "OFF");
@ -509,11 +509,11 @@ void SetCpControlRegister()
fifo.bFF_GPReadEnable = m_CPCtrlReg.GPReadEnable; fifo.bFF_GPReadEnable = m_CPCtrlReg.GPReadEnable;
} }
DEBUG_LOG(COMMANDPROCESSOR, "\t GPREAD %s | BP %s | Int %s | OvF %s | UndF %s | LINK %s", DEBUG_LOG_FMT(COMMANDPROCESSOR, "\t GPREAD {} | BP {} | Int {} | OvF {} | UndF {} | LINK {}",
fifo.bFF_GPReadEnable ? "ON" : "OFF", fifo.bFF_BPEnable ? "ON" : "OFF", fifo.bFF_GPReadEnable ? "ON" : "OFF", fifo.bFF_BPEnable ? "ON" : "OFF",
fifo.bFF_BPInt ? "ON" : "OFF", m_CPCtrlReg.FifoOverflowIntEnable ? "ON" : "OFF", fifo.bFF_BPInt ? "ON" : "OFF", m_CPCtrlReg.FifoOverflowIntEnable ? "ON" : "OFF",
m_CPCtrlReg.FifoUnderflowIntEnable ? "ON" : "OFF", m_CPCtrlReg.FifoUnderflowIntEnable ? "ON" : "OFF",
m_CPCtrlReg.GPLinkEnable ? "ON" : "OFF"); m_CPCtrlReg.GPLinkEnable ? "ON" : "OFF");
} }
// NOTE: We intentionally don't emulate this function at the moment. // NOTE: We intentionally don't emulate this function at the moment.
@ -525,39 +525,40 @@ void SetCpClearRegister()
void HandleUnknownOpcode(u8 cmd_byte, void* buffer, bool preprocess) void HandleUnknownOpcode(u8 cmd_byte, void* buffer, bool preprocess)
{ {
// TODO(Omega): Maybe dump FIFO to file on this error // TODO(Omega): Maybe dump FIFO to file on this error
PanicAlertT("GFX FIFO: Unknown Opcode (0x%02x @ %p, %s).\n" PanicAlertFmtT("GFX FIFO: Unknown Opcode ({:#04x} @ {}, {}).\n"
"This means one of the following:\n" "This means one of the following:\n"
"* The emulated GPU got desynced, disabling dual core can help\n" "* The emulated GPU got desynced, disabling dual core can help\n"
"* Command stream corrupted by some spurious memory bug\n" "* Command stream corrupted by some spurious memory bug\n"
"* This really is an unknown opcode (unlikely)\n" "* This really is an unknown opcode (unlikely)\n"
"* Some other sort of bug\n\n" "* Some other sort of bug\n\n"
"Further errors will be sent to the Video Backend log and\n" "Further errors will be sent to the Video Backend log and\n"
"Dolphin will now likely crash or hang. Enjoy.", "Dolphin will now likely crash or hang. Enjoy.",
cmd_byte, buffer, preprocess ? "preprocess=true" : "preprocess=false"); cmd_byte, buffer, preprocess ? "preprocess=true" : "preprocess=false");
{ {
PanicAlert("Illegal command %02x\n" PanicAlertFmt("Illegal command {:02x}\n"
"CPBase: 0x%08x\n" "CPBase: {:#010x}\n"
"CPEnd: 0x%08x\n" "CPEnd: {:#010x}\n"
"CPHiWatermark: 0x%08x\n" "CPHiWatermark: {:#010x}\n"
"CPLoWatermark: 0x%08x\n" "CPLoWatermark: {:#010x}\n"
"CPReadWriteDistance: 0x%08x\n" "CPReadWriteDistance: {:#010x}\n"
"CPWritePointer: 0x%08x\n" "CPWritePointer: {:#010x}\n"
"CPReadPointer: 0x%08x\n" "CPReadPointer: {:#010x}\n"
"CPBreakpoint: 0x%08x\n" "CPBreakpoint: {:#010x}\n"
"bFF_GPReadEnable: %s\n" "bFF_GPReadEnable: {}\n"
"bFF_BPEnable: %s\n" "bFF_BPEnable: {}\n"
"bFF_BPInt: %s\n" "bFF_BPInt: {}\n"
"bFF_Breakpoint: %s\n" "bFF_Breakpoint: {}\n"
"bFF_GPLinkEnable: %s\n" "bFF_GPLinkEnable: {}\n"
"bFF_HiWatermarkInt: %s\n" "bFF_HiWatermarkInt: {}\n"
"bFF_LoWatermarkInt: %s\n", "bFF_LoWatermarkInt: {}\n",
cmd_byte, fifo.CPBase, fifo.CPEnd, fifo.CPHiWatermark, fifo.CPLoWatermark, cmd_byte, fifo.CPBase, fifo.CPEnd, fifo.CPHiWatermark, fifo.CPLoWatermark,
fifo.CPReadWriteDistance, fifo.CPWritePointer, fifo.CPReadPointer, fifo.CPBreakpoint, fifo.CPReadWriteDistance, fifo.CPWritePointer, fifo.CPReadPointer,
fifo.bFF_GPReadEnable ? "true" : "false", fifo.bFF_BPEnable ? "true" : "false", fifo.CPBreakpoint, fifo.bFF_GPReadEnable ? "true" : "false",
fifo.bFF_BPInt ? "true" : "false", fifo.bFF_Breakpoint ? "true" : "false", fifo.bFF_BPEnable ? "true" : "false", fifo.bFF_BPInt ? "true" : "false",
fifo.bFF_GPLinkEnable ? "true" : "false", fifo.bFF_HiWatermarkInt ? "true" : "false", fifo.bFF_Breakpoint ? "true" : "false", fifo.bFF_GPLinkEnable ? "true" : "false",
fifo.bFF_LoWatermarkInt ? "true" : "false"); fifo.bFF_HiWatermarkInt ? "true" : "false",
fifo.bFF_LoWatermarkInt ? "true" : "false");
} }
} }

31
Source/Core/VideoCommon/Fifo.cpp
View File

@ -123,7 +123,7 @@ void Init()
void Shutdown() void Shutdown()
{ {
if (s_gpu_mainloop.IsRunning()) if (s_gpu_mainloop.IsRunning())
PanicAlert("Fifo shutting down while active"); PanicAlertFmt("FIFO shutting down while active");
Common::FreeMemoryPages(s_video_buffer, FIFO_SIZE + 4); Common::FreeMemoryPages(s_video_buffer, FIFO_SIZE + 4);
s_video_buffer = nullptr; s_video_buffer = nullptr;
@ -167,7 +167,10 @@ void SyncGPU(SyncGPUReason reason, bool may_move_read_ptr)
// Opportunistically reset FIFOs so we don't wrap around. // Opportunistically reset FIFOs so we don't wrap around.
if (may_move_read_ptr && s_fifo_aux_write_ptr != s_fifo_aux_read_ptr) if (may_move_read_ptr && s_fifo_aux_write_ptr != s_fifo_aux_read_ptr)
PanicAlert("aux fifo not synced (%p, %p)", s_fifo_aux_write_ptr, s_fifo_aux_read_ptr); {
PanicAlertFmt("Aux FIFO not synced ({}, {})", fmt::ptr(s_fifo_aux_write_ptr),
fmt::ptr(s_fifo_aux_read_ptr));
}
memmove(s_fifo_aux_data, s_fifo_aux_read_ptr, s_fifo_aux_write_ptr - s_fifo_aux_read_ptr); memmove(s_fifo_aux_data, s_fifo_aux_read_ptr, s_fifo_aux_write_ptr - s_fifo_aux_read_ptr);
s_fifo_aux_write_ptr -= (s_fifo_aux_read_ptr - s_fifo_aux_data); s_fifo_aux_write_ptr -= (s_fifo_aux_read_ptr - s_fifo_aux_data);
@ -206,7 +209,7 @@ void PushFifoAuxBuffer(const void* ptr, size_t size)
{ {
// That will sync us up to the last 32 bytes, so this short region // That will sync us up to the last 32 bytes, so this short region
// of FIFO would have to point to a 2MB display list or something. // of FIFO would have to point to a 2MB display list or something.
PanicAlert("absurdly large aux buffer"); PanicAlertFmt("Absurdly large aux buffer");
return; return;
} }
} }
@ -224,13 +227,13 @@ void* PopFifoAuxBuffer(size_t size)
// Description: RunGpuLoop() sends data through this function. // Description: RunGpuLoop() sends data through this function.
static void ReadDataFromFifo(u32 readPtr) static void ReadDataFromFifo(u32 readPtr)
{ {
size_t len = 32; constexpr size_t len = 32;
if (len > (size_t)(s_video_buffer + FIFO_SIZE - s_video_buffer_write_ptr)) if (len > static_cast<size_t>(s_video_buffer + FIFO_SIZE - s_video_buffer_write_ptr))
{ {
size_t existing_len = s_video_buffer_write_ptr - s_video_buffer_read_ptr; const size_t existing_len = s_video_buffer_write_ptr - s_video_buffer_read_ptr;
if (len > (size_t)(FIFO_SIZE - existing_len)) if (len > static_cast<size_t>(FIFO_SIZE - existing_len))
{ {
PanicAlert("FIFO out of bounds (existing %zu + new %zu > %u)", existing_len, len, FIFO_SIZE); PanicAlertFmt("FIFO out of bounds (existing {} + new {} > {})", existing_len, len, FIFO_SIZE);
return; return;
} }
memmove(s_video_buffer, s_video_buffer_read_ptr, existing_len); memmove(s_video_buffer, s_video_buffer_read_ptr, existing_len);
@ -245,9 +248,9 @@ static void ReadDataFromFifo(u32 readPtr)
// The deterministic_gpu_thread version. // The deterministic_gpu_thread version.
static void ReadDataFromFifoOnCPU(u32 readPtr) static void ReadDataFromFifoOnCPU(u32 readPtr)
{ {
size_t len = 32; constexpr size_t len = 32;
u8* write_ptr = s_video_buffer_write_ptr; u8* write_ptr = s_video_buffer_write_ptr;
if (len > (size_t)(s_video_buffer + FIFO_SIZE - write_ptr)) if (len > static_cast<size_t>(s_video_buffer + FIFO_SIZE - write_ptr))
{ {
// We can't wrap around while the GPU is working on the data. // We can't wrap around while the GPU is working on the data.
// This should be very rare due to the reset in SyncGPU. // This should be very rare due to the reset in SyncGPU.
@ -260,14 +263,14 @@ static void ReadDataFromFifoOnCPU(u32 readPtr)
if (s_video_buffer_pp_read_ptr != s_video_buffer_read_ptr) if (s_video_buffer_pp_read_ptr != s_video_buffer_read_ptr)
{ {
PanicAlert("desynced read pointers"); PanicAlertFmt("Desynced read pointers");
return; return;
} }
write_ptr = s_video_buffer_write_ptr; write_ptr = s_video_buffer_write_ptr;
size_t existing_len = write_ptr - s_video_buffer_pp_read_ptr; const size_t existing_len = write_ptr - s_video_buffer_pp_read_ptr;
if (len > (size_t)(FIFO_SIZE - existing_len)) if (len > static_cast<size_t>(FIFO_SIZE - existing_len))
{ {
PanicAlert("FIFO out of bounds (existing %zu + new %zu > %u)", existing_len, len, FIFO_SIZE); PanicAlertFmt("FIFO out of bounds (existing {} + new {} > {})", existing_len, len, FIFO_SIZE);
return; return;
} }
} }

20
Source/Core/VideoCommon/FramebufferManager.cpp
View File

@ -43,38 +43,38 @@ bool FramebufferManager::Initialize()
{ {
if (!CreateEFBFramebuffer()) if (!CreateEFBFramebuffer())
{ {
PanicAlert("Failed to create EFB framebuffer"); PanicAlertFmt("Failed to create EFB framebuffer");
return false; return false;
} }
m_efb_cache_tile_size = static_cast<u32>(std::max(g_ActiveConfig.iEFBAccessTileSize, 0)); m_efb_cache_tile_size = static_cast<u32>(std::max(g_ActiveConfig.iEFBAccessTileSize, 0));
if (!CreateReadbackFramebuffer()) if (!CreateReadbackFramebuffer())
{ {
PanicAlert("Failed to create EFB readback framebuffer"); PanicAlertFmt("Failed to create EFB readback framebuffer");
return false; return false;
} }
if (!CompileReadbackPipelines()) if (!CompileReadbackPipelines())
{ {
PanicAlert("Failed to compile EFB readback pipelines"); PanicAlertFmt("Failed to compile EFB readback pipelines");
return false; return false;
} }
if (!CompileConversionPipelines()) if (!CompileConversionPipelines())
{ {
PanicAlert("Failed to compile EFB conversion pipelines"); PanicAlertFmt("Failed to compile EFB conversion pipelines");
return false; return false;
} }
if (!CompileClearPipelines()) if (!CompileClearPipelines())
{ {
PanicAlert("Failed to compile EFB clear pipelines"); PanicAlertFmt("Failed to compile EFB clear pipelines");
return false; return false;
} }
if (!CompilePokePipelines()) if (!CompilePokePipelines())
{ {
PanicAlert("Failed to compile EFB poke pipelines"); PanicAlertFmt("Failed to compile EFB poke pipelines");
return false; return false;
} }
@ -89,7 +89,7 @@ void FramebufferManager::RecreateEFBFramebuffer()
DestroyReadbackFramebuffer(); DestroyReadbackFramebuffer();
DestroyEFBFramebuffer(); DestroyEFBFramebuffer();
if (!CreateEFBFramebuffer() || !CreateReadbackFramebuffer()) if (!CreateEFBFramebuffer() || !CreateReadbackFramebuffer())
PanicAlert("Failed to recreate EFB framebuffer"); PanicAlertFmt("Failed to recreate EFB framebuffer");
} }
void FramebufferManager::RecompileShaders() void FramebufferManager::RecompileShaders()
@ -101,7 +101,7 @@ void FramebufferManager::RecompileShaders()
if (!CompileReadbackPipelines() || !CompileConversionPipelines() || !CompileClearPipelines() || if (!CompileReadbackPipelines() || !CompileConversionPipelines() || !CompileClearPipelines() ||
!CompilePokePipelines()) !CompilePokePipelines())
{ {
PanicAlert("Failed to recompile EFB pipelines"); PanicAlertFmt("Failed to recompile EFB pipelines");
} }
} }
@ -415,7 +415,7 @@ void FramebufferManager::SetEFBCacheTileSize(u32 size)
m_efb_cache_tile_size = size; m_efb_cache_tile_size = size;
DestroyReadbackFramebuffer(); DestroyReadbackFramebuffer();
if (!CreateReadbackFramebuffer()) if (!CreateReadbackFramebuffer())
PanicAlert("Failed to create EFB readback framebuffers"); PanicAlertFmt("Failed to create EFB readback framebuffers");
} }
void FramebufferManager::InvalidatePeekCache(bool forced) void FramebufferManager::InvalidatePeekCache(bool forced)
@ -939,7 +939,7 @@ void FramebufferManager::DoLoadState(PointerWrap& p)
if (!color_tex || !depth_tex || if (!color_tex || !depth_tex ||
color_tex->texture->GetLayers() != m_efb_color_texture->GetLayers()) color_tex->texture->GetLayers() != m_efb_color_texture->GetLayers())
{ {
WARN_LOG(VIDEO, "Failed to deserialize EFB contents. Clearing instead."); WARN_LOG_FMT(VIDEO, "Failed to deserialize EFB contents. Clearing instead.");
g_renderer->SetAndClearFramebuffer( g_renderer->SetAndClearFramebuffer(
m_efb_framebuffer.get(), {{0.0f, 0.0f, 0.0f, 0.0f}}, m_efb_framebuffer.get(), {{0.0f, 0.0f, 0.0f, 0.0f}},
g_ActiveConfig.backend_info.bSupportsReversedDepthRange ? 1.0f : 0.0f); g_ActiveConfig.backend_info.bSupportsReversedDepthRange ? 1.0f : 0.0f);

4
Source/Core/VideoCommon/FramebufferShaderGen.cpp
View File

@ -626,7 +626,7 @@ std::string GenerateTextureReinterpretShader(TextureFormat from_format, TextureF
break; break;
default: default:
WARN_LOG(VIDEO, "From format %u is not supported", static_cast<u32>(from_format)); WARN_LOG_FMT(VIDEO, "From format {} is not supported", static_cast<u32>(from_format));
return "{}\n"; return "{}\n";
} }
@ -678,7 +678,7 @@ std::string GenerateTextureReinterpretShader(TextureFormat from_format, TextureF
} }
break; break;
default: default:
WARN_LOG(VIDEO, "To format %u is not supported", static_cast<u32>(to_format)); WARN_LOG_FMT(VIDEO, "To format {} is not supported", static_cast<u32>(to_format));
return "{}\n"; return "{}\n";
} }

38
Source/Core/VideoCommon/HiresTextures.cpp
View File

@ -119,8 +119,8 @@ void HiresTexture::Update()
if (failed_insert) if (failed_insert)
{ {
ERROR_LOG(VIDEO, "One or more textures at path '%s' were already inserted", ERROR_LOG_FMT(VIDEO, "One or more textures at path '{}' were already inserted",
texture_directory.c_str()); texture_directory);
} }
} }
@ -371,7 +371,7 @@ std::unique_ptr<HiresTexture> HiresTexture::Load(const std::string& base_filenam
if (!LoadTexture(level, buffer)) if (!LoadTexture(level, buffer))
{ {
ERROR_LOG(VIDEO, "Custom texture %s failed to load", filename.c_str()); ERROR_LOG_FMT(VIDEO, "Custom texture {} failed to load", filename);
break; break;
} }
} }
@ -387,19 +387,19 @@ std::unique_ptr<HiresTexture> HiresTexture::Load(const std::string& base_filenam
const Level& first_mip = ret->m_levels[0]; const Level& first_mip = ret->m_levels[0];
if (first_mip.width * height != first_mip.height * width) if (first_mip.width * height != first_mip.height * width)
{ {
ERROR_LOG(VIDEO, ERROR_LOG_FMT(VIDEO,
"Invalid custom texture size %ux%u for texture %s. The aspect differs " "Invalid custom texture size {}x{} for texture {}. The aspect differs "
"from the native size %ux%u.", "from the native size {}x{}.",
first_mip.width, first_mip.height, first_mip_file.path.c_str(), width, height); first_mip.width, first_mip.height, first_mip_file.path, width, height);
} }
// Same deal if the custom texture isn't a multiple of the native size. // Same deal if the custom texture isn't a multiple of the native size.
if (width != 0 && height != 0 && (first_mip.width % width || first_mip.height % height)) if (width != 0 && height != 0 && (first_mip.width % width || first_mip.height % height))
{ {
ERROR_LOG(VIDEO, ERROR_LOG_FMT(VIDEO,
"Invalid custom texture size %ux%u for texture %s. Please use an integer " "Invalid custom texture size {}x{} for texture {}. Please use an integer "
"upscaling factor based on the native size %ux%u.", "upscaling factor based on the native size {}x{}.",
first_mip.width, first_mip.height, first_mip_file.path.c_str(), width, height); first_mip.width, first_mip.height, first_mip_file.path, width, height);
} }
// Verify that each mip level is the correct size (divide by 2 each time). // Verify that each mip level is the correct size (divide by 2 each time).
@ -416,16 +416,16 @@ std::unique_ptr<HiresTexture> HiresTexture::Load(const std::string& base_filenam
if (current_mip_width == level.width && current_mip_height == level.height) if (current_mip_width == level.width && current_mip_height == level.height)
continue; continue;
ERROR_LOG(VIDEO, ERROR_LOG_FMT(
"Invalid custom texture size %dx%d for texture %s. Mipmap level %u must be %dx%d.", VIDEO, "Invalid custom texture size {}x{} for texture {}. Mipmap level {} must be {}x{}.",
level.width, level.height, first_mip_file.path.c_str(), mip_level, level.width, level.height, first_mip_file.path, mip_level, current_mip_width,
current_mip_width, current_mip_height); current_mip_height);
} }
else else
{ {
// It is invalid to have more than a single 1x1 mipmap. // It is invalid to have more than a single 1x1 mipmap.
ERROR_LOG(VIDEO, "Custom texture %s has too many 1x1 mipmaps. Skipping extra levels.", ERROR_LOG_FMT(VIDEO, "Custom texture {} has too many 1x1 mipmaps. Skipping extra levels.",
first_mip_file.path.c_str()); first_mip_file.path);
} }
// Drop this mip level and any others after it. // Drop this mip level and any others after it.
@ -437,8 +437,8 @@ std::unique_ptr<HiresTexture> HiresTexture::Load(const std::string& base_filenam
if (std::any_of(ret->m_levels.begin(), ret->m_levels.end(), if (std::any_of(ret->m_levels.begin(), ret->m_levels.end(),
[&ret](const Level& l) { return l.format != ret->m_levels[0].format; })) [&ret](const Level& l) { return l.format != ret->m_levels[0].format; }))
{ {
ERROR_LOG(VIDEO, "Custom texture %s has inconsistent formats across mip levels.", ERROR_LOG_FMT(VIDEO, "Custom texture {} has inconsistent formats across mip levels.",
first_mip_file.path.c_str()); first_mip_file.path);
return nullptr; return nullptr;
} }

8
Source/Core/VideoCommon/HiresTextures_DDSLoader.cpp
View File

@ -410,10 +410,10 @@ bool ReadMipLevel(HiresTexture::Level* level, File::IOFile& file, const std::str
if (mip_level == 0 && info.block_size > 1 && if (mip_level == 0 && info.block_size > 1 &&
((width % info.block_size) != 0 || (height % info.block_size) != 0)) ((width % info.block_size) != 0 || (height % info.block_size) != 0))
{ {
ERROR_LOG(VIDEO, ERROR_LOG_FMT(VIDEO,
"Invalid dimensions for DDS texture %s. For compressed textures of this format, " "Invalid dimensions for DDS texture {}. For compressed textures of this format, "
"the width/height of the first mip level must be a multiple of %u.", "the width/height of the first mip level must be a multiple of {}.",
filename.c_str(), info.block_size); filename, info.block_size);
return false; return false;
} }

9
Source/Core/VideoCommon/ImageWrite.cpp
View File

@ -51,8 +51,7 @@ bool TextureToPng(const u8* data, int row_stride, const std::string& filename, i
File::IOFile fp(filename, "wb"); File::IOFile fp(filename, "wb");
if (!fp.IsOpen()) if (!fp.IsOpen())
{ {
PanicAlertT("Screenshot failed: Could not open file \"%s\" (error %d)", filename.c_str(), PanicAlertFmtT("Screenshot failed: Could not open file \"{}\" (error {})", filename, errno);
errno);
goto finalise; goto finalise;
} }
@ -60,7 +59,7 @@ bool TextureToPng(const u8* data, int row_stride, const std::string& filename, i
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr); png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
if (png_ptr == nullptr) if (png_ptr == nullptr)
{ {
PanicAlert("Screenshot failed: Could not allocate write struct"); PanicAlertFmt("Screenshot failed: Could not allocate write struct");
goto finalise; goto finalise;
} }
@ -68,7 +67,7 @@ bool TextureToPng(const u8* data, int row_stride, const std::string& filename, i
info_ptr = png_create_info_struct(png_ptr); info_ptr = png_create_info_struct(png_ptr);
if (info_ptr == nullptr) if (info_ptr == nullptr)
{ {
PanicAlert("Screenshot failed: Could not allocate info struct"); PanicAlertFmt("Screenshot failed: Could not allocate info struct");
goto finalise; goto finalise;
} }
@ -82,7 +81,7 @@ bool TextureToPng(const u8* data, int row_stride, const std::string& filename, i
// would need to be volatile). // would need to be volatile).
if (setjmp(png_jmpbuf(png_ptr))) if (setjmp(png_jmpbuf(png_ptr)))
{ {
PanicAlert("Screenshot failed: Error during PNG creation"); PanicAlertFmt("Screenshot failed: Error during PNG creation");
goto finalise; goto finalise;
} }

2
Source/Core/VideoCommon/IndexGenerator.cpp
View File

@ -165,7 +165,7 @@ u16* AddQuads(u16* index_ptr, u32 num_verts, u32 index)
template <bool pr> template <bool pr>
u16* AddQuads_nonstandard(u16* index_ptr, u32 num_verts, u32 index) u16* AddQuads_nonstandard(u16* index_ptr, u32 num_verts, u32 index)
{ {
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");
return AddQuads<pr>(index_ptr, num_verts, index); return AddQuads<pr>(index_ptr, num_verts, index);
} }

12
Source/Core/VideoCommon/OpcodeDecoding.cpp
View File

@ -111,7 +111,7 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list)
case GX_UNKNOWN_RESET: case GX_UNKNOWN_RESET:
total_cycles += 6; // Datel software uses this command total_cycles += 6; // Datel software uses this command
DEBUG_LOG(VIDEO, "GX Reset?: %08x", cmd_byte); DEBUG_LOG_FMT(VIDEO, "GX Reset?: {:08x}", cmd_byte);
break; break;
case GX_LOAD_CP_REG: case GX_LOAD_CP_REG:
@ -187,7 +187,7 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list)
if (in_display_list) if (in_display_list)
{ {
total_cycles += 6; total_cycles += 6;
INFO_LOG(VIDEO, "recursive display list detected"); INFO_LOG_FMT(VIDEO, "recursive display list detected");
} }
else else
{ {
@ -202,12 +202,12 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list)
case GX_CMD_UNKNOWN_METRICS: // zelda 4 swords calls it and checks the metrics registers after case GX_CMD_UNKNOWN_METRICS: // zelda 4 swords calls it and checks the metrics registers after
// that // that
total_cycles += 6; total_cycles += 6;
DEBUG_LOG(VIDEO, "GX 0x44: %08x", cmd_byte); DEBUG_LOG_FMT(VIDEO, "GX 0x44: {:08x}", cmd_byte);
break; break;
case GX_CMD_INVL_VC: // Invalidate Vertex Cache case GX_CMD_INVL_VC: // Invalidate Vertex Cache
total_cycles += 6; total_cycles += 6;
DEBUG_LOG(VIDEO, "Invalidate (vertex cache?)"); DEBUG_LOG_FMT(VIDEO, "Invalidate (vertex cache?)");
break; break;
case GX_LOAD_BP_REG: case GX_LOAD_BP_REG:
@ -257,8 +257,8 @@ u8* Run(DataReader src, u32* cycles, bool in_display_list)
{ {
if (!s_is_fifo_error_seen) if (!s_is_fifo_error_seen)
CommandProcessor::HandleUnknownOpcode(cmd_byte, opcode_start, is_preprocess); CommandProcessor::HandleUnknownOpcode(cmd_byte, opcode_start, is_preprocess);
ERROR_LOG(VIDEO, "FIFO: Unknown Opcode(0x%02x @ %p, preprocessing = %s)", cmd_byte, ERROR_LOG_FMT(VIDEO, "FIFO: Unknown Opcode({:#04x} @ {}, preprocessing = {})", cmd_byte,
opcode_start, is_preprocess ? "yes" : "no"); fmt::ptr(opcode_start), is_preprocess ? "yes" : "no");
s_is_fifo_error_seen = true; s_is_fifo_error_seen = true;
total_cycles += 1; total_cycles += 1;
} }

6
Source/Core/VideoCommon/PixelEngine.cpp
View File

@ -221,7 +221,7 @@ void RegisterMMIO(MMIO::Mapping* mmio, u32 base)
m_Control.PEToken = 0; // this flag is write only m_Control.PEToken = 0; // this flag is write only
m_Control.PEFinish = 0; // this flag is write only m_Control.PEFinish = 0; // this flag is write only
DEBUG_LOG(PIXELENGINE, "(w16) CTRL_REGISTER: 0x%04x", val); DEBUG_LOG_FMT(PIXELENGINE, "(w16) CTRL_REGISTER: {:#06x}", val);
UpdateInterrupts(); UpdateInterrupts();
})); }));
@ -294,7 +294,7 @@ static void RaiseEvent()
// THIS IS EXECUTED FROM VIDEO THREAD // THIS IS EXECUTED FROM VIDEO THREAD
void SetToken(const u16 token, const bool interrupt) void SetToken(const u16 token, const bool interrupt)
{ {
DEBUG_LOG(PIXELENGINE, "VIDEO Backend raises INT_CAUSE_PE_TOKEN (btw, token: %04x)", token); DEBUG_LOG_FMT(PIXELENGINE, "VIDEO Backend raises INT_CAUSE_PE_TOKEN (btw, token: {:04x})", token);
std::lock_guard<std::mutex> lk(s_token_finish_mutex); std::lock_guard<std::mutex> lk(s_token_finish_mutex);
@ -308,7 +308,7 @@ void SetToken(const u16 token, const bool interrupt)
// THIS IS EXECUTED FROM VIDEO THREAD (BPStructs.cpp) when a new frame has been drawn // THIS IS EXECUTED FROM VIDEO THREAD (BPStructs.cpp) when a new frame has been drawn
void SetFinish() void SetFinish()
{ {
DEBUG_LOG(PIXELENGINE, "VIDEO Set Finish"); DEBUG_LOG_FMT(PIXELENGINE, "VIDEO Set Finish");
std::lock_guard<std::mutex> lk(s_token_finish_mutex); std::lock_guard<std::mutex> lk(s_token_finish_mutex);

2
Source/Core/VideoCommon/PixelShaderGen.cpp
View File

@ -1521,7 +1521,7 @@ static void WriteFog(ShaderCode& out, const pixel_shader_uid_data* uid_data)
else else
{ {
if (uid_data->fog_fsel != 2) if (uid_data->fog_fsel != 2)
WARN_LOG(VIDEO, "Unknown Fog Type! %08x", uid_data->fog_fsel); WARN_LOG_FMT(VIDEO, "Unknown Fog Type! {:08x}", uid_data->fog_fsel);
} }
out.Write("\tint ifog = iround(fog * 256.0);\n"); out.Write("\tint ifog = iround(fog * 256.0);\n");

6
Source/Core/VideoCommon/PixelShaderManager.cpp
View File

@ -200,7 +200,7 @@ void PixelShaderManager::SetTevColor(int index, int component, s32 value)
c[component] = value; c[component] = value;
dirty = true; dirty = true;
PRIM_LOG("tev color%d: %d %d %d %d", index, c[0], c[1], c[2], c[3]); PRIM_LOG("tev color{}: {} {} {} {}", index, c[0], c[1], c[2], c[3]);
} }
void PixelShaderManager::SetTevKonstColor(int index, int component, s32 value) void PixelShaderManager::SetTevKonstColor(int index, int component, s32 value)
@ -220,7 +220,7 @@ void PixelShaderManager::SetTevKonstColor(int index, int component, s32 value)
constants.konst[index + 16 + component * 4][2] = value; constants.konst[index + 16 + component * 4][2] = value;
constants.konst[index + 16 + component * 4][3] = value; constants.konst[index + 16 + component * 4][3] = value;
PRIM_LOG("tev konst color%d: %d %d %d %d", index, c[0], c[1], c[2], c[3]); PRIM_LOG("tev konst color{}: {} {} {} {}", index, c[0], c[1], c[2], c[3]);
} }
void PixelShaderManager::SetTevOrder(int index, u32 order) void PixelShaderManager::SetTevOrder(int index, u32 order)
@ -352,7 +352,7 @@ void PixelShaderManager::SetIndMatrixChanged(int matrixidx)
constants.indtexmtx[2 * matrixidx + 1][3] = 17 - scale; constants.indtexmtx[2 * matrixidx + 1][3] = 17 - scale;
dirty = true; dirty = true;
PRIM_LOG("indmtx%d: scale=%d, mat=(%d %d %d; %d %d %d)", matrixidx, scale, PRIM_LOG("indmtx{}: scale={}, mat=({} {} {}; {} {} {})", matrixidx, scale,
bpmem.indmtx[matrixidx].col0.ma, bpmem.indmtx[matrixidx].col1.mc, bpmem.indmtx[matrixidx].col0.ma, bpmem.indmtx[matrixidx].col1.mc,
bpmem.indmtx[matrixidx].col2.me, bpmem.indmtx[matrixidx].col0.mb, bpmem.indmtx[matrixidx].col2.me, bpmem.indmtx[matrixidx].col0.mb,
bpmem.indmtx[matrixidx].col1.md, bpmem.indmtx[matrixidx].col2.mf); bpmem.indmtx[matrixidx].col1.md, bpmem.indmtx[matrixidx].col2.mf);

6
Source/Core/VideoCommon/PostProcessing.cpp
View File

@ -72,7 +72,7 @@ void PostProcessingConfiguration::LoadShader(const std::string& shader)
if (!File::ReadFileToString(path, code)) if (!File::ReadFileToString(path, code))
{ {
ERROR_LOG(VIDEO, "Post-processing shader not found: %s", path.c_str()); ERROR_LOG_FMT(VIDEO, "Post-processing shader not found: {}", path);
LoadDefaultShader(); LoadDefaultShader();
return; return;
} }
@ -640,7 +640,7 @@ bool PostProcessing::CompileVertexShader()
m_vertex_shader = g_renderer->CreateShaderFromSource(ShaderStage::Vertex, ss.str()); m_vertex_shader = g_renderer->CreateShaderFromSource(ShaderStage::Vertex, ss.str());
if (!m_vertex_shader) if (!m_vertex_shader)
{ {
PanicAlert("Failed to compile post-processing vertex shader"); PanicAlertFmt("Failed to compile post-processing vertex shader");
return false; return false;
} }
@ -729,7 +729,7 @@ bool PostProcessing::CompilePixelShader()
ShaderStage::Pixel, GetHeader() + m_config.GetShaderCode() + GetFooter()); ShaderStage::Pixel, GetHeader() + m_config.GetShaderCode() + GetFooter());
if (!m_pixel_shader) if (!m_pixel_shader)
{ {
PanicAlert("Failed to compile post-processing shader %s", m_config.GetShader().c_str()); PanicAlertFmt("Failed to compile post-processing shader {}", m_config.GetShader());
// Use default shader. // Use default shader.
m_config.LoadDefaultShader(); m_config.LoadDefaultShader();

22
Source/Core/VideoCommon/RenderBase.cpp
View File

@ -900,7 +900,7 @@ bool Renderer::InitializeImGui()
{ {
if (!ImGui::CreateContext()) if (!ImGui::CreateContext())
{ {
PanicAlert("Creating ImGui context failed"); PanicAlertFmt("Creating ImGui context failed");
return false; return false;
} }
@ -919,7 +919,7 @@ bool Renderer::InitializeImGui()
m_imgui_vertex_format = CreateNativeVertexFormat(vdecl); m_imgui_vertex_format = CreateNativeVertexFormat(vdecl);
if (!m_imgui_vertex_format) if (!m_imgui_vertex_format)
{ {
PanicAlert("Failed to create imgui vertex format"); PanicAlertFmt("Failed to create imgui vertex format");
return false; return false;
} }
@ -935,7 +935,7 @@ bool Renderer::InitializeImGui()
std::unique_ptr<AbstractTexture> font_tex = CreateTexture(font_tex_config); std::unique_ptr<AbstractTexture> font_tex = CreateTexture(font_tex_config);
if (!font_tex) if (!font_tex)
{ {
PanicAlert("Failed to create imgui texture"); PanicAlertFmt("Failed to create imgui texture");
return false; return false;
} }
font_tex->Load(0, font_tex_width, font_tex_height, font_tex_width, font_tex_pixels, font_tex->Load(0, font_tex_width, font_tex_height, font_tex_width, font_tex_pixels,
@ -962,7 +962,7 @@ bool Renderer::RecompileImGuiPipeline()
CreateShaderFromSource(ShaderStage::Pixel, FramebufferShaderGen::GenerateImGuiPixelShader()); CreateShaderFromSource(ShaderStage::Pixel, FramebufferShaderGen::GenerateImGuiPixelShader());
if (!vertex_shader || !pixel_shader) if (!vertex_shader || !pixel_shader)
{ {
PanicAlert("Failed to compile imgui shaders"); PanicAlertFmt("Failed to compile imgui shaders");
return false; return false;
} }
@ -974,7 +974,7 @@ bool Renderer::RecompileImGuiPipeline()
ShaderStage::Geometry, FramebufferShaderGen::GeneratePassthroughGeometryShader(1, 1)); ShaderStage::Geometry, FramebufferShaderGen::GeneratePassthroughGeometryShader(1, 1));
if (!geometry_shader) if (!geometry_shader)
{ {
PanicAlert("Failed to compile imgui geometry shader"); PanicAlertFmt("Failed to compile imgui geometry shader");
return false; return false;
} }
} }
@ -1000,7 +1000,7 @@ bool Renderer::RecompileImGuiPipeline()
m_imgui_pipeline = CreatePipeline(pconfig); m_imgui_pipeline = CreatePipeline(pconfig);
if (!m_imgui_pipeline) if (!m_imgui_pipeline)
{ {
PanicAlert("Failed to create imgui pipeline"); PanicAlertFmt("Failed to create imgui pipeline");
return false; return false;
} }
@ -1436,7 +1436,7 @@ bool Renderer::CheckFrameDumpRenderTexture(u32 target_width, u32 target_height)
AbstractTextureFormat::RGBA8, AbstractTextureFlag_RenderTarget)); AbstractTextureFormat::RGBA8, AbstractTextureFlag_RenderTarget));
if (!m_frame_dump_render_texture) if (!m_frame_dump_render_texture)
{ {
PanicAlert("Failed to allocate frame dump render texture"); PanicAlertFmt("Failed to allocate frame dump render texture");
return false; return false;
} }
m_frame_dump_render_framebuffer = CreateFramebuffer(m_frame_dump_render_texture.get(), nullptr); m_frame_dump_render_framebuffer = CreateFramebuffer(m_frame_dump_render_texture.get(), nullptr);
@ -1480,7 +1480,7 @@ void Renderer::FlushFrameDump()
} }
else else
{ {
ERROR_LOG(VIDEO, "Failed to map texture for dumping."); ERROR_LOG_FMT(VIDEO, "Failed to map texture for dumping.");
} }
m_frame_dump_needs_flush = false; m_frame_dump_needs_flush = false;
@ -1552,8 +1552,8 @@ void Renderer::FrameDumpThreadFunc()
#if !defined(HAVE_FFMPEG) #if !defined(HAVE_FFMPEG)
if (dump_to_ffmpeg) if (dump_to_ffmpeg)
{ {
WARN_LOG(VIDEO, "FrameDump: Dolphin was not compiled with FFmpeg, using fallback option. " WARN_LOG_FMT(VIDEO, "FrameDump: Dolphin was not compiled with FFmpeg, using fallback option. "
"Frames will be saved as PNG images instead."); "Frames will be saved as PNG images instead.");
dump_to_ffmpeg = false; dump_to_ffmpeg = false;
} }
#endif #endif
@ -1666,7 +1666,7 @@ bool Renderer::StartFrameDumpToImage(const FrameDump::FrameData&)
std::string filename = GetFrameDumpNextImageFileName(); std::string filename = GetFrameDumpNextImageFileName();
if (File::Exists(filename)) if (File::Exists(filename))
{ {
if (!AskYesNoT("Frame dump image(s) '%s' already exists. Overwrite?", filename.c_str())) if (!AskYesNoFmtT("Frame dump image(s) '{}' already exists. Overwrite?", filename))
return false; return false;
} }
} }

20
Source/Core/VideoCommon/ShaderCache.cpp
View File

@ -76,7 +76,7 @@ void ShaderCache::Reload()
ClearCaches(); ClearCaches();
if (!CompileSharedPipelines()) if (!CompileSharedPipelines())
PanicAlert("Failed to compile shared pipelines after reload."); PanicAlertFmt("Failed to compile shared pipelines after reload.");
if (g_ActiveConfig.bShaderCache) if (g_ActiveConfig.bShaderCache)
LoadCaches(); LoadCaches();
@ -249,7 +249,7 @@ void ShaderCache::LoadShaderCache(T& cache, APIType api_type, const char* type,
std::string filename = GetDiskShaderCacheFileName(api_type, type, include_gameid, true); std::string filename = GetDiskShaderCacheFileName(api_type, type, include_gameid, true);
CacheReader reader(cache); CacheReader reader(cache);
u32 count = cache.disk_cache.OpenAndRead(filename, reader); u32 count = cache.disk_cache.OpenAndRead(filename, reader);
INFO_LOG(VIDEO, "Loaded %u cached shaders from %s", count, filename.c_str()); INFO_LOG_FMT(VIDEO, "Loaded {} cached shaders from {}", count, filename);
} }
template <typename T> template <typename T>
@ -303,8 +303,8 @@ void ShaderCache::LoadPipelineCache(T& cache, LinearDiskCache<DiskKeyType, u8>&
std::string filename = GetDiskShaderCacheFileName(api_type, type, include_gameid, true); std::string filename = GetDiskShaderCacheFileName(api_type, type, include_gameid, true);
CacheReader reader(this, cache); CacheReader reader(this, cache);
u32 count = disk_cache.OpenAndRead(filename, reader); const u32 count = disk_cache.OpenAndRead(filename, reader);
INFO_LOG(VIDEO, "Loaded %u cached pipelines from %s", count, filename.c_str()); INFO_LOG_FMT(VIDEO, "Loaded {} cached pipelines from {}", count, filename);
// If any of the pipelines in the cache failed to create, it's likely because of a change of // If any of the pipelines in the cache failed to create, it's likely because of a change of
// driver version, or system configuration. In this case, when the UID cache picks up the pipeline // driver version, or system configuration. In this case, when the UID cache picks up the pipeline
@ -312,8 +312,8 @@ void ShaderCache::LoadPipelineCache(T& cache, LinearDiskCache<DiskKeyType, u8>&
// the old cache data around, so discard and recreate the disk cache. // the old cache data around, so discard and recreate the disk cache.
if (reader.AnyFailed()) if (reader.AnyFailed())
{ {
WARN_LOG(VIDEO, "Failed to load one or more pipelines from cache '%s'. Discarding.", WARN_LOG_FMT(VIDEO, "Failed to load one or more pipelines from cache '{}'. Discarding.",
filename.c_str()); filename);
disk_cache.Close(); disk_cache.Close();
File::Delete(filename); File::Delete(filename);
disk_cache.OpenAndRead(filename, reader); disk_cache.OpenAndRead(filename, reader);
@ -586,7 +586,8 @@ AbstractPipelineConfig ShaderCache::GetGXPipelineConfig(
if (config.blending_state.logicopenable && !g_ActiveConfig.backend_info.bSupportsLogicOp) if (config.blending_state.logicopenable && !g_ActiveConfig.backend_info.bSupportsLogicOp)
{ {
WARN_LOG(VIDEO, "Approximating logic op with blending, this will produce incorrect rendering."); WARN_LOG_FMT(VIDEO,
"Approximating logic op with blending, this will produce incorrect rendering.");
config.blending_state.ApproximateLogicOpWithBlending(); config.blending_state.ApproximateLogicOpWithBlending();
} }
@ -791,8 +792,7 @@ void ShaderCache::LoadPipelineUIDCache()
} }
} }
INFO_LOG(VIDEO, "Read %u pipeline UIDs from %s", INFO_LOG_FMT(VIDEO, "Read {} pipeline UIDs from {}", m_gx_pipeline_cache.size(), filename);
static_cast<unsigned>(m_gx_pipeline_cache.size()), filename.c_str());
} }
void ShaderCache::ClosePipelineUIDCache() void ShaderCache::ClosePipelineUIDCache()
@ -824,7 +824,7 @@ void ShaderCache::AppendGXPipelineUID(const GXPipelineUid& config)
SerializePipelineUid(config, disk_uid); SerializePipelineUid(config, disk_uid);
if (!m_gx_pipeline_uid_cache_file.WriteBytes(&disk_uid, sizeof(disk_uid))) if (!m_gx_pipeline_uid_cache_file.WriteBytes(&disk_uid, sizeof(disk_uid)))
{ {
WARN_LOG(VIDEO, "Writing pipeline UID to cache failed, closing file."); WARN_LOG_FMT(VIDEO, "Writing pipeline UID to cache failed, closing file.");
m_gx_pipeline_uid_cache_file.Close(); m_gx_pipeline_uid_cache_file.Close();
} }
} }

54
Source/Core/VideoCommon/TextureCacheBase.cpp
View File

@ -114,7 +114,7 @@ bool TextureCacheBase::Initialize()
{ {
if (!CreateUtilityTextures()) if (!CreateUtilityTextures())
{ {
PanicAlert("Failed to create utility textures."); PanicAlertFmt("Failed to create utility textures.");
return false; return false;
} }
@ -268,8 +268,8 @@ TextureCacheBase::ApplyPaletteToEntry(TCacheEntry* entry, u8* palette, TLUTForma
const AbstractPipeline* pipeline = g_shader_cache->GetPaletteConversionPipeline(tlutfmt); const AbstractPipeline* pipeline = g_shader_cache->GetPaletteConversionPipeline(tlutfmt);
if (!pipeline) if (!pipeline)
{ {
ERROR_LOG(VIDEO, "Failed to get conversion pipeline for format 0x%02X", ERROR_LOG_FMT(VIDEO, "Failed to get conversion pipeline for format {:#04X}",
static_cast<u32>(tlutfmt)); static_cast<u32>(tlutfmt));
return nullptr; return nullptr;
} }
@ -321,7 +321,7 @@ TextureCacheBase::ApplyPaletteToEntry(TCacheEntry* entry, u8* palette, TLUTForma
} }
else else
{ {
ERROR_LOG(VIDEO, "Texel buffer upload of %u bytes failed", palette_size); ERROR_LOG_FMT(VIDEO, "Texel buffer upload of {} bytes failed", palette_size);
g_renderer->EndUtilityDrawing(); g_renderer->EndUtilityDrawing();
} }
@ -337,9 +337,9 @@ TextureCacheBase::TCacheEntry* TextureCacheBase::ReinterpretEntry(const TCacheEn
g_shader_cache->GetTextureReinterpretPipeline(existing_entry->format.texfmt, new_format); g_shader_cache->GetTextureReinterpretPipeline(existing_entry->format.texfmt, new_format);
if (!pipeline) if (!pipeline)
{ {
ERROR_LOG(VIDEO, ERROR_LOG_FMT(VIDEO,
"Failed to obtain texture reinterpreting pipeline from format 0x%02X to 0x%02X", "Failed to obtain texture reinterpreting pipeline from format {:#04X} to {:#04X}",
static_cast<u32>(existing_entry->format.texfmt), static_cast<u32>(new_format)); static_cast<u32>(existing_entry->format.texfmt), static_cast<u32>(new_format));
return nullptr; return nullptr;
} }
@ -388,7 +388,7 @@ void TextureCacheBase::ScaleTextureCacheEntryTo(TextureCacheBase::TCacheEntry* e
const u32 max = g_ActiveConfig.backend_info.MaxTextureSize; const u32 max = g_ActiveConfig.backend_info.MaxTextureSize;
if (max < new_width || max < new_height) if (max < new_width || max < new_height)
{ {
ERROR_LOG(VIDEO, "Texture too big, width = %d, height = %d", new_width, new_height); ERROR_LOG_FMT(VIDEO, "Texture too big, width = {}, height = {}", new_width, new_height);
return; return;
} }
@ -397,7 +397,7 @@ void TextureCacheBase::ScaleTextureCacheEntryTo(TextureCacheBase::TCacheEntry* e
std::optional<TexPoolEntry> new_texture = AllocateTexture(newconfig); std::optional<TexPoolEntry> new_texture = AllocateTexture(newconfig);
if (!new_texture) if (!new_texture)
{ {
ERROR_LOG(VIDEO, "Scaling failed due to texture allocation failure"); ERROR_LOG_FMT(VIDEO, "Scaling failed due to texture allocation failure");
return; return;
} }
@ -465,7 +465,7 @@ void TextureCacheBase::SerializeTexture(AbstractTexture* tex, const TextureConfi
} }
else else
{ {
PanicAlert("Failed to create staging texture for serialization"); PanicAlertFmt("Failed to create staging texture for serialization");
} }
p.Do(texture_data); p.Do(texture_data);
@ -485,7 +485,7 @@ std::optional<TextureCacheBase::TexPoolEntry> TextureCacheBase::DeserializeTextu
auto tex = AllocateTexture(config); auto tex = AllocateTexture(config);
if (!tex) if (!tex)
{ {
PanicAlert("Failed to create texture for deserialization"); PanicAlertFmt("Failed to create texture for deserialization");
return std::nullopt; return std::nullopt;
} }
@ -494,13 +494,13 @@ std::optional<TextureCacheBase::TexPoolEntry> TextureCacheBase::DeserializeTextu
{ {
for (u32 level = 0; level < config.levels; level++) for (u32 level = 0; level < config.levels; level++)
{ {
u32 level_width = std::max(config.width >> level, 1u); const u32 level_width = std::max(config.width >> level, 1u);
u32 level_height = std::max(config.height >> level, 1u); const u32 level_height = std::max(config.height >> level, 1u);
size_t stride = AbstractTexture::CalculateStrideForFormat(config.format, level_width); const size_t stride = AbstractTexture::CalculateStrideForFormat(config.format, level_width);
size_t size = stride * level_height; const size_t size = stride * level_height;
if ((start + size) > texture_data.size()) if ((start + size) > texture_data.size())
{ {
ERROR_LOG(VIDEO, "Insufficient texture data for layer %u level %u", layer, level); ERROR_LOG_FMT(VIDEO, "Insufficient texture data for layer {} level {}", layer, level);
return tex; return tex;
} }
@ -1273,7 +1273,7 @@ TextureCacheBase::GetTexture(u32 address, u32 width, u32 height, const TextureFo
if (!src_data) if (!src_data)
{ {
ERROR_LOG(VIDEO, "Trying to use an invalid texture address 0x%8x", address); ERROR_LOG_FMT(VIDEO, "Trying to use an invalid texture address {:#010x}", address);
return nullptr; return nullptr;
} }
@ -1718,7 +1718,7 @@ TextureCacheBase::GetXFBTexture(u32 address, u32 width, u32 height, u32 stride,
const u8* src_data = Memory::GetPointer(address); const u8* src_data = Memory::GetPointer(address);
if (!src_data) if (!src_data)
{ {
ERROR_LOG(VIDEO, "Trying to load XFB texture from invalid address 0x%8x", address); ERROR_LOG_FMT(VIDEO, "Trying to load XFB texture from invalid address {:#010x}", address);
return nullptr; return nullptr;
} }
@ -2087,7 +2087,7 @@ void TextureCacheBase::CopyRenderTargetToTexture(
u8* dst = Memory::GetPointer(dstAddr); u8* dst = Memory::GetPointer(dstAddr);
if (dst == nullptr) if (dst == nullptr)
{ {
ERROR_LOG(VIDEO, "Trying to copy from EFB to invalid address 0x%8x", dstAddr); ERROR_LOG_FMT(VIDEO, "Trying to copy from EFB to invalid address {:#010x}", dstAddr);
return; return;
} }
@ -2145,7 +2145,7 @@ void TextureCacheBase::CopyRenderTargetToTexture(
// To avoid a "incorrect" result, we simply skip doing the copy_to_vram code path // To avoid a "incorrect" result, we simply skip doing the copy_to_vram code path
// so if the game does try to use the scrambled texture, dolphin will grab the scrambled // so if the game does try to use the scrambled texture, dolphin will grab the scrambled
// texture (or black if copy_to_ram is also disabled) out of ram. // texture (or black if copy_to_ram is also disabled) out of ram.
ERROR_LOG(VIDEO, "Memory stride too small (%i < %i)", dstStride, bytes_per_row); ERROR_LOG_FMT(VIDEO, "Memory stride too small ({} < {})", dstStride, bytes_per_row);
copy_to_vram = false; copy_to_vram = false;
} }
@ -2408,7 +2408,7 @@ std::unique_ptr<AbstractStagingTexture> TextureCacheBase::GetEFBCopyStagingTextu
std::unique_ptr<AbstractStagingTexture> tex = g_renderer->CreateStagingTexture( std::unique_ptr<AbstractStagingTexture> tex = g_renderer->CreateStagingTexture(
StagingTextureType::Readback, m_efb_encoding_texture->GetConfig()); StagingTextureType::Readback, m_efb_encoding_texture->GetConfig());
if (!tex) if (!tex)
WARN_LOG(VIDEO, "Failed to create EFB copy staging texture"); WARN_LOG_FMT(VIDEO, "Failed to create EFB copy staging texture");
return tex; return tex;
} }
@ -2487,8 +2487,8 @@ TextureCacheBase::AllocateTexture(const TextureConfig& config)
std::unique_ptr<AbstractTexture> texture = g_renderer->CreateTexture(config); std::unique_ptr<AbstractTexture> texture = g_renderer->CreateTexture(config);
if (!texture) if (!texture)
{ {
WARN_LOG(VIDEO, "Failed to allocate a %ux%ux%u texture", config.width, config.height, WARN_LOG_FMT(VIDEO, "Failed to allocate a {}x{}x{} texture", config.width, config.height,
config.layers); config.layers);
return {}; return {};
} }
@ -2498,8 +2498,8 @@ TextureCacheBase::AllocateTexture(const TextureConfig& config)
framebuffer = g_renderer->CreateFramebuffer(texture.get(), nullptr); framebuffer = g_renderer->CreateFramebuffer(texture.get(), nullptr);
if (!framebuffer) if (!framebuffer)
{ {
WARN_LOG(VIDEO, "Failed to allocate a %ux%ux%u framebuffer", config.width, config.height, WARN_LOG_FMT(VIDEO, "Failed to allocate a {}x{}x{} framebuffer", config.width, config.height,
config.layers); config.layers);
return {}; return {};
} }
} }
@ -2660,7 +2660,7 @@ void TextureCacheBase::CopyEFBToCacheEntry(TCacheEntry* entry, bool is_depth_cop
NeedsCopyFilterInShader(filter_coefficients))); NeedsCopyFilterInShader(filter_coefficients)));
if (!copy_pipeline) if (!copy_pipeline)
{ {
WARN_LOG(VIDEO, "Skipping EFB copy to VRAM due to missing pipeline."); WARN_LOG_FMT(VIDEO, "Skipping EFB copy to VRAM due to missing pipeline.");
return; return;
} }
@ -2728,7 +2728,7 @@ void TextureCacheBase::CopyEFB(AbstractStagingTexture* dst, const EFBCopyParams&
const AbstractPipeline* copy_pipeline = g_shader_cache->GetEFBCopyToRAMPipeline(params); const AbstractPipeline* copy_pipeline = g_shader_cache->GetEFBCopyToRAMPipeline(params);
if (!copy_pipeline) if (!copy_pipeline)
{ {
WARN_LOG(VIDEO, "Skipping EFB copy to VRAM due to missing pipeline."); WARN_LOG_FMT(VIDEO, "Skipping EFB copy to VRAM due to missing pipeline.");
return; return;
} }

9
Source/Core/VideoCommon/TextureConversionShader.cpp
View File

@ -49,7 +49,8 @@ u16 GetEncodedSampleCount(EFBCopyFormat format)
case EFBCopyFormat::XFB: case EFBCopyFormat::XFB:
return 2; return 2;
default: default:
PanicAlert("Invalid EFB Copy Format (0x%X)! (GetEncodedSampleCount)", static_cast<int>(format)); PanicAlertFmt("Invalid EFB Copy Format ({:#X})! (GetEncodedSampleCount)",
static_cast<int>(format));
return 1; return 1;
} }
} }
@ -839,8 +840,8 @@ std::string GenerateEncodingShader(const EFBCopyParams& params, APIType api_type
WriteXFBEncoder(code, api_type, params); WriteXFBEncoder(code, api_type, params);
break; break;
default: default:
PanicAlert("Invalid EFB Copy Format (0x%X)! (GenerateEncodingShader)", PanicAlertFmt("Invalid EFB Copy Format ({:#X})! (GenerateEncodingShader)",
static_cast<int>(params.copy_format)); static_cast<int>(params.copy_format));
break; break;
} }
@ -1487,7 +1488,7 @@ float4 DecodePixel(int val)
break; break;
default: default:
PanicAlert("Unknown format"); PanicAlertFmt("Unknown format");
break; break;
} }

10
Source/Core/VideoCommon/TextureConverterShaderGen.cpp
View File

@ -209,7 +209,8 @@ ShaderCode GeneratePixelShader(APIType api_type, const UidData* uid_data)
break; break;
default: default:
ERROR_LOG(VIDEO, "Unknown copy zbuf format: 0x%X", static_cast<int>(uid_data->dst_format)); ERROR_LOG_FMT(VIDEO, "Unknown copy zbuf format: {:#X}",
static_cast<int>(uid_data->dst_format));
out.Write(" ocol0 = float4(texcol.bgr, 0.0);\n"); out.Write(" ocol0 = float4(texcol.bgr, 0.0);\n");
break; break;
} }
@ -239,8 +240,8 @@ ShaderCode GeneratePixelShader(APIType api_type, const UidData* uid_data)
break; break;
default: default:
ERROR_LOG(VIDEO, "Unknown copy intensity format: 0x%X", ERROR_LOG_FMT(VIDEO, "Unknown copy intensity format: {:#X}",
static_cast<int>(uid_data->dst_format)); static_cast<int>(uid_data->dst_format));
out.Write(" ocol0 = texcol;\n"); out.Write(" ocol0 = texcol;\n");
break; break;
} }
@ -315,7 +316,8 @@ ShaderCode GeneratePixelShader(APIType api_type, const UidData* uid_data)
break; break;
default: default:
ERROR_LOG(VIDEO, "Unknown copy color format: 0x%X", static_cast<int>(uid_data->dst_format)); ERROR_LOG_FMT(VIDEO, "Unknown copy color format: {:#X}",
static_cast<int>(uid_data->dst_format));
out.Write(" ocol0 = texcol;\n"); out.Write(" ocol0 = texcol;\n");
break; break;
} }

20
Source/Core/VideoCommon/TextureDecoder_Common.cpp
View File

@ -51,7 +51,8 @@ int TexDecoder_GetTexelSizeInNibbles(TextureFormat format)
case TextureFormat::XFB: case TextureFormat::XFB:
return 4; return 4;
default: default:
PanicAlert("Invalid Texture Format (0x%X)! (GetTexelSizeInNibbles)", static_cast<int>(format)); PanicAlertFmt("Invalid Texture Format ({:#X})! (GetTexelSizeInNibbles)",
static_cast<int>(format));
return 1; return 1;
} }
} }
@ -90,7 +91,8 @@ int TexDecoder_GetBlockWidthInTexels(TextureFormat format)
case TextureFormat::XFB: case TextureFormat::XFB:
return 16; return 16;
default: default:
PanicAlert("Invalid Texture Format (0x%X)! (GetBlockWidthInTexels)", static_cast<int>(format)); PanicAlertFmt("Invalid Texture Format ({:#X})! (GetBlockWidthInTexels)",
static_cast<int>(format));
return 8; return 8;
} }
} }
@ -124,7 +126,8 @@ int TexDecoder_GetBlockHeightInTexels(TextureFormat format)
case TextureFormat::XFB: case TextureFormat::XFB:
return 1; return 1;
default: default:
PanicAlert("Invalid Texture Format (0x%X)! (GetBlockHeightInTexels)", static_cast<int>(format)); PanicAlertFmt("Invalid Texture Format ({:#X})! (GetBlockHeightInTexels)",
static_cast<int>(format));
return 4; return 4;
} }
} }
@ -158,8 +161,8 @@ int TexDecoder_GetEFBCopyBlockWidthInTexels(EFBCopyFormat format)
case EFBCopyFormat::XFB: case EFBCopyFormat::XFB:
return 16; return 16;
default: default:
PanicAlert("Invalid EFB Copy Format (0x%X)! (GetEFBCopyBlockWidthInTexels)", PanicAlertFmt("Invalid EFB Copy Format ({:#X})! (GetEFBCopyBlockWidthInTexels)",
static_cast<int>(format)); static_cast<int>(format));
return 8; return 8;
} }
} }
@ -193,8 +196,8 @@ int TexDecoder_GetEFBCopyBlockHeightInTexels(EFBCopyFormat format)
case EFBCopyFormat::XFB: case EFBCopyFormat::XFB:
return 1; return 1;
default: default:
PanicAlert("Invalid EFB Copy Format (0x%X)! (GetEFBCopyBlockHeightInTexels)", PanicAlertFmt("Invalid EFB Copy Format ({:#X})! (GetEFBCopyBlockHeightInTexels)",
static_cast<int>(format)); static_cast<int>(format));
return 4; return 4;
} }
} }
@ -245,7 +248,8 @@ TextureFormat TexDecoder_GetEFBCopyBaseFormat(EFBCopyFormat format)
case EFBCopyFormat::XFB: case EFBCopyFormat::XFB:
return TextureFormat::XFB; return TextureFormat::XFB;
default: default:
PanicAlert("Invalid EFB Copy Format (0x%X)! (GetEFBCopyBaseFormat)", static_cast<int>(format)); PanicAlertFmt("Invalid EFB Copy Format ({:#X})! (GetEFBCopyBaseFormat)",
static_cast<int>(format));
return static_cast<TextureFormat>(format); return static_cast<TextureFormat>(format);
} }
} }

4
Source/Core/VideoCommon/TextureDecoder_x64.cpp
View File

@ -1491,8 +1491,8 @@ void _TexDecoder_DecodeImpl(u32* dst, const u8* src, int width, int height, Text
break; break;
default: default:
PanicAlert("Invalid Texture Format (0x%X)! (_TexDecoder_DecodeImpl)", PanicAlertFmt("Invalid Texture Format ({:#X})! (_TexDecoder_DecodeImpl)",
static_cast<int>(texformat)); static_cast<int>(texformat));
break; break;
} }
} }

10
Source/Core/VideoCommon/VertexLoader.cpp
View File

@ -25,14 +25,14 @@ static void PosMtx_ReadDirect_UByte(VertexLoader* loader)
if (loader->m_counter < 3) if (loader->m_counter < 3)
VertexLoaderManager::position_matrix_index[loader->m_counter + 1] = posmtx; VertexLoaderManager::position_matrix_index[loader->m_counter + 1] = posmtx;
DataWrite<u32>(posmtx); DataWrite<u32>(posmtx);
PRIM_LOG("posmtx: %d, ", posmtx); PRIM_LOG("posmtx: {}, ", posmtx);
} }
static void TexMtx_ReadDirect_UByte(VertexLoader* loader) static void TexMtx_ReadDirect_UByte(VertexLoader* loader)
{ {
loader->m_curtexmtx[loader->m_texmtxread] = DataRead<u8>() & 0x3f; loader->m_curtexmtx[loader->m_texmtxread] = DataRead<u8>() & 0x3f;
PRIM_LOG("texmtx%d: %d, ", loader->m_texmtxread, loader->m_curtexmtx[loader->m_texmtxread]); PRIM_LOG("texmtx{}: {}, ", loader->m_texmtxread, loader->m_curtexmtx[loader->m_texmtxread]);
loader->m_texmtxread++; loader->m_texmtxread++;
} }
@ -184,9 +184,9 @@ void VertexLoader::CompileVertexTranslator()
if (pFunc == nullptr) if (pFunc == nullptr)
{ {
PanicAlert("VertexLoader_Normal::GetFunction(%i %i %i %i) returned zero!", PanicAlertFmt("VertexLoader_Normal::GetFunction({} {} {} {}) returned zero!",
(u32)m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements, m_VtxDesc.Normal, m_VtxAttr.NormalFormat, m_VtxAttr.NormalElements,
m_VtxAttr.NormalIndex3); m_VtxAttr.NormalIndex3);
} }
WriteCall(pFunc); WriteCall(pFunc);

31
Source/Core/VideoCommon/VertexLoaderBase.cpp
View File

@ -168,11 +168,11 @@ public:
} }
else else
{ {
ERROR_LOG(VIDEO, "Can't compare vertex loaders that expect different vertex formats!"); ERROR_LOG_FMT(VIDEO, "Can't compare vertex loaders that expect different vertex formats!");
ERROR_LOG(VIDEO, "a: m_VertexSize %d, m_native_components 0x%08x, stride %d", ERROR_LOG_FMT(VIDEO, "a: m_VertexSize {}, m_native_components {:#010x}, stride {}",
a->m_VertexSize, a->m_native_components, a->m_native_vtx_decl.stride); a->m_VertexSize, a->m_native_components, a->m_native_vtx_decl.stride);
ERROR_LOG(VIDEO, "b: m_VertexSize %d, m_native_components 0x%08x, stride %d", ERROR_LOG_FMT(VIDEO, "b: m_VertexSize {}, m_native_components {:#010x}, stride {}",
b->m_VertexSize, b->m_native_components, b->m_native_vtx_decl.stride); b->m_VertexSize, b->m_native_components, b->m_native_vtx_decl.stride);
} }
} }
} }
@ -188,16 +188,21 @@ public:
b->RunVertices(src, DataReader(buffer_b.data(), buffer_b.data() + buffer_b.size()), count); b->RunVertices(src, DataReader(buffer_b.data(), buffer_b.data() + buffer_b.size()), count);
if (count_a != count_b) if (count_a != count_b)
ERROR_LOG(VIDEO, {
"The two vertex loaders have loaded a different amount of vertices (a: %d, b: %d).", ERROR_LOG_FMT(
count_a, count_b); VIDEO,
"The two vertex loaders have loaded a different amount of vertices (a: {}, b: {}).",
count_a, count_b);
}
if (memcmp(buffer_a.data(), buffer_b.data(), if (memcmp(buffer_a.data(), buffer_b.data(),
std::min(count_a, count_b) * m_native_vtx_decl.stride)) std::min(count_a, count_b) * m_native_vtx_decl.stride))
ERROR_LOG(VIDEO, {
"The two vertex loaders have loaded different data " ERROR_LOG_FMT(VIDEO,
"(guru meditation 0x%016" PRIx64 ", 0x%08x, 0x%08x, 0x%08x).", "The two vertex loaders have loaded different data "
m_VtxDesc.Hex, m_vat.g0.Hex, m_vat.g1.Hex, m_vat.g2.Hex); "(guru meditation {:#018x}, {:#010x}, {:#010x}, {:#010x}).",
m_VtxDesc.Hex, m_vat.g0.Hex, m_vat.g1.Hex, m_vat.g2.Hex);
}
memcpy(dst.GetPointer(), buffer_a.data(), count_a * m_native_vtx_decl.stride); memcpy(dst.GetPointer(), buffer_a.data(), count_a * m_native_vtx_decl.stride);
m_numLoadedVertices += count; m_numLoadedVertices += count;
@ -246,6 +251,6 @@ std::unique_ptr<VertexLoaderBase> VertexLoaderBase::CreateVertexLoader(const TVt
if (loader->IsInitialized()) if (loader->IsInitialized())
return loader; return loader;
PanicAlert("No Vertex Loader found."); PanicAlertFmt("No Vertex Loader found.");
return nullptr; return nullptr;
} }

2
Source/Core/VideoCommon/VertexLoader_Normal.cpp
View File

@ -15,7 +15,7 @@
#include "VideoCommon/VertexLoaderUtils.h" #include "VideoCommon/VertexLoaderUtils.h"
// warning: mapping buffer should be disabled to use this // warning: mapping buffer should be disabled to use this
#define LOG_NORM() // PRIM_LOG("norm: %f %f %f, ", ((float*)g_vertex_manager_write_ptr)[-3], #define LOG_NORM() // PRIM_LOG("norm: {} {} {}, ", ((float*)g_vertex_manager_write_ptr)[-3],
// ((float*)g_vertex_manager_write_ptr)[-2], // ((float*)g_vertex_manager_write_ptr)[-2],
// ((float*)g_vertex_manager_write_ptr)[-1]); // ((float*)g_vertex_manager_write_ptr)[-1]);

49
Source/Core/VideoCommon/VertexManagerBase.cpp
View File

@ -144,13 +144,19 @@ DataReader VertexManagerBase::PrepareForAdditionalData(int primitive, u32 count,
Flush(); Flush();
if (count > m_index_generator.GetRemainingIndices()) if (count > m_index_generator.GetRemainingIndices())
ERROR_LOG(VIDEO, "Too little remaining index values. Use 32-bit or reset them on flush."); {
ERROR_LOG_FMT(VIDEO, "Too little remaining index values. Use 32-bit or reset them on flush.");
}
if (count > GetRemainingIndices(primitive)) if (count > GetRemainingIndices(primitive))
ERROR_LOG(VIDEO, "VertexManager: Buffer not large enough for all indices! " {
"Increase MAXIBUFFERSIZE or we need primitive breaking after all."); ERROR_LOG_FMT(VIDEO, "VertexManager: Buffer not large enough for all indices! "
"Increase MAXIBUFFERSIZE or we need primitive breaking after all.");
}
if (needed_vertex_bytes > GetRemainingSize()) if (needed_vertex_bytes > GetRemainingSize())
ERROR_LOG(VIDEO, "VertexManager: Buffer not large enough for all vertices! " {
"Increase MAXVBUFFERSIZE or we need primitive breaking after all."); ERROR_LOG_FMT(VIDEO, "VertexManager: Buffer not large enough for all vertices! "
"Increase MAXVBUFFERSIZE or we need primitive breaking after all.");
}
} }
m_cull_all = cullall; m_cull_all = cullall;
@ -358,11 +364,12 @@ void VertexManagerBase::Flush()
if (xfmem.numTexGen.numTexGens != bpmem.genMode.numtexgens || if (xfmem.numTexGen.numTexGens != bpmem.genMode.numtexgens ||
xfmem.numChan.numColorChans != bpmem.genMode.numcolchans) xfmem.numChan.numColorChans != bpmem.genMode.numcolchans)
{ {
ERROR_LOG(VIDEO, ERROR_LOG_FMT(
"Mismatched configuration between XF and BP stages - %u/%u texgens, %u/%u colors. " VIDEO,
"Skipping draw. Please report on the issue tracker.", "Mismatched configuration between XF and BP stages - {}/{} texgens, {}/{} colors. "
xfmem.numTexGen.numTexGens, bpmem.genMode.numtexgens.Value(), "Skipping draw. Please report on the issue tracker.",
xfmem.numChan.numColorChans, bpmem.genMode.numcolchans.Value()); xfmem.numTexGen.numTexGens, bpmem.genMode.numtexgens.Value(), xfmem.numChan.numColorChans,
bpmem.genMode.numcolchans.Value());
// Analytics reporting so we can discover which games have this problem, that way when we // Analytics reporting so we can discover which games have this problem, that way when we
// eventually simulate the behavior we have test cases for it. // eventually simulate the behavior we have test cases for it.
@ -381,7 +388,7 @@ void VertexManagerBase::Flush()
} }
#if defined(_DEBUG) || defined(DEBUGFAST) #if defined(_DEBUG) || defined(DEBUGFAST)
PRIM_LOG("frame%d:\n texgen=%u, numchan=%u, dualtex=%u, ztex=%u, cole=%u, alpe=%u, ze=%u", PRIM_LOG("frame{}:\n texgen={}, numchan={}, dualtex={}, ztex={}, cole={}, alpe={}, ze={}",
g_ActiveConfig.iSaveTargetId, xfmem.numTexGen.numTexGens, xfmem.numChan.numColorChans, g_ActiveConfig.iSaveTargetId, xfmem.numTexGen.numTexGens, xfmem.numChan.numColorChans,
xfmem.dualTexTrans.enabled, bpmem.ztex2.op.Value(), bpmem.blendmode.colorupdate.Value(), xfmem.dualTexTrans.enabled, bpmem.ztex2.op.Value(), bpmem.blendmode.colorupdate.Value(),
bpmem.blendmode.alphaupdate.Value(), bpmem.zmode.updateenable.Value()); bpmem.blendmode.alphaupdate.Value(), bpmem.zmode.updateenable.Value());
@ -389,11 +396,11 @@ void VertexManagerBase::Flush()
for (u32 i = 0; i < xfmem.numChan.numColorChans; ++i) for (u32 i = 0; i < xfmem.numChan.numColorChans; ++i)
{ {
LitChannel* ch = &xfmem.color[i]; LitChannel* ch = &xfmem.color[i];
PRIM_LOG("colchan%u: matsrc=%u, light=0x%x, ambsrc=%u, diffunc=%u, attfunc=%u", i, PRIM_LOG("colchan{}: matsrc={}, light={:#x}, ambsrc={}, diffunc={}, attfunc={}", i,
ch->matsource.Value(), ch->GetFullLightMask(), ch->ambsource.Value(), ch->matsource.Value(), ch->GetFullLightMask(), ch->ambsource.Value(),
ch->diffusefunc.Value(), ch->attnfunc.Value()); ch->diffusefunc.Value(), ch->attnfunc.Value());
ch = &xfmem.alpha[i]; ch = &xfmem.alpha[i];
PRIM_LOG("alpchan%u: matsrc=%u, light=0x%x, ambsrc=%u, diffunc=%u, attfunc=%u", i, PRIM_LOG("alpchan{}: matsrc={}, light={:#x}, ambsrc={}, diffunc={}, attfunc={}", i,
ch->matsource.Value(), ch->GetFullLightMask(), ch->ambsource.Value(), ch->matsource.Value(), ch->GetFullLightMask(), ch->ambsource.Value(),
ch->diffusefunc.Value(), ch->attnfunc.Value()); ch->diffusefunc.Value(), ch->attnfunc.Value());
} }
@ -406,15 +413,15 @@ void VertexManagerBase::Flush()
if (tinfo.texgentype != XF_TEXGEN_REGULAR) if (tinfo.texgentype != XF_TEXGEN_REGULAR)
tinfo.projection = 0; tinfo.projection = 0;
PRIM_LOG("txgen%u: proj=%u, input=%u, gentype=%u, srcrow=%u, embsrc=%u, emblght=%u, " PRIM_LOG("txgen{}: proj={}, input={}, gentype={}, srcrow={}, embsrc={}, emblght={}, "
"postmtx=%u, postnorm=%u", "postmtx={}, postnorm={}",
i, tinfo.projection.Value(), tinfo.inputform.Value(), tinfo.texgentype.Value(), i, tinfo.projection.Value(), tinfo.inputform.Value(), tinfo.texgentype.Value(),
tinfo.sourcerow.Value(), tinfo.embosssourceshift.Value(), tinfo.sourcerow.Value(), tinfo.embosssourceshift.Value(),
tinfo.embosslightshift.Value(), xfmem.postMtxInfo[i].index.Value(), tinfo.embosslightshift.Value(), xfmem.postMtxInfo[i].index.Value(),
xfmem.postMtxInfo[i].normalize.Value()); xfmem.postMtxInfo[i].normalize.Value());
} }
PRIM_LOG("pixel: tev=%u, ind=%u, texgen=%u, dstalpha=%u, alphatest=0x%x", PRIM_LOG("pixel: tev={}, ind={}, texgen={}, dstalpha={}, alphatest={:#x}",
bpmem.genMode.numtevstages.Value() + 1, bpmem.genMode.numindstages.Value(), bpmem.genMode.numtevstages.Value() + 1, bpmem.genMode.numindstages.Value(),
bpmem.genMode.numtexgens.Value(), bpmem.dstalpha.enable.Value(), bpmem.genMode.numtexgens.Value(), bpmem.dstalpha.enable.Value(),
(bpmem.alpha_test.hex >> 16) & 0xff); (bpmem.alpha_test.hex >> 16) & 0xff);
@ -502,9 +509,9 @@ void VertexManagerBase::Flush()
if (xfmem.numTexGen.numTexGens != bpmem.genMode.numtexgens) if (xfmem.numTexGen.numTexGens != bpmem.genMode.numtexgens)
{ {
ERROR_LOG(VIDEO, ERROR_LOG_FMT(VIDEO,
"xf.numtexgens (%d) does not match bp.numtexgens (%d). Error in command stream.", "xf.numtexgens ({}) does not match bp.numtexgens ({}). Error in command stream.",
xfmem.numTexGen.numTexGens, bpmem.genMode.numtexgens.Value()); xfmem.numTexGen.numTexGens, bpmem.genMode.numtexgens.Value());
} }
} }
@ -813,12 +820,12 @@ void VertexManagerBase::OnEndFrame()
{ {
std::ostringstream ss; std::ostringstream ss;
std::for_each(m_cpu_accesses_this_frame.begin(), m_cpu_accesses_this_frame.end(), [&ss](u32 idx) { ss << idx << ","; }); std::for_each(m_cpu_accesses_this_frame.begin(), m_cpu_accesses_this_frame.end(), [&ss](u32 idx) { ss << idx << ","; });
WARN_LOG(VIDEO, "CPU EFB accesses in last frame: %s", ss.str().c_str()); WARN_LOG_FMT(VIDEO, "CPU EFB accesses in last frame: {}", ss.str());
} }
{ {
std::ostringstream ss; std::ostringstream ss;
std::for_each(m_scheduled_command_buffer_kicks.begin(), m_scheduled_command_buffer_kicks.end(), [&ss](u32 idx) { ss << idx << ","; }); std::for_each(m_scheduled_command_buffer_kicks.begin(), m_scheduled_command_buffer_kicks.end(), [&ss](u32 idx) { ss << idx << ","; });
WARN_LOG(VIDEO, "Scheduled command buffer kicks: %s", ss.str().c_str()); WARN_LOG_FMT(VIDEO, "Scheduled command buffer kicks: {}", ss.str());
} }
#endif #endif

4
Source/Core/VideoCommon/VertexShaderManager.cpp
View File

@ -412,10 +412,10 @@ void VertexShaderManager::SetConstants()
break; break;
default: default:
ERROR_LOG(VIDEO, "Unknown projection type: %d", xfmem.projection.type); ERROR_LOG_FMT(VIDEO, "Unknown projection type: {}", xfmem.projection.type);
} }
PRIM_LOG("Projection: %f %f %f %f %f %f", rawProjection[0], rawProjection[1], rawProjection[2], PRIM_LOG("Projection: {} {} {} {} {} {}", rawProjection[0], rawProjection[1], rawProjection[2],
rawProjection[3], rawProjection[4], rawProjection[5]); rawProjection[3], rawProjection[4], rawProjection[5]);
auto corrected_matrix = s_viewportCorrection * Common::Matrix44::FromArray(g_fProjectionMatrix); auto corrected_matrix = s_viewportCorrection * Common::Matrix44::FromArray(g_fProjectionMatrix);

14
Source/Core/VideoCommon/VideoBackendBase.cpp
View File

@ -10,7 +10,7 @@
#include <string> #include <string>
#include <vector> #include <vector>
#include "fmt/format.h" #include <fmt/format.h>
#include "Common/ChunkFile.h" #include "Common/ChunkFile.h"
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
@ -163,8 +163,9 @@ u16 VideoBackendBase::Video_GetBoundingBox(int index)
static bool warn_once = true; static bool warn_once = true;
if (warn_once) if (warn_once)
{ {
ERROR_LOG(VIDEO, "BBox shall be used but it is disabled. Please use a gameini to enable it " ERROR_LOG_FMT(VIDEO,
"for this game."); "BBox shall be used but it is disabled. Please use a gameini to enable it "
"for this game.");
} }
warn_once = false; warn_once = false;
return 0; return 0;
@ -175,9 +176,10 @@ u16 VideoBackendBase::Video_GetBoundingBox(int index)
static bool warn_once = true; static bool warn_once = true;
if (warn_once) if (warn_once)
{ {
PanicAlertT("This game requires bounding box emulation to run properly but your graphics " PanicAlertFmtT(
"card or its drivers do not support it. As a result you will experience bugs or " "This game requires bounding box emulation to run properly but your graphics "
"freezes while running this game."); "card or its drivers do not support it. As a result you will experience bugs or "
"freezes while running this game.");
} }
warn_once = false; warn_once = false;
return 0; return 0;

8
Source/Core/VideoCommon/VideoCommon.h
View File

@ -20,11 +20,13 @@ constexpr u32 MAX_XFB_WIDTH = 720;
// that are next to each other in memory (TODO: handle that situation). // that are next to each other in memory (TODO: handle that situation).
constexpr u32 MAX_XFB_HEIGHT = 576; constexpr u32 MAX_XFB_HEIGHT = 576;
#define PRIM_LOG(...) DEBUG_LOG(VIDEO, ##__VA_ARGS__) #define PRIM_LOG(...) DEBUG_LOG_FMT(VIDEO, ##__VA_ARGS__)
// warning: mapping buffer should be disabled to use this // warning: mapping buffer should be disabled to use this
// #define LOG_VTX() DEBUG_LOG(VIDEO, "vtx: %f %f %f, ", ((float*)g_vertex_manager_write_ptr)[-3], // #define LOG_VTX() DEBUG_LOG_FMT(VIDEO, "vtx: {} {} {}, ",
// ((float*)g_vertex_manager_write_ptr)[-2], ((float*)g_vertex_manager_write_ptr)[-1]); // ((float*)g_vertex_manager_write_ptr)[-3],
// ((float*)g_vertex_manager_write_ptr)[-2],
// ((float*)g_vertex_manager_write_ptr)[-1]);
#define LOG_VTX() #define LOG_VTX()

6
Source/Core/VideoCommon/XFStructs.cpp
View File

@ -179,7 +179,7 @@ static void XFRegWritten(int transferSize, u32 baseAddress, DataReader src)
case 0x104d: case 0x104d:
case 0x104e: case 0x104e:
case 0x104f: case 0x104f:
DEBUG_LOG(VIDEO, "Possible Normal Mtx XF reg?: %x=%x", address, newValue); DEBUG_LOG_FMT(VIDEO, "Possible Normal Mtx XF reg?: {:x}={:x}", address, newValue);
break; break;
case 0x1013: case 0x1013:
@ -190,7 +190,7 @@ static void XFRegWritten(int transferSize, u32 baseAddress, DataReader src)
default: default:
if (newValue != 0) // Ignore writes of zero. if (newValue != 0) // Ignore writes of zero.
WARN_LOG(VIDEO, "Unknown XF Reg: %x=%x", address, newValue); WARN_LOG_FMT(VIDEO, "Unknown XF Reg: {:x}={:x}", address, newValue);
break; break;
} }
@ -207,7 +207,7 @@ void LoadXFReg(u32 transferSize, u32 baseAddress, DataReader src)
// do not allow writes past registers // do not allow writes past registers
if (baseAddress + transferSize > 0x1058) if (baseAddress + transferSize > 0x1058)
{ {
WARN_LOG(VIDEO, "XF load exceeds address space: %x %d bytes", baseAddress, transferSize); WARN_LOG_FMT(VIDEO, "XF load exceeds address space: {:x} {} bytes", baseAddress, transferSize);
if (baseAddress >= 0x1058) if (baseAddress >= 0x1058)
transferSize = 0; transferSize = 0;