jmCommon.h

#ifndef JUGIMAP_COMMON_H
#define JUGIMAP_COMMON_H
 
#include <assert.h>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
 
 
 
namespace jugimap {
 
 
 
 
 
 
template< typename T>
struct Vec2
{
    T x;                    
    T y;                    
 
 
    Vec2(): x(0),y(0){}
 
    Vec2(T _x, T _y) : x(_x),y(_y){}
 
    inline void Set(T _x, T _y){ x = _x;  y = _y;}
 
    inline bool operator==(const Vec2<T> &v) const { return(x==v.x && y==v.y);}
 
    inline bool operator!=(const Vec2<T> &v) const { return !(*this==v);}
 
    inline bool Equals(const Vec2<T> &v, float epsilon = 0.00001f) const { return(x==v.x && y==v.y); }
 
    inline Vec2<T> operator-() const { return Vec2<T>(-x,-y); }
 
    inline Vec2<T> operator*(const Vec2<T>&v) const { return Vec2<T>(x*v.x,y*v.y);}
 
    inline Vec2<T> operator/(const Vec2<T>&v) const { return Vec2<T>(x/v.x,y/v.y);}
 
    inline Vec2<T> operator+(const Vec2<T>&v) const { return Vec2<T>(x+v.x,y+v.y);}
 
    inline Vec2<T> operator-(const Vec2<T>&v) const { return Vec2<T>(x-v.x,y-v.y);}
 
    inline Vec2<T>& operator+=(const Vec2<T>&v)
    {
        x += v.x;
        y += v.y;
        return *this;
    }
 
    inline Vec2<T>& operator-=(const Vec2<T>&v)
    {
        x -= v.x;
        y -= v.y;
        return *this;
    }
 
    inline Vec2<T>& operator*=(const Vec2<T>&v)
    {
        x *= v.x;
        y *= v.y;
        return *this;
    }
 
    inline Vec2<T>& operator/=(const Vec2<T>&v)
    {
        x /= v.x;
        y /= v.y;
        return *this;
    }
 
    inline Vec2<T>& operator+=(T s)
    {
        x += s;
        y += s;
        return *this;
    }
 
    inline Vec2<T>& operator-=(T s)
    {
        x -= s;
        y -= s;
        return *this;
    }
 
    inline Vec2<T>& operator*=(T s)
    {
        x *= s;
        y *= s;
        return *this;
    }
 
    inline Vec2<T>& operator/=(T s)
    {
        x /= s;
        y /= s;
        return *this;
    }
 
    inline Vec2<T> operator*(double s) const { return Vec2<T>(x*s,y*s);}
 
    inline Vec2<T> operator/(double s) const { return Vec2<T>(x/s,y/s);}
 
    inline Vec2<T> operator+(T s) const { return Vec2<T>(x+s,y+s);}
 
    inline Vec2<T> operator-(T s) const { return Vec2<T>(x-s,y-s);}
 
    inline double GetLength() const { return std::sqrt(x*x+y*y);}
 
    inline double GetLength2() const { return x*x+y*y;}
 
    inline double Distance(const Vec2<T>&v) const { return (v-*this).GetLength();}
 
    inline double Distance2(const Vec2<T>&v) const { return (v-*this).GetLength2();}
 
    inline Vec2<T> Normalize() const { return *this/GetLength();}
 
    inline T Dot(const Vec2<T> &v) const { return x*v.x+y*v.y;}
 
};
 
 
template<>
inline bool Vec2<float>::Equals(const Vec2<float>&v, float epsilon) const
{
    return  fabs(x - v.x)<epsilon && fabs(y - v.y)<epsilon ;
}
 
typedef Vec2<int> Vec2i;            
typedef Vec2<float> Vec2f;          
 
 
 
 
template<typename T>
struct Rect
{
 
    Vec2<T> min;            
    Vec2<T> max;            
 
 
    Rect(){}
 
    Rect( T xMin, T yMin, T xMax, T yMax) { min = Vec2<T>( xMin,yMin ); max = Vec2<T>( xMax,yMax ); }
 
    Rect(const Vec2<T> &_min, const Vec2<T> &_max){ min = _min; max = _max; }
 
    bool operator==(const Rect<T> &r) const { return(min==r.min && max==r.max); }
 
    bool operator!=(const Rect<T> &r) const { return !(*this==r); }
 
    inline bool Equals(const Rect<T> &r, float epsilon = 0.00001f) const { return(min==r.min && max==r.max); }
 
    inline T GetWidth() const { return max.x-min.x; }
 
    inline T GetHeight() const { return max.y-min.y; }
 
    Rect<T> Unite(const Rect<T> &r) const
    {
        T x0 = std::min<T>( min.x, r.min.x );
        T y0 = std::min<T>( min.y, r.min.y );
        T x1 = std::max<T>( max.x, r.max.x );
        T y1 = std::max<T>( max.y, r.max.y );
        return Rect<T>( x0,y0,x1,y1 );
    }
 
    Rect<T> Expand(const Vec2<T> &v) const
    {
        T x0 = std::min<T>( min.x, v.x );
        T y0 = std::min<T>( min.y, v.y );
        T x1 = std::max<T>( max.x, v.x );
        T y1 = std::max<T>( max.y, v.y );
        return Rect<T>( x0,y0,x1,y1 );
    }
 
    inline Vec2<T> GetSize() const { return max-min;}
 
    Vec2<T> GetCenter() const {return (min+max)/2;}
 
    inline bool IsEmpty(){return (max.x==min.x || max.y==min.y);}
 
    inline bool IsValid(){return (max.x>=min.x || max.y>=min.y);}
 
    inline bool Contains(const Vec2<T> &v) const { return v.x>=min.x && v.x<max.x && v.y>=min.y && v.y<max.y; }
 
    inline bool Contains(const Rect<T> &r) const { return min.x<=r.min.x && max.x>=r.max.x && min.y<=r.min.y && max.y>=r.max.y;}
 
    inline bool Intersects(const Rect<T> &r) const {return r.max.x>min.x && r.min.x<max.x && r.max.y>min.y && r.min.y<max.y;}
 
};
 
 
template<>
inline bool Rect<float>::Equals(const Rect<float>&r, float epsilon) const
{
    return min.Equals(r.min, epsilon) && max.Equals(r.max, epsilon);
}
 
typedef Rect<int> Recti;                
typedef Rect<float> Rectf;              
 
 
 
template<typename T>
struct AffineMat3
{
 
    Vec2<T> i;              
    Vec2<T> j;              
    Vec2<T> t;              
 
    AffineMat3(){i.x=1; j.y=1;}
 
    AffineMat3(const Vec2<T> &_i, const Vec2<T> &_j, const Vec2<T> &_t): i(_i),j(_j),t(_t){}
 
    AffineMat3(T ix, T iy, T jx, T jy, T tx, T ty){ i.x=ix; i.y=iy; j.x=jx; j.y=jy; t.x=tx; t.y=ty; }
 
 
    inline AffineMat3<T> Invert() const
    {
        float idet = 1.0/(i.x*j.y-i.y*j.x);
        return AffineMat3<T>(
            j.y*idet , -i.y*idet,
            -j.x*idet , i.x*idet,
            (j.x*t.y-j.y*t.x)*idet , (i.y*t.x-i.x*t.y)*idet );
    }
 
    Vec2<T> operator*(const Vec2<T> &v) const
    {
        return Vec2<T>( i.x*v.x + j.x*v.y + t.x , i.y*v.x + j.y*v.y + t.y );
    }
 
    inline AffineMat3<T> operator*(const AffineMat3<T> &m ) const
    {
        return AffineMat3<T>(
            i.x*m.i.x + j.x*m.i.y       , i.y*m.i.x + j.y*m.i.y ,
            i.x*m.j.x + j.x*m.j.y       , i.y*m.j.x + j.y*m.j.y ,
            i.x*m.t.x + j.x*m.t.y + t.x , i.y*m.t.x + j.y*m.t.y + t.y );
    }
 
    inline Vec2<T> Transform(const Vec2<T> &v) const
    {
        return Vec2<T>( i.x*v.x + j.x*v.y + t.x , i.y*v.x + j.y*v.y + t.y );
    }
 
 
    inline Vec2<T> Transform(T x, T y)  const
    {
        return Vec2<T>( i.x*x + j.x*y + t.x , i.y*x + j.y*y + t.y );
    }
 
 
    inline AffineMat3<T> Transform(float ix, float iy, float jx, float jy, float tx, float ty)  const
    {
        return AffineMat3<T>(
            i.x*ix + j.x*iy       , i.y*ix + j.y*iy ,
            i.x*jx + j.x*jy       , i.y*jx + j.y*jy ,
            i.x*tx + j.x*ty + t.x , i.y*tx + j.y*ty + t.y );
    }
 
 
    inline AffineMat3<T> Translate(T tx, T ty) const
    {
        return Transform( 1,0,0,1,tx,ty );
    }
 
 
    inline AffineMat3<T> Translate(const Vec2<T> &tv) const { return Transform( 1,0,0,1,tv.x,tv.y );}
 
    inline AffineMat3<T> Rotate(double rz) const { return Transform( std::cos( rz ),-std::sin( rz ), std::sin( rz ), std::cos( rz ),0,0 );}
 
    inline AffineMat3<T> Scale(T sx, T sy) const { return Transform( sx,0,0,sy,0,0 );}
 
    inline AffineMat3<T> Scale(const Vec2<T> &sv) const { return Transform( sv.x,0,0,sv.y,0,0 );}
 
    AffineMat3<T> static Translation(T tx, T ty){ return AffineMat3<T>( 1,0,0,1,tx,ty ); }
 
    AffineMat3<T> static Translation(const Vec2<T> &tv){ return AffineMat3<T>( 1,0,0,1,tv.x,tv.y );}
 
    AffineMat3<T> static Rotation(double rz){ return AffineMat3<T>( std::cos( rz ),-std::sin( rz ), std::sin( rz ), std::cos( rz ),0,0 ); }
 
    AffineMat3<T> static Scaling(T sx, T sy){ return AffineMat3<T>( sx,0,0,sy,0,0 ); }
 
    AffineMat3<T> static Scaling(const Vec2<T> &sv){ return AffineMat3<T>( sv.x,0,0,sv.y,0,0 );}
 
 
    AffineMat3<T> static Ortho(T left, T right, T bottom, T top)
    {
 
        T w = right-left;
        T h = top-bottom;
 
        AffineMat3<T> r;
        r.i.x=2/w;
        r.j.y=2/h;
        r.t.x=-(right+left)/w;
        r.t.y=-(top+bottom)/h;
        return r;
    }
 
};
 
typedef AffineMat3<float> AffineMat3f;      
 
 
 
 
//================================================================================================================================
 
 
struct Parameter
{
    std::string name;               
    std::string value;              
    int kind = -1;                  
 
 
    static bool Exists(const std::vector<Parameter> &parameters, const std::string &name, const std::string &value="");
 
    static std::string GetValue(const std::vector<Parameter> &parameters, const std::string &name, const std::string &defaultValue="");
 
    static int GetIntValue(const std::vector<Parameter> &parameters, const std::string &name, int defaultValue=0);
 
    static float GetFloatValue(const std::vector<Parameter> &parameters, const std::string &name, float defaultValue=0.0);
 
 
    static Parameter Parse(const std::string &s);
 
};
 
 
 
//================================================================================================================================
 
 
class Easing
{
public:
 
    enum class Kind : int
    {
        LINEAR = 0,             
        EASE_START = 1,         
        EASE_END = 2,           
        EASE_START_END = 3,     
        CONSTANT = 4            
    };
 
 
    float GetValue(float p);
 
    Kind kind = Kind::LINEAR;
 
};
 
 
//================================================================================================================================
 
 
class Tween
{
public:
    friend class Tweens;
 
    enum class Mode
    {
        NORMAL,             
        REVERSE,            
        LOOP,               
        LOOP_REVERSE        
    };
 
    //~Tween();
 
 
    void Init(float _valueStart, float _valueEnd, float _durationS, Easing::Kind _easingKind);
 
 
    void Play();
 
 
    float Update();
 
 
    bool IsIdle() { return state==stateIDLE || state == stateNEVER_INITIALIZED; }
 
 
    void Stop();
 
 
    void Pause();
 
 
    void Resume();
 
 
    void SetEasingKind(Easing::Kind _kind) { easing.kind = _kind; }
 
 
    void SetMode(Mode _mode) { mode = _mode;}
 
 
    float GetStartValue(){ return valueStart;}
 
 
    float GetEndValue(){ return valueEnd;}
 
 
 
 
private:
    float value = 0;
    float valueStart = 0.0;
    float valueEnd = 0.0;
    int timeStartMS = 0;
    int timeEndMS = 0;
    int durationMS = 0;
    Easing easing;
 
    int state = stateNEVER_INITIALIZED;
    static const int stateNEVER_INITIALIZED = -1;
    static const int stateIDLE = 0;
    static const int statePLAYING = 1;
    static const int statePAUSED = 3;
 
 
    Mode mode = Mode::NORMAL;
    bool reverse = false;
 
    int stateStored = 0;
    int msTimeStored = 0;
 
 
};
 
 
//================================================================================================================================
 
 
struct CustomObject
{
public:
 
    virtual ~CustomObject(){}
 
    virtual std::string GetInfo(){ return ""; }
 
 
    void SetTag(int _tag){ tag = _tag; }
 
    int GetTag(){ return tag; }
 
 
private:
    int tag = 0;
 
};
 
 
 
 
}
 
 
 
 
#endif