sstypes.h

#ifndef __SSTYPES__
#define __SSTYPES__

#include <string>
#include <vector>
#include <math.h>
#include <algorithm>

//===============================================================
//Macros 
//===============================================================
#define SS_DECLARE_ENUM_STRING_DEF(type) \
    SsString    __EnumToString_( type::_enum n );\
    void    __StringToEnum_( SsString n , type::_enum& out);\




//===============================================================
// Declare Type
//===============================================================

//文字列の設定
typedef std::string SsString;



struct SsPoint2
{
public:
    float   x;
    float   y;

public:
    SsPoint2( float _x , float _y )
    {
        x = _x ; y = _y;
    }
    SsPoint2() : x(0) , y(0){}

    static  float   distance_sq(const SsPoint2 & l, const SsPoint2 & r)
    {
        float x = l.x - r.x;
        float y = l.y - r.y;
        float sq = x * x + y * y;
        return sq;      
    }

    static  float   distance(const SsPoint2 & l, const SsPoint2 & r)
    {
        return  sqrt( distance_sq(l, r) );
    }

    SsPoint2 operator +( const SsPoint2& r) const
    {
        return SsPoint2(x + r.x, y + r.y);
    }

    SsPoint2 operator -( const SsPoint2& r) const
    {
        return SsPoint2(x - r.x, y - r.y);
    }

    SsPoint2 operator *( float r) const
    {
        return SsPoint2(x * r, y * r);
    }

    SsPoint2 operator /( float r) const
    {
        return SsPoint2(x / r, y / r);
    }

};

struct SsPoint3
{
public:
    float   x;
    float   y;
    float   z;

public:
    SsPoint3( float _x , float _y , float _z)
    {
        x = _x ; y = _y;z = _z;
    }
    SsPoint3() : x(0) , y(0) ,z(0){}
};

typedef SsPoint2 SsVector2;
typedef SsPoint3 SsVector3;
typedef unsigned int u32;
typedef unsigned char u8;




template <typename T>
class SsTRect
{
public:
    T   x, y, w, h;

    SsTRect(): x(0), y(0), w(0), h(0)  {}
    SsTRect(T ax, T ay, T aw, T ah): x(ax), y(ay), w(aw), h(ah) {}
    SsTRect(const SsTRect& r): x(r.x), y(r.y), w(r.w), h(r.h) {}

    bool    operator ==(const SsTRect& r) const {return x == r.x && y == r.y && w == r.w && h == r.h;}
    bool    operator !=(const SsTRect& r) const {return !(*this == r);}
private:
};


typedef SsTRect<int>    SsIRect;


template <typename T>
class SsTColor
{
public:
    T   r, g, b, a;

    SsTColor(): r(0), g(0), b(0), a(0) {}
    SsTColor(T ar, T ag, T ab, T aa): r(ar), g(ag), b(ab), a(aa) {}
    SsTColor(const SsTColor& s): r(s.r), g(s.g), b(s.b), a(s.a) {}

    void    fromARGB(u32 c);
    void    fromBGRA(u32 c);

    u32     toARGB() const;

    bool    operator ==(const SsTColor& rhs) const
    {
        return r == rhs.r
            && g == rhs.g
            && b == rhs.b
            && a == rhs.a;
    }

private:
};


template<> inline SsTColor<float>::SsTColor(): r(0.5f), g(0.5f), b(0.5f), a(1.f) {}
template<> inline void SsTColor<float>::fromARGB(u32 c)
{
    a = (float)(c >> 24) / 255.f;
    r = (float)((c >> 16) & 0xff) / 255.f;
    g = (float)((c >> 8) & 0xff) / 255.f;
    b = (float)(c & 0xff) / 255.f;
}
template<> inline void SsTColor<float>::fromBGRA(u32 c)
{
    b = (float)(c >> 24) / 255.f;
    g = (float)((c >> 16) & 0xff) / 255.f;
    r = (float)((c >> 8) & 0xff) / 255.f;
    a = (float)(c & 0xff) / 255.f;
}
template<> inline u32 SsTColor<float>::toARGB() const
{
    u32 c = (u8)(a * 255) << 24 | (u8)(r * 255) << 16 | (u8)(g * 255) << 8 | (u8)(b * 255);
    return c;
}




template<> inline SsTColor<u32>::SsTColor(): r(255), g(255), b(255), a(255) {}
template<> inline void SsTColor<u32>::fromARGB(u32 c)
{
    a = (c >> 24);
    r = ((c >> 16) & 0xff);
    g = ((c >> 8) & 0xff);
    b = (c & 0xff);
}
template<> inline void SsTColor<u32>::fromBGRA(u32 c)
{
    b = (c >> 24) ;
    g = ((c >> 16) & 0xff) ;
    r = ((c >> 8) & 0xff) ;
    a = (c & 0xff) ;
}
template<> inline u32 SsTColor<u32>::toARGB() const
{
    u32 c = (u8)(a) << 24 | (u8)(r) << 16 | (u8)(g) << 8 | (u8)(b);
    return c;
}

typedef SsTColor<float> SsFColor;


typedef SsTColor<u32> SsColor;


struct ToLower {
    char operator()(char c) { return tolower(c); }
};
inline void ConvertStringToSsColor( const std::string& str , SsColor& out)
{
    char *endptr;
    unsigned long x;

    std::string temp = "0x";
    temp+=str;
    
    transform(temp.begin(), temp.end(), temp.begin(), ToLower());
    x = strtoul(temp.c_str(), &endptr, 16);
    out.fromARGB( x );
}



class SsCurve
{
public:
    float   startTime;      
    float   startValue;     
    float   endTime;        
    float   endValue;       

    float   startKeyTime;   
    float   endKeyTime;     

    bool    syncStartEnd;   

    SsCurve() : startTime(0.f), startValue(0.f), endTime(0.f), endValue(0.f), startKeyTime(0.f), endKeyTime(0.f){}
    ~SsCurve(){}

};



//---------------------------------------------------------------
namespace SsPartsSortMode
{
    enum _enum
    {
        invalid = -1, 
        prio,           
        z,              
        num
    };
};
SS_DECLARE_ENUM_STRING_DEF( SsPartsSortMode );

//---------------------------------------------------------------
namespace SsPartType
{
    enum _enum
    {
        invalid = -1,
        null,           
        normal,         
        text,           
        instance,       
        num
    };
};
SS_DECLARE_ENUM_STRING_DEF( SsPartType );


//---------------------------------------------------------------
namespace SsBoundsType
{
    enum _enum 
    {
        invalid = -1,
        none,           
        quad,           
        aabb,           
        circle,         
        circle_smin,    
        circle_smax,    
        num
    };
};
SS_DECLARE_ENUM_STRING_DEF( SsBoundsType );


//---------------------------------------------------------------
namespace SsInheritType
{
    enum _enum
    {
        invalid = -1,
        parent,         
        self,           
        num
    };
};
SS_DECLARE_ENUM_STRING_DEF( SsInheritType );

//---------------------------------------------------------------
namespace SsBlendType
{
    enum _enum{
        invalid=-1,
        mix,            
        mul,            
        add,            
        sub,            
        num
    };
};
SS_DECLARE_ENUM_STRING_DEF( SsBlendType );


namespace SsColorBlendTarget
{
    enum _enum{
        invalid = -1,
        whole,  
        vertex, 
        num
    };
};
SS_DECLARE_ENUM_STRING_DEF( SsColorBlendTarget );



namespace SsInterpolationType
{
    enum _enum 
    {
        invalid = -1,
        none,           
        linear,         
        hermite,        
        bezier,         
        acceleration,   
        deceleration,   
        num,
    };
};
SS_DECLARE_ENUM_STRING_DEF( SsInterpolationType );


namespace SsTexWrapMode
{
    enum _enum
    {
        invalid = -1,   
        clamp,          
        repeat,         
        mirror,         
        num
    };
};

SS_DECLARE_ENUM_STRING_DEF(SsTexWrapMode);

namespace SsTexFilterMode
{
    enum _enum
    {
        invalid = -1,
        nearest,    
        linear,     
        num
    };
};
SS_DECLARE_ENUM_STRING_DEF(SsTexFilterMode);




namespace SsAttributeKind
{
    enum _enum
    {
        invalid=-1, 
        cell=0,     
        posx,       
        posy,       
        posz,       
        rotx,       
        roty,       
        rotz,       
        sclx,       
        scly,       
        alpha,      
        prio,       
        fliph,      
        flipv,      
        hide,       
        color,      
        vertex,     
        pivotx,     
        pivoty,     
        anchorx,    
        anchory,    
        sizex,      
        sizey,      
        imgfliph,   
        imgflipv,   
        uvtx,       
        uvty,       
        uvrz,       
        uvsx,       
        uvsy,       
        boundr,     
        user,       
        instance,   
        num,
    };
};


SS_DECLARE_ENUM_STRING_DEF(SsAttributeKind);

namespace SsKeyValueType
{
    enum _enum
    {
        _unkown = -1,
        _bool = 0,
        _float,
        _int,
        _string,
        _cellmap,
        _vertexAnime,
        _colorAnime,
        _userData,
    };
};


struct SsColorBlendValue
{
    SsColor     rgba;   
    float       rate;   

    SsColorBlendValue(): rate(0){}

};


struct SsVertexAnime
{
    SsPoint2    offsets[4]; 
    SsPoint2&   getOffsets(int index){ return offsets[index];}
};




class ISSTexture;
class SsCell;



struct SsColorAnime
{
    SsColorBlendTarget::_enum   target;     //ブレンドの適用方法  単色(全体) , 頂点単位 
    SsBlendType::_enum          blendType;  //ブレンド種別 (mix　乗算　加算　減算）
    SsColorBlendValue           color;      //単色。全体の場合に使用されるカラー値
    SsColorBlendValue           colors[4];  //頂点単位の場合使用されるカラー値

    SsColorBlendValue&          getColors(int index){ return colors[index];}
    int                         getTargetToInt(){ return (int)target;}
    int                         getBlendTypeToInt(){ return (int)blendType;}
    SsColorAnime() : 
            target( SsColorBlendTarget::invalid ) ,
                blendType( SsBlendType::invalid ){}

};

//参照セル値
struct SsRefCell
{
    int         mapid;
    std::string name;

    
};
class SsUserDataAnime
{
public:
    bool            useInteger; 
    bool            usePoint;   
    bool            useRect;    
    bool            useString;  

    int             integer;    
    SsPoint2        point;      
    SsIRect         rect;       
    SsString        string;     

    SsUserDataAnime() : 
        useInteger(false),
        usePoint(false),
        useRect(false),
        useString(false){}
};

class SsInstanceAttr
{
public:
    bool        infinity;
    bool        reverse;
    bool        pingpong;
    bool        independent;
    int         loopNum;
    SsString    startLabel;
    int         startOffset;
    SsString    endLabel;
    int         endOffset;
    float       speed;


    //テンポラリ <-エディタ用計算値の可能性もあるので後で整理
    int         curKeyframe; //この値があるキーフレーム値 (計算値）
    float       liveFrame;  //再生時間の累積

    SsInstanceAttr():
        infinity( false ),
        reverse( false ),
        pingpong( false ),
        independent( false ),
        loopNum( 1 ),
        startLabel("_start"),
        startOffset(0),
        endLabel("_end"),
        endOffset(0),
        curKeyframe( 0 ),
        speed(1.0f)
    {}

};


#endif