mirrors/Panda3DS
0
0
Fork 0
mirror of https://github.com/wheremyfoodat/Panda3DS.git synced 2025-09-26 11:18:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Formatting fixes (#781)

Browse source 
* Formatting

* More formatting

* More formatting

* More formatting
This commit is contained in:
wheremyfoodat 2025-07-21 00:33:24 +03:00 • committed by GitHub
commit 146dc92a0f
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
6 changed files with 408 additions and 532 deletions
Download patch file Download diff file Expand all files Collapse all files

67
include/PICA/float_types.hpp
View file

@ -6,6 +6,7 @@
#include <cmath>
#include <cstring>
#include "helpers.hpp"
namespace Floats {
@ -44,8 +45,7 @@ namespace Floats {
else
exponent += bias;
hex = sign | (mantissa << (23 - M)) | (exponent << 23);
}
else {
} else {
hex = sign;
}
@ -54,47 +54,30 @@ namespace Floats {
return res;
}
static Float<M, E> zero() {
return fromFloat32(0.f);
}
static Float<M, E> zero() { return fromFloat32(0.f); }
// Not recommended for anything but logging
float toFloat32() const {
return value;
}
float toFloat32() const { return value; }
double toFloat64() const {
return static_cast<double>(value);
}
double toFloat64() const { return static_cast<double>(value); }
operator float() {
return toFloat32();
}
operator float() { return toFloat32(); }
operator double() {
return toFloat64();
}
operator double() { return toFloat64(); }
Float<M, E> operator*(const Float<M, E>& flt) const {
float result = value * flt.toFloat32();
// PICA gives 0 instead of NaN when multiplying by inf
if (std::isnan(result))
if (!std::isnan(value) && !std::isnan(flt.toFloat32()))
result = 0.f;
if (!std::isnan(value) && !std::isnan(flt.toFloat32())) result = 0.f;
return Float<M, E>::fromFloat32(result);
}
Float<M, E> operator/(const Float<M, E>& flt) const {
return Float<M, E>::fromFloat32(toFloat32() / flt.toFloat32());
}
Float<M, E> operator/(const Float<M, E>& flt) const { return Float<M, E>::fromFloat32(toFloat32() / flt.toFloat32()); }
Float<M, E> operator+(const Float<M, E>& flt) const {
return Float<M, E>::fromFloat32(toFloat32() + flt.toFloat32());
}
Float<M, E> operator+(const Float<M, E>& flt) const { return Float<M, E>::fromFloat32(toFloat32() + flt.toFloat32()); }
Float<M, E> operator-(const Float<M, E>& flt) const {
return Float<M, E>::fromFloat32(toFloat32() - flt.toFloat32());
}
Float<M, E> operator-(const Float<M, E>& flt) const { return Float<M, E>::fromFloat32(toFloat32() - flt.toFloat32()); }
Float<M, E>& operator*=(const Float<M, E>& flt) {
value = operator*(flt).value;
@ -116,33 +99,19 @@ namespace Floats {
return *this;
}
Float<M, E> operator-() const {
return Float<M, E>::fromFloat32(-toFloat32());
}
Float<M, E> operator-() const { return Float<M, E>::fromFloat32(-toFloat32()); }
bool operator<(const Float<M, E>& flt) const {
return toFloat32() < flt.toFloat32();
}
bool operator<(const Float<M, E>& flt) const { return toFloat32() < flt.toFloat32(); }
bool operator>(const Float<M, E>& flt) const {
return toFloat32() > flt.toFloat32();
}
bool operator>(const Float<M, E>& flt) const { return toFloat32() > flt.toFloat32(); }
bool operator>=(const Float<M, E>& flt) const {
return toFloat32() >= flt.toFloat32();
}
bool operator>=(const Float<M, E>& flt) const { return toFloat32() >= flt.toFloat32(); }
bool operator<=(const Float<M, E>& flt) const {
return toFloat32() <= flt.toFloat32();
}
bool operator<=(const Float<M, E>& flt) const { return toFloat32() <= flt.toFloat32(); }
bool operator==(const Float<M, E>& flt) const {
return toFloat32() == flt.toFloat32();
}
bool operator==(const Float<M, E>& flt) const { return toFloat32() == flt.toFloat32(); }
bool operator!=(const Float<M, E>& flt) const {
return toFloat32() != flt.toFloat32();
}
bool operator!=(const Float<M, E>& flt) const { return toFloat32() != flt.toFloat32(); }
private:
static constexpr unsigned MASK = (1 << (M + E + 1)) - 1;

1
include/panda_qt/config_window.hpp
View file

@ -16,7 +16,6 @@
#include "emulator.hpp"
#include "frontend_settings.hpp"
#include "input_mappings.hpp"
#include "panda_qt/input_window.hpp"
class ConfigWindow : public QDialog {

3
include/panda_qt/thread_debugger.hpp
View file

@ -5,9 +5,6 @@
#include <QTimer>
#include <QVBoxLayout>
#include <QtWidgets>
#include <atomic>
#include <chrono>
#include <thread>
#include "emulator.hpp"

2
include/sdl_sensors.hpp
View file

@ -1,6 +1,6 @@
#pragma once
#include <cmath>
#include <algorithm>
#include <glm/glm.hpp>
#include "helpers.hpp"

185
include/swap.hpp
View file

@ -23,6 +23,7 @@
#include <cstdlib>
#endif
#include <cstring>
#include "helpers.hpp"
// GCC
@ -57,15 +58,9 @@
namespace Common {
#ifdef _MSC_VER
[[nodiscard]] inline u16 swap16(u16 data) noexcept {
return _byteswap_ushort(data);
}
[[nodiscard]] inline u32 swap32(u32 data) noexcept {
return _byteswap_ulong(data);
}
[[nodiscard]] inline u64 swap64(u64 data) noexcept {
return _byteswap_uint64(data);
}
[[nodiscard]] inline u16 swap16(u16 data) noexcept { return _byteswap_ushort(data); }
[[nodiscard]] inline u32 swap32(u32 data) noexcept { return _byteswap_ulong(data); }
[[nodiscard]] inline u64 swap64(u64 data) noexcept { return _byteswap_uint64(data); }
#elif defined(__clang__) || defined(__GNUC__)
#if defined(__Bitrig__) || defined(__OpenBSD__)
// redefine swap16, swap32, swap64 as inline functions
@ -73,28 +68,18 @@ namespace Common {
#undef swap32
#undef swap64
#endif
[[nodiscard]] inline u16 swap16(u16 data) noexcept {
return __builtin_bswap16(data);
}
[[nodiscard]] inline u32 swap32(u32 data) noexcept {
return __builtin_bswap32(data);
}
[[nodiscard]] inline u64 swap64(u64 data) noexcept {
return __builtin_bswap64(data);
}
[[nodiscard]] inline u16 swap16(u16 data) noexcept { return __builtin_bswap16(data); }
[[nodiscard]] inline u32 swap32(u32 data) noexcept { return __builtin_bswap32(data); }
[[nodiscard]] inline u64 swap64(u64 data) noexcept { return __builtin_bswap64(data); }
#else
// Generic implementation.
[[nodiscard]] inline u16 swap16(u16 data) noexcept {
return (data >> 8) | (data << 8);
}
[[nodiscard]] inline u16 swap16(u16 data) noexcept { return (data >> 8) | (data << 8); }
[[nodiscard]] inline u32 swap32(u32 data) noexcept {
return ((data & 0xFF000000U) >> 24) | ((data & 0x00FF0000U) >> 8) |
((data & 0x0000FF00U) << 8) | ((data & 0x000000FFU) << 24);
return ((data & 0xFF000000U) >> 24) | ((data & 0x00FF0000U) >> 8) | ((data & 0x0000FF00U) << 8) | ((data & 0x000000FFU) << 24);
}
[[nodiscard]] inline u64 swap64(u64 data) noexcept {
return ((data & 0xFF00000000000000ULL) >> 56) | ((data & 0x00FF000000000000ULL) >> 40) |
((data & 0x0000FF0000000000ULL) >> 24) | ((data & 0x000000FF00000000ULL) >> 8) |
((data & 0x00000000FF000000ULL) << 8) | ((data & 0x0000000000FF0000ULL) << 24) |
return ((data & 0xFF00000000000000ULL) >> 56) | ((data & 0x00FF000000000000ULL) >> 40) | ((data & 0x0000FF0000000000ULL) >> 24) |
((data & 0x000000FF00000000ULL) >> 8) | ((data & 0x00000000FF000000ULL) << 8) | ((data & 0x0000000000FF0000ULL) << 24) |
((data & 0x000000000000FF00ULL) << 40) | ((data & 0x00000000000000FFULL) << 56);
}
#endif
@ -132,14 +117,10 @@ struct swap_struct_t {
protected:
T value;
static T swap(T v) {
return F::swap(v);
}
static T swap(T v) { return F::swap(v); }
public:
T swap() const {
return swap(value);
}
T swap() const { return swap(value); }
swap_struct_t() = default;
swap_struct_t(const T& v) : value(swap(v)) {}
@ -149,76 +130,44 @@ public:
return *this;
}
operator s8() const {
return static_cast<s8>(swap());
}
operator u8() const {
return static_cast<u8>(swap());
}
operator s16() const {
return static_cast<s16>(swap());
}
operator u16() const {
return static_cast<u16>(swap());
}
operator s32() const {
return static_cast<s32>(swap());
}
operator u32() const {
return static_cast<u32>(swap());
}
operator s64() const {
return static_cast<s64>(swap());
}
operator u64() const {
return static_cast<u64>(swap());
}
operator float() const {
return static_cast<float>(swap());
}
operator double() const {
return static_cast<double>(swap());
}
operator s8() const { return static_cast<s8>(swap()); }
operator u8() const { return static_cast<u8>(swap()); }
operator s16() const { return static_cast<s16>(swap()); }
operator u16() const { return static_cast<u16>(swap()); }
operator s32() const { return static_cast<s32>(swap()); }
operator u32() const { return static_cast<u32>(swap()); }
operator s64() const { return static_cast<s64>(swap()); }
operator u64() const { return static_cast<u64>(swap()); }
operator float() const { return static_cast<float>(swap()); }
operator double() const { return static_cast<double>(swap()); }
// +v
swapped_t operator+() const {
return +swap();
}
swapped_t operator+() const { return +swap(); }
// -v
swapped_t operator-() const {
return -swap();
}
swapped_t operator-() const { return -swap(); }
// v / 5
swapped_t operator/(const swapped_t& i) const {
return swap() / i.swap();
}
swapped_t operator/(const swapped_t& i) const { return swap() / i.swap(); }
template <typename S>
swapped_t operator/(const S& i) const {
return swap() / i;
}
// v * 5
swapped_t operator*(const swapped_t& i) const {
return swap() * i.swap();
}
swapped_t operator*(const swapped_t& i) const { return swap() * i.swap(); }
template <typename S>
swapped_t operator*(const S& i) const {
return swap() * i;
}
// v + 5
swapped_t operator+(const swapped_t& i) const {
return swap() + i.swap();
}
swapped_t operator+(const swapped_t& i) const { return swap() + i.swap(); }
template <typename S>
swapped_t operator+(const S& i) const {
return swap() + static_cast<T>(i);
}
// v - 5
swapped_t operator-(const swapped_t& i) const {
return swap() - i.swap();
}
swapped_t operator-(const swapped_t& i) const { return swap() - i.swap(); }
template <typename S>
swapped_t operator-(const S& i) const {
return swap() - static_cast<T>(i);
@ -270,72 +219,54 @@ public:
}
// Comparaison
// v == i
bool operator==(const swapped_t& i) const {
return swap() == i.swap();
}
bool operator==(const swapped_t& i) const { return swap() == i.swap(); }
template <typename S>
bool operator==(const S& i) const {
return swap() == i;
}
// v != i
bool operator!=(const swapped_t& i) const {
return swap() != i.swap();
}
bool operator!=(const swapped_t& i) const { return swap() != i.swap(); }
template <typename S>
bool operator!=(const S& i) const {
return swap() != i;
}
// v > i
bool operator>(const swapped_t& i) const {
return swap() > i.swap();
}
bool operator>(const swapped_t& i) const { return swap() > i.swap(); }
template <typename S>
bool operator>(const S& i) const {
return swap() > i;
}
// v < i
bool operator<(const swapped_t& i) const {
return swap() < i.swap();
}
bool operator<(const swapped_t& i) const { return swap() < i.swap(); }
template <typename S>
bool operator<(const S& i) const {
return swap() < i;
}
// v >= i
bool operator>=(const swapped_t& i) const {
return swap() >= i.swap();
}
bool operator>=(const swapped_t& i) const { return swap() >= i.swap(); }
template <typename S>
bool operator>=(const S& i) const {
return swap() >= i;
}
// v <= i
bool operator<=(const swapped_t& i) const {
return swap() <= i.swap();
}
bool operator<=(const swapped_t& i) const { return swap() <= i.swap(); }
template <typename S>
bool operator<=(const S& i) const {
return swap() <= i;
}
// logical
swapped_t operator!() const {
return !swap();
}
swapped_t operator!() const { return !swap(); }
// bitmath
swapped_t operator~() const {
return ~swap();
}
swapped_t operator~() const { return ~swap(); }
swapped_t operator&(const swapped_t& b) const {
return swap() & b.swap();
}
swapped_t operator&(const swapped_t& b) const { return swap() & b.swap(); }
template <typename S>
swapped_t operator&(const S& b) const {
return swap() & b;
@ -350,9 +281,7 @@ public:
return *this;
}
swapped_t operator|(const swapped_t& b) const {
return swap() | b.swap();
}
swapped_t operator|(const swapped_t& b) const { return swap() | b.swap(); }
template <typename S>
swapped_t operator|(const S& b) const {
return swap() | b;
@ -367,9 +296,7 @@ public:
return *this;
}
swapped_t operator^(const swapped_t& b) const {
return swap() ^ b.swap();
}
swapped_t operator^(const swapped_t& b) const { return swap() ^ b.swap(); }
template <typename S>
swapped_t operator^(const S& b) const {
return swap() ^ b;
@ -532,37 +459,27 @@ bool operator==(const S& p, const swap_struct_t<T, F> v) {
template <typename T>
struct swap_64_t {
static T swap(T x) {
return static_cast<T>(Common::swap64(x));
}
static T swap(T x) { return static_cast<T>(Common::swap64(x)); }
};
template <typename T>
struct swap_32_t {
static T swap(T x) {
return static_cast<T>(Common::swap32(x));
}
static T swap(T x) { return static_cast<T>(Common::swap32(x)); }
};
template <typename T>
struct swap_16_t {
static T swap(T x) {
return static_cast<T>(Common::swap16(x));
}
static T swap(T x) { return static_cast<T>(Common::swap16(x)); }
};
template <typename T>
struct swap_float_t {
static T swap(T x) {
return static_cast<T>(Common::swapf(x));
}
static T swap(T x) { return static_cast<T>(Common::swapf(x)); }
};
template <typename T>
struct swap_double_t {
static T swap(T x) {
return static_cast<T>(Common::swapd(x));
}
static T swap(T x) { return static_cast<T>(Common::swapd(x)); }
};
template <typename T>
@ -579,13 +496,9 @@ public:
return *this;
}
operator T() const {
return swap(value);
}
operator T() const { return swap(value); }
explicit operator base() const {
return static_cast<base>(swap(value));
}
explicit operator base() const { return static_cast<base>(swap(value)); }
protected:
T value{};
@ -598,9 +511,7 @@ protected:
std::is_same_v<base, u64>, swap_64_t<u64>, std::conditional_t<
std::is_same_v<base, s64>, swap_64_t<s64>, void>>>>>>;
// clang-format on
static T swap(T x) {
return static_cast<T>(swap_t::swap(static_cast<base>(x)));
}
static T swap(T x) { return static_cast<T>(swap_t::swap(static_cast<base>(x))); }
};
struct SwapTag {}; // Use the different endianness from the system