Types.h

Go to the documentation of this file.

#include <stdint.h>
 
#pragma once
 
namespace Gorgon {
        
    typedef unsigned char Byte;
    
#ifdef GORGON_USE_DOUBLE
    typedef double Float;
#else
    typedef float Float;
#endif
 
    template<class T_>
    class Range {
    public:
        Range() = default;
        Range(T_ start, T_ end) : Start(start), End(end) { }
 
        void Normalize() {
            if(Start > End) {
                auto t = End;
                End = Start;
                Start = t;
            }
        }
 
        T_ Difference() const { 
            return End - Start;
        }
 
        T_ Start = T_();
        T_ End   = T_();
    };
    
    typedef uint32_t Char;
    
    static const Float PI = (Float)3.141592653589793;
    
    class Empty {};
    
    enum class YesNoAuto {
        No = 0,
        Yes = 1,
        Auto = 2
    };
 
    enum class YesNoUnset {
        No = 0,
        Yes = 1,
        Unset = 2
    };
 
    inline int NumberOfSetBits(uint32_t i) {
        i = i - ((i >> 1) & 0x55555555);
        i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
        return (((i + (i >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24;
    }
    
    inline uint32_t CeilToPowerOf2(uint32_t v) {
        v--;
        v |= v >> 1;
        v |= v >> 2;
        v |= v >> 4;
        v |= v >> 8;
        v |= v >> 16;
        v++;
        
        return v;
    }
    
    template<class T_>
    void FitInto(T_ &v, T_ min, T_ max) {
        //replace with std::clamp once C++17 is enforced
        
        v = v < min ? min : (v > max ? max : v);
    }
    
    template<class T_>
    T_ Clamp(T_ v, T_ min, T_ max) {
        //replace with std::clamp once C++17 is enforced
        
        return v < min ? min : (v > max ? max : v);
    }
 
    template<class T_>
    bool Between(T_ v, T_ min, T_ max) {
        return v >= min && v < max;
    }
 
    template<class T_>
    bool Between(Range<T_> range, T_ v) {
        return v >= range.Start && v < range.End;
    }
 
    template<class T_>
    bool BetweenInclusive(T_ v, T_ min, T_ max) {
        return v >= min && v <= max;
    }
    template <typename T_>
    int Sign(T_ val) {
        return (T_{} < val) - (val < T_{});
    }
    
    template <typename T_>
    T_ PositiveMod(T_ value, T_ mod) {
        return ((value%mod)+mod)%mod;
    }
 
    class AssumeOwnershipTag { };
    
    static constexpr AssumeOwnershipTag AssumeOwnership;
 
    class Updatable {
    public:
        virtual ~Updatable() {}
 
        virtual void Update() = 0;
    };
    
    enum class Parity {
        None = 0,
        Odd  = 1,
        Even = 2,
    };
    
    enum class ItemPosition {
        Nowhere = 0,
        Alone   = 1,
        First   = 2,
        Middle  = 3,
        Last    = 4
    };
 
    
#ifdef DOXYGEN
#   define ENUMCLASS enum
#else
#   define ENUMCLASS enum class
#endif
}