PSXFixed.hpp

Go to the documentation of this file.

 
#ifndef COM_SAXBOPHONE_UNMOVING_PSX_FIXED_HPP
#define COM_SAXBOPHONE_UNMOVING_PSX_FIXED_HPP
 
// we can get int32 and size_t from the C++ standard library when build is hosted
#if __STDC_HOSTED__
#include <cstddef> // size_t
#include <cstdint> // int32
#else
// NOTE: this C header is specific to the PSX SDK
#include <sys/types.h> // int32, size_t
#endif
/*
 * get other symbols from the C headers as these are guaranteed to exist both in
 * C++ and the PSX SDK
 */
#include <stdio.h>  // snprintf
#include <stdlib.h> // abs
 
namespace unmoving {
    class PSXFixed; // forward-declaration to allow declaration of user-defined literals
 
    constexpr PSXFixed operator"" _fx(long double literal);
 
    constexpr PSXFixed operator"" _fx(unsigned long long int literal);
 
    class PSXFixed {
    public:
        using UnderlyingType = int32_t;
        static constexpr size_t DECIMAL_BITS = 19;
        static constexpr size_t FRACTION_BITS = 12;
        static constexpr UnderlyingType SCALE = 1 << PSXFixed::FRACTION_BITS;
        static constexpr double PRECISION = 1.0 / PSXFixed::SCALE;
        static constexpr double ACCURACY = PSXFixed::PRECISION / 2.0;
        static constexpr UnderlyingType DECIMAL_MAX = (1 << PSXFixed::DECIMAL_BITS) - 1;
        static constexpr UnderlyingType DECIMAL_MIN = -(1 << PSXFixed::DECIMAL_BITS);
        static constexpr double FRACTIONAL_MAX = PSXFixed::DECIMAL_MAX + (1.0 - PSXFixed::PRECISION);
        static constexpr double FRACTIONAL_MIN = PSXFixed::DECIMAL_MIN;
        static constexpr PSXFixed MAX() {
            return PSXFixed((UnderlyingType)2147483647);
        }
        static constexpr PSXFixed MIN() {
            return PSXFixed((UnderlyingType)-2147483648);
        }
        constexpr PSXFixed() : _raw_value(0) {}
        constexpr PSXFixed(UnderlyingType raw_value) : _raw_value(raw_value) {}
        constexpr PSXFixed(double value) {
            double scaled = value * PSXFixed::SCALE;
            // separate into integer and fraction so we can round the fraction
            UnderlyingType integral = (UnderlyingType)scaled;
            double remainder = scaled - integral;
            // there's no rounding function in the PS1 stdlib so round manually
            if (remainder <= -0.5 or remainder >= 0.5) { // round half to infinity
                integral += (integral < 0 ? -1 : 1);
            }
            this->_raw_value = integral;
        }
        static constexpr PSXFixed from_integer(int value) {
            return PSXFixed(value << PSXFixed::FRACTION_BITS);
        }
        constexpr operator UnderlyingType() const {
            return this->_raw_value;
        }
        explicit constexpr operator double() const {
            return (double)this->_raw_value / PSXFixed::SCALE;
        }
        explicit constexpr operator float() const {
            // reuse cast to double and then narrow it to float
            return (float)(double)*this;
        }
        constexpr UnderlyingType to_integer() const {
            // can't use a right-shift here due to it not handling negative values properly
            return this->_raw_value / PSXFixed::SCALE;
        }
        constexpr bool to_c_str(char* buffer, size_t buffer_size) const {
            // don't write to a null-pointer!
            if (buffer == nullptr) { return false; }
            // need at least 14 characters and 1 for the null-terminator
            if (buffer_size < 15) { return false; } // refuse if not at least this many in buffer
            int decimal_part = this->_raw_value / 4096; // floor-divide
            // decompose the fractional part into an unsigned int to allow us to scale it up for more decimal places
            unsigned int remainder = ((unsigned int)abs(this->_raw_value)) % 4096;
            // 1M is the maximum we can scale it up without overflow, since 4096*1M = 4096M, compared to max uint32 = ~4294M
            unsigned int fractional_part = (remainder * 1'000'000) / 4096; // this gives us 6 decimal places
            // can't print a negative sign if negative but decimal_part is zero
            if (this->_raw_value < 0 and decimal_part == 0) {
                snprintf(buffer, buffer_size, "-0.%06u", fractional_part);
            } else { // otherwise, we can rely on snprintf() to do it for us
                snprintf(buffer, buffer_size, "%d.%06u", decimal_part, fractional_part);
            }
            return true;
        }
        constexpr PSXFixed& operator++() {
            *this += PSXFixed::SCALE;
            return *this;
        }
        constexpr PSXFixed& operator--() {
            *this -= PSXFixed::SCALE;
            return *this;
        }
        constexpr PSXFixed operator++(int) {
            PSXFixed old = *this; // copy old value
            ++*this; // prefix increment
            return old; // return old value
        }
        constexpr PSXFixed operator--(int) {
            PSXFixed old = *this; // copy old value
            --*this; // prefix decrement
            return old; // return old value
        }
        constexpr PSXFixed& operator +=(const PSXFixed& rhs) {
            this->_raw_value += rhs._raw_value;
            return *this;
        }
        constexpr PSXFixed& operator -=(const PSXFixed& rhs) {
            this->_raw_value -= rhs._raw_value;
            return *this;
        }
        constexpr PSXFixed& operator *=(const PSXFixed& rhs) {
            // XXX: no int64_t on PS1, software emulation kicks in automatically
            int64_t result = (int64_t)this->_raw_value * rhs._raw_value;
            // shift back down
            this->_raw_value = (UnderlyingType)(result / PSXFixed::SCALE);
            return *this;
        }
        constexpr PSXFixed& operator *=(const UnderlyingType& rhs) {
            this->_raw_value *= rhs;
            return *this;
        }
        constexpr PSXFixed& operator /=(const PSXFixed& rhs) {
            // XXX: no int64_t on PS1, software emulation kicks in automatically
            int64_t scaled = (int64_t)this->_raw_value * PSXFixed::SCALE;
            this->_raw_value = (UnderlyingType)(scaled / rhs._raw_value);
            return *this;
        }
        constexpr PSXFixed& operator /=(const UnderlyingType& rhs) {
            this->_raw_value /= rhs;
            return *this;
        }
        constexpr PSXFixed operator-() const {
            return PSXFixed(-this->_raw_value);
        }
        constexpr friend PSXFixed operator+(PSXFixed lhs, const PSXFixed& rhs) {
            lhs += rhs;
            return lhs;
        }
        constexpr friend PSXFixed operator-(PSXFixed lhs, const PSXFixed& rhs) {
            lhs -= rhs;
            return lhs;
        }
        constexpr friend PSXFixed operator*(PSXFixed lhs, const PSXFixed& rhs) {
            lhs *= rhs;
            return lhs;
        }
        constexpr friend PSXFixed operator*(PSXFixed lhs, const UnderlyingType& rhs) {
            lhs *= rhs;
            return lhs;
        }
        constexpr friend PSXFixed operator*(UnderlyingType lhs, const PSXFixed& rhs) {
            return rhs * lhs;
        }
        constexpr friend PSXFixed operator/(PSXFixed lhs, const PSXFixed& rhs) {
            lhs /= rhs;
            return lhs;
        }
        constexpr friend PSXFixed operator/(PSXFixed lhs, const UnderlyingType& rhs) {
            lhs /= rhs;
            return lhs;
        }
 
    private:
        UnderlyingType _raw_value;
    };
 
    constexpr PSXFixed operator"" _fx(long double literal) {
        return PSXFixed((double)literal);
    }
 
    constexpr PSXFixed operator"" _fx(unsigned long long int literal) {
        return PSXFixed::from_integer((PSXFixed::UnderlyingType)literal);
    }
}
 
#endif // include guard