ssloader_ssae.h

Go to the documentation of this file.

#ifndef __SSLOADER_SSAE__
#define __SSLOADER_SSAE__
 
#include "sstypes.h"
#include "ssarchiver.h"
#include "ssattribute.h"
 
#define SPRITESTUDIO6_SSAEVERSION "2.00.01"
 
namespace spritestudio6
{
 
class SsAnimation;
 
 
 
 

class SsAnimationSettings
{
public:
    int                     fps;         
    int                     frameCount;       
    SsPartsSortMode::_enum    sortMode;       
    SsPoint2                canvasSize;       
    SsVector2              pivot;         
    int                     startFrame;       
    int                     endFrame;       
 
    SsAnimationSettings(){}
    virtual ~SsAnimationSettings(){}
public:

    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        SPRITESTUDIO6SDK_SSAR_DECLARE( fps );
        SPRITESTUDIO6SDK_SSAR_DECLARE( frameCount );
        SPRITESTUDIO6SDK_SSAR_DECLARE( canvasSize );
        SPRITESTUDIO6SDK_SSAR_DECLARE( pivot );
        SPRITESTUDIO6SDK_SSAR_DECLARE_ENUM(sortMode);
        //タグが存在しない（Ver5.8以前のデータ）場合は初期値を入れる
        if (SPRITESTUDIO6SDK_SSAR_DECLARE(startFrame) == false)
        {
            startFrame = 0;
        }
        if (SPRITESTUDIO6SDK_SSAR_DECLARE(endFrame) == false)
        {
            endFrame = frameCount - 1;
        }
    }
};
 
 
 
//パーツ一つあたりの情報を保持するデータです。
class   SsPart
{
public:
    SsString                name;
    int                     arrayIndex;       
    int                     parentIndex; 
    SsPartType::_enum      type;           
    SsBoundsType::_enum      boundsType;       
    SsInheritType::_enum    inheritType; 
    SsBlendType::_enum        alphaBlendType;   
    int                     show;           
    int                     locked;           
    SsString                colorLabel;       
    bool                    maskInfluence; 
 
    float                   inheritRates[(int)SsAttributeKind::num];    
 
    //参照アニメーション名
    //ツールはともかくランタイムでは勿体ない使い方なので何らか考えること
    //--------------------------------------------------------------------------------------
    //インスタンスパーツパラメータ
    //--------------------------------------------------------------------------------------
    SsString                refAnimePack;   
    SsString                refAnime;       
 
    //--------------------------------------------------------------------------------------
    //エフェクトパーツパラメータ
    //--------------------------------------------------------------------------------------
    SsString                refEffectName; 
 
    //--------------------------------------------------------------------------------------
    //ボーンパーツパラメータ
    //--------------------------------------------------------------------------------------
    int                     boneLength;       
    SsVector2              bonePosition;   
    float                   boneRotation;   
 
    SsVector2              weightPosition;   
    float                   weightImpact;   
 
    //--------------------------------------------------------------------------------------
    //メッシュパーツパラメータ
    //--------------------------------------------------------------------------------------
    int                     meshWeightType;   
    int                     meshWeightStrong;
 
    //--------------------------------------------------------------------------------------
    //コンストレイントパーツパラメータ
    //--------------------------------------------------------------------------------------
    int                         IKDepth;     
    SsIkRotationArrow::_enum    IKRotationArrow;
 
public:
    SsPart() : 
      name("") , arrayIndex(0), parentIndex(0) , show(0) , locked(0) , maskInfluence(true)
      {
            refEffectName = "";
            boneLength = 0;
            bonePosition = SsVector2(0,0);
            boneRotation = 0;
            weightPosition = SsVector2(0, 0);
            weightImpact = 0;
            meshWeightType = 0;
            meshWeightStrong = 0;
            IKDepth = 0;
            IKRotationArrow = SsIkRotationArrow::arrowfree;
 
        
            //memset( inheritRates , 0 , sizeof( float) * SsAttributeKind::num );
            for (int i = 0; i < (int)SsAttributeKind::num ; ++i)
                inheritRates[i] = 1.f;
 
            //継承率の初期値
            //継承のタグがない場合に、この値が適用される
            // 反転・非表示フラグは継承しない from 旧SS
            //SS5　では初期値は１
/*
            inheritRates[(int)SsAttributeKind::fliph] = 0.f;
            inheritRates[(int)SsAttributeKind::flipv] = 0.f;
            inheritRates[(int)SsAttributeKind::hide] = 0.f;
*/
            // イメージ反転も継承しない 2013.04.03 水 15:08
            inheritRates[(int)SsAttributeKind::imgfliph] = 0.f;
            inheritRates[(int)SsAttributeKind::imgflipv] = 0.f;
      }
    virtual ~SsPart(){}
 

    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        SPRITESTUDIO6SDK_SSAR_DECLARE( name );
        SPRITESTUDIO6SDK_SSAR_DECLARE( arrayIndex );
        SPRITESTUDIO6SDK_SSAR_DECLARE( parentIndex );
 
        SPRITESTUDIO6SDK_SSAR_DECLARE_ENUM( type );
        SPRITESTUDIO6SDK_SSAR_DECLARE_ENUM( boundsType );
        SPRITESTUDIO6SDK_SSAR_DECLARE_ENUM( inheritType );
        SPRITESTUDIO6SDK_SSAR_DECLARE_ENUM( alphaBlendType );
        SPRITESTUDIO6SDK_SSAR_DECLARE( show );
        SPRITESTUDIO6SDK_SSAR_DECLARE( locked );
        SPRITESTUDIO6SDK_SSAR_DECLARE( colorLabel );
        SPRITESTUDIO6SDK_SSAR_DECLARE( maskInfluence );
 
        SPRITESTUDIO6SDK_SSAR_DECLARE( refAnimePack );
        SPRITESTUDIO6SDK_SSAR_DECLARE( refAnime );
 
        SPRITESTUDIO6SDK_SSAR_DECLARE( refEffectName );
 
        SPRITESTUDIO6SDK_SSAR_DECLARE( boneLength );
        SPRITESTUDIO6SDK_SSAR_DECLARE( bonePosition );
        SPRITESTUDIO6SDK_SSAR_DECLARE( boneRotation );
        SPRITESTUDIO6SDK_SSAR_DECLARE( weightPosition );
        SPRITESTUDIO6SDK_SSAR_DECLARE( weightImpact );
        SPRITESTUDIO6SDK_SSAR_DECLARE( meshWeightType );
        SPRITESTUDIO6SDK_SSAR_DECLARE( meshWeightStrong );
        SPRITESTUDIO6SDK_SSAR_DECLARE( IKDepth );
        SPRITESTUDIO6SDK_SSAR_DECLARE_ENUM( IKRotationArrow );
 
        //継承率後に改良を実施
        if ( ar->getType() == EnumSsArchiver::in )
        {
            libXML::XMLElement* e = ar->getxml()->FirstChildElement( "ineheritRates" );
            if ( e )
            {
                libXML::XMLElement* ec = e->FirstChildElement();
                while(ec)
                {
                    //継承設定の取得
                    const char* tag = ec->Value();
                    SsAttributeKind::_enum enumattr;
 
                    __StringToEnum_( tag , enumattr );
                    inheritRates[(int)enumattr] = (float)atof( ec->GetText() );
                    ec = ec->NextSiblingElement();
                }
            }
        }
    }
};
 
enum 
{
    // MEMO: ssplayer_mesh.hにSSMESHPART_BONEMAXがあるので統合を考えること。
    SSMESHBIND_BONEMAX = 128,
};
class SsMeshBindInfo
{
public:
    int         weight[SSMESHBIND_BONEMAX];
    SsString    boneName[SSMESHBIND_BONEMAX];
    int         boneIndex[SSMESHBIND_BONEMAX];
    SsVector3   offset[SSMESHBIND_BONEMAX];
    int         bindBoneNum;
 
    SsMeshBindInfo()
    {
        for (int i = 0; i < SSMESHBIND_BONEMAX; i++)
        {
            weight[i] = 0;
            boneName[i] = "";
            boneIndex[i] = 0;
            offset[i] = SsVector3(0, 0, 0);
        }
        bindBoneNum = 0;
 
    }
    virtual ~SsMeshBindInfo() {}
 
    void    fromString(SsString str);
 
};
 
 
 
//メッシュ1枚毎の情報
class  SsMeshBind 
{
public:
    SsString     meshName;
 
    std::vector<SsMeshBindInfo>   meshVerticesBindArray;
 
public:
    SsMeshBind() {}
    virtual ~SsMeshBind() {}
 
    void    loader(ISsXmlArchiver* ar);
 
    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        loader(ar);
    }
 
 
};
 
 
//アニメーションを構成するパーツをリスト化したものです。
class SsModel
{
public:
    //MEMO: SsPartとSsMeshBindのポインタはXMLからの生成などの都合、スマートポインタ化していません
    std::vector<SsPart*>    partList;   
    SsAnimation*         setupAnimation;   
 
    std::vector<SsMeshBind*>        meshList;
    std::map<SsString,int>          boneList;       
 
 
public:
    SsModel(){}
    virtual~ SsModel()
    {
        for ( std::vector<SsPart*>::iterator itr = partList.begin() ; 
            itr != partList.end() ; itr ++ ) delete (*itr);
 
        for ( std::vector<SsMeshBind*>::iterator itr = meshList.begin() ; 
            itr != meshList.end() ; itr ++ ) delete (*itr);
    }

    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        std::vector<SsString> tempMeshList;
 
        SPRITESTUDIO6SDK_SSAR_DECLARE_LIST( partList );
        SPRITESTUDIO6SDK_SSAR_DECLARE( boneList );
        SPRITESTUDIO6SDK_SSAR_DECLARE_LIST( meshList );
        setupAnimation = NULL;
    }
};
 
 
typedef std::vector<SsAttribute*>   SsAttributeList;
 
class SsPartAnime
{
public:
    SsString                    partName;
    SsAttributeList              attributes;
 
public:
    SsPartAnime(){}
    virtual ~SsPartAnime(){
        for ( SsAttributeList::iterator itr = attributes.begin() ; 
            itr != attributes.end() ; itr ++ ) delete (*itr); 
    }

    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        SPRITESTUDIO6SDK_SSAR_DECLARE( partName );
        SPRITESTUDIO6SDK_SSAR_DECLARE_LISTEX( attributes , "attribute" );
    }
};
 

class SsLabel
{
public:
    SsString    name;   
    int         time;   
 
    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        SPRITESTUDIO6SDK_SSAR_DECLARE( name );
        SPRITESTUDIO6SDK_SSAR_DECLARE( time );
    }
 
private:
 
};
 
 
class SsAnimation
{
public:
    SsString    name;                           
    bool        overrideSettings;               
    SsAnimationSettings          settings;       
    std::vector<SsPartAnime*>   partAnimes;       
    std::vector<SsLabel*>       labels;           
    bool                        isSetup;     
 
public:
    SsAnimation(){}
    virtual ~SsAnimation()
    {
        for ( std::vector<SsPartAnime*>::iterator itr = partAnimes.begin() ; 
            itr != partAnimes.end() ; itr ++ ) delete (*itr); 
        for ( std::vector<SsLabel*>::iterator itr = labels.begin() ; 
            itr != labels.end() ; itr ++ ) delete (*itr); 
    }

    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        SPRITESTUDIO6SDK_SSAR_DECLARE( name );
        SPRITESTUDIO6SDK_SSAR_STRUCT_DECLARE( settings );
        SPRITESTUDIO6SDK_SSAR_DECLARE_LISTEX( labels , "value" );
        SPRITESTUDIO6SDK_SSAR_DECLARE_LISTEX( partAnimes , "partAnime" );
        SPRITESTUDIO6SDK_SSAR_DECLARE(isSetup);
    }
};

class SsAnimePack
{
public:
    SsString                    version;
    SsAnimationSettings          settings;       
    SsString                    name;           
    SsModel                      Model;         
    std::vector<SsString>       cellmapNames;   
    std::vector<SsAnimation*>   animeList;     
 
    SsAnimePack(){}
    virtual ~SsAnimePack()
    {
        for ( std::vector<SsAnimation*>::iterator itr = animeList.begin() ; 
            itr != animeList.end() ; itr ++ ) delete (*itr);       
    }

    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        SPRITESTUDIO6SDK_SSAR_DECLARE_ATTRIBUTE(version);
        SPRITESTUDIO6SDK_SSAR_STRUCT_DECLARE( settings );
        SPRITESTUDIO6SDK_SSAR_DECLARE( name );
        SPRITESTUDIO6SDK_SSAR_STRUCT_DECLARE( Model );
        SPRITESTUDIO6SDK_SSAR_DECLARE( cellmapNames );
        SPRITESTUDIO6SDK_SSAR_DECLARE_LISTEX( animeList , "anime" );
 
        //モデルにセットアップアニメーションを設定する
        int i;
        int size = (int)animeList.size();
        for (i = 0; i < size; i++)
        {
            SsAnimation* anime = animeList[i];
            if (anime->isSetup != 0)
            {
                Model.setupAnimation = anime;
                break;
            }
        }
 
 
    }
 
    //アニメーション名からアニメーションを取得する
    SsAnimation*    findAnimation(SsString& name);
 
};
 
/*
* @class ssloader_ssae
* @brief ssaeファイルをロードするためのクラスです。
*/
class   ssloader_ssae
{
public:
    ssloader_ssae(){}
    virtual ~ssloader_ssae(){}

    static SsAnimePack*  Load(const std::string& filename );
    static SsAnimePack*  Parse(const char* xmlstr , size_t len);
 
};
 
 
 
 
}   // namespace spritestudio6
 
 
#endif