ssloader_ssae.h

#ifndef __SSLOADER_SSAE__
#define __SSLOADER_SSAE__

#include "sstypes.h"
#include "ssarchiver.h"
#include "ssattribute.h"


class SsAnimationSettings
{
public:
    int                     fps;            
    int                     frameCount;     
    SsPartsSortMode::_enum  sortMode;       
    SsPoint2        canvasSize;             
    SsVector2       pivot;                  

    SsAnimationSettings(){}
    virtual ~SsAnimationSettings(){}
public:

    SSSERIALIZE_BLOCK
    {
        SSAR_DECLARE( fps );
        SSAR_DECLARE( frameCount );
        SSAR_DECLARE( canvasSize );
        SSAR_DECLARE( pivot );
    }
};



//パーツ一つあたりの情報を保持するデータです。
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;         

    float                   inheritRates[(int)SsAttributeKind::num];    

    //参照アニメーション名
    //ツールはともかくランタイムでは勿体ない使い方なので何らか考えること
    SsString        refAnimePack;   
    SsString        refAnime;       

public:
    SsPart() : 
      name("") , arrayIndex(0), parentIndex(0) , show(0) , locked(0)
      {
            //memset( inheritRates , 0 , sizeof( float) * SsAttributeKind::num );
            for (int i = 0; i < (int)SsAttributeKind::num ; ++i)
                inheritRates[i] = 1.f;
            // 反転・非表示フラグは継承しない from 旧SS
            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(){}


    SSSERIALIZE_BLOCK
    {
        SSAR_DECLARE( name );
        SSAR_DECLARE( arrayIndex );
        SSAR_DECLARE( parentIndex );

        SSAR_DECLARE_ENUM( type );
        SSAR_DECLARE_ENUM( boundsType );
        SSAR_DECLARE_ENUM( inheritType );
        SSAR_DECLARE_ENUM( alphaBlendType );
        SSAR_DECLARE( show );
        SSAR_DECLARE( locked );
        SSAR_DECLARE( refAnimePack );
        SSAR_DECLARE( refAnime );

        //継承率後に改良を実施
        if ( ar->getType() == EnumSsArchiver::in )
        {
            XMLElement* e = ar->getxml()->FirstChildElement( "ineheritRates" );
            if ( e )
            {
                XMLElement* ec = e->FirstChildElement();
                while(ec)
                {
                    const char* tag = ec->GetText();
                    SsAttributeKind::_enum enumattr;

                    __StringToEnum_( tag , enumattr );
                    inheritRates[(int)enumattr] = (float)atof( ec->Value() );
                    ec = ec->NextSiblingElement();
                }
            }
        }

    }
};


//アニメーションを構成するパーツをリスト化したものです。
class SsModel
{
public:
    std::vector<SsPart*>    partList;   

public:
    SsModel(){}
    virtual~ SsModel()
    {
        for ( std::vector<SsPart*>::iterator itr = partList.begin() ; 
            itr != partList.end() ; itr ++ ) delete (*itr);
    }

    SSSERIALIZE_BLOCK
    {
        SSAR_DECLARE_LIST( partList );
    }

};


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);   
    }

    SSSERIALIZE_BLOCK
    {
        SSAR_DECLARE( partName );
        SSAR_DECLARE_LISTEX( attributes , "attribute" );
    }
};


class SsLabel
{
public:
    SsString    name;   
    int         time;   

    SSSERIALIZE_BLOCK
    {
        SSAR_DECLARE( name );
        SSAR_DECLARE( time );
    }

private:

};


class SsAnimation
{
public:
    SsString    name;                           
    bool        overrideSettings;               
    SsAnimationSettings         settings;       
    std::vector<SsPartAnime*>   partAnimes;     

    std::vector<SsLabel*>   labels;
    //SsLabelList               labels;     ///< ラベルリスト
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);   
    }

    SSSERIALIZE_BLOCK
    {
        SSAR_DECLARE( name );
        SSAR_STRUCT_DECLARE( settings );
        SSAR_DECLARE_LISTEX( partAnimes , "partAnime" );
        SSAR_DECLARE_LISTEX( labels , "labels" );
    }
};

class SsAnimePack
{
public:
    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);        
    }

    SSSERIALIZE_BLOCK
    {
        SSAR_STRUCT_DECLARE( settings );
        SSAR_DECLARE( name );
        SSAR_STRUCT_DECLARE( Model );
        SSAR_DECLARE( cellmapNames );
        SSAR_DECLARE_LISTEX( animeList , "anime" );
    }

    //アニメーション名からアニメーションを取得する
    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 );

};






#endif