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

SmallString: Add missing methods 

Backport of
79c226efff
2cd747983a
6b7cf6a432
f75a5605eb
This commit is contained in:
Stenzek 2024-04-12 23:24:20 +10:00 committed by Connor McLaughlin
parent ece20b1307
commit 9fa409a1a9
19 changed files with 404 additions and 221 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
common/Console.cpp
View File

@ -103,7 +103,7 @@ __ri void Log::WriteToConsole(LOGLEVEL level, ConsoleColors color, std::string_v
buffer.append(s_ansi_color_codes[color]); buffer.append(s_ansi_color_codes[color]);
if (s_log_timestamps) if (s_log_timestamps)
buffer.append_fmt(TIMESTAMP_FORMAT_STRING, Log::GetCurrentMessageTime()); buffer.append_format(TIMESTAMP_FORMAT_STRING, Log::GetCurrentMessageTime());
buffer.append(message); buffer.append(message);
buffer.append('\n'); buffer.append('\n');
@ -352,7 +352,7 @@ bool Log::SetFileOutputLevel(LOGLEVEL level, std::string path)
s_file_path = {}; s_file_path = {};
if (IsConsoleOutputEnabled()) if (IsConsoleOutputEnabled())
WriteToConsole(LOGLEVEL_ERROR, Color_StrongRed, TinyString::from_fmt("Failed to open log file '{}'", path)); WriteToConsole(LOGLEVEL_ERROR, Color_StrongRed, TinyString::from_format("Failed to open log file '{}'", path));
} }
} }
} }

2
common/DynamicLibrary.cpp
View File

@ -82,7 +82,7 @@ bool DynamicLibrary::Open(const char* filename, Error* error)
m_handle = reinterpret_cast<void*>(LoadLibraryW(StringUtil::UTF8StringToWideString(filename).c_str())); m_handle = reinterpret_cast<void*>(LoadLibraryW(StringUtil::UTF8StringToWideString(filename).c_str()));
if (!m_handle) if (!m_handle)
{ {
Error::SetWin32(error, TinyString::from_fmt("Loading {} failed: ", filename), GetLastError()); Error::SetWin32(error, TinyString::from_format("Loading {} failed: ", filename), GetLastError());
return false; return false;
} }

203
common/SmallString.cpp
View File

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: 2002-2023 PCSX2 Dev Team // SPDX-FileCopyrightText: 2002-2024 PCSX2 Dev Team
// SPDX-License-Identifier: LGPL-3.0+ // SPDX-License-Identifier: LGPL-3.0+
#include "SmallString.h" #include "SmallString.h"
@ -39,12 +39,12 @@ SmallStringBase::SmallStringBase(SmallStringBase&& move)
assign(std::move(move)); assign(std::move(move));
} }
SmallStringBase::SmallStringBase(const std::string_view& sv) SmallStringBase::SmallStringBase(const std::string_view sv)
{ {
assign(sv); assign(sv);
} }
SmallStringBase::SmallStringBase(const std::string& str) SmallStringBase::SmallStringBase(const std::string& str)
{ {
assign(str); assign(str);
} }
@ -89,7 +89,7 @@ void SmallStringBase::reserve(u32 new_reserve)
m_on_heap = true; m_on_heap = true;
} }
m_buffer_size = real_reserve; m_buffer_size = new_reserve;
} }
void SmallStringBase::shrink_to_fit() void SmallStringBase::shrink_to_fit()
@ -125,7 +125,7 @@ SmallStringBase& SmallStringBase::operator=(SmallStringBase&& move)
return *this; return *this;
} }
SmallStringBase& SmallStringBase::operator=(const std::string_view& str) SmallStringBase& SmallStringBase::operator=(const std::string_view str)
{ {
assign(str); assign(str);
return *this; return *this;
@ -172,6 +172,18 @@ void SmallStringBase::append(const char* str, u32 length)
m_buffer[m_length] = 0; m_buffer[m_length] = 0;
} }
void SmallStringBase::append_hex(const void* data, size_t len)
{
if (len == 0)
return;
make_room_for(static_cast<u32>(len) * 4);
const u8* bytes = static_cast<const u8*>(data);
append_format("{:02X}", bytes[0]);
for (size_t i = 1; i < len; i++)
append_format(", {:02X}", bytes[i]);
}
void SmallStringBase::prepend(const char* str, u32 length) void SmallStringBase::prepend(const char* str, u32 length)
{ {
if (length == 0) if (length == 0)
@ -207,27 +219,27 @@ void SmallStringBase::append(const std::string& str)
append(str.c_str(), static_cast<u32>(str.length())); append(str.c_str(), static_cast<u32>(str.length()));
} }
void SmallStringBase::append(const std::string_view& str) void SmallStringBase::append(const std::string_view str)
{ {
append(str.data(), static_cast<u32>(str.length())); append(str.data(), static_cast<u32>(str.length()));
} }
void SmallStringBase::append_format(const char* format, ...) void SmallStringBase::append_sprintf(const char* format, ...)
{ {
std::va_list ap; std::va_list ap;
va_start(ap, format); va_start(ap, format);
append_format_va(format, ap); append_vsprintf(format, ap);
va_end(ap); va_end(ap);
} }
void SmallStringBase::append_format_va(const char* format, va_list ap) void SmallStringBase::append_vsprintf(const char* format, va_list ap)
{ {
// We have a 1KB byte buffer on the stack here. If this is too little, we'll grow it via the heap, // We have a 1KB byte buffer on the stack here. If this is too little, we'll grow it via the heap,
// but 1KB should be enough for most strings. // but 1KB should be enough for most strings.
char stack_buffer[1024]; char stack_buffer[1024];
char* heap_buffer = nullptr; char* heap_buffer = nullptr;
char* buffer = stack_buffer; char* buffer = stack_buffer;
u32 buffer_size = std::size(stack_buffer); u32 buffer_size = static_cast<u32>(std::size(stack_buffer));
u32 written; u32 written;
for (;;) for (;;)
@ -273,27 +285,27 @@ void SmallStringBase::prepend(const std::string& str)
prepend(str.c_str(), static_cast<u32>(str.length())); prepend(str.c_str(), static_cast<u32>(str.length()));
} }
void SmallStringBase::prepend(const std::string_view& str) void SmallStringBase::prepend(const std::string_view str)
{ {
prepend(str.data(), static_cast<u32>(str.length())); prepend(str.data(), static_cast<u32>(str.length()));
} }
void SmallStringBase::prepend_format(const char* format, ...) void SmallStringBase::prepend_sprintf(const char* format, ...)
{ {
va_list ap; va_list ap;
va_start(ap, format); va_start(ap, format);
prepend_format_va(format, ap); prepend_vsprintf(format, ap);
va_end(ap); va_end(ap);
} }
void SmallStringBase::prepend_format_va(const char* format, va_list ArgPtr) void SmallStringBase::prepend_vsprintf(const char* format, va_list ArgPtr)
{ {
// We have a 1KB byte buffer on the stack here. If this is too little, we'll grow it via the heap, // We have a 1KB byte buffer on the stack here. If this is too little, we'll grow it via the heap,
// but 1KB should be enough for most strings. // but 1KB should be enough for most strings.
char stack_buffer[1024]; char stack_buffer[1024];
char* heap_buffer = NULL; char* heap_buffer = NULL;
char* buffer = stack_buffer; char* buffer = stack_buffer;
u32 buffer_size = std::size(stack_buffer); u32 buffer_size = static_cast<u32>(std::size(stack_buffer));
u32 written; u32 written;
for (;;) for (;;)
@ -359,23 +371,23 @@ void SmallStringBase::insert(s32 offset, const std::string& str)
insert(offset, str.c_str(), static_cast<u32>(str.size())); insert(offset, str.c_str(), static_cast<u32>(str.size()));
} }
void SmallStringBase::insert(s32 offset, const std::string_view& str) void SmallStringBase::insert(s32 offset, const std::string_view str)
{ {
insert(offset, str.data(), static_cast<u32>(str.size())); insert(offset, str.data(), static_cast<u32>(str.size()));
} }
void SmallStringBase::format(const char* format, ...) void SmallStringBase::sprintf(const char* format, ...)
{ {
va_list ap; va_list ap;
va_start(ap, format); va_start(ap, format);
format_va(format, ap); vsprintf(format, ap);
va_end(ap); va_end(ap);
} }
void SmallStringBase::format_va(const char* format, va_list ap) void SmallStringBase::vsprintf(const char* format, va_list ap)
{ {
clear(); clear();
append_format_va(format, ap); append_vsprintf(format, ap);
} }
void SmallStringBase::assign(const SmallStringBase& copy) void SmallStringBase::assign(const SmallStringBase& copy)
@ -421,12 +433,18 @@ void SmallStringBase::assign(const std::string& str)
append(str.data(), static_cast<u32>(str.size())); append(str.data(), static_cast<u32>(str.size()));
} }
void SmallStringBase::assign(const std::string_view& str) void SmallStringBase::assign(const std::string_view str)
{ {
clear(); clear();
append(str.data(), static_cast<u32>(str.size())); append(str.data(), static_cast<u32>(str.size()));
} }
void SmallStringBase::vformat(fmt::string_view fmt, fmt::format_args args)
{
clear();
fmt::vformat_to(std::back_inserter(*this), fmt, args);
}
bool SmallStringBase::equals(const char* str) const bool SmallStringBase::equals(const char* str) const
{ {
if (m_length == 0) if (m_length == 0)
@ -440,10 +458,16 @@ bool SmallStringBase::equals(const SmallStringBase& str) const
return (m_length == str.m_length && (m_length == 0 || std::strcmp(m_buffer, str.m_buffer) == 0)); return (m_length == str.m_length && (m_length == 0 || std::strcmp(m_buffer, str.m_buffer) == 0));
} }
bool SmallStringBase::equals(const std::string_view& str) const bool SmallStringBase::equals(const std::string_view str) const
{ {
return (m_length == static_cast<u32>(str.length()) && return (m_length == static_cast<u32>(str.length()) &&
(m_length == 0 || CASE_N_COMPARE(m_buffer, str.data(), m_length) == 0)); (m_length == 0 || std::memcmp(m_buffer, str.data(), m_length) == 0));
}
bool SmallStringBase::equals(const std::string& str) const
{
return (m_length == static_cast<u32>(str.length()) &&
(m_length == 0 || std::memcmp(m_buffer, str.data(), m_length) == 0));
} }
bool SmallStringBase::iequals(const char* otherText) const bool SmallStringBase::iequals(const char* otherText) const
@ -459,30 +483,114 @@ bool SmallStringBase::iequals(const SmallStringBase& str) const
return (m_length == str.m_length && (m_length == 0 || std::strcmp(m_buffer, str.m_buffer) == 0)); return (m_length == str.m_length && (m_length == 0 || std::strcmp(m_buffer, str.m_buffer) == 0));
} }
bool SmallStringBase::iequals(const std::string_view& str) const bool SmallStringBase::iequals(const std::string_view str) const
{ {
return (m_length == static_cast<u32>(str.length()) && return (m_length == static_cast<u32>(str.length()) &&
(m_length == 0 || CASE_N_COMPARE(m_buffer, str.data(), m_length) == 0)); (m_length == 0 || CASE_N_COMPARE(m_buffer, str.data(), m_length) == 0));
} }
int SmallStringBase::compare(const SmallStringBase& str) const bool SmallStringBase::iequals(const std::string& str) const
{ {
return std::strcmp(m_buffer, str.m_buffer); return (m_length == static_cast<u32>(str.length()) &&
(m_length == 0 || CASE_N_COMPARE(m_buffer, str.data(), m_length) == 0));
} }
int SmallStringBase::compare(const char* otherText) const int SmallStringBase::compare(const char* otherText) const
{ {
return std::strcmp(m_buffer, otherText); return compare(std::string_view(otherText));
} }
int SmallStringBase::icompare(const SmallStringBase& otherString) const int SmallStringBase::compare(const SmallStringBase& str) const
{ {
return CASE_COMPARE(m_buffer, otherString.m_buffer); if (m_length == 0)
return (str.m_length == 0) ? 0 : -1;
else if (str.m_length == 0)
return 1;
const int res = std::strncmp(m_buffer, str.m_buffer, std::min(m_length, str.m_length));
if (m_length == str.m_length || res != 0)
return res;
else
return (m_length > str.m_length) ? 1 : -1;
}
int SmallStringBase::compare(const std::string_view str) const
{
const u32 slength = static_cast<u32>(str.length());
if (m_length == 0)
return (slength == 0) ? 0 : -1;
else if (slength == 0)
return 1;
const int res = std::strncmp(m_buffer, str.data(), std::min(m_length, slength));
if (m_length == slength || res != 0)
return res;
else
return (m_length > slength) ? 1 : -1;
}
int SmallStringBase::compare(const std::string& str) const
{
const u32 slength = static_cast<u32>(str.length());
if (m_length == 0)
return (slength == 0) ? 0 : -1;
else if (slength == 0)
return 1;
const int res = std::strncmp(m_buffer, str.data(), std::min(m_length, slength));
if (m_length == slength || res != 0)
return res;
else
return (m_length > slength) ? 1 : -1;
} }
int SmallStringBase::icompare(const char* otherText) const int SmallStringBase::icompare(const char* otherText) const
{ {
return CASE_COMPARE(m_buffer, otherText); return icompare(std::string_view(otherText));
}
int SmallStringBase::icompare(const SmallStringBase& str) const
{
if (m_length == 0)
return (str.m_length == 0) ? 0 : -1;
else if (str.m_length == 0)
return 1;
const int res = CASE_N_COMPARE(m_buffer, str.m_buffer, std::min(m_length, str.m_length));
if (m_length == str.m_length || res != 0)
return res;
else
return (m_length > str.m_length) ? 1 : -1;
}
int SmallStringBase::icompare(const std::string_view str) const
{
const u32 slength = static_cast<u32>(str.length());
if (m_length == 0)
return (slength == 0) ? 0 : -1;
else if (slength == 0)
return 1;
const int res = CASE_N_COMPARE(m_buffer, str.data(), std::min(m_length, slength));
if (m_length == slength || res != 0)
return res;
else
return (m_length > slength) ? 1 : -1;
}
int SmallStringBase::icompare(const std::string& str) const
{
const u32 slength = static_cast<u32>(str.length());
if (m_length == 0)
return (slength == 0) ? 0 : -1;
else if (slength == 0)
return 1;
const int res = CASE_N_COMPARE(m_buffer, str.data(), std::min(m_length, slength));
if (m_length == slength || res != 0)
return res;
else
return (m_length > slength) ? 1 : -1;
} }
bool SmallStringBase::starts_with(const char* str, bool case_sensitive) const bool SmallStringBase::starts_with(const char* str, bool case_sensitive) const
@ -505,7 +613,17 @@ bool SmallStringBase::starts_with(const SmallStringBase& str, bool case_sensitiv
(CASE_N_COMPARE(str.m_buffer, m_buffer, other_length) == 0); (CASE_N_COMPARE(str.m_buffer, m_buffer, other_length) == 0);
} }
bool SmallStringBase::starts_with(const std::string_view& str, bool case_sensitive) const bool SmallStringBase::starts_with(const std::string_view str, bool case_sensitive) const
{
const u32 other_length = static_cast<u32>(str.length());
if (other_length > m_length)
return false;
return (case_sensitive) ? (std::strncmp(str.data(), m_buffer, other_length) == 0) :
(CASE_N_COMPARE(str.data(), m_buffer, other_length) == 0);
}
bool SmallStringBase::starts_with(const std::string& str, bool case_sensitive) const
{ {
const u32 other_length = static_cast<u32>(str.length()); const u32 other_length = static_cast<u32>(str.length());
if (other_length > m_length) if (other_length > m_length)
@ -537,7 +655,18 @@ bool SmallStringBase::ends_with(const SmallStringBase& str, bool case_sensitive)
(CASE_N_COMPARE(str.m_buffer, m_buffer + start_offset, other_length) == 0); (CASE_N_COMPARE(str.m_buffer, m_buffer + start_offset, other_length) == 0);
} }
bool SmallStringBase::ends_with(const std::string_view& str, bool case_sensitive) const bool SmallStringBase::ends_with(const std::string_view str, bool case_sensitive) const
{
const u32 other_length = static_cast<u32>(str.length());
if (other_length > m_length)
return false;
const u32 start_offset = m_length - other_length;
return (case_sensitive) ? (std::strncmp(str.data(), m_buffer + start_offset, other_length) == 0) :
(CASE_N_COMPARE(str.data(), m_buffer + start_offset, other_length) == 0);
}
bool SmallStringBase::ends_with(const std::string& str, bool case_sensitive) const
{ {
const u32 other_length = static_cast<u32>(str.length()); const u32 other_length = static_cast<u32>(str.length());
if (other_length > m_length) if (other_length > m_length)
@ -589,6 +718,16 @@ s32 SmallStringBase::find(const char* str, u32 offset) const
return at ? static_cast<s32>(at - m_buffer) : -1; return at ? static_cast<s32>(at - m_buffer) : -1;
} }
u32 SmallStringBase::count(char ch) const
{
const char* ptr = m_buffer;
const char* end = ptr + m_length;
u32 count = 0;
while (ptr != end)
count += static_cast<u32>(*(ptr++) == ch);
return count;
}
void SmallStringBase::resize(u32 new_size, char fill, bool shrink_if_smaller) void SmallStringBase::resize(u32 new_size, char fill, bool shrink_if_smaller)
{ {
// if going larger, or we don't own the buffer, realloc // if going larger, or we don't own the buffer, realloc

146
common/SmallString.h
View File

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: 2002-2023 PCSX2 Dev Team // SPDX-FileCopyrightText: 2002-2024 PCSX2 Dev Team
// SPDX-License-Identifier: LGPL-3.0+ // SPDX-License-Identifier: LGPL-3.0+
#pragma once #pragma once
@ -29,7 +29,7 @@ public:
SmallStringBase(const SmallStringBase& copy); SmallStringBase(const SmallStringBase& copy);
SmallStringBase(SmallStringBase&& move); SmallStringBase(SmallStringBase&& move);
SmallStringBase(const std::string& str); SmallStringBase(const std::string& str);
SmallStringBase(const std::string_view& sv); SmallStringBase(const std::string_view sv);
// Destructor. Child classes may not have any destructors, as this is not virtual. // Destructor. Child classes may not have any destructors, as this is not virtual.
~SmallStringBase(); ~SmallStringBase();
@ -38,7 +38,7 @@ public:
void assign(const char* str); void assign(const char* str);
void assign(const char* str, u32 length); void assign(const char* str, u32 length);
void assign(const std::string& copy); void assign(const std::string& copy);
void assign(const std::string_view& copy); void assign(const std::string_view copy);
void assign(const SmallStringBase& copy); void assign(const SmallStringBase& copy);
void assign(SmallStringBase&& move); void assign(SmallStringBase&& move);
@ -55,15 +55,18 @@ public:
void append(const char* appendText); void append(const char* appendText);
void append(const char* str, u32 length); void append(const char* str, u32 length);
void append(const std::string& str); void append(const std::string& str);
void append(const std::string_view& str); void append(const std::string_view str);
void append(const SmallStringBase& str); void append(const SmallStringBase& str);
// append formatted string to this string // append formatted string to this string
void append_format(const char* format, ...) /*printflike(2, 3)*/; void append_sprintf(const char* format, ...) /*printflike(2, 3)*/;
void append_format_va(const char* format, va_list ap); void append_vsprintf(const char* format, va_list ap);
template <typename... T> template <typename... T>
void append_fmt(fmt::format_string<T...> fmt, T&&... args); void append_format(fmt::format_string<T...> fmt, T&&... args);
// append hex string
void append_hex(const void* data, size_t len);
// append a single character to this string // append a single character to this string
void prepend(char c); void prepend(char c);
@ -72,53 +75,61 @@ public:
void prepend(const char* str); void prepend(const char* str);
void prepend(const char* str, u32 length); void prepend(const char* str, u32 length);
void prepend(const std::string& str); void prepend(const std::string& str);
void prepend(const std::string_view& str); void prepend(const std::string_view str);
void prepend(const SmallStringBase& str); void prepend(const SmallStringBase& str);
// append formatted string to this string // append formatted string to this string
void prepend_format(const char* format, ...) /*printflike(2, 3)*/; void prepend_sprintf(const char* format, ...) /*printflike(2, 3)*/;
void prepend_format_va(const char* format, va_list ap); void prepend_vsprintf(const char* format, va_list ap);
template <typename... T> template <typename... T>
void prepend_fmt(fmt::format_string<T...> fmt, T&&... args); void prepend_format(fmt::format_string<T...> fmt, T&&... args);
// insert a string at the specified offset // insert a string at the specified offset
void insert(s32 offset, const char* str); void insert(s32 offset, const char* str);
void insert(s32 offset, const char* str, u32 length); void insert(s32 offset, const char* str, u32 length);
void insert(s32 offset, const std::string& str); void insert(s32 offset, const std::string& str);
void insert(s32 offset, const std::string_view& str); void insert(s32 offset, const std::string_view str);
void insert(s32 offset, const SmallStringBase& str); void insert(s32 offset, const SmallStringBase& str);
// set to formatted string // set to formatted string
void format(const char* format, ...) /*printflike(2, 3)*/; void sprintf(const char* format, ...) /*printflike(2, 3)*/;
void format_va(const char* format, va_list ap); void vsprintf(const char* format, va_list ap);
template <typename... T> template <typename... T>
void fmt(fmt::format_string<T...> fmt, T&&... args); void format(fmt::format_string<T...> fmt, T&&... args);
void vformat(fmt::string_view fmt, fmt::format_args args);
// compare one string to another // compare one string to another
bool equals(const char* str) const; bool equals(const char* str) const;
bool equals(const SmallStringBase& str) const; bool equals(const SmallStringBase& str) const;
bool equals(const std::string_view& str) const; bool equals(const std::string_view str) const;
bool equals(const std::string& str) const;
bool iequals(const char* str) const; bool iequals(const char* str) const;
bool iequals(const SmallStringBase& str) const; bool iequals(const SmallStringBase& str) const;
bool iequals(const std::string_view& str) const; bool iequals(const std::string_view str) const;
bool iequals(const std::string& str) const;
// numerical compares // numerical compares
int compare(const char* str) const; int compare(const char* str) const;
int compare(const SmallStringBase& str) const; int compare(const SmallStringBase& str) const;
int compare(const std::string_view& str) const; int compare(const std::string_view str) const;
int compare(const std::string& str) const;
int icompare(const char* str) const; int icompare(const char* str) const;
int icompare(const SmallStringBase& str) const; int icompare(const SmallStringBase& str) const;
int icompare(const std::string_view& str) const; int icompare(const std::string_view str) const;
int icompare(const std::string& str) const;
// starts with / ends with // starts with / ends with
bool starts_with(const char* str, bool case_sensitive = true) const; bool starts_with(const char* str, bool case_sensitive = true) const;
bool starts_with(const std::string_view& str, bool case_sensitive = true) const;
bool starts_with(const SmallStringBase& str, bool case_sensitive = true) const; bool starts_with(const SmallStringBase& str, bool case_sensitive = true) const;
bool starts_with(const std::string_view str, bool case_sensitive = true) const;
bool starts_with(const std::string& str, bool case_sensitive = true) const;
bool ends_with(const char* str, bool case_sensitive = true) const; bool ends_with(const char* str, bool case_sensitive = true) const;
bool ends_with(const std::string_view& str, bool case_sensitive = true) const;
bool ends_with(const SmallStringBase& str, bool case_sensitive = true) const; bool ends_with(const SmallStringBase& str, bool case_sensitive = true) const;
bool ends_with(const std::string_view str, bool case_sensitive = true) const;
bool ends_with(const std::string& str, bool case_sensitive = true) const;
// searches for a character inside a string // searches for a character inside a string
// rfind is the same except it starts at the end instead of the start // rfind is the same except it starts at the end instead of the start
@ -131,6 +142,9 @@ public:
// returns -1 if it is not found, otherwise the offset in the string // returns -1 if it is not found, otherwise the offset in the string
s32 find(const char* str, u32 offset = 0) const; s32 find(const char* str, u32 offset = 0) const;
// returns the number of instances of the specified character
u32 count(char ch) const;
// removes characters from string // removes characters from string
void erase(s32 offset, s32 count = std::numeric_limits<s32>::max()); void erase(s32 offset, s32 count = std::numeric_limits<s32>::max());
@ -179,21 +193,25 @@ public:
// comparative operators // comparative operators
__fi bool operator==(const char* str) const { return equals(str); } __fi bool operator==(const char* str) const { return equals(str); }
__fi bool operator==(const SmallStringBase& str) const { return equals(str); } __fi bool operator==(const SmallStringBase& str) const { return equals(str); }
__fi bool operator==(const std::string_view& str) const { return equals(str); } __fi bool operator==(const std::string_view str) const { return equals(str); }
__fi bool operator==(const std::string& str) const { return equals(str); }
__fi bool operator!=(const char* str) const { return !equals(str); } __fi bool operator!=(const char* str) const { return !equals(str); }
__fi bool operator!=(const SmallStringBase& str) const { return !equals(str); } __fi bool operator!=(const SmallStringBase& str) const { return !equals(str); }
__fi bool operator!=(const std::string_view& str) const { return !equals(str); } __fi bool operator!=(const std::string_view str) const { return !equals(str); }
__fi bool operator!=(const std::string& str) const { return !equals(str); }
__fi bool operator<(const char* str) const { return (compare(str) < 0); } __fi bool operator<(const char* str) const { return (compare(str) < 0); }
__fi bool operator<(const SmallStringBase& str) const { return (compare(str) < 0); } __fi bool operator<(const SmallStringBase& str) const { return (compare(str) < 0); }
__fi bool operator<(const std::string_view& str) const { return (compare(str) < 0); } __fi bool operator<(const std::string_view str) const { return (compare(str) < 0); }
__fi bool operator<(const std::string& str) const { return (compare(str) < 0); }
__fi bool operator>(const char* str) const { return (compare(str) > 0); } __fi bool operator>(const char* str) const { return (compare(str) > 0); }
__fi bool operator>(const SmallStringBase& str) const { return (compare(str) > 0); } __fi bool operator>(const SmallStringBase& str) const { return (compare(str) > 0); }
__fi bool operator>(const std::string_view& str) const { return (compare(str) > 0); } __fi bool operator>(const std::string_view str) const { return (compare(str) > 0); }
__fi bool operator>(const std::string& str) const { return (compare(str) > 0); }
SmallStringBase& operator=(const SmallStringBase& copy); SmallStringBase& operator=(const SmallStringBase& copy);
SmallStringBase& operator=(const char* str); SmallStringBase& operator=(const char* str);
SmallStringBase& operator=(const std::string& str); SmallStringBase& operator=(const std::string& str);
SmallStringBase& operator=(const std::string_view& str); SmallStringBase& operator=(const std::string_view str);
SmallStringBase& operator=(SmallStringBase&& move); SmallStringBase& operator=(SmallStringBase&& move);
protected: protected:
@ -253,7 +271,7 @@ public:
assign(move); assign(move);
} }
__fi SmallStackString(const std::string_view& sv) __fi SmallStackString(const std::string_view sv)
{ {
init(); init();
assign(sv); assign(sv);
@ -283,7 +301,7 @@ public:
return *this; return *this;
} }
__fi SmallStackString& operator=(const std::string_view& sv) __fi SmallStackString& operator=(const std::string_view sv)
{ {
assign(sv); assign(sv);
return *this; return *this;
@ -296,26 +314,12 @@ public:
} }
// Override the fromstring method // Override the fromstring method
__fi static SmallStackString from_format(const char* format, ...) /*printflike(1, 2)*/ static SmallStackString from_sprintf(const char* format, ...) /*printflike(1, 2)*/;
{
std::va_list ap;
va_start(ap, format);
SmallStackString ret;
ret.format_va(format, ap);
va_end(ap);
return ret;
}
template <typename... T> template <typename... T>
__fi static SmallStackString from_fmt(fmt::format_string<T...> fmt, T&&... args) static SmallStackString from_format(fmt::format_string<T...> fmt, T&&... args);
{
SmallStackString ret; static SmallStackString from_vformat(fmt::string_view fmt, fmt::format_args args);
fmt::vformat_to(std::back_inserter(ret), fmt, fmt::make_format_args(args...));
return ret;
}
private: private:
char m_stack_buffer[L + 1]; char m_stack_buffer[L + 1];
@ -333,18 +337,54 @@ private:
} }
}; };
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4459) // warning C4459: declaration of 'uint' hides global declaration
#endif
template <u32 L>
__fi SmallStackString<L> SmallStackString<L>::from_sprintf(const char* format, ...)
{
std::va_list ap;
va_start(ap, format);
SmallStackString ret;
ret.vsprintf(format, ap);
va_end(ap);
return ret;
}
template <u32 L>
template <typename... T>
__fi SmallStackString<L> SmallStackString<L>::from_format(fmt::format_string<T...> fmt, T&&... args)
{
SmallStackString<L> ret;
fmt::vformat_to(std::back_inserter(ret), fmt, fmt::make_format_args(args...));
return ret;
}
template <u32 L>
__fi SmallStackString<L> SmallStackString<L>::from_vformat(fmt::string_view fmt, fmt::format_args args)
{
SmallStackString<L> ret;
fmt::vformat_to(std::back_inserter(ret), fmt, args);
return ret;
}
// stack string types // stack string types
typedef SmallStackString<64> TinyString; using TinyString = SmallStackString<64>;
typedef SmallStackString<256> SmallString; using SmallString = SmallStackString<256>;
template <typename... T> template <typename... T>
__fi void SmallStringBase::append_fmt(fmt::format_string<T...> fmt, T&&... args) __fi void SmallStringBase::append_format(fmt::format_string<T...> fmt, T&&... args)
{ {
fmt::vformat_to(std::back_inserter(*this), fmt, fmt::make_format_args(args...)); fmt::vformat_to(std::back_inserter(*this), fmt, fmt::make_format_args(args...));
} }
template <typename... T> template <typename... T>
__fi void SmallStringBase::prepend_fmt(fmt::format_string<T...> fmt, T&&... args) __fi void SmallStringBase::prepend_format(fmt::format_string<T...> fmt, T&&... args)
{ {
TinyString str; TinyString str;
fmt::vformat_to(std::back_inserter(str), fmt, fmt::make_format_args(args...)); fmt::vformat_to(std::back_inserter(str), fmt, fmt::make_format_args(args...));
@ -352,12 +392,16 @@ __fi void SmallStringBase::prepend_fmt(fmt::format_string<T...> fmt, T&&... args
} }
template <typename... T> template <typename... T>
__fi void SmallStringBase::fmt(fmt::format_string<T...> fmt, T&&... args) __fi void SmallStringBase::format(fmt::format_string<T...> fmt, T&&... args)
{ {
clear(); clear();
fmt::vformat_to(std::back_inserter(*this), fmt, fmt::make_format_args(args...)); fmt::vformat_to(std::back_inserter(*this), fmt, fmt::make_format_args(args...));
} }
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#define MAKE_FORMATTER(type) \ #define MAKE_FORMATTER(type) \
template <> \ template <> \
struct fmt::formatter<type> \ struct fmt::formatter<type> \

4
pcsx2-qt/AboutDialog.cpp
View File

@ -24,11 +24,11 @@ static QString GetDocFileUrl(std::string_view name)
#ifdef _WIN32 #ifdef _WIN32
// Windows uses the docs directory in bin. // Windows uses the docs directory in bin.
const std::string path = Path::Combine(EmuFolders::AppRoot, const std::string path = Path::Combine(EmuFolders::AppRoot,
TinyString::from_fmt("docs" FS_OSPATH_SEPARATOR_STR "{}", name)); TinyString::from_format("docs" FS_OSPATH_SEPARATOR_STR "{}", name));
#else #else
// Linux/Mac has this in the Resources directory. // Linux/Mac has this in the Resources directory.
const std::string path = Path::Combine(EmuFolders::Resources, const std::string path = Path::Combine(EmuFolders::Resources,
TinyString::from_fmt("docs" FS_OSPATH_SEPARATOR_STR "{}", name)); TinyString::from_format("docs" FS_OSPATH_SEPARATOR_STR "{}", name));
#endif #endif
return QUrl::fromLocalFile(QString::fromStdString(path)).toString(); return QUrl::fromLocalFile(QString::fromStdString(path)).toString();
} }

4
pcsx2-qt/Translations.cpp
View File

@ -308,14 +308,14 @@ void QtHost::UpdateGlyphRangesAndClearCache(QWidget* dialog_parent, const std::s
{ {
// Non-standard fonts always go to the user resources directory, since they're downloaded on demand. // Non-standard fonts always go to the user resources directory, since they're downloaded on demand.
font_path = Path::Combine(EmuFolders::UserResources, font_path = Path::Combine(EmuFolders::UserResources,
SmallString::from_fmt("fonts" FS_OSPATH_SEPARATOR_STR "{}", imgui_font_name)); SmallString::from_format("fonts" FS_OSPATH_SEPARATOR_STR "{}", imgui_font_name));
if (!DownloadMissingFont(dialog_parent, imgui_font_name, font_path)) if (!DownloadMissingFont(dialog_parent, imgui_font_name, font_path))
font_path.clear(); font_path.clear();
} }
if (font_path.empty()) if (font_path.empty())
{ {
// Use the default font. // Use the default font.
font_path = EmuFolders::GetOverridableResourcePath(SmallString::from_fmt( font_path = EmuFolders::GetOverridableResourcePath(SmallString::from_format(
"fonts" FS_OSPATH_SEPARATOR_STR "{}", DEFAULT_IMGUI_FONT_NAME)); "fonts" FS_OSPATH_SEPARATOR_STR "{}", DEFAULT_IMGUI_FONT_NAME));
} }

24
pcsx2/Achievements.cpp
View File

@ -262,7 +262,7 @@ void Achievements::ReportRCError(int err, fmt::format_string<T...> fmt, T&&... a
{ {
SmallString str; SmallString str;
fmt::vformat_to(std::back_inserter(str), fmt, fmt::make_format_args(args...)); fmt::vformat_to(std::back_inserter(str), fmt, fmt::make_format_args(args...));
str.append_fmt("{} ({})", rc_error_str(err), err); str.append_format("{} ({})", rc_error_str(err), err);
ReportError(str); ReportError(str);
} }
@ -1560,7 +1560,7 @@ std::string Achievements::GetAchievementBadgePath(const rc_client_achievement_t*
return path; return path;
path = Path::Combine(s_image_directory, path = Path::Combine(s_image_directory,
TinyString::from_fmt("achievement_{}_{}_{}.png", s_game_id, achievement->id, s_achievement_state_strings[state])); TinyString::from_format("achievement_{}_{}_{}.png", s_game_id, achievement->id, s_achievement_state_strings[state]));
if (!FileSystem::FileExists(path.c_str())) if (!FileSystem::FileExists(path.c_str()))
{ {
@ -1581,7 +1581,7 @@ std::string Achievements::GetUserBadgePath(const std::string_view& username)
std::string path; std::string path;
const std::string clean_username = Path::SanitizeFileName(username); const std::string clean_username = Path::SanitizeFileName(username);
if (!clean_username.empty()) if (!clean_username.empty())
path = Path::Combine(s_image_directory, TinyString::from_fmt("user_{}.png", clean_username)); path = Path::Combine(s_image_directory, TinyString::from_format("user_{}.png", clean_username));
return path; return path;
} }
@ -2188,12 +2188,12 @@ void Achievements::DrawAchievementsWindow()
{ {
if (s_game_summary.num_unlocked_achievements == s_game_summary.num_core_achievements) if (s_game_summary.num_unlocked_achievements == s_game_summary.num_core_achievements)
{ {
text.fmt(TRANSLATE_FS("Achievements", "You have unlocked all achievements and earned {} points!"), text.format(TRANSLATE_FS("Achievements", "You have unlocked all achievements and earned {} points!"),
s_game_summary.points_unlocked); s_game_summary.points_unlocked);
} }
else else
{ {
text.fmt(TRANSLATE_FS("Achievements", "You have unlocked {0} of {1} achievements, earning {2} of {3} possible points."), text.format(TRANSLATE_FS("Achievements", "You have unlocked {0} of {1} achievements, earning {2} of {3} possible points."),
s_game_summary.num_unlocked_achievements, s_game_summary.num_core_achievements, s_game_summary.points_unlocked, s_game_summary.num_unlocked_achievements, s_game_summary.num_core_achievements, s_game_summary.points_unlocked,
s_game_summary.points_core); s_game_summary.points_core);
} }
@ -2220,7 +2220,7 @@ void Achievements::DrawAchievementsWindow()
dl->AddRectFilled(progress_bb.Min, ImVec2(progress_bb.Min.x + fraction * progress_bb.GetWidth(), progress_bb.Max.y), dl->AddRectFilled(progress_bb.Min, ImVec2(progress_bb.Min.x + fraction * progress_bb.GetWidth(), progress_bb.Max.y),
ImGui::GetColorU32(ImGuiFullscreen::UISecondaryColor)); ImGui::GetColorU32(ImGuiFullscreen::UISecondaryColor));
text.fmt("{}%", static_cast<int>(std::round(fraction * 100.0f))); text.format("{}%", static_cast<int>(std::round(fraction * 100.0f)));
text_size = ImGui::CalcTextSize(text.c_str(), text.end_ptr()); text_size = ImGui::CalcTextSize(text.c_str(), text.end_ptr());
const ImVec2 text_pos(progress_bb.Min.x + ((progress_bb.Max.x - progress_bb.Min.x) / 2.0f) - (text_size.x / 2.0f), const ImVec2 text_pos(progress_bb.Min.x + ((progress_bb.Max.x - progress_bb.Min.x) / 2.0f) - (text_size.x / 2.0f),
progress_bb.Min.y + ((progress_bb.Max.y - progress_bb.Min.y) / 2.0f) - (text_size.y / 2.0f)); progress_bb.Min.y + ((progress_bb.Max.y - progress_bb.Min.y) / 2.0f) - (text_size.y / 2.0f));
@ -2312,7 +2312,7 @@ void Achievements::DrawAchievement(const rc_client_achievement_t* cheevo)
ImRect bb; ImRect bb;
bool visible, hovered; bool visible, hovered;
ImGuiFullscreen::MenuButtonFrame(TinyString::from_fmt("chv_{}", cheevo->id), true, ImGuiFullscreen::MenuButtonFrame(TinyString::from_format("chv_{}", cheevo->id), true,
!is_measured ? ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT + extra_summary_height + unlock_size : !is_measured ? ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT + extra_summary_height + unlock_size :
ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT + extra_summary_height + progress_height_unscaled + progress_spacing_unscaled, ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT + extra_summary_height + progress_height_unscaled + progress_spacing_unscaled,
&visible, &hovered, &bb.Min, &bb.Max, 0, alpha); &visible, &hovered, &bb.Min, &bb.Max, 0, alpha);
@ -2347,7 +2347,7 @@ void Achievements::DrawAchievement(const rc_client_achievement_t* cheevo)
SmallString text; SmallString text;
const float midpoint = bb.Min.y + g_large_font->FontSize + spacing; const float midpoint = bb.Min.y + g_large_font->FontSize + spacing;
text.fmt((cheevo->points != 1) ? TRANSLATE_FS("Achievements", "{} points") : TRANSLATE_FS("Achievements", "{} point"), cheevo->points); text.format((cheevo->points != 1) ? TRANSLATE_FS("Achievements", "{} points") : TRANSLATE_FS("Achievements", "{} point"), cheevo->points);
const ImVec2 points_size(g_medium_font->CalcTextSizeA(g_medium_font->FontSize, FLT_MAX, 0.0f, text.c_str(), text.end_ptr())); const ImVec2 points_size(g_medium_font->CalcTextSizeA(g_medium_font->FontSize, FLT_MAX, 0.0f, text.c_str(), text.end_ptr()));
const float points_template_start = bb.Max.x - points_template_size.x; const float points_template_start = bb.Max.x - points_template_size.x;
@ -2398,7 +2398,7 @@ void Achievements::DrawAchievement(const rc_client_achievement_t* cheevo)
if (is_unlocked) if (is_unlocked)
{ {
text.fmt(TRANSLATE_FS("Achievements", "Unlocked: {}"), FullscreenUI::TimeToPrintableString(cheevo->unlock_time)); text.format(TRANSLATE_FS("Achievements", "Unlocked: {}"), FullscreenUI::TimeToPrintableString(cheevo->unlock_time));
const ImRect unlock_bb(summary_bb.Min.x, summary_bb.Max.y + spacing, summary_bb.Max.x, bb.Max.y); const ImRect unlock_bb(summary_bb.Min.x, summary_bb.Max.y + spacing, summary_bb.Max.x, bb.Max.y);
ImGui::RenderTextClipped(unlock_bb.Min, unlock_bb.Max, text.c_str(), text.end_ptr(), nullptr, ImVec2(0.0f, 0.0f), &unlock_bb); ImGui::RenderTextClipped(unlock_bb.Min, unlock_bb.Max, text.c_str(), text.end_ptr(), nullptr, ImVec2(0.0f, 0.0f), &unlock_bb);
@ -2564,7 +2564,7 @@ void Achievements::DrawLeaderboardsWindow()
u32 count = 0; u32 count = 0;
for (u32 i = 0; i < s_leaderboard_list->num_buckets; i++) for (u32 i = 0; i < s_leaderboard_list->num_buckets; i++)
count += s_leaderboard_list->buckets[i].num_leaderboards; count += s_leaderboard_list->buckets[i].num_leaderboards;
text.fmt(TRANSLATE_FS("Achievements", "This game has {} leaderboards."), count); text.format(TRANSLATE_FS("Achievements", "This game has {} leaderboards."), count);
} }
const ImRect summary_bb(ImVec2(left, top), ImVec2(right, top + g_medium_font->FontSize)); const ImRect summary_bb(ImVec2(left, top), ImVec2(right, top + g_medium_font->FontSize));
@ -2764,7 +2764,7 @@ void Achievements::DrawLeaderboardEntry(const rc_client_leaderboard_entry_t& ent
float text_start_x = bb.Min.x + LayoutScale(15.0f); float text_start_x = bb.Min.x + LayoutScale(15.0f);
SmallString text; SmallString text;
text.fmt("{}", entry.rank); text.format("{}", entry.rank);
ImGui::PushFont(g_large_font); ImGui::PushFont(g_large_font);
@ -2831,7 +2831,7 @@ void Achievements::DrawLeaderboardListEntry(const rc_client_leaderboard_t* lboar
static constexpr float alpha = 0.8f; static constexpr float alpha = 0.8f;
TinyString id_str; TinyString id_str;
id_str.fmt("{}", lboard->id); id_str.format("{}", lboard->id);
ImRect bb; ImRect bb;
bool visible, hovered; bool visible, hovered;

4
pcsx2/GS/GS.cpp
View File

@ -607,7 +607,7 @@ void GSgetStats(SmallStringBase& info)
{ {
const double fps = GetVerticalFrequency(); const double fps = GetVerticalFrequency();
const double fillrate = pm.Get(GSPerfMon::Fillrate); const double fillrate = pm.Get(GSPerfMon::Fillrate);
info.fmt("{} SW | {} S | {} P | {} D | {:.2f} U | {:.2f} D | {:.2f} mpps", info.format("{} SW | {} S | {} P | {} D | {:.2f} U | {:.2f} D | {:.2f} mpps",
api_name, api_name,
(int)pm.Get(GSPerfMon::SyncPoint), (int)pm.Get(GSPerfMon::SyncPoint),
(int)pm.Get(GSPerfMon::Prim), (int)pm.Get(GSPerfMon::Prim),
@ -622,7 +622,7 @@ void GSgetStats(SmallStringBase& info)
} }
else else
{ {
info.fmt("{} HW | {} P | {} D | {} DC | {} B | {} RP | {} RB | {} TC | {} TU", info.format("{} HW | {} P | {} D | {} DC | {} B | {} RP | {} RB | {} TC | {} TU",
api_name, api_name,
(int)pm.Get(GSPerfMon::Prim), (int)pm.Get(GSPerfMon::Prim),
(int)pm.Get(GSPerfMon::Draw), (int)pm.Get(GSPerfMon::Draw),

4
pcsx2/GS/GSCapture.cpp
View File

@ -844,7 +844,7 @@ bool GSCapture::DeliverVideoFrame(GSTexture* stex)
} }
#ifdef PCSX2_DEVBUILD #ifdef PCSX2_DEVBUILD
pf.tex->SetDebugName(TinyString::from_fmt("GSCapture {}x{} Download Texture", stex->GetWidth(), stex->GetHeight())); pf.tex->SetDebugName(TinyString::from_format("GSCapture {}x{} Download Texture", stex->GetWidth(), stex->GetHeight()));
#endif #endif
} }
@ -1361,7 +1361,7 @@ TinyString GSCapture::GetElapsedTime()
TinyString ret; TinyString ret;
if (seconds >= 0) if (seconds >= 0)
ret.fmt("{:02d}:{:02d}:{:02d}", seconds / 3600, (seconds % 3600) / 60, seconds % 60); ret.format("{:02d}:{:02d}:{:02d}", seconds / 3600, (seconds % 3600) / 60, seconds % 60);
return ret; return ret;
} }

2
pcsx2/GS/Renderers/Common/GSDevice.cpp
View File

@ -455,7 +455,7 @@ GSTexture* GSDevice::FetchSurface(GSTexture::Type type, int width, int height, i
{ {
const TextureLabel label = GetTextureLabel(type, format); const TextureLabel label = GetTextureLabel(type, format);
const u32 id = ++s_texture_counts[static_cast<u32>(label)]; const u32 id = ++s_texture_counts[static_cast<u32>(label)];
t->SetDebugName(TinyString::from_fmt("{} {}", TextureLabelString(label), id)); t->SetDebugName(TinyString::from_format("{} {}", TextureLabelString(label), id));
} }
#endif #endif
} }

18
pcsx2/GS/Renderers/DX12/GSDevice12.cpp
View File

@ -2452,7 +2452,7 @@ bool GSDevice12::CompileConvertPipelines()
if (!m_convert[index]) if (!m_convert[index])
return false; return false;
D3D12::SetObjectName(m_convert[index].get(), TinyString::from_fmt("Convert pipeline {}", static_cast<int>(i))); D3D12::SetObjectName(m_convert[index].get(), TinyString::from_format("Convert pipeline {}", static_cast<int>(i)));
if (i == ShaderConvert::COPY) if (i == ShaderConvert::COPY)
{ {
@ -2468,7 +2468,7 @@ bool GSDevice12::CompileConvertPipelines()
if (!m_color_copy[j]) if (!m_color_copy[j])
return false; return false;
D3D12::SetObjectName(m_color_copy[j].get(), TinyString::from_fmt("Color copy pipeline (r={}, g={}, b={}, a={})", D3D12::SetObjectName(m_color_copy[j].get(), TinyString::from_format("Color copy pipeline (r={}, g={}, b={}, a={})",
j & 1u, (j >> 1) & 1u, (j >> 2) & 1u, (j >> 3) & 1u)); j & 1u, (j >> 1) & 1u, (j >> 2) & 1u, (j >> 3) & 1u));
} }
} }
@ -2493,7 +2493,7 @@ bool GSDevice12::CompileConvertPipelines()
if (!m_color_copy[j]) if (!m_color_copy[j])
return false; return false;
D3D12::SetObjectName(m_color_copy[j].get(), TinyString::from_fmt("Color copy pipeline (r={}, g={}, b={}, a={})", D3D12::SetObjectName(m_color_copy[j].get(), TinyString::from_format("Color copy pipeline (r={}, g={}, b={}, a={})",
j & 1u, (j >> 1) & 1u, (j >> 2) & 1u, (j >> 3) & 1u)); j & 1u, (j >> 1) & 1u, (j >> 2) & 1u, (j >> 3) & 1u));
} }
} }
@ -2511,7 +2511,7 @@ bool GSDevice12::CompileConvertPipelines()
if (!arr[ds]) if (!arr[ds])
return false; return false;
D3D12::SetObjectName(arr[ds].get(), TinyString::from_fmt("HDR {}/copy pipeline (ds={})", is_setup ? "setup" : "finish", ds)); D3D12::SetObjectName(arr[ds].get(), TinyString::from_format("HDR {}/copy pipeline (ds={})", is_setup ? "setup" : "finish", ds));
} }
} }
} }
@ -2539,7 +2539,7 @@ bool GSDevice12::CompileConvertPipelines()
return false; return false;
D3D12::SetObjectName(m_date_image_setup_pipelines[ds][datm].get(), D3D12::SetObjectName(m_date_image_setup_pipelines[ds][datm].get(),
TinyString::from_fmt("DATE image clear pipeline (ds={}, datm={})", ds, (datm == 1 || datm == 3))); TinyString::from_format("DATE image clear pipeline (ds={}, datm={})", ds, (datm == 1 || datm == 3)));
} }
} }
@ -2584,7 +2584,7 @@ bool GSDevice12::CompilePresentPipelines()
if (!m_present[index]) if (!m_present[index])
return false; return false;
D3D12::SetObjectName(m_present[index].get(), TinyString::from_fmt("Present pipeline {}", static_cast<int>(i))); D3D12::SetObjectName(m_present[index].get(), TinyString::from_format("Present pipeline {}", static_cast<int>(i)));
} }
return true; return true;
@ -2620,7 +2620,7 @@ bool GSDevice12::CompileInterlacePipelines()
if (!m_interlace[i]) if (!m_interlace[i])
return false; return false;
D3D12::SetObjectName(m_convert[i].get(), TinyString::from_fmt("Interlace pipeline {}", static_cast<int>(i))); D3D12::SetObjectName(m_convert[i].get(), TinyString::from_format("Interlace pipeline {}", static_cast<int>(i)));
} }
return true; return true;
@ -2657,7 +2657,7 @@ bool GSDevice12::CompileMergePipelines()
if (!m_merge[i]) if (!m_merge[i])
return false; return false;
D3D12::SetObjectName(m_convert[i].get(), TinyString::from_fmt("Merge pipeline {}", i)); D3D12::SetObjectName(m_convert[i].get(), TinyString::from_format("Merge pipeline {}", i));
} }
return true; return true;
@ -2990,7 +2990,7 @@ GSDevice12::ComPtr<ID3D12PipelineState> GSDevice12::CreateTFXPipeline(const Pipe
if (pipeline) if (pipeline)
{ {
D3D12::SetObjectName( D3D12::SetObjectName(
pipeline.get(), TinyString::from_fmt("TFX Pipeline {:08X}/{:08X}{:016X}", p.vs.key, p.ps.key_hi, p.ps.key_lo)); pipeline.get(), TinyString::from_format("TFX Pipeline {:08X}/{:08X}{:016X}", p.vs.key, p.ps.key_hi, p.ps.key_lo));
} }
return pipeline; return pipeline;

18
pcsx2/GS/Renderers/HW/GSTextureCache.cpp
View File

@ -2943,7 +2943,7 @@ bool GSTextureCache::PrepareDownloadTexture(u32 width, u32 height, GSTexture::Fo
} }
#ifdef PCSX2_DEVBUILD #ifdef PCSX2_DEVBUILD
(*tex)->SetDebugName(TinyString::from_fmt("Texture Cache {}x{} {} Readback", (*tex)->SetDebugName(TinyString::from_format("Texture Cache {}x{} {} Readback",
new_width, new_height, GSTexture::GetFormatName(format))); new_width, new_height, GSTexture::GetFormatName(format)));
#endif #endif
@ -4414,12 +4414,12 @@ GSTextureCache::Source* GSTextureCache::CreateSource(const GIFRegTEX0& TEX0, con
{ {
if (psm.pal > 0) if (psm.pal > 0)
{ {
src->m_texture->SetDebugName(TinyString::from_fmt("Offset {},{} from 0x{:X} {} CBP 0x{:X}", x_offset, y_offset, src->m_texture->SetDebugName(TinyString::from_format("Offset {},{} from 0x{:X} {} CBP 0x{:X}", x_offset, y_offset,
static_cast<u32>(TEX0.TBP0), psm_str(TEX0.PSM), static_cast<u32>(TEX0.CBP))); static_cast<u32>(TEX0.TBP0), psm_str(TEX0.PSM), static_cast<u32>(TEX0.CBP)));
} }
else else
{ {
src->m_texture->SetDebugName(TinyString::from_fmt("Offset {},{} from 0x{:X} {} ", x_offset, y_offset, src->m_texture->SetDebugName(TinyString::from_format("Offset {},{} from 0x{:X} {} ", x_offset, y_offset,
static_cast<u32>(TEX0.TBP0), psm_str(TEX0.PSM), static_cast<u32>(TEX0.CBP))); static_cast<u32>(TEX0.TBP0), psm_str(TEX0.PSM), static_cast<u32>(TEX0.CBP)));
} }
} }
@ -4664,7 +4664,7 @@ GSTextureCache::Source* GSTextureCache::CreateSource(const GIFRegTEX0& TEX0, con
#ifdef PCSX2_DEVBUILD #ifdef PCSX2_DEVBUILD
if (GSConfig.UseDebugDevice) if (GSConfig.UseDebugDevice)
{ {
src->m_texture->SetDebugName(TinyString::from_fmt("{}x{} copy of 0x{:X} {}", new_size.x, new_size.y, src->m_texture->SetDebugName(TinyString::from_format("{}x{} copy of 0x{:X} {}", new_size.x, new_size.y,
static_cast<u32>(TEX0.TBP0), psm_str(TEX0.PSM))); static_cast<u32>(TEX0.TBP0), psm_str(TEX0.PSM)));
} }
#endif #endif
@ -4700,12 +4700,12 @@ GSTextureCache::Source* GSTextureCache::CreateSource(const GIFRegTEX0& TEX0, con
{ {
if (psm.pal > 0) if (psm.pal > 0)
{ {
src->m_texture->SetDebugName(TinyString::from_fmt("Reinterpret 0x{:X} from {} to {} CBP 0x{:X}", src->m_texture->SetDebugName(TinyString::from_format("Reinterpret 0x{:X} from {} to {} CBP 0x{:X}",
static_cast<u32>(TEX0.TBP0), psm_str(dst->m_TEX0.PSM), psm_str(TEX0.PSM), static_cast<u32>(TEX0.CBP))); static_cast<u32>(TEX0.TBP0), psm_str(dst->m_TEX0.PSM), psm_str(TEX0.PSM), static_cast<u32>(TEX0.CBP)));
} }
else else
{ {
src->m_texture->SetDebugName(TinyString::from_fmt("Reinterpret 0x{:X} from {} to {}", src->m_texture->SetDebugName(TinyString::from_format("Reinterpret 0x{:X} from {} to {}",
static_cast<u32>(TEX0.TBP0), psm_str(dst->m_TEX0.PSM), psm_str(TEX0.PSM))); static_cast<u32>(TEX0.TBP0), psm_str(dst->m_TEX0.PSM), psm_str(TEX0.PSM)));
} }
} }
@ -4795,13 +4795,13 @@ GSTextureCache::Source* GSTextureCache::CreateSource(const GIFRegTEX0& TEX0, con
{ {
if (psm.pal > 0) if (psm.pal > 0)
{ {
src->m_texture->SetDebugName(TinyString::from_fmt("{}x{} {} @ 0x{:X} TBW={} CBP=0x{:X}", src->m_texture->SetDebugName(TinyString::from_format("{}x{} {} @ 0x{:X} TBW={} CBP=0x{:X}",
tw, th, psm_str(TEX0.PSM), static_cast<u32>(TEX0.TBP0), static_cast<u32>(TEX0.TBW), tw, th, psm_str(TEX0.PSM), static_cast<u32>(TEX0.TBP0), static_cast<u32>(TEX0.TBW),
static_cast<u32>(TEX0.CBP))); static_cast<u32>(TEX0.CBP)));
} }
else else
{ {
src->m_texture->SetDebugName(TinyString::from_fmt("{}x{} {} @ 0x{:X} TBW={}", src->m_texture->SetDebugName(TinyString::from_format("{}x{} {} @ 0x{:X} TBW={}",
tw, th, psm_str(TEX0.PSM), static_cast<u32>(TEX0.TBP0), static_cast<u32>(TEX0.TBW))); tw, th, psm_str(TEX0.PSM), static_cast<u32>(TEX0.TBP0), static_cast<u32>(TEX0.TBW)));
} }
} }
@ -6373,7 +6373,7 @@ void GSTextureCache::Target::UpdateTextureDebugName()
#ifdef PCSX2_DEVBUILD #ifdef PCSX2_DEVBUILD
if (GSConfig.UseDebugDevice) if (GSConfig.UseDebugDevice)
{ {
m_texture->SetDebugName(SmallString::from_fmt("{} 0x{:X} {} BW={} {}x{}", m_texture->SetDebugName(SmallString::from_format("{} 0x{:X} {} BW={} {}x{}",
m_type ? "DS" : "RT", static_cast<u32>(m_TEX0.TBP0), psm_str(m_TEX0.PSM), static_cast<u32>(m_TEX0.TBW), m_type ? "DS" : "RT", static_cast<u32>(m_TEX0.TBP0), psm_str(m_TEX0.PSM), static_cast<u32>(m_TEX0.TBW),
m_unscaled_size.x, m_unscaled_size.y)); m_unscaled_size.x, m_unscaled_size.y));
} }

88
pcsx2/ImGui/FullscreenUI.cpp
View File

@ -61,11 +61,11 @@ namespace
public: public:
__fi IconStackString(const char* icon, const char* str) __fi IconStackString(const char* icon, const char* str)
{ {
SmallStackString<L>::fmt("{} {}", icon, Host::TranslateToStringView(TR_CONTEXT, str)); SmallStackString<L>::format("{} {}", icon, Host::TranslateToStringView(TR_CONTEXT, str));
} }
__fi IconStackString(const char* icon, const char* str, const char* suffix) __fi IconStackString(const char* icon, const char* str, const char* suffix)
{ {
SmallStackString<L>::fmt("{} {}##{}", icon, Host::TranslateToStringView(TR_CONTEXT, str), suffix); SmallStackString<L>::format("{} {}##{}", icon, Host::TranslateToStringView(TR_CONTEXT, str), suffix);
} }
}; };
} // namespace } // namespace
@ -1186,7 +1186,7 @@ void FullscreenUI::DrawInputBindingButton(
SettingsInterface* bsi, InputBindingInfo::Type type, const char* section, const char* name, const char* display_name, const char* icon_name, bool show_type) SettingsInterface* bsi, InputBindingInfo::Type type, const char* section, const char* name, const char* display_name, const char* icon_name, bool show_type)
{ {
TinyString title; TinyString title;
title.fmt("{}/{}", section, name); title.format("{}/{}", section, name);
std::string value = bsi->GetStringValue(section, name); std::string value = bsi->GetStringValue(section, name);
const bool oneline = (std::count_if(value.begin(), value.end(), [](char ch) { return (ch == '&'); }) <= 1); const bool oneline = (std::count_if(value.begin(), value.end(), [](char ch) { return (ch == '&'); }) <= 1);
@ -1207,24 +1207,24 @@ void FullscreenUI::DrawInputBindingButton(
{ {
if (icon_name) if (icon_name)
{ {
title.fmt("{} {}", icon_name, display_name); title.format("{} {}", icon_name, display_name);
} }
else else
{ {
switch (type) switch (type)
{ {
case InputBindingInfo::Type::Button: case InputBindingInfo::Type::Button:
title.fmt(ICON_FA_DOT_CIRCLE " {}", display_name); title.format(ICON_FA_DOT_CIRCLE " {}", display_name);
break; break;
case InputBindingInfo::Type::Axis: case InputBindingInfo::Type::Axis:
case InputBindingInfo::Type::HalfAxis: case InputBindingInfo::Type::HalfAxis:
title.fmt(ICON_FA_BULLSEYE " {}", display_name); title.format(ICON_FA_BULLSEYE " {}", display_name);
break; break;
case InputBindingInfo::Type::Motor: case InputBindingInfo::Type::Motor:
title.fmt(ICON_PF_CONTROLLER_VIBRATION " {}", display_name); title.format(ICON_PF_CONTROLLER_VIBRATION " {}", display_name);
break; break;
case InputBindingInfo::Type::Macro: case InputBindingInfo::Type::Macro:
title.fmt(ICON_PF_THUNDERBOLT " {}", display_name); title.format(ICON_PF_THUNDERBOLT " {}", display_name);
break; break;
default: default:
title = display_name; title = display_name;
@ -2294,7 +2294,7 @@ void FullscreenUI::DrawSettingInfoSetting(SettingsInterface* bsi, const char* se
const char* translation_ctx) const char* translation_ctx)
{ {
SmallString title; SmallString title;
title.fmt(ICON_FA_COG " {}", Host::TranslateToStringView(translation_ctx, si.display_name)); title.format(ICON_FA_COG " {}", Host::TranslateToStringView(translation_ctx, si.display_name));
switch (si.type) switch (si.type)
{ {
case SettingInfo::Type::Boolean: case SettingInfo::Type::Boolean:
@ -2516,7 +2516,7 @@ void FullscreenUI::DrawSettingsWindow()
if (s_game_settings_entry) if (s_game_settings_entry)
{ {
NavTitle(SmallString::from_fmt( NavTitle(SmallString::from_format(
"{} ({})", Host::TranslateToCString(TR_CONTEXT, titles[static_cast<u32>(pages[index])]), s_game_settings_entry->GetTitle(true))); "{} ({})", Host::TranslateToCString(TR_CONTEXT, titles[static_cast<u32>(pages[index])]), s_game_settings_entry->GetTitle(true)));
} }
else else
@ -3649,14 +3649,14 @@ void FullscreenUI::DrawMemoryCardSettingsPage()
for (u32 port = 0; port < NUM_MEMORY_CARD_PORTS; port++) for (u32 port = 0; port < NUM_MEMORY_CARD_PORTS; port++)
{ {
SmallString str; SmallString str;
str.fmt(FSUI_FSTR("Slot {}"), port + 1); str.format(FSUI_FSTR("Slot {}"), port + 1);
MenuHeading(str.c_str()); MenuHeading(str.c_str());
std::string enable_key(fmt::format("Slot{}_Enable", port + 1)); std::string enable_key(fmt::format("Slot{}_Enable", port + 1));
std::string file_key(fmt::format("Slot{}_Filename", port + 1)); std::string file_key(fmt::format("Slot{}_Filename", port + 1));
DrawToggleSetting(bsi, DrawToggleSetting(bsi,
SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR_S(ICON_PF_MEMORY_CARD, "Card Enabled", "##card_enabled_{}")), port), SmallString::from_format(fmt::runtime(FSUI_ICONSTR_S(ICON_PF_MEMORY_CARD, "Card Enabled", "##card_enabled_{}")), port),
FSUI_CSTR("If not set, this card will be considered unplugged."), "MemoryCards", enable_key.c_str(), true); FSUI_CSTR("If not set, this card will be considered unplugged."), "MemoryCards", enable_key.c_str(), true);
const bool enabled = GetEffectiveBoolSetting(bsi, "MemoryCards", enable_key.c_str(), true); const bool enabled = GetEffectiveBoolSetting(bsi, "MemoryCards", enable_key.c_str(), true);
@ -3664,7 +3664,7 @@ void FullscreenUI::DrawMemoryCardSettingsPage()
std::optional<std::string> value(bsi->GetOptionalStringValue("MemoryCards", file_key.c_str(), std::optional<std::string> value(bsi->GetOptionalStringValue("MemoryCards", file_key.c_str(),
IsEditingGameSettings(bsi) ? std::nullopt : std::optional<const char*>(FileMcd_GetDefaultName(port).c_str()))); IsEditingGameSettings(bsi) ? std::nullopt : std::optional<const char*>(FileMcd_GetDefaultName(port).c_str())));
if (MenuButtonWithValue(SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR_S(ICON_FA_FILE, "Card Name", "##card_name_{}")), port), if (MenuButtonWithValue(SmallString::from_format(fmt::runtime(FSUI_ICONSTR_S(ICON_FA_FILE, "Card Name", "##card_name_{}")), port),
FSUI_CSTR("The selected memory card image will be used for this slot."), FSUI_CSTR("The selected memory card image will be used for this slot."),
value.has_value() ? value->c_str() : FSUI_CSTR("Use Global Setting"), enabled)) value.has_value() ? value->c_str() : FSUI_CSTR("Use Global Setting"), enabled))
{ {
@ -3722,7 +3722,7 @@ void FullscreenUI::DrawMemoryCardSettingsPage()
}); });
} }
if (MenuButton(SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR_S(ICON_FA_EJECT, "Eject Card", "##eject_card_{}")), port), if (MenuButton(SmallString::from_format(fmt::runtime(FSUI_ICONSTR_S(ICON_FA_EJECT, "Eject Card", "##eject_card_{}")), port),
FSUI_CSTR("Removes the current card from the slot."), enabled)) FSUI_CSTR("Removes the current card from the slot."), enabled))
{ {
bsi->SetStringValue("MemoryCards", file_key.c_str(), ""); bsi->SetStringValue("MemoryCards", file_key.c_str(), "");
@ -3952,12 +3952,12 @@ void FullscreenUI::DrawControllerSettingsPage()
ImGui::PushID(global_slot); ImGui::PushID(global_slot);
if (mtap_enabled[mtap_port]) if (mtap_enabled[mtap_port])
{ {
MenuHeading(SmallString::from_fmt( MenuHeading(SmallString::from_format(
fmt::runtime(FSUI_ICONSTR(ICON_FA_PLUG, "Controller Port {}{}")), mtap_port + 1, mtap_slot_names[mtap_slot])); fmt::runtime(FSUI_ICONSTR(ICON_FA_PLUG, "Controller Port {}{}")), mtap_port + 1, mtap_slot_names[mtap_slot]));
} }
else else
{ {
MenuHeading(SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_FA_PLUG, "Controller Port {}")), mtap_port + 1)); MenuHeading(SmallString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_FA_PLUG, "Controller Port {}")), mtap_port + 1));
} }
const char* section = sections[global_slot]; const char* section = sections[global_slot];
@ -3998,12 +3998,12 @@ void FullscreenUI::DrawControllerSettingsPage()
if (mtap_enabled[mtap_port]) if (mtap_enabled[mtap_port])
{ {
MenuHeading(SmallString::from_fmt( MenuHeading(SmallString::from_format(
fmt::runtime(FSUI_ICONSTR(ICON_PF_EMPTY_KEYCAP, "Controller Port {}{} Macros")), mtap_port + 1, mtap_slot_names[mtap_slot])); fmt::runtime(FSUI_ICONSTR(ICON_PF_EMPTY_KEYCAP, "Controller Port {}{} Macros")), mtap_port + 1, mtap_slot_names[mtap_slot]));
} }
else else
{ {
MenuHeading(SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_PF_EMPTY_KEYCAP, "Controller Port {} Macros")), mtap_port + 1)); MenuHeading(SmallString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_PF_EMPTY_KEYCAP, "Controller Port {} Macros")), mtap_port + 1));
} }
static bool macro_button_expanded[Pad::NUM_CONTROLLER_PORTS][Pad::NUM_MACRO_BUTTONS_PER_CONTROLLER] = {}; static bool macro_button_expanded[Pad::NUM_CONTROLLER_PORTS][Pad::NUM_MACRO_BUTTONS_PER_CONTROLLER] = {};
@ -4012,13 +4012,13 @@ void FullscreenUI::DrawControllerSettingsPage()
{ {
bool& expanded = macro_button_expanded[global_slot][macro_index]; bool& expanded = macro_button_expanded[global_slot][macro_index];
expanded ^= expanded ^=
MenuHeadingButton(SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_PF_EMPTY_KEYCAP, "Macro Button {}")), macro_index + 1), MenuHeadingButton(SmallString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_PF_EMPTY_KEYCAP, "Macro Button {}")), macro_index + 1),
macro_button_expanded[global_slot][macro_index] ? ICON_FA_CHEVRON_UP : ICON_FA_CHEVRON_DOWN); macro_button_expanded[global_slot][macro_index] ? ICON_FA_CHEVRON_UP : ICON_FA_CHEVRON_DOWN);
if (!expanded) if (!expanded)
continue; continue;
DrawInputBindingButton( DrawInputBindingButton(
bsi, InputBindingInfo::Type::Macro, section, TinyString::from_fmt("Macro{}", macro_index + 1), "Trigger", nullptr); bsi, InputBindingInfo::Type::Macro, section, TinyString::from_format("Macro{}", macro_index + 1), "Trigger", nullptr);
std::string binds_string(bsi->GetStringValue(section, fmt::format("Macro{}Binds", macro_index + 1).c_str())); std::string binds_string(bsi->GetStringValue(section, fmt::format("Macro{}Binds", macro_index + 1).c_str()));
TinyString pretty_binds_string; TinyString pretty_binds_string;
@ -4035,7 +4035,7 @@ void FullscreenUI::DrawControllerSettingsPage()
break; break;
} }
} }
pretty_binds_string.append_fmt("{}{}", pretty_binds_string.empty() ? "" : " ", dispname); pretty_binds_string.append_format("{}{}", pretty_binds_string.empty() ? "" : " ", dispname);
} }
} }
if (MenuButtonWithValue(FSUI_ICONSTR(ICON_FA_KEYBOARD, "Buttons"), nullptr, pretty_binds_string.empty() ? FSUI_CSTR("-") : pretty_binds_string.c_str(), true, if (MenuButtonWithValue(FSUI_ICONSTR(ICON_FA_KEYBOARD, "Buttons"), nullptr, pretty_binds_string.empty() ? FSUI_CSTR("-") : pretty_binds_string.c_str(), true,
@ -4101,12 +4101,12 @@ void FullscreenUI::DrawControllerSettingsPage()
}); });
} }
const TinyString freq_key = TinyString::from_fmt("Macro{}Frequency", macro_index + 1); const TinyString freq_key = TinyString::from_format("Macro{}Frequency", macro_index + 1);
const TinyString freq_label = TinyString::from_fmt(ICON_FA_CLOCK " {}##macro_{}_frequency", FSUI_VSTR("Frequency"), macro_index + 1); const TinyString freq_label = TinyString::from_format(ICON_FA_CLOCK " {}##macro_{}_frequency", FSUI_VSTR("Frequency"), macro_index + 1);
s32 frequency = bsi->GetIntValue(section, freq_key.c_str(), 0); s32 frequency = bsi->GetIntValue(section, freq_key.c_str(), 0);
const SmallString freq_summary = const SmallString freq_summary =
((frequency == 0) ? TinyString(FSUI_VSTR("Disabled")) : ((frequency == 0) ? TinyString(FSUI_VSTR("Disabled")) :
TinyString::from_fmt(FSUI_FSTR("{} Frames"), frequency)); TinyString::from_format(FSUI_FSTR("{} Frames"), frequency));
if (MenuButtonWithValue(freq_label, FSUI_CSTR("Determines the frequency at which the macro will toggle the buttons on and off (aka auto fire)."), freq_summary, true)) if (MenuButtonWithValue(freq_label, FSUI_CSTR("Determines the frequency at which the macro will toggle the buttons on and off (aka auto fire)."), freq_summary, true))
ImGui::OpenPopup(freq_label.c_str()); ImGui::OpenPopup(freq_label.c_str());
@ -4160,13 +4160,13 @@ void FullscreenUI::DrawControllerSettingsPage()
{ {
if (mtap_enabled[mtap_port]) if (mtap_enabled[mtap_port])
{ {
MenuHeading(SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_FA_SLIDERS_H, "Controller Port {}{} Settings")), MenuHeading(SmallString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_FA_SLIDERS_H, "Controller Port {}{} Settings")),
mtap_port + 1, mtap_slot_names[mtap_slot])); mtap_port + 1, mtap_slot_names[mtap_slot]));
} }
else else
{ {
MenuHeading( MenuHeading(
SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_FA_SLIDERS_H, "Controller Port {} Settings")), mtap_port + 1)); SmallString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_FA_SLIDERS_H, "Controller Port {} Settings")), mtap_port + 1));
} }
for (const SettingInfo& si : ci->settings) for (const SettingInfo& si : ci->settings)
@ -4179,7 +4179,7 @@ void FullscreenUI::DrawControllerSettingsPage()
for (u32 port = 0; port < USB::NUM_PORTS; port++) for (u32 port = 0; port < USB::NUM_PORTS; port++)
{ {
ImGui::PushID(port); ImGui::PushID(port);
MenuHeading(TinyString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_FA_PLUG, "USB Port {}")), port + 1)); MenuHeading(TinyString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_FA_PLUG, "USB Port {}")), port + 1));
const std::string type(USB::GetConfigDevice(*bsi, port)); const std::string type(USB::GetConfigDevice(*bsi, port));
if (MenuButton(FSUI_ICONSTR(ICON_PF_USB, "Device Type"), USB::GetDeviceName(type))) if (MenuButton(FSUI_ICONSTR(ICON_PF_USB, "Device Type"), USB::GetDeviceName(type)))
@ -4240,7 +4240,7 @@ void FullscreenUI::DrawControllerSettingsPage()
const std::span<const InputBindingInfo> bindings(USB::GetDeviceBindings(type, subtype)); const std::span<const InputBindingInfo> bindings(USB::GetDeviceBindings(type, subtype));
if (!bindings.empty()) if (!bindings.empty())
{ {
MenuHeading(TinyString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_FA_KEYBOARD, "{} Bindings")), USB::GetDeviceName(type))); MenuHeading(TinyString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_FA_KEYBOARD, "{} Bindings")), USB::GetDeviceName(type)));
if (MenuButton(FSUI_ICONSTR(ICON_FA_TRASH, "Clear Bindings"), FSUI_CSTR("Clears all bindings for this USB controller."))) if (MenuButton(FSUI_ICONSTR(ICON_FA_TRASH, "Clear Bindings"), FSUI_CSTR("Clears all bindings for this USB controller.")))
{ {
@ -4259,7 +4259,7 @@ void FullscreenUI::DrawControllerSettingsPage()
const std::span<const SettingInfo> settings(USB::GetDeviceSettings(type, subtype)); const std::span<const SettingInfo> settings(USB::GetDeviceSettings(type, subtype));
if (!settings.empty()) if (!settings.empty())
{ {
MenuHeading(TinyString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_FA_SLIDERS_H, "{} Settings")), USB::GetDeviceName(type))); MenuHeading(TinyString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_FA_SLIDERS_H, "{} Settings")), USB::GetDeviceName(type)));
const std::string section(USB::GetConfigSection(port)); const std::string section(USB::GetConfigSection(port));
for (const SettingInfo& si : settings) for (const SettingInfo& si : settings)
@ -4481,7 +4481,7 @@ void FullscreenUI::DrawPatchesOrCheatsSettingsPage(bool cheats)
if (cheats && s_game_cheat_unlabelled_count > 0) if (cheats && s_game_cheat_unlabelled_count > 0)
{ {
ActiveButton(SmallString::from_fmt(master_enable ? FSUI_FSTR("{} unlabelled patch codes will automatically activate.") : ActiveButton(SmallString::from_format(master_enable ? FSUI_FSTR("{} unlabelled patch codes will automatically activate.") :
FSUI_FSTR("{} unlabelled patch codes found but not enabled."), FSUI_FSTR("{} unlabelled patch codes found but not enabled."),
s_game_cheat_unlabelled_count), s_game_cheat_unlabelled_count),
false, false, ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY); false, false, ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY);
@ -4659,13 +4659,13 @@ void FullscreenUI::DrawPauseMenu(MainWindowType type)
const std::string session_time_str(GameList::FormatTimespan(session_time, true)); const std::string session_time_str(GameList::FormatTimespan(session_time, true));
SmallString buf; SmallString buf;
buf.fmt(FSUI_FSTR("This Session: {}"), session_time_str); buf.format(FSUI_FSTR("This Session: {}"), session_time_str);
const ImVec2 session_size(g_medium_font->CalcTextSizeA(g_medium_font->FontSize, std::numeric_limits<float>::max(), -1.0f, buf)); const ImVec2 session_size(g_medium_font->CalcTextSizeA(g_medium_font->FontSize, std::numeric_limits<float>::max(), -1.0f, buf));
const ImVec2 session_pos( const ImVec2 session_pos(
display_size.x - LayoutScale(10.0f) - session_size.x, time_pos.y + g_large_font->FontSize + LayoutScale(4.0f)); display_size.x - LayoutScale(10.0f) - session_size.x, time_pos.y + g_large_font->FontSize + LayoutScale(4.0f));
DrawShadowedText(dl, g_medium_font, session_pos, text_color, buf); DrawShadowedText(dl, g_medium_font, session_pos, text_color, buf);
buf.fmt(FSUI_FSTR("All Time: {}"), played_time_str); buf.format(FSUI_FSTR("All Time: {}"), played_time_str);
const ImVec2 total_size(g_medium_font->CalcTextSizeA(g_medium_font->FontSize, std::numeric_limits<float>::max(), -1.0f, buf)); const ImVec2 total_size(g_medium_font->CalcTextSizeA(g_medium_font->FontSize, std::numeric_limits<float>::max(), -1.0f, buf));
const ImVec2 total_pos( const ImVec2 total_pos(
display_size.x - LayoutScale(10.0f) - total_size.x, session_pos.y + g_medium_font->FontSize + LayoutScale(4.0f)); display_size.x - LayoutScale(10.0f) - total_size.x, session_pos.y + g_medium_font->FontSize + LayoutScale(4.0f));
@ -4820,7 +4820,7 @@ void FullscreenUI::DrawPauseMenu(MainWindowType type)
void FullscreenUI::InitializePlaceholderSaveStateListEntry(SaveStateListEntry* li, s32 slot) void FullscreenUI::InitializePlaceholderSaveStateListEntry(SaveStateListEntry* li, s32 slot)
{ {
li->title = fmt::format("{}##game_slot_{}", TinyString::from_fmt(FSUI_FSTR("Save Slot {0}"), slot), slot); li->title = fmt::format("{}##game_slot_{}", TinyString::from_format(FSUI_FSTR("Save Slot {0}"), slot), slot);
li->summary = FSUI_STR("No save present in this slot."); li->summary = FSUI_STR("No save present in this slot.");
li->path = {}; li->path = {};
li->timestamp = 0; li->timestamp = 0;
@ -4839,7 +4839,7 @@ bool FullscreenUI::InitializeSaveStateListEntry(
return false; return false;
} }
li->title = fmt::format("{}##game_slot_{}", TinyString::from_fmt(FSUI_FSTR("Save Slot {0}"), slot), slot); li->title = fmt::format("{}##game_slot_{}", TinyString::from_format(FSUI_FSTR("Save Slot {0}"), slot), slot);
li->summary = fmt::format(FSUI_FSTR("Saved {}"), TimeToPrintableString(sd.ModificationTime)); li->summary = fmt::format(FSUI_FSTR("Saved {}"), TimeToPrintableString(sd.ModificationTime));
li->slot = slot; li->slot = slot;
li->timestamp = sd.ModificationTime; li->timestamp = sd.ModificationTime;
@ -5651,10 +5651,10 @@ void FullscreenUI::DrawGameList(const ImVec2& heading_size)
ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 15.0f); ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 15.0f);
// file tile // file tile
ImGui::TextWrapped("%s", SmallString::from_fmt(FSUI_FSTR("File: {}"), Path::GetFileName(selected_entry->path)).c_str()); ImGui::TextWrapped("%s", SmallString::from_format(FSUI_FSTR("File: {}"), Path::GetFileName(selected_entry->path)).c_str());
// crc // crc
ImGui::TextUnformatted(TinyString::from_fmt(FSUI_FSTR("CRC: {:08X}"), selected_entry->crc)); ImGui::TextUnformatted(TinyString::from_format(FSUI_FSTR("CRC: {:08X}"), selected_entry->crc));
// region // region
{ {
@ -5679,13 +5679,13 @@ void FullscreenUI::DrawGameList(const ImVec2& heading_size)
// play time // play time
ImGui::TextUnformatted( ImGui::TextUnformatted(
SmallString::from_fmt(FSUI_FSTR("Time Played: {}"), GameList::FormatTimespan(selected_entry->total_played_time))); SmallString::from_format(FSUI_FSTR("Time Played: {}"), GameList::FormatTimespan(selected_entry->total_played_time)));
ImGui::TextUnformatted( ImGui::TextUnformatted(
SmallString::from_fmt(FSUI_FSTR("Last Played: {}"), GameList::FormatTimestamp(selected_entry->last_played_time))); SmallString::from_format(FSUI_FSTR("Last Played: {}"), GameList::FormatTimestamp(selected_entry->last_played_time)));
// size // size
ImGui::TextUnformatted( ImGui::TextUnformatted(
SmallString::from_fmt(FSUI_FSTR("Size: {:.2f} MB"), static_cast<float>(selected_entry->total_size) / 1048576.0f)); SmallString::from_format(FSUI_FSTR("Size: {:.2f} MB"), static_cast<float>(selected_entry->total_size) / 1048576.0f));
ImGui::PopFont(); ImGui::PopFont();
} }
@ -5925,7 +5925,7 @@ void FullscreenUI::DrawGameListSettingsPage(const ImVec2& heading_size)
{FSUI_ICONSTR(ICON_FA_WINDOW_CLOSE, "Close Menu"), false}, {FSUI_ICONSTR(ICON_FA_WINDOW_CLOSE, "Close Menu"), false},
}; };
OpenChoiceDialog(SmallString::from_fmt(ICON_FA_FOLDER " {}", it.first).c_str(), false, std::move(options), OpenChoiceDialog(SmallString::from_format(ICON_FA_FOLDER " {}", it.first).c_str(), false, std::move(options),
[dir = it.first, recursive = it.second](s32 index, const std::string& title, bool checked) { [dir = it.first, recursive = it.second](s32 index, const std::string& title, bool checked) {
if (index < 0) if (index < 0)
return; return;
@ -6317,10 +6317,10 @@ void FullscreenUI::DrawAchievementsSettingsPage(std::unique_lock<std::mutex>& se
if (bsi->ContainsValue("Achievements", "Token")) if (bsi->ContainsValue("Achievements", "Token"))
{ {
ImGui::PushStyleColor(ImGuiCol_TextDisabled, ImGui::GetStyle().Colors[ImGuiCol_Text]); ImGui::PushStyleColor(ImGuiCol_TextDisabled, ImGui::GetStyle().Colors[ImGuiCol_Text]);
ActiveButton(SmallString::from_fmt( ActiveButton(SmallString::from_format(
fmt::runtime(FSUI_ICONSTR(ICON_FA_USER, "Username: {}")), bsi->GetStringValue("Achievements", "Username")), fmt::runtime(FSUI_ICONSTR(ICON_FA_USER, "Username: {}")), bsi->GetStringValue("Achievements", "Username")),
false, false, ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY); false, false, ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY);
ActiveButton(SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_FA_CLOCK, "Login token generated on {}")), ActiveButton(SmallString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_FA_CLOCK, "Login token generated on {}")),
TimeToPrintableString(static_cast<time_t>( TimeToPrintableString(static_cast<time_t>(
StringUtil::FromChars<u64>(bsi->GetStringValue("Achievements", "LoginTimestamp", "0")).value_or(0)))), StringUtil::FromChars<u64>(bsi->GetStringValue("Achievements", "LoginTimestamp", "0")).value_or(0)))),
false, false, ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY); false, false, ImGuiFullscreen::LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY);
@ -6345,7 +6345,7 @@ void FullscreenUI::DrawAchievementsSettingsPage(std::unique_lock<std::mutex>& se
const auto lock = Achievements::GetLock(); const auto lock = Achievements::GetLock();
ImGui::PushStyleColor(ImGuiCol_TextDisabled, ImGui::GetStyle().Colors[ImGuiCol_Text]); ImGui::PushStyleColor(ImGuiCol_TextDisabled, ImGui::GetStyle().Colors[ImGuiCol_Text]);
ActiveButton(SmallString::from_fmt(fmt::runtime(FSUI_ICONSTR(ICON_FA_BOOKMARK, "Game: {0} ({1})")), Achievements::GetGameID(), ActiveButton(SmallString::from_format(fmt::runtime(FSUI_ICONSTR(ICON_FA_BOOKMARK, "Game: {0} ({1})")), Achievements::GetGameID(),
Achievements::GetGameTitle()), Achievements::GetGameTitle()),
false, false, LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY); false, false, LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY);
@ -6353,7 +6353,7 @@ void FullscreenUI::DrawAchievementsSettingsPage(std::unique_lock<std::mutex>& se
if (!rich_presence_string.empty()) if (!rich_presence_string.empty())
{ {
ActiveButton( ActiveButton(
SmallString::from_fmt(ICON_FA_MAP "{}", rich_presence_string), false, false, LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY); SmallString::from_format(ICON_FA_MAP "{}", rich_presence_string), false, false, LAYOUT_MENU_BUTTON_HEIGHT_NO_SUMMARY);
} }
else else
{ {

60
pcsx2/ImGui/ImGuiOverlays.cpp
View File

@ -87,9 +87,9 @@ __ri void ImGuiManager::FormatProcessorStat(SmallStringBase& text, double usage,
// which the processor time is divided by to get a utilization percentage. Let's clamp it at 100%, // which the processor time is divided by to get a utilization percentage. Let's clamp it at 100%,
// so that people don't get confused, and remove the decimal places when it's there while we're at it. // so that people don't get confused, and remove the decimal places when it's there while we're at it.
if (usage >= 99.95) if (usage >= 99.95)
text.append_fmt("100% ({:.2f}ms)", time); text.append_format("100% ({:.2f}ms)", time);
else else
text.append_fmt("{:.1f}% ({:.2f}ms)", usage, time); text.append_format("{:.1f}% ({:.2f}ms)", usage, time);
} }
__ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float margin, float spacing) __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, float margin, float spacing)
@ -126,31 +126,31 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
switch (PerformanceMetrics::GetInternalFPSMethod()) switch (PerformanceMetrics::GetInternalFPSMethod())
{ {
case PerformanceMetrics::InternalFPSMethod::GSPrivilegedRegister: case PerformanceMetrics::InternalFPSMethod::GSPrivilegedRegister:
text.append_fmt("G: {:.2f} [P] | V: {:.2f}", PerformanceMetrics::GetInternalFPS(), text.append_format("G: {:.2f} [P] | V: {:.2f}", PerformanceMetrics::GetInternalFPS(),
PerformanceMetrics::GetFPS()); PerformanceMetrics::GetFPS());
break; break;
case PerformanceMetrics::InternalFPSMethod::DISPFBBlit: case PerformanceMetrics::InternalFPSMethod::DISPFBBlit:
text.append_fmt("G: {:.2f} [B] | V: {:.2f}", PerformanceMetrics::GetInternalFPS(), text.append_format("G: {:.2f} [B] | V: {:.2f}", PerformanceMetrics::GetInternalFPS(),
PerformanceMetrics::GetFPS()); PerformanceMetrics::GetFPS());
break; break;
case PerformanceMetrics::InternalFPSMethod::None: case PerformanceMetrics::InternalFPSMethod::None:
default: default:
text.append_fmt("V: {:.2f}", PerformanceMetrics::GetFPS()); text.append_format("V: {:.2f}", PerformanceMetrics::GetFPS());
break; break;
} }
first = false; first = false;
} }
if (GSConfig.OsdShowSpeed) if (GSConfig.OsdShowSpeed)
{ {
text.append_fmt("{}{}%", first ? "" : " | ", static_cast<u32>(std::round(speed))); text.append_format("{}{}%", first ? "" : " | ", static_cast<u32>(std::round(speed)));
const float target_speed = VMManager::GetTargetSpeed(); const float target_speed = VMManager::GetTargetSpeed();
if (target_speed == 0.0f) if (target_speed == 0.0f)
text.append(" (Max)"); text.append(" (Max)");
else else
text.append_fmt(" ({:.0f}%)", target_speed * 100.0f); text.append_format(" ({:.0f}%)", target_speed * 100.0f);
} }
if (!text.empty()) if (!text.empty())
{ {
@ -183,20 +183,20 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
GSgetInternalResolution(&width, &height); GSgetInternalResolution(&width, &height);
text.clear(); text.clear();
text.append_fmt("{}x{} {} {}", width, height, ReportVideoMode(), ReportInterlaceMode()); text.append_format("{}x{} {} {}", width, height, ReportVideoMode(), ReportInterlaceMode());
DRAW_LINE(fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255)); DRAW_LINE(fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
} }
if (GSConfig.OsdShowCPU) if (GSConfig.OsdShowCPU)
{ {
text.clear(); text.clear();
text.append_fmt("{:.2f}ms | {:.2f}ms | {:.2f}ms", PerformanceMetrics::GetMinimumFrameTime(), text.append_format("{:.2f}ms | {:.2f}ms | {:.2f}ms", PerformanceMetrics::GetMinimumFrameTime(),
PerformanceMetrics::GetAverageFrameTime(), PerformanceMetrics::GetMaximumFrameTime()); PerformanceMetrics::GetAverageFrameTime(), PerformanceMetrics::GetMaximumFrameTime());
DRAW_LINE(fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255)); DRAW_LINE(fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
text.clear(); text.clear();
if (EmuConfig.Speedhacks.EECycleRate != 0 || EmuConfig.Speedhacks.EECycleSkip != 0) if (EmuConfig.Speedhacks.EECycleRate != 0 || EmuConfig.Speedhacks.EECycleSkip != 0)
text.append_fmt("EE[{}/{}]: ", EmuConfig.Speedhacks.EECycleRate, EmuConfig.Speedhacks.EECycleSkip); text.append_format("EE[{}/{}]: ", EmuConfig.Speedhacks.EECycleRate, EmuConfig.Speedhacks.EECycleSkip);
else else
text = "EE: "; text = "EE: ";
FormatProcessorStat(text, PerformanceMetrics::GetCPUThreadUsage(), PerformanceMetrics::GetCPUThreadAverageTime()); FormatProcessorStat(text, PerformanceMetrics::GetCPUThreadUsage(), PerformanceMetrics::GetCPUThreadAverageTime());
@ -210,7 +210,7 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
for (u32 i = 0; i < gs_sw_threads; i++) for (u32 i = 0; i < gs_sw_threads; i++)
{ {
text.clear(); text.clear();
text.append_fmt("SW-{}: ", i); text.append_format("SW-{}: ", i);
FormatProcessorStat(text, PerformanceMetrics::GetGSSWThreadUsage(i), PerformanceMetrics::GetGSSWThreadAverageTime(i)); FormatProcessorStat(text, PerformanceMetrics::GetGSSWThreadUsage(i), PerformanceMetrics::GetGSSWThreadAverageTime(i));
DRAW_LINE(fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255)); DRAW_LINE(fixed_font, text.c_str(), IM_COL32(255, 255, 255, 255));
} }
@ -291,7 +291,7 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
const ImVec2 wpos(ImGui::GetCurrentWindow()->Pos); const ImVec2 wpos(ImGui::GetCurrentWindow()->Pos);
text.clear(); text.clear();
text.append_fmt("{:.1f} ms", max); text.append_format("{:.1f} ms", max);
text_size = fixed_font->CalcTextSizeA(fixed_font->FontSize, FLT_MAX, 0.0f, text.c_str(), text.c_str() + text.length()); text_size = fixed_font->CalcTextSizeA(fixed_font->FontSize, FLT_MAX, 0.0f, text.c_str(), text.c_str() + text.length());
win_dl->AddText(ImVec2(wpos.x + history_size.x - text_size.x - spacing + shadow_offset, wpos.y + shadow_offset), win_dl->AddText(ImVec2(wpos.x + history_size.x - text_size.x - spacing + shadow_offset, wpos.y + shadow_offset),
IM_COL32(0, 0, 0, 100), text.c_str(), text.c_str() + text.length()); IM_COL32(0, 0, 0, 100), text.c_str(), text.c_str() + text.length());
@ -299,7 +299,7 @@ __ri void ImGuiManager::DrawPerformanceOverlay(float& position_y, float scale, f
text.c_str() + text.length()); text.c_str() + text.length());
text.clear(); text.clear();
text.append_fmt("{:.1f} ms", min); text.append_format("{:.1f} ms", min);
text_size = fixed_font->CalcTextSizeA(fixed_font->FontSize, FLT_MAX, 0.0f, text.c_str(), text.c_str() + text.length()); text_size = fixed_font->CalcTextSizeA(fixed_font->FontSize, FLT_MAX, 0.0f, text.c_str(), text.c_str() + text.length());
win_dl->AddText(ImVec2(wpos.x + history_size.x - text_size.x - spacing + shadow_offset, win_dl->AddText(ImVec2(wpos.x + history_size.x - text_size.x - spacing + shadow_offset,
wpos.y + history_size.y - fixed_font->FontSize + shadow_offset), wpos.y + history_size.y - fixed_font->FontSize + shadow_offset),
@ -501,9 +501,9 @@ __ri void ImGuiManager::DrawInputsOverlay(float scale, float margin, float spaci
const Pad::ControllerInfo& cinfo = pad->GetInfo(); const Pad::ControllerInfo& cinfo = pad->GetInfo();
if (cinfo.icon_name) if (cinfo.icon_name)
text.fmt("{} {}", cinfo.icon_name, slot + 1u); text.format("{} {}", cinfo.icon_name, slot + 1u);
else else
text.fmt("{} |", slot + 1u); text.format("{} |", slot + 1u);
for (u32 bind = 0; bind < static_cast<u32>(cinfo.bindings.size()); bind++) for (u32 bind = 0; bind < static_cast<u32>(cinfo.bindings.size()); bind++)
{ {
@ -517,9 +517,9 @@ __ri void ImGuiManager::DrawInputsOverlay(float scale, float margin, float spaci
const float value = pad->GetEffectiveInput(bind); const float value = pad->GetEffectiveInput(bind);
const float abs_value = std::abs(value); const float abs_value = std::abs(value);
if (abs_value >= (254.0f / 255.0f)) if (abs_value >= (254.0f / 255.0f))
text.append_fmt(" {}", bi.icon_name ? bi.icon_name : bi.name); text.append_format(" {}", bi.icon_name ? bi.icon_name : bi.name);
else if (abs_value >= (1.0f / 255.0f)) else if (abs_value >= (1.0f / 255.0f))
text.append_fmt(" {}: {:.2f}", bi.icon_name ? bi.icon_name : bi.name, value); text.append_format(" {}: {:.2f}", bi.icon_name ? bi.icon_name : bi.name, value);
} }
break; break;
@ -528,9 +528,9 @@ __ri void ImGuiManager::DrawInputsOverlay(float scale, float margin, float spaci
// buttons display the value from 0 through 255. // buttons display the value from 0 through 255.
const float value = pad->GetEffectiveInput(bind); const float value = pad->GetEffectiveInput(bind);
if (value >= 254.0f) if (value >= 254.0f)
text.append_fmt(" {}", bi.icon_name ? bi.icon_name : bi.name); text.append_format(" {}", bi.icon_name ? bi.icon_name : bi.name);
else if (value > 0.0f) else if (value > 0.0f)
text.append_fmt(" {}: {:.0f}", bi.icon_name ? bi.icon_name : bi.name, value); text.append_format(" {}: {:.0f}", bi.icon_name ? bi.icon_name : bi.name, value);
} }
break; break;
@ -559,7 +559,7 @@ __ri void ImGuiManager::DrawInputsOverlay(float scale, float margin, float spaci
if (bindings.empty()) if (bindings.empty())
continue; continue;
text.fmt("{} {} ", ICON_PF_USB, port + 1u); text.format("{} {} ", ICON_PF_USB, port + 1u);
for (const InputBindingInfo& bi : bindings) for (const InputBindingInfo& bi : bindings)
{ {
@ -571,9 +571,9 @@ __ri void ImGuiManager::DrawInputsOverlay(float scale, float margin, float spaci
// axes are only shown if not resting/past deadzone. values are normalized. // axes are only shown if not resting/past deadzone. values are normalized.
const float value = static_cast<float>(USB::GetDeviceBindValue(port, bi.bind_index)); const float value = static_cast<float>(USB::GetDeviceBindValue(port, bi.bind_index));
if (value >= (254.0f / 255.0f)) if (value >= (254.0f / 255.0f))
text.append_fmt(" {}", bi.icon_name ? bi.icon_name : bi.name); text.append_format(" {}", bi.icon_name ? bi.icon_name : bi.name);
else if (value > (1.0f / 255.0f)) else if (value > (1.0f / 255.0f))
text.append_fmt(" {}: {:.2f}", bi.icon_name ? bi.icon_name : bi.name, value); text.append_format(" {}: {:.2f}", bi.icon_name ? bi.icon_name : bi.name, value);
} }
break; break;
@ -582,9 +582,9 @@ __ri void ImGuiManager::DrawInputsOverlay(float scale, float margin, float spaci
// buttons display the value from 0 through 255. values are normalized, so denormalize them. // buttons display the value from 0 through 255. values are normalized, so denormalize them.
const float value = static_cast<float>(USB::GetDeviceBindValue(port, bi.bind_index)) * 255.0f; const float value = static_cast<float>(USB::GetDeviceBindValue(port, bi.bind_index)) * 255.0f;
if (value >= 254.0f) if (value >= 254.0f)
text.append_fmt(" {}", bi.icon_name ? bi.icon_name : bi.name); text.append_format(" {}", bi.icon_name ? bi.icon_name : bi.name);
else if (value > 0.0f) else if (value > 0.0f)
text.append_fmt(" {}: {:.0f}", bi.icon_name ? bi.icon_name : bi.name, value); text.append_format(" {}: {:.0f}", bi.icon_name ? bi.icon_name : bi.name, value);
} }
break; break;
@ -634,17 +634,17 @@ __ri void ImGuiManager::DrawInputRecordingOverlay(float& position_y, float scale
// Status Indicators // Status Indicators
if (g_InputRecording.getControls().isRecording()) if (g_InputRecording.getControls().isRecording())
{ {
DRAW_LINE(standard_font, TinyString::from_fmt(TRANSLATE_FS("ImGuiOverlays", "{} Recording Input"), ICON_PF_CIRCLE).c_str(), IM_COL32(255, 0, 0, 255)); DRAW_LINE(standard_font, TinyString::from_format(TRANSLATE_FS("ImGuiOverlays", "{} Recording Input"), ICON_PF_CIRCLE).c_str(), IM_COL32(255, 0, 0, 255));
} }
else else
{ {
DRAW_LINE(standard_font, TinyString::from_fmt(TRANSLATE_FS("ImGuiOverlays", "{} Replaying"), ICON_FA_PLAY).c_str(), IM_COL32(97, 240, 84, 255)); DRAW_LINE(standard_font, TinyString::from_format(TRANSLATE_FS("ImGuiOverlays", "{} Replaying"), ICON_FA_PLAY).c_str(), IM_COL32(97, 240, 84, 255));
} }
// Input Recording Metadata // Input Recording Metadata
DRAW_LINE(fixed_font, TinyString::from_fmt(TRANSLATE_FS("ImGuiOverlays", "Input Recording Active: {}"), g_InputRecording.getData().getFilename()).c_str(), IM_COL32(117, 255, 241, 255)); DRAW_LINE(fixed_font, TinyString::from_format(TRANSLATE_FS("ImGuiOverlays", "Input Recording Active: {}"), g_InputRecording.getData().getFilename()).c_str(), IM_COL32(117, 255, 241, 255));
DRAW_LINE(fixed_font, TinyString::from_fmt(TRANSLATE_FS("ImGuiOverlays", "Frame: {}/{} ({})"), g_InputRecording.getFrameCounter() + 1, g_InputRecording.getData().getTotalFrames(), g_FrameCount).c_str(), IM_COL32(117, 255, 241, 255)); DRAW_LINE(fixed_font, TinyString::from_format(TRANSLATE_FS("ImGuiOverlays", "Frame: {}/{} ({})"), g_InputRecording.getFrameCounter() + 1, g_InputRecording.getData().getTotalFrames(), g_FrameCount).c_str(), IM_COL32(117, 255, 241, 255));
DRAW_LINE(fixed_font, TinyString::from_fmt(TRANSLATE_FS("ImGuiOverlays", "Undo Count: {}"), g_InputRecording.getData().getUndoCount()).c_str(), IM_COL32(117, 255, 241, 255)); DRAW_LINE(fixed_font, TinyString::from_format(TRANSLATE_FS("ImGuiOverlays", "Undo Count: {}"), g_InputRecording.getData().getUndoCount()).c_str(), IM_COL32(117, 255, 241, 255));
#undef DRAW_LINE #undef DRAW_LINE
} }
@ -659,7 +659,7 @@ __ri void ImGuiManager::DrawVideoCaptureOverlay(float& position_y, float scale,
ImDrawList* dl = ImGui::GetBackgroundDrawList(); ImDrawList* dl = ImGui::GetBackgroundDrawList();
static constexpr const char* ICON = ICON_PF_CIRCLE; static constexpr const char* ICON = ICON_PF_CIRCLE;
const TinyString text_msg = TinyString::from_fmt(" {}", GSCapture::GetElapsedTime()); const TinyString text_msg = TinyString::from_format(" {}", GSCapture::GetElapsedTime());
const ImVec2 icon_size = standard_font->CalcTextSizeA(standard_font->FontSize, std::numeric_limits<float>::max(), const ImVec2 icon_size = standard_font->CalcTextSizeA(standard_font->FontSize, std::numeric_limits<float>::max(),
-1.0f, ICON, nullptr, nullptr); -1.0f, ICON, nullptr, nullptr);
const ImVec2 text_size = standard_font->CalcTextSizeA(standard_font->FontSize, std::numeric_limits<float>::max(), const ImVec2 text_size = standard_font->CalcTextSizeA(standard_font->FontSize, std::numeric_limits<float>::max(),

6
pcsx2/Input/DInputSource.cpp
View File

@ -384,17 +384,17 @@ TinyString DInputSource::ConvertKeyToString(InputBindingKey key)
if (key.source_subtype == InputSubclass::ControllerAxis) if (key.source_subtype == InputSubclass::ControllerAxis)
{ {
const char* modifier = (key.modifier == InputModifier::FullAxis ? "Full" : (key.modifier == InputModifier::Negate ? "-" : "+")); const char* modifier = (key.modifier == InputModifier::FullAxis ? "Full" : (key.modifier == InputModifier::Negate ? "-" : "+"));
ret.fmt("DInput-{}/{}Axis{}{}", u32(key.source_index), modifier, u32(key.data), (key.invert && !ShouldIgnoreInversion()) ? "~" : ""); ret.format("DInput-{}/{}Axis{}{}", u32(key.source_index), modifier, u32(key.data), (key.invert && !ShouldIgnoreInversion()) ? "~" : "");
} }
else if (key.source_subtype == InputSubclass::ControllerButton && key.data >= MAX_NUM_BUTTONS) else if (key.source_subtype == InputSubclass::ControllerButton && key.data >= MAX_NUM_BUTTONS)
{ {
const u32 hat_num = (key.data - MAX_NUM_BUTTONS) / NUM_HAT_DIRECTIONS; const u32 hat_num = (key.data - MAX_NUM_BUTTONS) / NUM_HAT_DIRECTIONS;
const u32 hat_dir = (key.data - MAX_NUM_BUTTONS) % NUM_HAT_DIRECTIONS; const u32 hat_dir = (key.data - MAX_NUM_BUTTONS) % NUM_HAT_DIRECTIONS;
ret.fmt("DInput-{}/Hat{}{}", u32(key.source_index), hat_num, s_hat_directions[hat_dir]); ret.format("DInput-{}/Hat{}{}", u32(key.source_index), hat_num, s_hat_directions[hat_dir]);
} }
else if (key.source_subtype == InputSubclass::ControllerButton) else if (key.source_subtype == InputSubclass::ControllerButton)
{ {
ret.fmt("DInput-{}/Button{}", u32(key.source_index), u32(key.data)); ret.format("DInput-{}/Button{}", u32(key.source_index), u32(key.data));
} }
} }

18
pcsx2/Input/SDLInputSource.cpp
View File

@ -480,30 +480,30 @@ TinyString SDLInputSource::ConvertKeyToString(InputBindingKey key)
{ {
const char* modifier = (key.modifier == InputModifier::FullAxis ? "Full" : (key.modifier == InputModifier::Negate ? "-" : "+")); const char* modifier = (key.modifier == InputModifier::FullAxis ? "Full" : (key.modifier == InputModifier::Negate ? "-" : "+"));
if (key.data < std::size(s_sdl_axis_names)) if (key.data < std::size(s_sdl_axis_names))
ret.fmt("SDL-{}/{}{}", static_cast<u32>(key.source_index), modifier, s_sdl_axis_names[key.data]); ret.format("SDL-{}/{}{}", static_cast<u32>(key.source_index), modifier, s_sdl_axis_names[key.data]);
else else
ret.fmt("SDL-{}/{}Axis{}{}", static_cast<u32>(key.source_index), modifier, key.data, (key.invert && !ShouldIgnoreInversion()) ? "~" : ""); ret.format("SDL-{}/{}Axis{}{}", static_cast<u32>(key.source_index), modifier, key.data, (key.invert && !ShouldIgnoreInversion()) ? "~" : "");
} }
else if (key.source_subtype == InputSubclass::ControllerButton) else if (key.source_subtype == InputSubclass::ControllerButton)
{ {
if (key.data < std::size(s_sdl_button_names)) if (key.data < std::size(s_sdl_button_names))
ret.fmt("SDL-{}/{}", static_cast<u32>(key.source_index), s_sdl_button_names[key.data]); ret.format("SDL-{}/{}", static_cast<u32>(key.source_index), s_sdl_button_names[key.data]);
else else
ret.fmt("SDL-{}/Button{}", static_cast<u32>(key.source_index), key.data); ret.format("SDL-{}/Button{}", static_cast<u32>(key.source_index), key.data);
} }
else if (key.source_subtype == InputSubclass::ControllerHat) else if (key.source_subtype == InputSubclass::ControllerHat)
{ {
const u32 hat_index = key.data / static_cast<u32>(std::size(s_sdl_hat_direction_names)); const u32 hat_index = key.data / static_cast<u32>(std::size(s_sdl_hat_direction_names));
const u32 hat_direction = key.data % static_cast<u32>(std::size(s_sdl_hat_direction_names)); const u32 hat_direction = key.data % static_cast<u32>(std::size(s_sdl_hat_direction_names));
ret.fmt("SDL-{}/Hat{}{}", static_cast<u32>(key.source_index), hat_index, s_sdl_hat_direction_names[hat_direction]); ret.format("SDL-{}/Hat{}{}", static_cast<u32>(key.source_index), hat_index, s_sdl_hat_direction_names[hat_direction]);
} }
else if (key.source_subtype == InputSubclass::ControllerMotor) else if (key.source_subtype == InputSubclass::ControllerMotor)
{ {
ret.fmt("SDL-{}/{}Motor", static_cast<u32>(key.source_index), key.data ? "Large" : "Small"); ret.format("SDL-{}/{}Motor", static_cast<u32>(key.source_index), key.data ? "Large" : "Small");
} }
else if (key.source_subtype == InputSubclass::ControllerHaptic) else if (key.source_subtype == InputSubclass::ControllerHaptic)
{ {
ret.fmt("SDL-{}/Haptic", static_cast<u32>(key.source_index)); ret.format("SDL-{}/Haptic", static_cast<u32>(key.source_index));
} }
} }
@ -520,14 +520,14 @@ TinyString SDLInputSource::ConvertKeyToIcon(InputBindingKey key)
{ {
if (key.data < std::size(s_sdl_axis_icons) && key.modifier != InputModifier::FullAxis) if (key.data < std::size(s_sdl_axis_icons) && key.modifier != InputModifier::FullAxis)
{ {
ret.fmt("SDL-{} {}", static_cast<u32>(key.source_index), ret.format("SDL-{} {}", static_cast<u32>(key.source_index),
s_sdl_axis_icons[key.data][key.modifier == InputModifier::None]); s_sdl_axis_icons[key.data][key.modifier == InputModifier::None]);
} }
} }
else if (key.source_subtype == InputSubclass::ControllerButton) else if (key.source_subtype == InputSubclass::ControllerButton)
{ {
if (key.data < std::size(s_sdl_button_icons)) if (key.data < std::size(s_sdl_button_icons))
ret.fmt("SDL-{} {}", static_cast<u32>(key.source_index), s_sdl_button_icons[key.data]); ret.format("SDL-{} {}", static_cast<u32>(key.source_index), s_sdl_button_icons[key.data]);
} }
} }

10
pcsx2/Input/XInputSource.cpp
View File

@ -324,15 +324,15 @@ TinyString XInputSource::ConvertKeyToString(InputBindingKey key)
if (key.source_subtype == InputSubclass::ControllerAxis && key.data < std::size(s_axis_names)) if (key.source_subtype == InputSubclass::ControllerAxis && key.data < std::size(s_axis_names))
{ {
const char modifier = key.modifier == InputModifier::Negate ? '-' : '+'; const char modifier = key.modifier == InputModifier::Negate ? '-' : '+';
ret.fmt("XInput-{}/{}{}", static_cast<u32>(key.source_index), modifier, s_axis_names[key.data]); ret.format("XInput-{}/{}{}", static_cast<u32>(key.source_index), modifier, s_axis_names[key.data]);
} }
else if (key.source_subtype == InputSubclass::ControllerButton && key.data < std::size(s_button_names)) else if (key.source_subtype == InputSubclass::ControllerButton && key.data < std::size(s_button_names))
{ {
ret.fmt("XInput-{}/{}", static_cast<u32>(key.source_index), s_button_names[key.data]); ret.format("XInput-{}/{}", static_cast<u32>(key.source_index), s_button_names[key.data]);
} }
else if (key.source_subtype == InputSubclass::ControllerMotor) else if (key.source_subtype == InputSubclass::ControllerMotor)
{ {
ret.fmt("XInput-{}/{}Motor", static_cast<u32>(key.source_index), key.data ? "Large" : "Small"); ret.format("XInput-{}/{}Motor", static_cast<u32>(key.source_index), key.data ? "Large" : "Small");
} }
} }
@ -349,14 +349,14 @@ TinyString XInputSource::ConvertKeyToIcon(InputBindingKey key)
{ {
if (key.data < std::size(s_axis_icons) && key.modifier != InputModifier::FullAxis) if (key.data < std::size(s_axis_icons) && key.modifier != InputModifier::FullAxis)
{ {
ret.fmt("XInput-{} {}", static_cast<u32>(key.source_index), ret.format("XInput-{} {}", static_cast<u32>(key.source_index),
s_axis_icons[key.data][key.modifier == InputModifier::None]); s_axis_icons[key.data][key.modifier == InputModifier::None]);
} }
} }
else if (key.source_subtype == InputSubclass::ControllerButton) else if (key.source_subtype == InputSubclass::ControllerButton)
{ {
if (key.data < std::size(s_button_icons)) if (key.data < std::size(s_button_icons))
ret.fmt("XInput-{} {}", static_cast<u32>(key.source_index), s_button_icons[key.data]); ret.format("XInput-{} {}", static_cast<u32>(key.source_index), s_button_icons[key.data]);
} }
} }

2
pcsx2/Patch.cpp
View File

@ -102,7 +102,7 @@ namespace Patch
SmallString ToString() const SmallString ToString() const
{ {
return SmallString::from_fmt("{},{},{},{:08x},{:x}", s_place_to_string[static_cast<u8>(placetopatch)], return SmallString::from_format("{},{},{},{:08x},{:x}", s_place_to_string[static_cast<u8>(placetopatch)],
s_cpu_to_string[static_cast<u8>(cpu)], s_type_to_string[static_cast<u8>(type)], addr, data); s_cpu_to_string[static_cast<u8>(cpu)], s_type_to_string[static_cast<u8>(type)], addr, data);
} }
}; };

6
pcsx2/Pcsx2Config.cpp
View File

@ -526,13 +526,13 @@ void Pcsx2Config::CpuOptions::LoadSave(SettingsWrapper& wrap)
SettingsWrapSection("EmuCore/CPU"); SettingsWrapSection("EmuCore/CPU");
const auto read_fpcr = [&wrap, &CURRENT_SETTINGS_SECTION](FPControlRegister& fpcr, std::string_view prefix) { const auto read_fpcr = [&wrap, &CURRENT_SETTINGS_SECTION](FPControlRegister& fpcr, std::string_view prefix) {
fpcr.SetDenormalsAreZero(wrap.EntryBitBool(CURRENT_SETTINGS_SECTION, TinyString::from_fmt("{}.DenormalsAreZero", prefix), fpcr.SetDenormalsAreZero(wrap.EntryBitBool(CURRENT_SETTINGS_SECTION, TinyString::from_format("{}.DenormalsAreZero", prefix),
fpcr.GetDenormalsAreZero(), fpcr.GetDenormalsAreZero())); fpcr.GetDenormalsAreZero(), fpcr.GetDenormalsAreZero()));
fpcr.SetFlushToZero(wrap.EntryBitBool(CURRENT_SETTINGS_SECTION, TinyString::from_fmt("{}.DenormalsAreZero", prefix), fpcr.SetFlushToZero(wrap.EntryBitBool(CURRENT_SETTINGS_SECTION, TinyString::from_format("{}.DenormalsAreZero", prefix),
fpcr.GetFlushToZero(), fpcr.GetFlushToZero())); fpcr.GetFlushToZero(), fpcr.GetFlushToZero()));
uint round_mode = static_cast<uint>(fpcr.GetRoundMode()); uint round_mode = static_cast<uint>(fpcr.GetRoundMode());
wrap.Entry(CURRENT_SETTINGS_SECTION, TinyString::from_fmt("{}.Roundmode", prefix), round_mode, round_mode); wrap.Entry(CURRENT_SETTINGS_SECTION, TinyString::from_format("{}.Roundmode", prefix), round_mode, round_mode);
round_mode = std::min(round_mode, static_cast<uint>(FPRoundMode::MaxCount) - 1u); round_mode = std::min(round_mode, static_cast<uint>(FPRoundMode::MaxCount) - 1u);
fpcr.SetRoundMode(static_cast<FPRoundMode>(round_mode)); fpcr.SetRoundMode(static_cast<FPRoundMode>(round_mode));
}; };