summaryrefslogtreecommitdiffstats
path: root/src/common
diff options
context:
space:
mode:
Diffstat (limited to 'src/common')
-rw-r--r--src/common/alignment.h4
-rw-r--r--src/common/bit_set.h2
-rw-r--r--src/common/color.h50
-rw-r--r--src/common/file_util.cpp16
-rw-r--r--src/common/file_util.h18
-rw-r--r--src/common/hash.h4
-rw-r--r--src/common/logging/backend.cpp8
-rw-r--r--src/common/logging/log.h8
-rw-r--r--src/common/vector_math.h362
-rw-r--r--src/common/x64/xbyak_util.h2
10 files changed, 259 insertions, 215 deletions
diff --git a/src/common/alignment.h b/src/common/alignment.h
index b77da4a92..b9dd38746 100644
--- a/src/common/alignment.h
+++ b/src/common/alignment.h
@@ -9,13 +9,13 @@ namespace Common {
template <typename T>
constexpr T AlignUp(T value, size_t size) {
- static_assert(std::is_unsigned<T>::value, "T must be an unsigned value.");
+ static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
return static_cast<T>(value + (size - value % size) % size);
}
template <typename T>
constexpr T AlignDown(T value, size_t size) {
- static_assert(std::is_unsigned<T>::value, "T must be an unsigned value.");
+ static_assert(std::is_unsigned_v<T>, "T must be an unsigned value.");
return static_cast<T>(value - value % size);
}
diff --git a/src/common/bit_set.h b/src/common/bit_set.h
index 84e3cbe58..5a197d8c1 100644
--- a/src/common/bit_set.h
+++ b/src/common/bit_set.h
@@ -96,7 +96,7 @@ static inline int LeastSignificantSetBit(u64 val) {
template <typename IntTy>
class BitSet {
- static_assert(!std::is_signed<IntTy>::value, "BitSet should not be used with signed types");
+ static_assert(!std::is_signed_v<IntTy>, "BitSet should not be used with signed types");
public:
// A reference to a particular bit, returned from operator[].
diff --git a/src/common/color.h b/src/common/color.h
index 24a445dac..0379040be 100644
--- a/src/common/color.h
+++ b/src/common/color.h
@@ -4,6 +4,8 @@
#pragma once
+#include <cstring>
+
#include "common/common_types.h"
#include "common/swap.h"
#include "common/vector_math.h"
@@ -55,7 +57,7 @@ constexpr u8 Convert8To6(u8 value) {
* @param bytes Pointer to encoded source color
* @return Result color decoded as Math::Vec4<u8>
*/
-inline const Math::Vec4<u8> DecodeRGBA8(const u8* bytes) {
+inline Math::Vec4<u8> DecodeRGBA8(const u8* bytes) {
return {bytes[3], bytes[2], bytes[1], bytes[0]};
}
@@ -64,7 +66,7 @@ inline const Math::Vec4<u8> DecodeRGBA8(const u8* bytes) {
* @param bytes Pointer to encoded source color
* @return Result color decoded as Math::Vec4<u8>
*/
-inline const Math::Vec4<u8> DecodeRGB8(const u8* bytes) {
+inline Math::Vec4<u8> DecodeRGB8(const u8* bytes) {
return {bytes[2], bytes[1], bytes[0], 255};
}
@@ -73,7 +75,7 @@ inline const Math::Vec4<u8> DecodeRGB8(const u8* bytes) {
* @param bytes Pointer to encoded source color
* @return Result color decoded as Math::Vec4<u8>
*/
-inline const Math::Vec4<u8> DecodeRG8(const u8* bytes) {
+inline Math::Vec4<u8> DecodeRG8(const u8* bytes) {
return {bytes[1], bytes[0], 0, 255};
}
@@ -82,8 +84,9 @@ inline const Math::Vec4<u8> DecodeRG8(const u8* bytes) {
* @param bytes Pointer to encoded source color
* @return Result color decoded as Math::Vec4<u8>
*/
-inline const Math::Vec4<u8> DecodeRGB565(const u8* bytes) {
- const u16_le pixel = *reinterpret_cast<const u16_le*>(bytes);
+inline Math::Vec4<u8> DecodeRGB565(const u8* bytes) {
+ u16_le pixel;
+ std::memcpy(&pixel, bytes, sizeof(pixel));
return {Convert5To8((pixel >> 11) & 0x1F), Convert6To8((pixel >> 5) & 0x3F),
Convert5To8(pixel & 0x1F), 255};
}
@@ -93,8 +96,9 @@ inline const Math::Vec4<u8> DecodeRGB565(const u8* bytes) {
* @param bytes Pointer to encoded source color
* @return Result color decoded as Math::Vec4<u8>
*/
-inline const Math::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
- const u16_le pixel = *reinterpret_cast<const u16_le*>(bytes);
+inline Math::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
+ u16_le pixel;
+ std::memcpy(&pixel, bytes, sizeof(pixel));
return {Convert5To8((pixel >> 11) & 0x1F), Convert5To8((pixel >> 6) & 0x1F),
Convert5To8((pixel >> 1) & 0x1F), Convert1To8(pixel & 0x1)};
}
@@ -104,8 +108,9 @@ inline const Math::Vec4<u8> DecodeRGB5A1(const u8* bytes) {
* @param bytes Pointer to encoded source color
* @return Result color decoded as Math::Vec4<u8>
*/
-inline const Math::Vec4<u8> DecodeRGBA4(const u8* bytes) {
- const u16_le pixel = *reinterpret_cast<const u16_le*>(bytes);
+inline Math::Vec4<u8> DecodeRGBA4(const u8* bytes) {
+ u16_le pixel;
+ std::memcpy(&pixel, bytes, sizeof(pixel));
return {Convert4To8((pixel >> 12) & 0xF), Convert4To8((pixel >> 8) & 0xF),
Convert4To8((pixel >> 4) & 0xF), Convert4To8(pixel & 0xF)};
}
@@ -116,7 +121,9 @@ inline const Math::Vec4<u8> DecodeRGBA4(const u8* bytes) {
* @return Depth value as an u32
*/
inline u32 DecodeD16(const u8* bytes) {
- return *reinterpret_cast<const u16_le*>(bytes);
+ u16_le data;
+ std::memcpy(&data, bytes, sizeof(data));
+ return data;
}
/**
@@ -133,7 +140,7 @@ inline u32 DecodeD24(const u8* bytes) {
* @param bytes Pointer to encoded source values
* @return Resulting values stored as a Math::Vec2
*/
-inline const Math::Vec2<u32> DecodeD24S8(const u8* bytes) {
+inline Math::Vec2<u32> DecodeD24S8(const u8* bytes) {
return {static_cast<u32>((bytes[2] << 16) | (bytes[1] << 8) | bytes[0]), bytes[3]};
}
@@ -175,8 +182,10 @@ inline void EncodeRG8(const Math::Vec4<u8>& color, u8* bytes) {
* @param bytes Destination pointer to store encoded color
*/
inline void EncodeRGB565(const Math::Vec4<u8>& color, u8* bytes) {
- *reinterpret_cast<u16_le*>(bytes) =
+ const u16_le data =
(Convert8To5(color.r()) << 11) | (Convert8To6(color.g()) << 5) | Convert8To5(color.b());
+
+ std::memcpy(bytes, &data, sizeof(data));
}
/**
@@ -185,9 +194,10 @@ inline void EncodeRGB565(const Math::Vec4<u8>& color, u8* bytes) {
* @param bytes Destination pointer to store encoded color
*/
inline void EncodeRGB5A1(const Math::Vec4<u8>& color, u8* bytes) {
- *reinterpret_cast<u16_le*>(bytes) = (Convert8To5(color.r()) << 11) |
- (Convert8To5(color.g()) << 6) |
- (Convert8To5(color.b()) << 1) | Convert8To1(color.a());
+ const u16_le data = (Convert8To5(color.r()) << 11) | (Convert8To5(color.g()) << 6) |
+ (Convert8To5(color.b()) << 1) | Convert8To1(color.a());
+
+ std::memcpy(bytes, &data, sizeof(data));
}
/**
@@ -196,9 +206,10 @@ inline void EncodeRGB5A1(const Math::Vec4<u8>& color, u8* bytes) {
* @param bytes Destination pointer to store encoded color
*/
inline void EncodeRGBA4(const Math::Vec4<u8>& color, u8* bytes) {
- *reinterpret_cast<u16_le*>(bytes) = (Convert8To4(color.r()) << 12) |
- (Convert8To4(color.g()) << 8) |
- (Convert8To4(color.b()) << 4) | Convert8To4(color.a());
+ const u16 data = (Convert8To4(color.r()) << 12) | (Convert8To4(color.g()) << 8) |
+ (Convert8To4(color.b()) << 4) | Convert8To4(color.a());
+
+ std::memcpy(bytes, &data, sizeof(data));
}
/**
@@ -207,7 +218,8 @@ inline void EncodeRGBA4(const Math::Vec4<u8>& color, u8* bytes) {
* @param bytes Pointer where to store the encoded value
*/
inline void EncodeD16(u32 value, u8* bytes) {
- *reinterpret_cast<u16_le*>(bytes) = value & 0xFFFF;
+ const u16_le data = static_cast<u16>(value);
+ std::memcpy(bytes, &data, sizeof(data));
}
/**
diff --git a/src/common/file_util.cpp b/src/common/file_util.cpp
index 7aeda737f..3ce590062 100644
--- a/src/common/file_util.cpp
+++ b/src/common/file_util.cpp
@@ -884,11 +884,21 @@ std::string_view RemoveTrailingSlash(std::string_view path) {
return path;
}
-std::string SanitizePath(std::string_view path_) {
+std::string SanitizePath(std::string_view path_, DirectorySeparator directory_separator) {
std::string path(path_);
- std::replace(path.begin(), path.end(), '\\', '/');
+ char type1 = directory_separator == DirectorySeparator::BackwardSlash ? '/' : '\\';
+ char type2 = directory_separator == DirectorySeparator::BackwardSlash ? '\\' : '/';
+
+ if (directory_separator == DirectorySeparator::PlatformDefault) {
+#ifdef _WIN32
+ type1 = '/';
+ type2 = '\\';
+#endif
+ }
+
+ std::replace(path.begin(), path.end(), type1, type2);
path.erase(std::unique(path.begin(), path.end(),
- [](char c1, char c2) { return c1 == '/' && c2 == '/'; }),
+ [type2](char c1, char c2) { return c1 == type2 && c2 == type2; }),
path.end());
return std::string(RemoveTrailingSlash(path));
}
diff --git a/src/common/file_util.h b/src/common/file_util.h
index 430dac41c..2711872ae 100644
--- a/src/common/file_util.h
+++ b/src/common/file_util.h
@@ -182,8 +182,12 @@ std::vector<T> SliceVector(const std::vector<T>& vector, size_t first, size_t la
return std::vector<T>(vector.begin() + first, vector.begin() + first + last);
}
-// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'.
-std::string SanitizePath(std::string_view path);
+enum class DirectorySeparator { ForwardSlash, BackwardSlash, PlatformDefault };
+
+// Removes trailing slash, makes all '\\' into '/', and removes duplicate '/'. Makes '/' into '\\'
+// depending if directory_separator is BackwardSlash or PlatformDefault and running on windows
+std::string SanitizePath(std::string_view path,
+ DirectorySeparator directory_separator = DirectorySeparator::ForwardSlash);
// simple wrapper for cstdlib file functions to
// hopefully will make error checking easier
@@ -208,7 +212,7 @@ public:
template <typename T>
size_t ReadArray(T* data, size_t length) const {
- static_assert(std::is_trivially_copyable<T>(),
+ static_assert(std::is_trivially_copyable_v<T>,
"Given array does not consist of trivially copyable objects");
if (!IsOpen()) {
@@ -220,7 +224,7 @@ public:
template <typename T>
size_t WriteArray(const T* data, size_t length) {
- static_assert(std::is_trivially_copyable<T>(),
+ static_assert(std::is_trivially_copyable_v<T>,
"Given array does not consist of trivially copyable objects");
if (!IsOpen()) {
return std::numeric_limits<size_t>::max();
@@ -231,19 +235,19 @@ public:
template <typename T>
size_t ReadBytes(T* data, size_t length) const {
- static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
+ static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
return ReadArray(reinterpret_cast<char*>(data), length);
}
template <typename T>
size_t WriteBytes(const T* data, size_t length) {
- static_assert(std::is_trivially_copyable<T>(), "T must be trivially copyable");
+ static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
return WriteArray(reinterpret_cast<const char*>(data), length);
}
template <typename T>
size_t WriteObject(const T& object) {
- static_assert(!std::is_pointer<T>::value, "Given object is a pointer");
+ static_assert(!std::is_pointer_v<T>, "WriteObject arguments must not be a pointer");
return WriteArray(&object, 1);
}
diff --git a/src/common/hash.h b/src/common/hash.h
index 73c326980..2c761e545 100644
--- a/src/common/hash.h
+++ b/src/common/hash.h
@@ -28,7 +28,7 @@ static inline u64 ComputeHash64(const void* data, size_t len) {
*/
template <typename T>
static inline u64 ComputeStructHash64(const T& data) {
- static_assert(std::is_trivially_copyable<T>(),
+ static_assert(std::is_trivially_copyable_v<T>,
"Type passed to ComputeStructHash64 must be trivially copyable");
return ComputeHash64(&data, sizeof(data));
}
@@ -38,7 +38,7 @@ template <typename T>
struct HashableStruct {
// In addition to being trivially copyable, T must also have a trivial default constructor,
// because any member initialization would be overridden by memset
- static_assert(std::is_trivial<T>(), "Type passed to HashableStruct must be trivial");
+ static_assert(std::is_trivial_v<T>, "Type passed to HashableStruct must be trivial");
/*
* We use a union because "implicitly-defined copy/move constructor for a union X copies the
* object representation of X." and "implicitly-defined copy assignment operator for a union X
diff --git a/src/common/logging/backend.cpp b/src/common/logging/backend.cpp
index 355abd682..e80784c3c 100644
--- a/src/common/logging/backend.cpp
+++ b/src/common/logging/backend.cpp
@@ -171,15 +171,21 @@ void FileBackend::Write(const Entry& entry) {
SUB(Service, ARP) \
SUB(Service, BCAT) \
SUB(Service, BPC) \
+ SUB(Service, BTDRV) \
SUB(Service, BTM) \
SUB(Service, Capture) \
+ SUB(Service, ERPT) \
+ SUB(Service, ETicket) \
+ SUB(Service, EUPLD) \
SUB(Service, Fatal) \
SUB(Service, FGM) \
SUB(Service, Friend) \
SUB(Service, FS) \
+ SUB(Service, GRC) \
SUB(Service, HID) \
SUB(Service, LBL) \
SUB(Service, LDN) \
+ SUB(Service, LDR) \
SUB(Service, LM) \
SUB(Service, Migration) \
SUB(Service, Mii) \
@@ -188,11 +194,13 @@ void FileBackend::Write(const Entry& entry) {
SUB(Service, NFC) \
SUB(Service, NFP) \
SUB(Service, NIFM) \
+ SUB(Service, NIM) \
SUB(Service, NS) \
SUB(Service, NVDRV) \
SUB(Service, PCIE) \
SUB(Service, PCTL) \
SUB(Service, PCV) \
+ SUB(Service, PM) \
SUB(Service, PREPO) \
SUB(Service, PSC) \
SUB(Service, SET) \
diff --git a/src/common/logging/log.h b/src/common/logging/log.h
index a889ebefa..e12f47f8f 100644
--- a/src/common/logging/log.h
+++ b/src/common/logging/log.h
@@ -58,15 +58,21 @@ enum class Class : ClassType {
Service_Audio, ///< The Audio (Audio control) service
Service_BCAT, ///< The BCAT service
Service_BPC, ///< The BPC service
+ Service_BTDRV, ///< The Bluetooth driver service
Service_BTM, ///< The BTM service
Service_Capture, ///< The capture service
+ Service_ERPT, ///< The error reporting service
+ Service_ETicket, ///< The ETicket service
+ Service_EUPLD, ///< The error upload service
Service_Fatal, ///< The Fatal service
Service_FGM, ///< The FGM service
Service_Friend, ///< The friend service
Service_FS, ///< The FS (Filesystem) service
+ Service_GRC, ///< The game recording service
Service_HID, ///< The HID (Human interface device) service
Service_LBL, ///< The LBL (LCD backlight) service
Service_LDN, ///< The LDN (Local domain network) service
+ Service_LDR, ///< The loader service
Service_LM, ///< The LM (Logger) service
Service_Migration, ///< The migration service
Service_Mii, ///< The Mii service
@@ -75,11 +81,13 @@ enum class Class : ClassType {
Service_NFC, ///< The NFC (Near-field communication) service
Service_NFP, ///< The NFP service
Service_NIFM, ///< The NIFM (Network interface) service
+ Service_NIM, ///< The NIM service
Service_NS, ///< The NS services
Service_NVDRV, ///< The NVDRV (Nvidia driver) service
Service_PCIE, ///< The PCIe service
Service_PCTL, ///< The PCTL (Parental control) service
Service_PCV, ///< The PCV service
+ Service_PM, ///< The PM service
Service_PREPO, ///< The PREPO (Play report) service
Service_PSC, ///< The PSC service
Service_SET, ///< The SET (Settings) service
diff --git a/src/common/vector_math.h b/src/common/vector_math.h
index cca43bd4c..8feb49941 100644
--- a/src/common/vector_math.h
+++ b/src/common/vector_math.h
@@ -43,139 +43,135 @@ template <typename T>
class Vec4;
template <typename T>
-static inline Vec2<T> MakeVec(const T& x, const T& y);
-template <typename T>
-static inline Vec3<T> MakeVec(const T& x, const T& y, const T& z);
-template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w);
-
-template <typename T>
class Vec2 {
public:
T x{};
T y{};
- Vec2() = default;
- Vec2(const T& _x, const T& _y) : x(_x), y(_y) {}
+ constexpr Vec2() = default;
+ constexpr Vec2(const T& x_, const T& y_) : x(x_), y(y_) {}
template <typename T2>
- Vec2<T2> Cast() const {
- return Vec2<T2>((T2)x, (T2)y);
+ constexpr Vec2<T2> Cast() const {
+ return Vec2<T2>(static_cast<T2>(x), static_cast<T2>(y));
}
- static Vec2 AssignToAll(const T& f) {
- return Vec2<T>(f, f);
+ static constexpr Vec2 AssignToAll(const T& f) {
+ return Vec2{f, f};
}
- Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
- return MakeVec(x + other.x, y + other.y);
+ constexpr Vec2<decltype(T{} + T{})> operator+(const Vec2& other) const {
+ return {x + other.x, y + other.y};
}
- void operator+=(const Vec2& other) {
+ constexpr Vec2& operator+=(const Vec2& other) {
x += other.x;
y += other.y;
+ return *this;
}
- Vec2<decltype(T{} - T{})> operator-(const Vec2& other) const {
- return MakeVec(x - other.x, y - other.y);
+ constexpr Vec2<decltype(T{} - T{})> operator-(const Vec2& other) const {
+ return {x - other.x, y - other.y};
}
- void operator-=(const Vec2& other) {
+ constexpr Vec2& operator-=(const Vec2& other) {
x -= other.x;
y -= other.y;
+ return *this;
}
template <typename U = T>
- Vec2<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
- return MakeVec(-x, -y);
+ constexpr Vec2<std::enable_if_t<std::is_signed_v<U>, U>> operator-() const {
+ return {-x, -y};
}
- Vec2<decltype(T{} * T{})> operator*(const Vec2& other) const {
- return MakeVec(x * other.x, y * other.y);
+ constexpr Vec2<decltype(T{} * T{})> operator*(const Vec2& other) const {
+ return {x * other.x, y * other.y};
}
+
template <typename V>
- Vec2<decltype(T{} * V{})> operator*(const V& f) const {
- return MakeVec(x * f, y * f);
+ constexpr Vec2<decltype(T{} * V{})> operator*(const V& f) const {
+ return {x * f, y * f};
}
+
template <typename V>
- void operator*=(const V& f) {
+ constexpr Vec2& operator*=(const V& f) {
*this = *this * f;
+ return *this;
}
+
template <typename V>
- Vec2<decltype(T{} / V{})> operator/(const V& f) const {
- return MakeVec(x / f, y / f);
+ constexpr Vec2<decltype(T{} / V{})> operator/(const V& f) const {
+ return {x / f, y / f};
}
+
template <typename V>
- void operator/=(const V& f) {
+ constexpr Vec2& operator/=(const V& f) {
*this = *this / f;
+ return *this;
}
- T Length2() const {
+ constexpr T Length2() const {
return x * x + y * y;
}
// Only implemented for T=float
float Length() const;
- void SetLength(const float l);
- Vec2 WithLength(const float l) const;
- float Distance2To(Vec2& other);
- Vec2 Normalized() const;
float Normalize(); // returns the previous length, which is often useful
- T& operator[](int i) // allow vector[1] = 3 (vector.y=3)
- {
+ constexpr T& operator[](std::size_t i) {
return *((&x) + i);
}
- T operator[](const int i) const {
+ constexpr const T& operator[](std::size_t i) const {
return *((&x) + i);
}
- void SetZero() {
+ constexpr void SetZero() {
x = 0;
y = 0;
}
// Common aliases: UV (texel coordinates), ST (texture coordinates)
- T& u() {
+ constexpr T& u() {
return x;
}
- T& v() {
+ constexpr T& v() {
return y;
}
- T& s() {
+ constexpr T& s() {
return x;
}
- T& t() {
+ constexpr T& t() {
return y;
}
- const T& u() const {
+ constexpr const T& u() const {
return x;
}
- const T& v() const {
+ constexpr const T& v() const {
return y;
}
- const T& s() const {
+ constexpr const T& s() const {
return x;
}
- const T& t() const {
+ constexpr const T& t() const {
return y;
}
// swizzlers - create a subvector of specific components
- const Vec2 yx() const {
+ constexpr Vec2 yx() const {
return Vec2(y, x);
}
- const Vec2 vu() const {
+ constexpr Vec2 vu() const {
return Vec2(y, x);
}
- const Vec2 ts() const {
+ constexpr Vec2 ts() const {
return Vec2(y, x);
}
};
template <typename T, typename V>
-Vec2<T> operator*(const V& f, const Vec2<T>& vec) {
+constexpr Vec2<T> operator*(const V& f, const Vec2<T>& vec) {
return Vec2<T>(f * vec.x, f * vec.y);
}
-typedef Vec2<float> Vec2f;
+using Vec2f = Vec2<float>;
template <>
inline float Vec2<float>::Length() const {
@@ -196,147 +192,151 @@ public:
T y{};
T z{};
- Vec3() = default;
- Vec3(const T& _x, const T& _y, const T& _z) : x(_x), y(_y), z(_z) {}
+ constexpr Vec3() = default;
+ constexpr Vec3(const T& x_, const T& y_, const T& z_) : x(x_), y(y_), z(z_) {}
template <typename T2>
- Vec3<T2> Cast() const {
- return MakeVec<T2>((T2)x, (T2)y, (T2)z);
+ constexpr Vec3<T2> Cast() const {
+ return Vec3<T2>(static_cast<T2>(x), static_cast<T2>(y), static_cast<T2>(z));
}
- // Only implemented for T=int and T=float
- static Vec3 FromRGB(unsigned int rgb);
- unsigned int ToRGB() const; // alpha bits set to zero
-
- static Vec3 AssignToAll(const T& f) {
- return MakeVec(f, f, f);
+ static constexpr Vec3 AssignToAll(const T& f) {
+ return Vec3(f, f, f);
}
- Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
- return MakeVec(x + other.x, y + other.y, z + other.z);
+ constexpr Vec3<decltype(T{} + T{})> operator+(const Vec3& other) const {
+ return {x + other.x, y + other.y, z + other.z};
}
- void operator+=(const Vec3& other) {
+
+ constexpr Vec3& operator+=(const Vec3& other) {
x += other.x;
y += other.y;
z += other.z;
+ return *this;
}
- Vec3<decltype(T{} - T{})> operator-(const Vec3& other) const {
- return MakeVec(x - other.x, y - other.y, z - other.z);
+
+ constexpr Vec3<decltype(T{} - T{})> operator-(const Vec3& other) const {
+ return {x - other.x, y - other.y, z - other.z};
}
- void operator-=(const Vec3& other) {
+
+ constexpr Vec3& operator-=(const Vec3& other) {
x -= other.x;
y -= other.y;
z -= other.z;
+ return *this;
}
template <typename U = T>
- Vec3<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
- return MakeVec(-x, -y, -z);
+ constexpr Vec3<std::enable_if_t<std::is_signed_v<U>, U>> operator-() const {
+ return {-x, -y, -z};
}
- Vec3<decltype(T{} * T{})> operator*(const Vec3& other) const {
- return MakeVec(x * other.x, y * other.y, z * other.z);
+
+ constexpr Vec3<decltype(T{} * T{})> operator*(const Vec3& other) const {
+ return {x * other.x, y * other.y, z * other.z};
}
+
template <typename V>
- Vec3<decltype(T{} * V{})> operator*(const V& f) const {
- return MakeVec(x * f, y * f, z * f);
+ constexpr Vec3<decltype(T{} * V{})> operator*(const V& f) const {
+ return {x * f, y * f, z * f};
}
+
template <typename V>
- void operator*=(const V& f) {
+ constexpr Vec3& operator*=(const V& f) {
*this = *this * f;
+ return *this;
}
template <typename V>
- Vec3<decltype(T{} / V{})> operator/(const V& f) const {
- return MakeVec(x / f, y / f, z / f);
+ constexpr Vec3<decltype(T{} / V{})> operator/(const V& f) const {
+ return {x / f, y / f, z / f};
}
+
template <typename V>
- void operator/=(const V& f) {
+ constexpr Vec3& operator/=(const V& f) {
*this = *this / f;
+ return *this;
}
- T Length2() const {
+ constexpr T Length2() const {
return x * x + y * y + z * z;
}
// Only implemented for T=float
float Length() const;
- void SetLength(const float l);
- Vec3 WithLength(const float l) const;
- float Distance2To(Vec3& other);
Vec3 Normalized() const;
float Normalize(); // returns the previous length, which is often useful
- T& operator[](int i) // allow vector[2] = 3 (vector.z=3)
- {
+ constexpr T& operator[](std::size_t i) {
return *((&x) + i);
}
- T operator[](const int i) const {
+
+ constexpr const T& operator[](std::size_t i) const {
return *((&x) + i);
}
- void SetZero() {
+ constexpr void SetZero() {
x = 0;
y = 0;
z = 0;
}
// Common aliases: UVW (texel coordinates), RGB (colors), STQ (texture coordinates)
- T& u() {
+ constexpr T& u() {
return x;
}
- T& v() {
+ constexpr T& v() {
return y;
}
- T& w() {
+ constexpr T& w() {
return z;
}
- T& r() {
+ constexpr T& r() {
return x;
}
- T& g() {
+ constexpr T& g() {
return y;
}
- T& b() {
+ constexpr T& b() {
return z;
}
- T& s() {
+ constexpr T& s() {
return x;
}
- T& t() {
+ constexpr T& t() {
return y;
}
- T& q() {
+ constexpr T& q() {
return z;
}
- const T& u() const {
+ constexpr const T& u() const {
return x;
}
- const T& v() const {
+ constexpr const T& v() const {
return y;
}
- const T& w() const {
+ constexpr const T& w() const {
return z;
}
- const T& r() const {
+ constexpr const T& r() const {
return x;
}
- const T& g() const {
+ constexpr const T& g() const {
return y;
}
- const T& b() const {
+ constexpr const T& b() const {
return z;
}
- const T& s() const {
+ constexpr const T& s() const {
return x;
}
- const T& t() const {
+ constexpr const T& t() const {
return y;
}
- const T& q() const {
+ constexpr const T& q() const {
return z;
}
@@ -345,7 +345,7 @@ public:
// _DEFINE_SWIZZLER2 defines a single such function, DEFINE_SWIZZLER2 defines all of them for all
// component names (x<->r) and permutations (xy<->yx)
#define _DEFINE_SWIZZLER2(a, b, name) \
- const Vec2<T> name() const { \
+ constexpr Vec2<T> name() const { \
return Vec2<T>(a, b); \
}
#define DEFINE_SWIZZLER2(a, b, a2, b2, a3, b3, a4, b4) \
@@ -366,7 +366,7 @@ public:
};
template <typename T, typename V>
-Vec3<T> operator*(const V& f, const Vec3<T>& vec) {
+constexpr Vec3<T> operator*(const V& f, const Vec3<T>& vec) {
return Vec3<T>(f * vec.x, f * vec.y, f * vec.z);
}
@@ -387,7 +387,7 @@ inline float Vec3<float>::Normalize() {
return length;
}
-typedef Vec3<float> Vec3f;
+using Vec3f = Vec3<float>;
template <typename T>
class Vec4 {
@@ -397,86 +397,88 @@ public:
T z{};
T w{};
- Vec4() = default;
- Vec4(const T& _x, const T& _y, const T& _z, const T& _w) : x(_x), y(_y), z(_z), w(_w) {}
+ constexpr Vec4() = default;
+ constexpr Vec4(const T& x_, const T& y_, const T& z_, const T& w_)
+ : x(x_), y(y_), z(z_), w(w_) {}
template <typename T2>
- Vec4<T2> Cast() const {
- return Vec4<T2>((T2)x, (T2)y, (T2)z, (T2)w);
+ constexpr Vec4<T2> Cast() const {
+ return Vec4<T2>(static_cast<T2>(x), static_cast<T2>(y), static_cast<T2>(z),
+ static_cast<T2>(w));
}
- // Only implemented for T=int and T=float
- static Vec4 FromRGBA(unsigned int rgba);
- unsigned int ToRGBA() const;
-
- static Vec4 AssignToAll(const T& f) {
- return Vec4<T>(f, f, f, f);
+ static constexpr Vec4 AssignToAll(const T& f) {
+ return Vec4(f, f, f, f);
}
- Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
- return MakeVec(x + other.x, y + other.y, z + other.z, w + other.w);
+ constexpr Vec4<decltype(T{} + T{})> operator+(const Vec4& other) const {
+ return {x + other.x, y + other.y, z + other.z, w + other.w};
}
- void operator+=(const Vec4& other) {
+
+ constexpr Vec4& operator+=(const Vec4& other) {
x += other.x;
y += other.y;
z += other.z;
w += other.w;
+ return *this;
}
- Vec4<decltype(T{} - T{})> operator-(const Vec4& other) const {
- return MakeVec(x - other.x, y - other.y, z - other.z, w - other.w);
+
+ constexpr Vec4<decltype(T{} - T{})> operator-(const Vec4& other) const {
+ return {x - other.x, y - other.y, z - other.z, w - other.w};
}
- void operator-=(const Vec4& other) {
+
+ constexpr Vec4& operator-=(const Vec4& other) {
x -= other.x;
y -= other.y;
z -= other.z;
w -= other.w;
+ return *this;
}
template <typename U = T>
- Vec4<std::enable_if_t<std::is_signed<U>::value, U>> operator-() const {
- return MakeVec(-x, -y, -z, -w);
+ constexpr Vec4<std::enable_if_t<std::is_signed_v<U>, U>> operator-() const {
+ return {-x, -y, -z, -w};
}
- Vec4<decltype(T{} * T{})> operator*(const Vec4& other) const {
- return MakeVec(x * other.x, y * other.y, z * other.z, w * other.w);
+
+ constexpr Vec4<decltype(T{} * T{})> operator*(const Vec4& other) const {
+ return {x * other.x, y * other.y, z * other.z, w * other.w};
}
+
template <typename V>
- Vec4<decltype(T{} * V{})> operator*(const V& f) const {
- return MakeVec(x * f, y * f, z * f, w * f);
+ constexpr Vec4<decltype(T{} * V{})> operator*(const V& f) const {
+ return {x * f, y * f, z * f, w * f};
}
+
template <typename V>
- void operator*=(const V& f) {
+ constexpr Vec4& operator*=(const V& f) {
*this = *this * f;
+ return *this;
}
+
template <typename V>
- Vec4<decltype(T{} / V{})> operator/(const V& f) const {
- return MakeVec(x / f, y / f, z / f, w / f);
+ constexpr Vec4<decltype(T{} / V{})> operator/(const V& f) const {
+ return {x / f, y / f, z / f, w / f};
}
+
template <typename V>
- void operator/=(const V& f) {
+ constexpr Vec4& operator/=(const V& f) {
*this = *this / f;
+ return *this;
}
- T Length2() const {
+ constexpr T Length2() const {
return x * x + y * y + z * z + w * w;
}
- // Only implemented for T=float
- float Length() const;
- void SetLength(const float l);
- Vec4 WithLength(const float l) const;
- float Distance2To(Vec4& other);
- Vec4 Normalized() const;
- float Normalize(); // returns the previous length, which is often useful
-
- T& operator[](int i) // allow vector[2] = 3 (vector.z=3)
- {
+ constexpr T& operator[](std::size_t i) {
return *((&x) + i);
}
- T operator[](const int i) const {
+
+ constexpr const T& operator[](std::size_t i) const {
return *((&x) + i);
}
- void SetZero() {
+ constexpr void SetZero() {
x = 0;
y = 0;
z = 0;
@@ -484,29 +486,29 @@ public:
}
// Common alias: RGBA (colors)
- T& r() {
+ constexpr T& r() {
return x;
}
- T& g() {
+ constexpr T& g() {
return y;
}
- T& b() {
+ constexpr T& b() {
return z;
}
- T& a() {
+ constexpr T& a() {
return w;
}
- const T& r() const {
+ constexpr const T& r() const {
return x;
}
- const T& g() const {
+ constexpr const T& g() const {
return y;
}
- const T& b() const {
+ constexpr const T& b() const {
return z;
}
- const T& a() const {
+ constexpr const T& a() const {
return w;
}
@@ -518,7 +520,7 @@ public:
// DEFINE_SWIZZLER2_COMP2 defines two component functions for all component names (x<->r) and
// permutations (xy<->yx)
#define _DEFINE_SWIZZLER2(a, b, name) \
- const Vec2<T> name() const { \
+ constexpr Vec2<T> name() const { \
return Vec2<T>(a, b); \
}
#define DEFINE_SWIZZLER2_COMP1(a, a2) \
@@ -545,7 +547,7 @@ public:
#undef _DEFINE_SWIZZLER2
#define _DEFINE_SWIZZLER3(a, b, c, name) \
- const Vec3<T> name() const { \
+ constexpr Vec3<T> name() const { \
return Vec3<T>(a, b, c); \
}
#define DEFINE_SWIZZLER3_COMP1(a, a2) \
@@ -579,51 +581,51 @@ public:
};
template <typename T, typename V>
-Vec4<decltype(V{} * T{})> operator*(const V& f, const Vec4<T>& vec) {
- return MakeVec(f * vec.x, f * vec.y, f * vec.z, f * vec.w);
+constexpr Vec4<decltype(V{} * T{})> operator*(const V& f, const Vec4<T>& vec) {
+ return {f * vec.x, f * vec.y, f * vec.z, f * vec.w};
}
-typedef Vec4<float> Vec4f;
+using Vec4f = Vec4<float>;
template <typename T>
-static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec2<T>& a, const Vec2<T>& b) {
+constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec2<T>& a, const Vec2<T>& b) {
return a.x * b.x + a.y * b.y;
}
template <typename T>
-static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec3<T>& a, const Vec3<T>& b) {
+constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec3<T>& a, const Vec3<T>& b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}
template <typename T>
-static inline decltype(T{} * T{} + T{} * T{}) Dot(const Vec4<T>& a, const Vec4<T>& b) {
+constexpr decltype(T{} * T{} + T{} * T{}) Dot(const Vec4<T>& a, const Vec4<T>& b) {
return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
}
template <typename T>
-static inline Vec3<decltype(T{} * T{} - T{} * T{})> Cross(const Vec3<T>& a, const Vec3<T>& b) {
- return MakeVec(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+constexpr Vec3<decltype(T{} * T{} - T{} * T{})> Cross(const Vec3<T>& a, const Vec3<T>& b) {
+ return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
}
// linear interpolation via float: 0.0=begin, 1.0=end
template <typename X>
-static inline decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
- const float t) {
+constexpr decltype(X{} * float{} + X{} * float{}) Lerp(const X& begin, const X& end,
+ const float t) {
return begin * (1.f - t) + end * t;
}
// linear interpolation via int: 0=begin, base=end
template <typename X, int base>
-static inline decltype((X{} * int{} + X{} * int{}) / base) LerpInt(const X& begin, const X& end,
- const int t) {
+constexpr decltype((X{} * int{} + X{} * int{}) / base) LerpInt(const X& begin, const X& end,
+ const int t) {
return (begin * (base - t) + end * t) / base;
}
// bilinear interpolation. s is for interpolating x00-x01 and x10-x11, and t is for the second
// interpolation.
template <typename X>
-inline auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X& x11, const float s,
- const float t) {
+constexpr auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X& x11, const float s,
+ const float t) {
auto y0 = Lerp(x00, x01, s);
auto y1 = Lerp(x10, x11, s);
return Lerp(y0, y1, t);
@@ -631,42 +633,42 @@ inline auto BilinearInterp(const X& x00, const X& x01, const X& x10, const X& x1
// Utility vector factories
template <typename T>
-static inline Vec2<T> MakeVec(const T& x, const T& y) {
+constexpr Vec2<T> MakeVec(const T& x, const T& y) {
return Vec2<T>{x, y};
}
template <typename T>
-static inline Vec3<T> MakeVec(const T& x, const T& y, const T& z) {
+constexpr Vec3<T> MakeVec(const T& x, const T& y, const T& z) {
return Vec3<T>{x, y, z};
}
template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const T& y, const Vec2<T>& zw) {
+constexpr Vec4<T> MakeVec(const T& x, const T& y, const Vec2<T>& zw) {
return MakeVec(x, y, zw[0], zw[1]);
}
template <typename T>
-static inline Vec3<T> MakeVec(const Vec2<T>& xy, const T& z) {
+constexpr Vec3<T> MakeVec(const Vec2<T>& xy, const T& z) {
return MakeVec(xy[0], xy[1], z);
}
template <typename T>
-static inline Vec3<T> MakeVec(const T& x, const Vec2<T>& yz) {
+constexpr Vec3<T> MakeVec(const T& x, const Vec2<T>& yz) {
return MakeVec(x, yz[0], yz[1]);
}
template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w) {
+constexpr Vec4<T> MakeVec(const T& x, const T& y, const T& z, const T& w) {
return Vec4<T>{x, y, z, w};
}
template <typename T>
-static inline Vec4<T> MakeVec(const Vec2<T>& xy, const T& z, const T& w) {
+constexpr Vec4<T> MakeVec(const Vec2<T>& xy, const T& z, const T& w) {
return MakeVec(xy[0], xy[1], z, w);
}
template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
+constexpr Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
return MakeVec(x, yz[0], yz[1], w);
}
@@ -674,17 +676,17 @@ static inline Vec4<T> MakeVec(const T& x, const Vec2<T>& yz, const T& w) {
// Even if someone wanted to use an odd object like Vec2<Vec2<T>>, the compiler would error
// out soon enough due to misuse of the returned structure.
template <typename T>
-static inline Vec4<T> MakeVec(const Vec2<T>& xy, const Vec2<T>& zw) {
+constexpr Vec4<T> MakeVec(const Vec2<T>& xy, const Vec2<T>& zw) {
return MakeVec(xy[0], xy[1], zw[0], zw[1]);
}
template <typename T>
-static inline Vec4<T> MakeVec(const Vec3<T>& xyz, const T& w) {
+constexpr Vec4<T> MakeVec(const Vec3<T>& xyz, const T& w) {
return MakeVec(xyz[0], xyz[1], xyz[2], w);
}
template <typename T>
-static inline Vec4<T> MakeVec(const T& x, const Vec3<T>& yzw) {
+constexpr Vec4<T> MakeVec(const T& x, const Vec3<T>& yzw) {
return MakeVec(x, yzw[0], yzw[1], yzw[2]);
}
diff --git a/src/common/x64/xbyak_util.h b/src/common/x64/xbyak_util.h
index 0f52f704b..ec76e0a47 100644
--- a/src/common/x64/xbyak_util.h
+++ b/src/common/x64/xbyak_util.h
@@ -34,7 +34,7 @@ inline bool IsWithin2G(const Xbyak::CodeGenerator& code, uintptr_t target) {
template <typename T>
inline void CallFarFunction(Xbyak::CodeGenerator& code, const T f) {
- static_assert(std::is_pointer<T>(), "Argument must be a (function) pointer.");
+ static_assert(std::is_pointer_v<T>, "Argument must be a (function) pointer.");
size_t addr = reinterpret_cast<size_t>(f);
if (IsWithin2G(code, addr)) {
code.call(f);
generated by cgit v1.2.3 (git 2.25.1) at 2024-10-03 14:59:18 +0200