sstypes.h

Go to the documentation of this file.

#ifndef __SSTYPES__
#define __SSTYPES__
#pragma warning(disable : 4819)
#include <stdlib.h>
#include <string>
#include <vector>
#include <cmath>
#include <algorithm>
 
//===============================================================
//Macros 
//===============================================================
#define SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF(type) \
    SsString    __EnumToString_( type::_enum n );\
    void    __StringToEnum_( SsString n , type::_enum& out);\
 
// 未使用引数の警告避け
#ifndef SPRITESTUDIO6SDK_NOUSE_ARGUMENT
    #define SPRITESTUDIO6SDK_NOUSE_ARGUMENT(_name_) ( void )( &_name_ );
#endif
 
namespace spritestudio6
{
 
//===============================================================
// 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);
    }
 
    float   length_sq() const
    {
        return (x * x) + (y * y);
    }
 
    float   length() const
    {
#ifdef _WIN32
        float r = length_sq();
        if ( r < 0.0001f && r > -0.0001f ) return 0;
 
        return (float)std::sqrtf( r );
#else
        return (float)sqrt( length_sq() );
#endif
    }
 
    static void normalize(const SsPoint2& in, SsPoint2* out)
    {
 
        float len = in.length();
        float div = 0;
 
        if ( len == 0 )
        {
            div = 0;
        }else{
            div = (float)1 / in.length();
        }
 
        out->x = in.x * div;
        out->y = in.y * div;
    }
 
    void        normalize()
    {
        normalize(*this, this);
    }
 
    //----------------------------------------------------------------------------
    static  float   dot(const SsPoint2& l, const SsPoint2 r)
    {
        return (l.x * r.x) + (l.y * r.y);
    }
    static  float   cross(const SsPoint2& l, const SsPoint2& r)
    {
        return (l.x * r.y) - (l.y * r.x);
    }
 
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    static  float   get_angle_unit(const SsPoint2& v0, const SsPoint2 v1)
    {
        float ip = dot(v0, v1);
        if (ip > 1.0f) ip = 1.0f;
        if (ip < -1.0f) ip = -1.0f;
        float f = acos(ip);
        return f;      
        
    }
    //----------------------------------------------------------------------------
    //----------------------------------------------------------------------------
    static  float   get_angle(const SsPoint2& v0, const SsPoint2& v1)
    {
        SsPoint2 uv0(v0), uv1(v1);
        uv0.normalize();
        uv1.normalize();
        return get_angle_unit(uv0, uv1);
    }
 
    // v0 から v1 への左回りの角度を返す
    static  float   get_angle_360_unit(const SsPoint2& v0, const SsPoint2 v1)
    {
        float ang = get_angle_unit(v0, v1);
        float c = cross(v0, v1);
 
        if (c < 0)
        {
            ang = (3.1415926535897932385f)*2.0f - ang;
        }
        return ang;
    }
 
    static  float   get_angle_360(const SsPoint2& v0, const SsPoint2 v1)
    {
        SsPoint2 uv0(v0), uv1(v1);
        uv0.normalize();
        uv1.normalize();
        return get_angle_360_unit(uv0, uv1);
    }
 
 
};

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;
}
 
 
 
template<> inline SsTColor<u8>::SsTColor(): r(255), g(255), b(255), a(255) {}
template<> inline void SsTColor<u8>::fromARGB(u32 c)
{
    a = (c >> 24);
    r = ((c >> 16) & 0xff);
    g = ((c >> 8) & 0xff);
    b = (c & 0xff);
}
template<> inline void SsTColor<u8>::fromBGRA(u32 c)
{
    b = (c >> 24) ;
    g = ((c >> 16) & 0xff) ;
    r = ((c >> 8) & 0xff) ;
    a = (c & 0xff) ;
}
template<> inline u32 SsTColor<u8>::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;
 
 
typedef SsTColor<u8> SsU8Color;
 
struct ToLower {
    char operator()(char c) { return (char)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
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF( SsPartsSortMode );
 
//---------------------------------------------------------------
namespace SsPartType
{
    enum _enum
    {
        invalid = -1,
        null,           
        normal,           
        text,           
        instance,       
        armature,       
        effect,           
        mesh,           
        movenode,       
        constraint,       
        mask,           
        joint,         
        bonepoint,     
 
        num
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF( SsPartType );
 
 
//---------------------------------------------------------------
namespace SsBoundsType
{
    enum _enum 
    {
        invalid = -1,
        none,           
        quad,           
        aabb,           
        circle,           
        circle_smin, 
        circle_smax, 
        num
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF( SsBoundsType );
 
 
//---------------------------------------------------------------
namespace SsInheritType
{
    enum _enum
    {
        invalid = -1,
        parent,           
        self,           
        num
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF( SsInheritType );
 
//---------------------------------------------------------------
namespace SsBlendType
{
    enum _enum{
        invalid=-1,
        mix,         
        mul,         
        add,         
        sub,         
        mulalpha,       
        screen,       
        exclusion,     
        invert,       
        num
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF( SsBlendType );
 

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

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

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

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

namespace SsAttributeKind
{
    enum _enum
    {
        invalid=-1,  
        cell=0,     
        posx,       
        posy,       
        posz,       
        rotx,       
        roty,       
        rotz,       
        sclx,       
        scly,       
        losclx,       
        loscly,       
        alpha,     
        loalpha, 
        prio,       
        fliph,     
        flipv,     
        hide,       
        partsColor,   
        color,     
        shader,       
        vertex,       
        pivotx,       
        pivoty,       
        anchorx, 
        anchory, 
        sizex,     
        sizey,     
        imgfliph,   
        imgflipv,   
        uvtx,       
        uvty,       
        uvrz,       
        uvsx,       
        uvsy,       
        boundr,       
        mask,       
        user,       
        signal,       
        instance,   
        effect,       
        deform,       
        num,
    };
};
 
 
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF(SsAttributeKind);
 
namespace SsKeyValueType
{
    enum _enum
    {
        _unkown = -1,
        _bool = 0,
        _float,
        _int,
        _string,
        _cellmap,
        _vertexAnime,
        _colorAnime,
        _userData,
        _instance,
    };
};
 
 
 
 
 

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 SsPartsColorAnime
{
    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; }
    SsPartsColorAnime() :
        target(SsColorBlendTarget::invalid),
        blendType(SsBlendType::invalid) {}
 
};

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 SsShaderAnime
{
    SsString                id;               // シェーダータイプ
    float                   param[4];      // シェーダー値
 
    SsShaderAnime()
    {
        id = "";
        for ( int i = 0; i < 4; i++ ) {
            param[i] = 0.0f;
        }
    }
 
};
 
 
//エフェクト関連の定義
//エフェクトのノードタイプ
namespace SsEffectNodeType
{
    enum _enum{
        invalid=-1,
        root,
        emmiter,
        particle,
        num
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF( SsEffectNodeType );
 
 
 
//エフェクト関連の定義
//エフェクトのブレンドタイプ
namespace SsRenderBlendType
{
    enum _enum{
        invalid=-1,
        Mix,
        Add,
        num
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF( SsRenderBlendType );
 
 
//2.0.1で追加　IKの方向
namespace SsIkRotationArrow
{
    enum _enum
    {
        unknown = -1,
        arrowfree = 0,
        clockwise,
        anticlockwise,
        num
    };
};
 
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF(SsIkRotationArrow);

namespace SsSequenceType
{
    enum _enum
    {
        invalid=-1,
        last,       
        keep,       
        top,     
        num,
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF( SsSequenceType );
 
namespace SsSignalParamType
{
    enum _enum
    {
        none,
        index,
        integer,
        floating,
        num
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF( SsSignalParamType );
 
 
class SsEffectAttr
{
public:
    // ↓5.7 で追加
    int                 startTime;             
    float               speed;                 
    bool                independent;         
    int                 loopflag;               
    bool                attrInitialized;
    int                 curKeyframe;         
    SsEffectAttr() :
        startTime(0),
        speed(1.0f),
        independent(false),
        loopflag(0),
        attrInitialized(false),
        curKeyframe(0)
    {}
 
    void init()
    {
        startTime = 0;
        speed = 1.0f;
        independent = false;
        loopflag = 0;
        attrInitialized = false;
        curKeyframe = 0;
    }
};
 
 
 
//参照セル値
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)
    {}
};
 
union SsSignalParamValue
{
    int         i;
    float       f;
};
 
class SsSignalParam
{
public:
    SsString                    paramId; 
    SsSignalParamType::_enum    type;       
    SsSignalParamValue            value;     
 
    SsSignalParam()
    :   paramId  ("")
    ,   type    (SsSignalParamType::none)
    {
        value.i = 0;
    }
};
 
class SsSignalCommand
{
public:
    bool                        active;       
    SsString                    commandId; 
    std::vector<SsSignalParam>  params;       
    SsString                    note;       
 
    SsSignalCommand()
    :   active        (true)
    ,   commandId  ("")
    ,   note        ("")
    {
        params.clear();
    }
};
 
class SsSignalAttr
{
public:
    std::vector<SsSignalCommand>    commands;   
 
    SsSignalAttr()
    {
        commands.clear();
    }
};
 
class SsInstanceAttr
{
public:
    bool        infinity;       
    bool        reverse;     
    bool        pingpong;       
    bool        independent; 
    int         loopflag;       
    int         loopNum;     
    SsString    startLabel;       
    int         startOffset; 
    SsString    endLabel;       
    int         endOffset;     
    float       speed;         
    int         startFrame;       
    int         endFrame;       
 
 
    //テンポラリ <-エディタ用計算値の可能性もあるので後で整理
    int         curKeyframe; //この値があるキーフレーム値 (計算値）
    float       liveFrame; //再生時間の累積
 
    SsInstanceAttr():
        infinity( false ),
        reverse( false ),
        pingpong( false ),
        independent(false),
        loopflag(0),
        loopNum( 1 ),
        startLabel("_start"),
        startOffset(0),
        endLabel("_end"),
        endOffset(0),
        curKeyframe( 0 ),
        speed(1.0f),
        startFrame(0),
        endFrame(0),
        liveFrame(0.0f)
   {}
 
};
 
//インスタンスアトリビュートのループフラグ
enum {
    INSTANCE_LOOP_FLAG_INFINITY = 1 << 0,
    INSTANCE_LOOP_FLAG_REVERSE = 1 << 1,
    INSTANCE_LOOP_FLAG_PINGPONG = 1 << 2,
    INSTANCE_LOOP_FLAG_INDEPENDENT = 1 << 3,
};
 
//エフェクトアトリビュートのループフラグ
enum {
    EFFECT_LOOP_FLAG_INFINITY = 1 << 0,
};
 
//メッシュの分割タイプ
namespace SsMeshDivType
{
    enum _enum
    {
        unknown,
        polyline_base,
        boxdiv,
        num
    };
};
SPRITESTUDIO6SDK_DECLARE_ENUM_STRING_DEF(SsMeshDivType);
 
struct SsTriangle
{
    int idxPo1;
    int idxPo2;
    int idxPo3;
 
};
 
struct SsBoneBind
{
    int     boneIndex;               //暫定でパーツIDを使用する
    float   blend;
};
 
typedef std::vector<SsBoneBind> SsBoneBindArray;
 
 
class SsDeformAttr
{
public:
    std::vector<SsVector2> verticeChgList;
 
    SsDeformAttr()
    {
        verticeChgList.clear();
    }
    SsDeformAttr(const SsDeformAttr& rhs)
    {
        *this = rhs;
    }
 
    bool    operator ==(const SsDeformAttr& r) const;
    bool    operator !=(const SsDeformAttr& r) const
    {
        return !(*this == r);
    }
 
    bool    operator ==(int n) const { SPRITESTUDIO6SDK_NOUSE_ARGUMENT(n);  return false; }
    bool    operator !=(int n) const { SPRITESTUDIO6SDK_NOUSE_ARGUMENT(n);  return false; }
 
    SsDeformAttr        operator +(const SsDeformAttr& rhs) const
    {
        return SsDeformAttr(rhs);
    }
 
    SsDeformAttr        operator *(const SsDeformAttr& rhs) const
    {
        return SsDeformAttr(rhs);
    }
 
    SsDeformAttr        operator /(const SsDeformAttr& rhs) const
    {
        return SsDeformAttr(rhs);
    }
 
    virtual SsString    ToString() const { return "SsDeformAttr" /* todo パラメータ出力*/; }
    virtual operator SsString() const { return ToString(); }
 
 
};
 
}   // namespace spritestudio6
 
#endif