ParaXSerializer.h

#pragma once
#include "ParaXModel/ParaXModel.h"

#include <vector>

namespace ParaEngine
{
    // forward declare
    class CParaFile;

    struct SerializerOptions
    {
        bool m_bBinary:1;
        bool m_bCompressed:1;
        bool m_bHasAnimation:1;
        bool m_bHasNorm:1;
    public:
        SerializerOptions():m_bBinary(false), m_bCompressed(false),m_bHasAnimation(true), m_bHasNorm(true){};
        SerializerOptions(bool bBinary):m_bBinary(bBinary), m_bCompressed(false),m_bHasAnimation(true), m_bHasNorm(true){};
    };

#ifdef USE_DIRECTX_RENDERER
    typedef ID3DXFileSaveObject* LPFileSaveObject;
    typedef ID3DXFileSaveData* LPFileSaveData;
    typedef ID3DXFileData* LPFileData;
#endif
    struct CParaRawData
    {
    private:
        std::vector<byte> m_RawData;
    public:
        CParaRawData(){}

        unsigned int GetSize() {return (unsigned int)m_RawData.size();}
        const byte* GetBuffer() {return &m_RawData.front();}

        unsigned int AddRawData(const DWORD * pData, int nCount){
            unsigned int nOffset = GetSize();
            if(nCount>0)
            {
                unsigned int nSize = nCount*sizeof(*pData);
                m_RawData.resize(nOffset+nSize);
                memcpy(&m_RawData[nOffset], pData, nSize);
            }
            return nOffset;
        };
        unsigned int AddRawData(const short * pData, int nCount){
            unsigned int nOffset = GetSize();
            if(nCount>0)
            {
                unsigned int nSize = nCount*sizeof(*pData);
                m_RawData.resize(nOffset+nSize);
                memcpy(&m_RawData[nOffset], pData, nSize);
            }
            return nOffset;
        };
        unsigned int AddRawData(const Vector2 * pData, int nCount){
            unsigned int nOffset = GetSize();
            if(nCount>0)
            {
                unsigned int nSize = nCount*sizeof(*pData);
                m_RawData.resize(nOffset+nSize);
                memcpy(&m_RawData[nOffset], pData, nSize);
            }
            return nOffset;
        };
        unsigned int AddRawData(const Vector3 * pData, int nCount){
            unsigned int nOffset = GetSize();
            if(nCount>0)
            {
                unsigned int nSize = nCount*sizeof(*pData);
                m_RawData.resize(nOffset+nSize);
                memcpy(&m_RawData[nOffset], pData, nSize);
            }
            return nOffset;
        };
        unsigned int AddRawData(const Vector4 * pData, int nCount){
            unsigned int nOffset = GetSize();
            if(nCount>0)
            {
                unsigned int nSize = nCount*sizeof(*pData);
                m_RawData.resize(nOffset+nSize);
                memcpy(&m_RawData[nOffset], pData, nSize);
            }
            return nOffset;
        };
        unsigned int AddRawData(const Matrix4 * pData, int nCount) {
            unsigned int nOffset = GetSize();
            if (nCount > 0)
            {
                unsigned int nSize = nCount * sizeof(*pData);
                m_RawData.resize(nOffset + nSize);
                memcpy(&m_RawData[nOffset], pData, nSize);
            }
            return nOffset;
        };

        unsigned int AddRawData(const char* pData, int nCount) {
            unsigned int nOffset = GetSize();
            if (nCount > 0)
            {
                unsigned int nSize = nCount * sizeof(*pData);
                m_RawData.resize(nOffset + nSize);
                memcpy(&m_RawData[nOffset], pData, nSize);
            }
            return nOffset;
        };
        unsigned int AddRawData(const std::string& str) {
            return AddRawData(str.c_str(), str.size()+1);
        };
    };
#ifdef USE_DIRECTX_RENDERER

    struct ParaXParser
    {
        CParaFile& m_file;
        bool    m_bIsValid;
        bool    m_bHeaderLoaded;

        ID3DXFileEnumObject *m_pDXEnum;
        ParaXHeaderDef m_xheader;
        LPFileData m_pParaXBody;
        LPFileData m_pParaXRawData;
        LPFileData m_pParaXRef;
        LPFileData m_pD3DMesh;
        LPFileData m_pD3DRootFrame;

        // x file template parsing
        LPD3DXFILE  m_pDXFileParser;    

    public:
        ParaXParser(CParaFile& file, LPD3DXFILE pDXFileParser=NULL );
        ~ParaXParser(){Finalize();};

        inline LPD3DXFILE GetFileParser() {return m_pDXFileParser;}
        void Finalize();
    };
#endif

    class CParaXSerializer
    {
    public:
        CParaXSerializer(void);
        ~CParaXSerializer(void);
        
        static SerializerOptions g_pDefaultOption;

    private:    
        CParaRawData m_rawdata;
        const byte*      m_pRaw;
    public:
        inline const byte* GetRawData(int nOffset) const { return (m_pRaw!=0)?(m_pRaw+nOffset):NULL; };
        void* LoadParaXMesh(CParaFile &f);

        static void ExportParaXMesh(const string& filePath, CParaXModel* pMesh);

#ifdef USE_DIRECTX_RENDERER

        void* LoadParaXMesh(CParaFile &f, ParaXParser& Parser);

        bool LoadParaX_Header(ParaXParser& Parser);
        void* LoadParaX_Body(ParaXParser& Parser);
        void LoadParaX_Finalize(ParaXParser& Parser);
        
        bool SaveParaXMesh(const string& filename, const CParaXModel& xmesh, SerializerOptions* pOptions=NULL);
        
    private:
        bool WriteAnimationBlock(AnimationBlock* b, const Animated<Vector3>& anims);
        bool WriteAnimationBlock(AnimationBlock* b, const AnimatedShort& anims);
        bool WriteAnimationBlock(AnimationBlock* b, const Animated<float>& anims);
        bool WriteAnimationBlock(AnimationBlock* b, const Animated<Quaternion>& anims);

        bool ReadAnimationBlock(const AnimationBlock* b, Animated<Vector3>& anims,int *gs);
        bool ReadAnimationBlock(const AnimationBlock* b, AnimatedShort& anims,int *gs);
        bool ReadAnimationBlock(const AnimationBlock* b, Animated<float>& anims,int *gs);
        bool ReadAnimationBlock(const AnimationBlock* b, Animated<Quaternion>& anims,int *gs);

        bool WriteParaXHeader(const CParaXModel& xmesh, LPFileSaveObject pFileData);
        //bool WriteParaXHeader(const CParaXModel& xmesh, LPFileSaveData pFileData);

        bool WriteXGlobalSequences(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXVertices(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXTextures(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXAttachments(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXColors(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXTransparency(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXViews(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXIndices0(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXGeosets(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXRenderPass(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXBones(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXTexAnims(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXParticleEmitters(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXRibbonEmitters(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXCameras(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXLights(const CParaXModel& xmesh, LPFileSaveData pFileData);
        bool WriteXAnimations(const CParaXModel& xmesh, LPFileSaveData pFileData);

        bool WriteXRawBytes(const CParaXModel& xmesh, LPFileSaveObject pFileData);

        bool ReadParaXHeader(ParaXHeaderDef& xheader, LPFileData pFileData);
        bool ReadXGlobalSequences(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXVertices(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXTextures(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXAttachments(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXColors(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXTransparency(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXViews(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXIndices0(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXGeosets(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXRenderPass(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXBones(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXTexAnims(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXParticleEmitters(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXRibbonEmitters(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXCameras(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXLights(CParaXModel& xmesh, LPFileData pFileData);
        bool ReadXAnimations(CParaXModel& xmesh, LPFileData pFileData);
#endif
    };

}