OgreStreamSerialiser.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OGRE
(Object-oriented Graphics Rendering Engine)
For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2012 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-----------------------------------------------------------------------------
*/
#ifndef __StreamSerialiser_H__
#define __StreamSerialiser_H__

#include "OgrePrerequisites.h"
#include "OgreDataStream.h"


namespace Ogre 
{
    class _OgreExport StreamSerialiser : public StreamAlloc
    {
    public:
        enum Endian
        {
            ENDIAN_AUTO,
            ENDIAN_BIG,
            ENDIAN_LITTLE
        };

        enum RealStorageFormat
        {
            REAL_FLOAT,
            REAL_DOUBLE
        };


        struct Chunk : public StreamAlloc
        {
            uint32 id;
            uint16 version;
            uint32 length;
            uint32 offset;

            Chunk() : id(0), version(1), length(0), offset(0) {}
        };

        StreamSerialiser(const DataStreamPtr& stream, Endian endianMode = ENDIAN_AUTO, 
            bool autoHeader = true, 
#if OGRE_DOUBLE_PRECISION
            RealStorageFormat realFormat = REAL_DOUBLE
#else
            RealStorageFormat realFormat = REAL_FLOAT
#endif
            );
        virtual ~StreamSerialiser();

        virtual Endian getEndian() const { return mEndian; }

        static uint32 makeIdentifier(const String& code);

        size_t getCurrentChunkDepth() const { return mChunkStack.size(); }

        uint32 getCurrentChunkID() const;

        size_t getOffsetFromChunkStart() const;

        virtual const Chunk* readChunkBegin();

        virtual const Chunk* readChunkBegin(uint32 id, uint16 maxVersion, const String& msg = StringUtil::BLANK);

        virtual void undoReadChunk(uint32 id);

        virtual uint32 peekNextChunkID(); 

        virtual void readChunkEnd(uint32 id);

        virtual bool isEndOfChunk(uint32 id);

        virtual bool eof() const;

        virtual const Chunk* getCurrentChunk() const;

        virtual void writeChunkBegin(uint32 id, uint16 version = 1);
        virtual void writeChunkEnd(uint32 id);

        virtual void writeData(const void* buf, size_t size, size_t count);

        template <typename T>
        void write(const T* pT, size_t count = 1)
        {
            writeData(pT, sizeof(T), count);
        }

        // Special-case Real since we need to deal with single/double precision
        virtual void write(const Real* val, size_t count = 1);

        virtual void write(const Vector2* vec, size_t count = 1);
        virtual void write(const Vector3* vec, size_t count = 1);
        virtual void write(const Vector4* vec, size_t count = 1);
        virtual void write(const Quaternion* q, size_t count = 1);
        virtual void write(const Matrix3* m, size_t count = 1);
        virtual void write(const Matrix4* m, size_t count = 1);
        virtual void write(const String* string);
        virtual void write(const AxisAlignedBox* aabb, size_t count = 1);
        virtual void write(const Sphere* sphere, size_t count = 1);
        virtual void write(const Plane* plane, size_t count = 1);
        virtual void write(const Ray* ray, size_t count = 1);
        virtual void write(const Radian* angle, size_t count = 1);
        virtual void write(const Node* node, size_t count = 1);
        virtual void write(const bool* boolean, size_t count = 1);


        virtual void readData(void* buf, size_t size, size_t count);

        template <typename T>
        void read(T* pT, size_t count = 1)
        {
            readData(pT, sizeof(T), count);
        }

        // Special case Real, single/double-precision issues
        virtual void read(Real* val, size_t count = 1);

        virtual void read(Vector2* vec, size_t count = 1);
        virtual void read(Vector3* vec, size_t count = 1);
        virtual void read(Vector4* vec, size_t count = 1);
        virtual void read(Quaternion* q, size_t count = 1);
        virtual void read(Matrix3* m, size_t count = 1);
        virtual void read(Matrix4* m, size_t count = 1);
        virtual void read(String* string);
        virtual void read(AxisAlignedBox* aabb, size_t count = 1);
        virtual void read(Sphere* sphere, size_t count = 1);
        virtual void read(Plane* plane, size_t count = 1);
        virtual void read(Ray* ray, size_t count = 1);
        virtual void read(Radian* angle, size_t count = 1);
        virtual void read(Node* node, size_t count = 1);
        virtual void read(bool* val, size_t count = 1);

    protected:
        DataStreamPtr mStream;
        Endian mEndian;
        bool mFlipEndian;
        bool mReadWriteHeader;
        RealStorageFormat mRealFormat;
        typedef deque<Chunk*>::type ChunkStack;
        ChunkStack mChunkStack;

        static uint32 HEADER_ID;
        static uint32 REVERSE_HEADER_ID;
        static uint32 CHUNK_HEADER_SIZE;

        virtual Chunk* readChunkImpl();
        virtual void writeChunkImpl(uint32 id, uint16 version);
        virtual void readHeader();
        virtual void writeHeader();
        virtual uint32 calculateChecksum(Chunk* c);
        virtual void checkStream(bool failOnEof = false, 
            bool validateReadable = false, bool validateWriteable = false) const;

        virtual void flipEndian(void * pData, size_t size, size_t count);
        virtual void flipEndian(void * pData, size_t size);
        virtual void determineEndianness();
        virtual Chunk* popChunk(uint id);

        virtual void writeFloatsAsDoubles(const float* val, size_t count);
        virtual void writeDoublesAsFloats(const double* val, size_t count);
        virtual void readFloatsAsDoubles(double* val, size_t count);
        virtual void readDoublesAsFloats(float* val, size_t count);
        template <typename T, typename U>
        void writeConverted(const T* src, U typeToWrite, size_t count)
        {
            U* tmp = OGRE_ALLOC_T(U, count, MEMCATEGORY_GENERAL);
            U* pDst = tmp;
            const T* pSrc = src;
            for (size_t i = 0; i < count; ++i)
                *pDst++ = static_cast<U>(*pSrc++);
            
            writeData(tmp, sizeof(U), count);

            OGRE_FREE(tmp, MEMCATEGORY_GENERAL);
        }
        template <typename T, typename U>
        void readConverted(T* dst, U typeToRead, size_t count)
        {
            U* tmp = OGRE_ALLOC_T(U, count, MEMCATEGORY_GENERAL);
            readData(tmp, sizeof(U), count);

            T* pDst = dst;
            const U* pSrc = tmp;
            for (size_t i = 0; i < count; ++i)
                *pDst++ = static_cast<T>(*pSrc++);


            OGRE_FREE(tmp, MEMCATEGORY_GENERAL);
        }

    };
}

#endif