ssloader_sspj.h

Go to the documentation of this file.

#ifndef __SSLOADER_SSPJ__
#define __SSLOADER_SSPJ__
 
#pragma warning(disable : 4819) //
 
#include "sstypes.h"
#include "ssarchiver.h"
#include "ssstring_uty.h"
 
#include "ssloader_ssae.h"
#include "ssloader_ssce.h"
#include "ssloader_ssee.h"
#include "ssloader_ssqe.h"
 
#include <memory>
#include <utility>
 
#define SPRITESTUDIO6_SSPJVERSION "2.00.00"
 
namespace spritestudio6
{

//  編集時設定のためよまない
//  <ssaxImport>                        //!< .ssax インポート設定
//  <copyWhenImportImageIsOutside>  //!< プロジェクトフォルダ外に画像ファイルがある場合にインポート先にコピーする。
//  <exportAnimeFileFormat>         //!< エクスポート時のアニメーションファイルのフォーマット 
//  <exportCellMapFileFormat>           //!< エクスポート時のセルマップファイルのフォーマット
//  <exportCellMap>                 //!< セルマップをエクスポートする
//  <copyImageWhenExportCellmap>        //!< セルマップのエクスポート時に画像ファイルをエクスポート先にコピーする
//  <ssaxExport>                        //!< .ssax エクスポート設定
//  <player>                    //!< 再生対象のプレイヤー。これにより使える機能に制限をかける。
//  <strictVer4>                //!< Ver4互換
//  <availableAttributes>       //!< 使用するアトリビュート
//  <defaultSetAttributes>  //!< 新規キー作成でデフォルトでキーが打たれるアトリビュート
class   SsProjectSetting
{
public:
    //他のメンバーもあるが、必要最低限のものを読み込む
 
    //アニメーションファイルの相対指定等
    SsString                    animeBaseDirectory;           
    SsString                    cellMapBaseDirectory;       
    SsString                    imageBaseDirectory;           
    SsString                    effectBaseDirectory;
 
 
    SsString                    exportBaseDirectory;     
    bool                        queryExportBaseDirectory;   
    SsTexWrapMode::_enum        wrapMode;                   
    SsTexFilterMode::_enum        filterMode;                   
 
    int                         vertexAnimeFloat;           
 
    SsProjectSetting() 
    {
        vertexAnimeFloat = false;                           
    }
    
    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        SPRITESTUDIO6SDK_SSAR_DECLARE(animeBaseDirectory);
        SPRITESTUDIO6SDK_SSAR_DECLARE(cellMapBaseDirectory);
        SPRITESTUDIO6SDK_SSAR_DECLARE(imageBaseDirectory);
        SPRITESTUDIO6SDK_SSAR_DECLARE(effectBaseDirectory);
 
        SPRITESTUDIO6SDK_SSAR_DECLARE(exportBaseDirectory);
        SPRITESTUDIO6SDK_SSAR_DECLARE(queryExportBaseDirectory);
        SPRITESTUDIO6SDK_SSAR_DECLARE_ENUM( wrapMode );
        SPRITESTUDIO6SDK_SSAR_DECLARE_ENUM( filterMode );
        SPRITESTUDIO6SDK_SSAR_DECLARE_ENUM(vertexAnimeFloat);
 
    }
};
 
 
typedef std::vector<std::unique_ptr<SsAnimePack>> SsAnimePackList;
typedef SsAnimePackList::iterator SsAnimePackListItr;
 
typedef std::vector<std::unique_ptr<SsCellMap>> SsSsCellMapList;
typedef SsSsCellMapList::iterator SsSsCellMapListItr;
 
 
typedef std::vector<std::unique_ptr<SsEffectFile>> SsEffectFileList;
typedef SsEffectFileList::iterator SsEffectFileListItr;
 
typedef std::vector<std::unique_ptr<SsSequencePack>> SsSequencePackList;
typedef SsSequencePackList::iterator SsSequencePackListItr;

class SsProject
{
public:
 
    SsString                version;
    SsProjectSetting        settings;           
 
    std::vector<SsString>   cellmapNames;       
    std::vector<SsString>   animepackNames;       
    std::vector<SsString>   effectFileNames; 
    std::vector<SsString>   textureList;     
    std::vector<SsString>   sequencepackNames; 
 
    SsAnimePackList      animeList;     
    SsSsCellMapList      cellmapList; 
    SsEffectFileList    effectfileList;   
    SsSequencePackList    sequenceList;   
 
    //ロード時に作成されるワーク
    SsString    m_proj_filepath; 
 
 
    SsProject(){}
    virtual ~SsProject();

    const SsProjectSetting& getProjectSetting(){ return settings;} 

    const size_t getAnimePackNum(){ return animepackNames.size(); }

    const size_t getCellMapNum(){ return cellmapNames.size(); }

    const size_t getEffectFileNum(){ return effectFileNames.size(); }

    const size_t getSequencePackNum(){ return sequencepackNames.size(); }
 

    SsAnimePackList& getAnimePackList(){ return animeList;}

    SsSsCellMapList& getCellMapList(){ return cellmapList;}
 
    //エフェクトファイルのリスト
    SsEffectFileList&   getEffectFileList(){ return effectfileList;}

    SsSequencePackList&   getSequencePackList(){ return sequenceList;}

    SsAnimePack* getAnimePack(int index){ return animeList[index].get();}

    SsCellMap* getCellMap(int index){ return cellmapList[index].get();}
 
    //エフェクトファイルの各情報を取得する
    SsEffectFile*   getEffectFile(int index){ return effectfileList[index].get();}

    SsSequencePack*   getSequencePack(int index){ return sequenceList[index].get();}
 
 
    //アニメパック名とアニメ名からアニメーションを取得する
    SsAnimation*     findAnimation( SsString& animePackName , SsString& AnimeName );
 
    SsAnimePack*     findAnimationPack( SsString& animePackName );
 
    //エフェクトの名前からエフェクトを取得する
    SsEffectFile*       findEffect( SsString& effectName );
 
 
    //シーケンスパック名とシーケンス名からシーケンスを取得する
    SsSequence*           findSequence( SsString& sequencePackName , SsString& SequenceName );
 
    SsSequencePack*       findSequencePack( SsString& sequencePackName );
 
    
 
    SsCellMap* findCellMap( SsString& str );
 

    SPRITESTUDIO6SDK_SERIALIZE_BLOCK
    {
        SPRITESTUDIO6SDK_SSAR_DECLARE_ATTRIBUTE(version);
        SPRITESTUDIO6SDK_SSAR_STRUCT_DECLARE( settings );
        SPRITESTUDIO6SDK_SSAR_DECLARE( cellmapNames );
        SPRITESTUDIO6SDK_SSAR_DECLARE( animepackNames );
        SPRITESTUDIO6SDK_SSAR_DECLARE( effectFileNames );
        SPRITESTUDIO6SDK_SSAR_DECLARE( sequencepackNames );
 
    }
 
public:

    void    setFilepath( const SsString& path ) { m_proj_filepath = path; }

    const   SsString&   getFilepath(){ return m_proj_filepath; }

    SsString    getSsceBasepath();

    SsString    getSsaeBasepath();
 
    SsString    getSseeBasepath();
 
    SsString    getImageBasepath();

    SsString    getSsqeBasepath();
 

    SsString    getAnimePackFilePath( size_t index , bool add_basepath = true) { 
        if ( animepackNames.size() <= index ) return "";
 
        if (add_basepath)
        {
            return getSsaeBasepath() + animepackNames[index];
        }else{
            return animepackNames[index];
        }
    }
 

    SsString    getCellMapFilePath( size_t index ) { 
        if ( cellmapNames.size() <= index ) return "";
        SsString str = getSsceBasepath();
 
        std::string f = cellmapNames[index];
        
        std::string ret = getFullPath( str , path2dir( cellmapNames[index] ) );
        ret = ret + path2file( cellmapNames[index] );
        ret = nomarizeFilename(ret);
 
        //str = str + cellmapNames[index];
        //return str ;
        return ret;
    }
 
    SsString    getEffectFilePath( size_t index ) { 
        if ( effectFileNames.size() <= index ) return "";
        return getSseeBasepath() + effectFileNames[index];
    }
 
    SsString    getCelMapFileOriginalPath( size_t index ) { 
        if ( cellmapNames.size() <= index ) return "";
        return cellmapNames[index] ;
    }

    SsString    getSequencePackFilePath( size_t index ) { 
        if ( sequencepackNames.size() <= index ) return "";
        return getSsqeBasepath() + sequencepackNames[index];
    }
 
};

class ssloader_sspj
{
private:
 
public:
    ssloader_sspj(){}
    virtual ~ssloader_sspj(){}
    
    static SsProject*  Load(const std::string& filename );
    static SsProject*  Parse_ProjectOnly(const char* xml , size_t len);
};
 
 
}   // namespace spritestudio6
 
#endif