ruby-ogre 0.0.5-x86-linux → 0.1.0-x86-linux

data/deps/include/OGRE/OgreStaticPluginLoader.h

@@ -1,205 +0,0 @@
-/*
------------------------------------------------------------------------------
-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
-Also see acknowledgements in Readme.html
-
-You may use this sample code for anything you like, it is not covered by the
-same license as the rest of the engine.
------------------------------------------------------------------------------
-*/
-/*
------------------------------------------------------------------------------
-Filename:    StaticPluginLoader.h
-Description: Utility class to load plugins statically
------------------------------------------------------------------------------
-*/
-
-#ifndef __StaticPluginLoader_H__
-#define __StaticPluginLoader_H__
-
-#include "Ogre.h"
-#include "OgreConfigFile.h"
-// Static plugin headers
-#ifdef OGRE_STATIC_CgProgramManager
-#  include "OgreCgPlugin.h"
-#endif
-#ifdef OGRE_STATIC_OctreeSceneManager
-#  include "OgreOctreePlugin.h"
-#endif
-#ifdef OGRE_STATIC_ParticleFX
-#  include "OgreParticleFXPlugin.h"
-#endif
-#ifdef OGRE_STATIC_BSPSceneManager
-#  include "OgreBspSceneManagerPlugin.h"
-#endif
-#ifdef OGRE_STATIC_GL
-#  include "OgreGLPlugin.h"
-#endif
-#ifdef OGRE_STATIC_GLES
-#  include "OgreGLESPlugin.h"
-#endif
-#ifdef OGRE_STATIC_GLES2
-#  include "OgreGLES2Plugin.h"
-#endif
-#ifdef OGRE_STATIC_Direct3D9
-#  include "OgreD3D9Plugin.h"
-#endif
-#ifdef OGRE_STATIC_Direct3D11
-#  include "OgreD3D11Plugin.h"
-#endif
-#ifdef OGRE_STATIC_PCZSceneManager
-#  include "OgrePCZPlugin.h"
-#endif
-#ifdef OGRE_STATIC_OctreeZone
-#  include "OgreOctreeZonePlugin.h"
-#endif
-
-namespace Ogre
-{
-	/** Utility class for loading some plugins statically.
-	@remarks
-		When loading plugins statically, you are limited to loading plugins 
-		that are known about at compile time. You should define preprocessor
-		symbols depending on which plugins you want to load - the symbol being
-		OGRE_STATIC_<pluginname>, with pluginname being the usual name of the
-		plugin DLL (no file extension, no debug suffix, and without the Plugin_ 
-		or RenderSystem_ prefix.)
-	*/
-	class StaticPluginLoader
-	{
-	protected:
-#ifdef OGRE_STATIC_CgProgramManager
-		CgPlugin* mCgPlugin;
-#endif
-#ifdef OGRE_STATIC_OctreeSceneManager
-		OctreePlugin* mOctreePlugin;
-#endif
-#ifdef OGRE_STATIC_ParticleFX
-		ParticleFXPlugin* mParticleFXPlugin;
-#endif
-#ifdef OGRE_STATIC_BSPSceneManager
-		BspSceneManagerPlugin* mBSPPlugin;
-#endif
-#ifdef OGRE_STATIC_PCZSceneManager
-		PCZPlugin* mPCZPlugin;
-#endif
-#ifdef OGRE_STATIC_OctreeZone
-		OctreeZonePlugin* mOctreeZonePlugin;
-#endif
-#ifdef OGRE_STATIC_GL
-		GLPlugin* mGLPlugin;
-#endif
-#ifdef OGRE_STATIC_GLES
-		GLESPlugin* mGLESPlugin;
-#endif
-#ifdef OGRE_STATIC_GLES2
-		GLES2Plugin* mGLES2Plugin;
-#endif
-#ifdef OGRE_STATIC_Direct3D9
-		D3D9Plugin* mD3D9Plugin;
-#endif
-#ifdef OGRE_STATIC_Direct3D11
-		D3D11Plugin* mD3D11Plugin;
-#endif
-	public:
-		StaticPluginLoader() {}
-
-		/** Load all the enabled plugins against the passed in root object. */
-		void load()
-		{
-			Root& root  = Root::getSingleton();
-#ifdef OGRE_STATIC_GL
-			mGLPlugin = OGRE_NEW GLPlugin();
-			root.installPlugin(mGLPlugin);
-#endif
-#ifdef OGRE_STATIC_GLES
-			mGLESPlugin = OGRE_NEW GLESPlugin();
-			root.installPlugin(mGLESPlugin);
-#endif
-#ifdef OGRE_STATIC_GLES2
-			mGLES2Plugin = OGRE_NEW GLES2Plugin();
-			root.installPlugin(mGLES2Plugin);
-#endif
-#ifdef OGRE_STATIC_Direct3D9
-			mD3D9Plugin = OGRE_NEW D3D9Plugin();
-			root.installPlugin(mD3D9Plugin);
-#endif
-
-#ifdef OGRE_STATIC_Direct3D11
-			mD3D11Plugin = OGRE_NEW D3D11Plugin();
-			root.installPlugin(mD3D11Plugin);
-#endif
-#ifdef OGRE_STATIC_CgProgramManager
-			mCgPlugin = OGRE_NEW CgPlugin();
-			root.installPlugin(mCgPlugin);
-#endif
-#ifdef OGRE_STATIC_OctreeSceneManager
-			mOctreePlugin = OGRE_NEW OctreePlugin();
-			root.installPlugin(mOctreePlugin);
-#endif
-#ifdef OGRE_STATIC_ParticleFX
-			mParticleFXPlugin = OGRE_NEW ParticleFXPlugin();
-			root.installPlugin(mParticleFXPlugin);
-#endif
-#ifdef OGRE_STATIC_BSPSceneManager
-			mBSPPlugin = OGRE_NEW BspSceneManagerPlugin();
-			root.installPlugin(mBSPPlugin);
-#endif
-#ifdef OGRE_STATIC_PCZSceneManager
-			mPCZPlugin = OGRE_NEW PCZPlugin();
-			root.installPlugin(mPCZPlugin);
-#endif
-#ifdef OGRE_STATIC_OctreeZone
-			mOctreeZonePlugin = OGRE_NEW OctreeZonePlugin();
-			root.installPlugin(mOctreeZonePlugin);
-#endif
-		}
-
-		void unload()
-		{
-			// don't unload plugins, since Root will have done that. Destroy here.
-#ifdef OGRE_STATIC_OctreeZone
-			OGRE_DELETE mOctreeZonePlugin;
-#endif
-#ifdef OGRE_STATIC_PCZSceneManager
-			OGRE_DELETE mPCZPlugin;
-#endif
-#ifdef OGRE_STATIC_BSPSceneManager
-			OGRE_DELETE mBSPPlugin;
-#endif
-#ifdef OGRE_STATIC_ParticleFX
-			OGRE_DELETE mParticleFXPlugin;
-#endif
-#ifdef OGRE_STATIC_OctreeSceneManager
-			OGRE_DELETE mOctreePlugin;
-#endif
-#ifdef OGRE_STATIC_CgProgramManager
-			OGRE_DELETE mCgPlugin;
-#endif
-#ifdef OGRE_STATIC_Direct3D9
-			OGRE_DELETE mD3D9Plugin;
-#endif
-#ifdef OGRE_STATIC_Direct3D11
-			OGRE_DELETE mD3D11Plugin;
-#endif
-#ifdef OGRE_STATIC_GL
-			OGRE_DELETE mGLPlugin;
-#endif
-#ifdef OGRE_STATIC_GLES
-			OGRE_DELETE mGLESPlugin;
-#endif
-#ifdef OGRE_STATIC_GLES2
-			OGRE_DELETE mGLES2Plugin;
-#endif
-            
-		}
-
-	};
-
-}
-
-#endif

data/deps/include/OGRE/OgreStdHeaders.h

@@ -1,128 +0,0 @@
-#ifndef __StdHeaders_H__
-#define __StdHeaders_H__
-
-#ifdef __BORLANDC__
-    #define __STD_ALGORITHM
-#endif
-
-#if defined ( OGRE_GCC_VISIBILITY ) && ((OGRE_PLATFORM == OGRE_PLATFORM_APPLE && !__LP64__) && OGRE_PLATFORM != OGRE_PLATFORM_APPLE_IOS)
-/* Until libstdc++ for gcc 4.2 is released, we have to declare all
- * symbols in libstdc++.so externally visible, otherwise we end up
- * with them marked as hidden by -fvisible=hidden.
- *
- * See http://gcc.gnu.org/bugzilla/show_bug.cgi?id=20218
- *
- * Due to a more strict linker included with Xcode 4, this is disabled on Mac OS X and iOS.
- * The reason? It changes the visibility of Boost functions.  The mismatch between visibility Boost when used in Ogre (default)
- * and Boost when compiled (hidden) results in mysterious link errors such as "Bad codegen, pointer diff".
- */
-#   pragma GCC visibility push(default)
-#endif
-
-#include <cassert>
-#include <cstdio>
-#include <cstdlib>
-#include <ctime>
-#include <cstring>
-#include <cstdarg>
-#include <cmath>
-
-// STL containers
-#include <vector>
-#include <map>
-#include <string>
-#include <set>
-#include <list>
-#include <deque>
-#include <queue>
-#include <bitset>
-
-// Note - not in the original STL, but exists in SGI STL and STLport
-// For gcc 4.3 see http://gcc.gnu.org/gcc-4.3/changes.html
-#if (OGRE_COMPILER == OGRE_COMPILER_GNUC) && !defined(STLPORT)
-#   if OGRE_COMP_VER >= 430
-#       include <tr1/unordered_map>
-#       include <tr1/unordered_set> 
-#   else
-#       include <ext/hash_map>
-#       include <ext/hash_set>
-#   endif
-#elif (OGRE_COMPILER == OGRE_COMPILER_CLANG)
-#   if defined(_LIBCPP_VERSION)
-#       include <unordered_map>
-#       include <unordered_set>
-#   else
-#       include <tr1/unordered_map>
-#       include <tr1/unordered_set>
-#   endif
-#else
-#   if (OGRE_COMPILER == OGRE_COMPILER_MSVC) && !defined(STLPORT) && OGRE_COMP_VER >= 1600 // VC++ 10.0
-#    	include <unordered_map>
-#    	include <unordered_set>
-#	else
-#   	include <hash_set>
-#   	include <hash_map>
-#	endif
-#endif 
-
-// STL algorithms & functions
-#include <algorithm>
-#include <functional>
-#include <limits>
-
-// C++ Stream stuff
-#include <fstream>
-#include <iostream>
-#include <iomanip>
-#include <sstream>
-
-#ifdef __BORLANDC__
-namespace Ogre
-{
-    using namespace std;
-}
-#endif
-
-extern "C" {
-
-#   include <sys/types.h>
-#   include <sys/stat.h>
-
-}
-
-#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
-#  undef min
-#  undef max
-#  if defined( __MINGW32__ )
-#    include <unistd.h>
-#  endif
-#endif
-
-#if OGRE_PLATFORM == OGRE_PLATFORM_LINUX || OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-extern "C" {
-
-#   include <unistd.h>
-#   include <dlfcn.h>
-
-}
-#endif
-
-#if OGRE_PLATFORM == OGRE_PLATFORM_APPLE || OGRE_PLATFORM == OGRE_PLATFORM_APPLE_IOS
-extern "C" {
-#   include <unistd.h>
-#   include <sys/param.h>
-#   include <CoreFoundation/CoreFoundation.h>
-}
-#endif
-
-#if OGRE_THREAD_SUPPORT
-#	if !defined(NOMINMAX) && defined(_MSC_VER)
-#		define NOMINMAX // required to stop windows.h messing up std::min
-#	endif
-#   include "Threading/OgreThreadHeaders.h"
-#endif
-
-#if defined ( OGRE_GCC_VISIBILITY ) && ((OGRE_PLATFORM == OGRE_PLATFORM_APPLE && !__LP64__) && OGRE_PLATFORM != OGRE_PLATFORM_APPLE_IOS)
-#   pragma GCC visibility pop
-#endif
-#endif

data/deps/include/OGRE/OgreStreamSerialiser.h

@@ -1,386 +0,0 @@
-/*
------------------------------------------------------------------------------
-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 
-{
-	/** \addtogroup Core
-	*  @{
-	*/
-	/** \addtogroup Resources
-	*  @{
-	*/
-
-	/** Utility class providing helper methods for reading / writing 
-		structured data held in a DataStream.
-	@remarks
-		The structure of a file read / written by this class is a series of 
-		'chunks'. A chunk-based format has the advantage of being extensible later, 
-		and it's robust, in that a reader can skip chunks that they are not 
-		able (or willing) to process.
-	@par
-		Chunks are contained serially in the file, but they can also be 
-		nested in order both to provide context, and to group chunks together for 
-		potential skipping. 
-	@par
-		The data format of a chunk is as follows:
-		-# Chunk ID (32-bit uint). This can be any number unique in a context, except the numbers 0x0000, 0x0001 and 0x1000, which are reserved for Ogre's use
-		-# Chunk version (16-bit uint). Chunks can change over time so this version number reflects that
-		-# Length (32-bit uint). The length of the chunk data section, including nested chunks. Note that
-			this length excludes this header, but includes the header of any nested chunks. 
-		-# Checksum (32-bit uint). Checksum value generated from the above - basically lets us check this is a valid chunk.
-		-# Chunk data
-		The 'Chunk data' section will contain chunk-specific data, which may include
-		other nested chunks.
-	*/
-	class _OgreExport StreamSerialiser : public StreamAlloc
-	{
-	public:
-		/// The endianness of files
-		enum Endian
-		{
-			/// Automatically determine endianness
-			ENDIAN_AUTO,
-			/// Use big endian (0x1000 is serialised as 0x10 0x00)
-			ENDIAN_BIG,
-			/// Use little endian (0x1000 is serialised as 0x00 0x10)
-			ENDIAN_LITTLE
-		};
-
-		/// The storage format of Real values
-		enum RealStorageFormat
-		{
-			/// Real is stored as float, reducing precision if you're using OGRE_DOUBLE_PRECISION
-			REAL_FLOAT,
-			/// Real as stored as double, not useful unless you're using OGRE_DOUBLE_PRECISION
-			REAL_DOUBLE
-		};
-
-
-		/// Definition of a chunk of data in a file
-		struct Chunk : public StreamAlloc
-		{
-			/// Identifier of the chunk (for example from makeIdentifier)  (stored)
-			uint32 id;
-			/// Version of the chunk (stored)
-			uint16 version;
-			/// Length of the chunk data in bytes, excluding the header of this chunk (stored)
-			uint32 length;
-			/// Location of the chunk (header) in bytes from the start of a stream (derived)
-			uint32 offset;
-
-			Chunk() : id(0), version(1), length(0), offset(0) {}
-		};
-
-		/** Constructor.
-		@param stream The stream on which you will read / write data.
-		@param endianMode The endian mode in which to read / writedata. If left at
-			the default, when writing the endian mode will be the native platform mode, 
-			and when reading it's expected that the first chunk encountered will be 
-			the header chunk, which will determine the endian mode.
-		@param autoHeader If true, the first write or read to this stream will 
-			automatically read / write the header too. This is required if you
-			set endianMode to ENDIAN_AUTO, but if you manually set the endian mode, 
-			then you can skip writing / reading the header if you wish, if for example
-			this stream is midway through a file which has already included header
-			information.
-		@param realFormat Set the format you want to write reals in. Only useful for files that 
-			you're writing (since when reading this is picked up from the file), 
-			and can only be changed if autoHeader is true, since real format is stored in the header. 
-			Defaults to float unless you're using OGRE_DOUBLE_PRECISION.
-		*/
-		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();
-
-		/** Get the endian mode.
-		@remarks
-			If the result is ENDIAN_AUTO, this mode will change when the first piece of
-			data is read / written. 
-		*/
-		virtual Endian getEndian() const { return mEndian; }
-
-		/** Pack a 4-character code into a 32-bit identifier.
-		@remarks
-			You can use this to generate id's for your chunks based on friendlier
-			4-character codes rather than assigning numerical IDs, if you like.
-		@param code String to pack - must be 4 characters.
-		*/
-		static uint32 makeIdentifier(const String& code);
-
-		/** Report the current depth of the chunk nesting, whether reading or writing. 
-		@remarks
-			Returns how many levels of nested chunks are currently being processed, 
-			either writing or reading. In order to tidily finish, you must call
-			read/writeChunkEnd this many times.
-		*/
-		size_t getCurrentChunkDepth() const { return mChunkStack.size(); }
-
-		/** Get the ID of the chunk that's currently being read/written, if any.
-		@return The id of the current chunk being read / written (at the tightest
-			level of nesting), or zero if no chunk is being processed.
-		*/
-		uint32 getCurrentChunkID() const;
-
-		/** Get the current byte position relative to the start of the data section
-			of the last chunk that was read or written. 
-		@return the offset. Note that a return value of 0 means that either the
-			position is at the start of the chunk data section (ie right after the
-			header), or that no chunk is currently active. Use getCurrentChunkID
-			or getCurrentChunkDepth to determine if a chunk is active.
-		*/
-		size_t getOffsetFromChunkStart() const;
-
-		/** Reads the start of the next chunk in the file.
-		@remarks
-			Files are serialised in a chunk-based manner, meaning that each section
-			of data is prepended by a chunk header. After reading this chunk header, 
-			the next set of data is available directly afterwards. 
-		@note
-			When you have finished with this chunk, you should call readChunkEnd. 
-			This will perform a bit of validation and clear the chunk from 
-			the stack. 
-		@return The Chunk that comes next
-		*/
-		virtual const Chunk* readChunkBegin();
-
-		/** Reads the start of the next chunk so long as it's of a given ID and version.
-		@remarks
-			This method operates like readChunkBegin, except it checks the ID and
-			version.
-		@param id The ID you're expecting. If the next chunk isn't of this ID, then
-			the chunk read is undone and the method returns null.
-		@param maxVersion The maximum version you're able to process. If the ID is correct
-			but the version	exceeds what is passed in here, the chunk is skipped over,
-			the problem logged and null is returned. 
-		@param msg Descriptive text added to the log if versions are not compatible
-		@return The chunk if it passes the validation.
-		*/
-		virtual const Chunk* readChunkBegin(uint32 id, uint16 maxVersion, const String& msg = StringUtil::BLANK);
-
-		/** Call this to 'rewind' the stream to just before the start of the current
-			chunk. 
-		@remarks
-			The most common case of wanting to use this is if you'd calledReadChunkBegin(), 
-			but the chunk you read wasn't one you wanted to process, and rather than
-			skipping over it (which readChunkEnd() would do), you want to backtrack
-			and give something else an opportunity to read it. 
-		@param id The id of the chunk that you were reading (for validation purposes)
-		*/
-		virtual void undoReadChunk(uint32 id);
-
-		/** Call this to 'peek' at the next chunk ID without permanently moving the stream pointer. */
-		virtual uint32 peekNextChunkID(); 
-
-		/** Finish the reading of a chunk.
-		@remarks
-			You can call this method at any point after calling readChunkBegin, even
-			if you didn't read all the rest of the data in the chunk. If you did 
-			not read to the end of a chunk, this method will automatically skip 
-			over the remainder of the chunk and position the stream just after it. 
-		@param id The id of the chunk that you were reading (for validation purposes)
-		*/
-		virtual void readChunkEnd(uint32 id);
-
-		/** Return whether the current data pointer is at the end of the current chunk.
-		@param id The id of the chunk that you were reading (for validation purposes)
-		*/
-		virtual bool isEndOfChunk(uint32 id);
-
-		/// Reports whether the stream is at the end of file
-		virtual bool eof() const;
-
-		/** Get the definition of the current chunk being read (if any). */
-		virtual const Chunk* getCurrentChunk() const;
-
-		/** Begin writing a new chunk.
-		@remarks
-			This starts the process of writing a new chunk to the stream. This will 
-			write the chunk header for you, and store a pointer so that the
-			class can automatically go back and fill in the size for you later
-			should you need it to. If you have already begun a chunk without ending
-			it, then this method will start a nested chunk within it. Once written, 
-			you can then start writing chunk-specific data into your stream.
-		@note If this is the first chunk in the file
-		@param id The identifier of the new chunk. Any value that's unique in the
-			file context is valid, except for the numbers 0x0001 and 0x1000 which are reserved
-			for internal header identification use. 
-		@param version The version of the chunk you're writing
-		*/
-		virtual void writeChunkBegin(uint32 id, uint16 version = 1);
-		/** End writing a chunk. 
-		@param id The identifier of the chunk - this is really just a safety check, 
-			since you can only end the chunk you most recently started.
-		*/
-		virtual void writeChunkEnd(uint32 id);
-
-		/** Write arbitrary data to a stream. 
-		@param buf Pointer to bytes
-		@param size The size of each element to write; each will be endian-flipped if
-			necessary
-		@param count The number of elements to write
-		*/
-		virtual void writeData(const void* buf, size_t size, size_t count);
-
-		/** Catch-all method to write primitive types. */
-		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);
-
-
-		/** Read arbitrary data from a stream. 
-		@param buf Pointer to bytes
-		@param size The size of each element to read; each will be endian-flipped if
-		necessary
-		@param count The number of elements to read
-		*/
-		virtual void readData(void* buf, size_t size, size_t count);
-
-		/** Catch-all method to read primitive types. */
-		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);
-
-		/// read a Vector3
-		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;
-		/// Current list of open chunks
-		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
-