shattered_ogrerb 0.5.0.1

data/vendor/ogrerb/src_headers/OGRE/OgreConvexBody.h

@@ -0,0 +1,252 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Copyright (c) 2006 Matthias Fink, netAllied GmbH <matthias.fink@web.de>								
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307, USA, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __ConvexBody_H__
+#define __ConvexBody_H__
+
+#include "OgrePrerequisites.h"
+#include "OgrePolygon.h"
+
+
+namespace Ogre
+{
+
+	/** Holds a solid representation of a convex body.
+		@remarks
+			Administers a convex body. All polygons of the body are convex and
+			planar. Several operations may be applied, ranging from intersection
+			to join where each result it itself a convex body.
+	*/
+	class _OgreExport ConvexBody
+	{
+	public:
+		typedef std::vector< Polygon* >	PolygonList;
+
+	protected:
+		PolygonList mPolygons;
+
+		// Static 'free list' of polygons to save reallocation, shared between all bodies
+		static PolygonList msFreePolygons;
+#if OGRE_THREAD_SUPPORT
+		static boost::recursive_mutex msFreePolygonsMutex;
+#endif
+
+	public:
+		ConvexBody();
+		~ConvexBody();
+		ConvexBody( const ConvexBody& cpy );
+
+		/** Build a new polygon representation from a frustum.
+		*/
+		void define(const Frustum& frustum);
+
+		/** Build a new polygon representation from an AAB.
+		*/
+		void define(const AxisAlignedBox& aab);
+
+		/** Clips the body with a frustum. The resulting holes
+			are filled with new polygons.
+		*/
+		void clip( const Frustum& frustum );
+
+		/** Clips the body with an AAB. The resulting holes
+			are filled with new polygons.
+		*/
+		void clip( const AxisAlignedBox& aab );
+
+		/** Clips the body with another body.
+		*/
+		void clip(const ConvexBody& body);
+
+		/** Clips the object by the positive half space of a plane
+		*/
+		void clip(const Plane& pl, bool keepNegative = true);
+
+		/** Extends the existing body to incorporate the passed in point as a
+			convex hull.
+		@remarks
+			You must already have constructed a basic body using a 'construct' 
+			method.
+		*/
+		void extend(const Vector3& pt);
+
+		/** Resets the object.
+		*/
+		void reset( void );
+
+		/** Returns the current number of polygons.
+		*/
+		size_t getPolygonCount( void ) const;
+
+		/** Returns the number of vertices for a polygon
+		*/
+		size_t getVertexCount( size_t poly ) const;
+
+		/** Returns a polygon.
+		*/
+		const Polygon& getPolygon( size_t poly ) const;
+
+		/** Returns a specific vertex of a polygon.
+		*/
+		const Vector3& getVertex( size_t poly, size_t vertex ) const;
+
+		/** Returns the normal of a specified polygon.
+		*/
+		const Vector3& getNormal( size_t poly );
+
+		/** Returns an AABB representation.
+		*/
+		AxisAlignedBox getAABB( void ) const;
+
+		/** Checks if the body has a closed hull.
+		*/
+		bool hasClosedHull( void ) const;
+
+		/** Merges all neighboring polygons into one single polygon if they are
+			lay in the same plane.
+		*/
+		void mergePolygons( void );
+
+		/** Determines if the current object is equal to the compared one.
+		*/
+		bool operator == ( const ConvexBody& rhs ) const;
+
+		/** Determines if the current object is not equal to the compared one.
+		*/
+		bool operator != ( const ConvexBody& rhs ) const
+		{ return !( *this == rhs ); }
+
+		/** Prints out the body with all its polygons.
+		*/
+		_OgreExport friend std::ostream& operator<< ( std::ostream& strm, const ConvexBody& body );
+
+		/** Log details of this body */
+		void logInfo() const;
+
+		/// Initialise the internal polygon pool used to minimise allocations
+		static void _initialisePool();
+		/// Tear down the internal polygon pool used to minimise allocations
+		static void _destroyPool();
+
+
+	protected:
+		/** Get a new polygon from the pool.
+		*/
+		static Polygon* allocatePolygon();
+		/** Release a polygon back tot he pool. */
+		static void freePolygon(Polygon* poly);
+		/** Inserts a polygon at a partcular point in the body.
+		@note
+			After this method is called, the ConvexBody 'owns' this Polygon
+			and will be responsible for deleting it.
+		*/
+		void insertPolygon(Polygon* pdata, size_t poly);
+		/** Inserts a polygon at the end.
+		@note
+			After this method is called, the ConvexBody 'owns' this Polygon
+			and will be responsible for deleting it.
+		*/
+		void insertPolygon(Polygon* pdata);
+
+		/** Inserts a vertex for a polygon at a particular point.
+		@note
+			No checks are done whether the assembled polygon is (still) planar, 
+			the caller must ensure that this is the case.
+		*/
+		void insertVertex(size_t poly, const Vector3& vdata, size_t vertex);
+		/** Inserts a vertex for a polygon at the end.
+		@note
+			No checks are done whether the assembled polygon is (still) planar, 
+			the caller must ensure that this is the case.
+		*/
+		void insertVertex(size_t poly, const Vector3& vdata);
+		/** Deletes a specific polygon.
+		*/
+		void deletePolygon(size_t poly);
+
+		/** Removes a specific polygon from the body without deleting it.
+		@note
+			The retrieved polygon needs to be deleted later by the caller.
+		*/
+		Polygon* unlinkPolygon(size_t poly);
+
+		/** Moves all polygons from the parameter body to this instance.
+		@note Both the passed in object and this instance are modified
+		*/
+		void moveDataFromBody(ConvexBody& body);
+
+		/** Deletes a specific vertex of a specific polygon.
+		*/
+		void deleteVertex(size_t poly, size_t vertex);
+
+		/** Replace a polygon at a particular index.
+		@note Again, the passed in polygon is owned by this object after this
+			call returns, and this object is resonsible for deleting it.
+		*/
+		void setPolygon(Polygon* pdata, size_t poly );
+
+		/** Replace a specific vertex of a polygon.
+		@note
+			No checks are done whether the assembled polygon is (still) planar, 
+			the caller must ensure that this is the case.
+		*/
+		void setVertex( size_t poly, const Vector3& vdata, size_t vertex );
+
+		/** Returns the single edges in an EdgeMap (= edges where one side is a vertex and the
+			other is empty space (a hole in the body)).
+		*/
+		Polygon::EdgeMap getSingleEdges() const;
+
+		/** Stores the edges of a specific polygon in a passed in structure.
+		*/
+		void storeEdgesOfPolygon(size_t poly, Polygon::EdgeMap *edgeMap) const;
+			
+		/** Allocates space for an specified amount of polygons with
+			each of them having a specified number of vertices.
+			@note
+				Old data (if available) will be erased.
+		*/
+		void allocateSpace(size_t numPolygons, size_t numVertices);
+
+		/** Searches for a pair (an edge) in the intersectionList with an entry
+			that equals vec, and removes it from the passed in list.
+		@param vec The vertex to search for in intersectionEdges
+		@param intersectionEdges A list of edges, which is updated if a match is found
+		@param vNext A reference to a vector which will be filled with the other
+			vertex at the matching edge, if found.
+		@returns True if a match was found
+		*/
+		bool findAndEraseEdgePair(const Vector3& vec, 
+			Polygon::EdgeMap& intersectionEdges, Vector3& vNext ) const;
+
+	};
+}
+
+#endif 
+

data/vendor/ogrerb/src_headers/OGRE/OgreDDSCodec.h

@@ -0,0 +1,90 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307, USA, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __OgreDDSCodec_H__
+#define __OgreDDSCodec_H__
+
+#include "OgreImageCodec.h"
+namespace Ogre {
+
+	// Forward declarations
+	struct DXTColourBlock;
+	struct DXTExplicitAlphaBlock;
+	struct DXTInterpolatedAlphaBlock;
+
+    /** Codec specialized in loading DDS (Direct Draw Surface) images.
+	@remarks
+		We implement our own codec here since we need to be able to keep DXT
+		data compressed if the card supports it.
+    */
+    class _OgreExport DDSCodec : public ImageCodec
+    {
+    private:
+        String mType;
+
+    	void flipEndian(void * pData, size_t size, size_t count) const;
+	    void flipEndian(void * pData, size_t size) const;
+
+		PixelFormat convertFourCCFormat(uint32 fourcc) const;
+		PixelFormat convertPixelFormat(uint32 rgbBits, uint32 rMask, 
+			uint32 gMask, uint32 bMask, uint32 aMask) const;
+
+		/// Unpack DXT colours into array of 16 colour values
+		void unpackDXTColour(PixelFormat pf, const DXTColourBlock& block, ColourValue* pCol) const;
+		/// Unpack DXT alphas into array of 16 colour values
+		void unpackDXTAlpha(const DXTExplicitAlphaBlock& block, ColourValue* pCol) const;
+		/// Unpack DXT alphas into array of 16 colour values
+		void unpackDXTAlpha(const DXTInterpolatedAlphaBlock& block, ColourValue* pCol) const;
+
+		/// Single registered codec instance
+		static DDSCodec* msInstance;
+	public:
+        DDSCodec();
+        virtual ~DDSCodec() { }
+
+        /// @copydoc Codec::code
+        DataStreamPtr code(MemoryDataStreamPtr& input, CodecDataPtr& pData) const;
+        /// @copydoc Codec::codeToFile
+        void codeToFile(MemoryDataStreamPtr& input, const String& outFileName, CodecDataPtr& pData) const;
+        /// @copydoc Codec::decode
+        DecodeResult decode(DataStreamPtr& input) const;
+
+        
+        virtual String getType() const;        
+
+		/// Static method to startup and register the DDS codec
+		static void startup(void);
+		/// Static method to shutdown and unregister the DDS codec
+		static void shutdown(void);
+
+    };
+
+} // namespace
+
+#endif
+

data/vendor/ogrerb/src_headers/OGRE/OgreDataStream.h

@@ -0,0 +1,442 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307, USA, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef __DataStream_H__
+#define __DataStream_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreString.h"
+#include "OgreSharedPtr.h"
+#include <istream>
+
+namespace Ogre {
+
+	/** General purpose class used for encapsulating the reading of data.
+	@remarks
+		This class performs basically the same tasks as std::basic_istream, 
+		except that it does not have any formatting capabilities, and is
+		designed to be subclassed to receive data from multiple sources,
+		including libraries which have no compatiblity with the STL's
+		stream interfaces. As such, this is an abstraction of a set of 
+		wrapper classes which pretend to be standard stream classes but 
+		can actually be implemented quite differently. 
+	@par
+		Generally, if a plugin or application provides an ArchiveFactory, 
+		it should also provide a DataStream subclass which will be used
+		to stream data out of that Archive implementation, unless it can 
+		use one of the common implementations included.
+	@note
+		Ogre makes no guarantees about thread safety, for performance reasons.
+		If you wish to access stream data asynchronously then you should
+		organise your own mutexes to avoid race conditions. 
+	*/
+	class _OgreExport DataStream
+	{
+	protected:
+		/// The name (e.g. resource name) that can be used to identify the source fot his data (optional)
+		String mName;		
+        /// Size of the data in the stream (may be 0 if size cannot be determined)
+        size_t mSize;
+        #define OGRE_STREAM_TEMP_SIZE 128
+	public:
+		/// Constructor for creating unnamed streams
+        DataStream() : mSize(0) {}
+		/// Constructor for creating named streams
+		DataStream(const String& name) : mName(name), mSize(0) {}
+		/// Returns the name of the stream, if it has one.
+		const String& getName(void) { return mName; }
+        virtual ~DataStream() {}
+		// Streaming operators
+        template<typename T> DataStream& operator>>(T& val);
+		/** Read the requisite number of bytes from the stream, 
+			stopping at the end of the file.
+		@param buf Reference to a buffer pointer
+		@param count Number of bytes to read
+		@returns The number of bytes read
+		*/
+		virtual size_t read(void* buf, size_t count) = 0;
+		/** Get a single line from the stream.
+		@remarks
+			The delimiter character is not included in the data
+			returned, and it is skipped over so the next read will occur
+			after it. The buffer contents will include a
+			terminating character.
+        @note
+            If you used this function, you <b>must</b> open the stream in <b>binary mode</b>,
+            otherwise, it'll produce unexpected results.
+		@param buf Reference to a buffer pointer
+		@param maxCount The maximum length of data to be read, excluding the terminating character
+		@param delim The delimiter to stop at
+		@returns The number of bytes read, excluding the terminating character
+		*/
+		virtual size_t readLine(char* buf, size_t maxCount, const String& delim = "\n");
+		
+	    /** Returns a String containing the next line of data, optionally 
+		    trimmed for whitespace. 
+	    @remarks
+		    This is a convenience method for text streams only, allowing you to 
+		    retrieve a String object containing the next line of data. The data
+		    is read up to the next newline character and the result trimmed if
+		    required.
+        @note
+            If you used this function, you <b>must</b> open the stream in <b>binary mode</b>,
+            otherwise, it'll produce unexpected results.
+	    @param 
+		    trimAfter If true, the line is trimmed for whitespace (as in 
+		    String.trim(true,true))
+	    */
+	    virtual String getLine( bool trimAfter = true );
+
+	    /** Returns a String containing the entire stream. 
+	    @remarks
+		    This is a convenience method for text streams only, allowing you to 
+		    retrieve a String object containing all the data in the stream.
+	    */
+	    virtual String getAsString(void);
+
+		/** Skip a single line from the stream.
+        @note
+            If you used this function, you <b>must</b> open the stream in <b>binary mode</b>,
+            otherwise, it'll produce unexpected results.
+		@param delim The delimiter(s) to stop at
+		@returns The number of bytes skipped
+		*/
+		virtual size_t skipLine(const String& delim = "\n");
+
+		/** Skip a defined number of bytes. This can also be a negative value, in which case
+		the file pointer rewinds a defined number of bytes. */
+		virtual void skip(long count) = 0;
+	
+		/** Repositions the read point to a specified byte.
+	    */
+	    virtual void seek( size_t pos ) = 0;
+		
+		/** Returns the current byte offset from beginning */
+	    virtual size_t tell(void) const = 0;
+
+		/** Returns true if the stream has reached the end.
+	    */
+	    virtual bool eof(void) const = 0;
+
+		/** Returns the total size of the data to be read from the stream, 
+			or 0 if this is indeterminate for this stream. 
+		*/
+        size_t size(void) const { return mSize; }
+
+        /** Close the stream; this makes further operations invalid. */
+        virtual void close(void) = 0;
+		
+
+	};
+
+	/** Shared pointer to allow data streams to be passed around without
+		worrying about deallocation
+	*/
+	typedef SharedPtr<DataStream> DataStreamPtr;
+
+	/// List of DataStream items
+	typedef std::list<DataStreamPtr> DataStreamList;
+	/// Shared pointer to list of DataStream items
+	typedef SharedPtr<DataStreamList> DataStreamListPtr;
+
+	/** Common subclass of DataStream for handling data from chunks of memory.
+	*/
+	class _OgreExport MemoryDataStream : public DataStream
+	{
+	protected:
+        /// Pointer to the start of the data area
+	    uchar* mData;
+        /// Pointer to the current position in the memory
+	    uchar* mPos;
+        /// Pointer to the end of the memory
+	    uchar* mEnd;
+        /// Do we delete the memory on close
+		bool mFreeOnClose;			
+	public:
+		
+		/** Wrap an existing memory chunk in a stream.
+		@param pMem Pointer to the exising memory
+		@param size The size of the memory chunk in bytes
+		@param freeOnClose If true, the memory associated will be destroyed
+			when the stream is destroyed.
+		*/
+		MemoryDataStream(void* pMem, size_t size, bool freeOnClose = false);
+		
+		/** Wrap an existing memory chunk in a named stream.
+		@param name The name to give the stream
+		@param pMem Pointer to the exising memory
+		@param size The size of the memory chunk in bytes
+		@param freeOnClose If true, the memory associated will be destroyed
+			when the stream is destroyed.
+		*/
+		MemoryDataStream(const String& name, void* pMem, size_t size, 
+				bool freeOnClose = false);
+
+		/** Create a stream which pre-buffers the contents of another stream.
+		@remarks
+			This constructor can be used to intentionally read in the entire
+			contents of another stream, copying them to the internal buffer
+			and thus making them available in memory as a single unit.
+		@param sourceStream Another DataStream which will provide the source
+			of data
+		@param freeOnClose If true, the memory associated will be destroyed
+			when the stream is destroyed.
+		*/
+		MemoryDataStream(DataStream& sourceStream, 
+				bool freeOnClose = true);
+		
+		/** Create a stream which pre-buffers the contents of another stream.
+		@remarks
+			This constructor can be used to intentionally read in the entire
+			contents of another stream, copying them to the internal buffer
+			and thus making them available in memory as a single unit.
+		@param sourceStream Weak reference to another DataStream which will provide the source
+			of data
+		@param freeOnClose If true, the memory associated will be destroyed
+			when the stream is destroyed.
+		*/
+		MemoryDataStream(DataStreamPtr& sourceStream, 
+				bool freeOnClose = true);
+
+		/** Create a named stream which pre-buffers the contents of 
+			another stream.
+		@remarks
+			This constructor can be used to intentionally read in the entire
+			contents of another stream, copying them to the internal buffer
+			and thus making them available in memory as a single unit.
+		@param name The name to give the stream
+		@param sourceStream Another DataStream which will provide the source
+			of data
+		@param freeOnClose If true, the memory associated will be destroyed
+			when the stream is destroyed.
+		*/
+		MemoryDataStream(const String& name, DataStream& sourceStream, 
+				bool freeOnClose = true);
+
+        /** Create a named stream which pre-buffers the contents of 
+        another stream.
+        @remarks
+        This constructor can be used to intentionally read in the entire
+        contents of another stream, copying them to the internal buffer
+        and thus making them available in memory as a single unit.
+        @param name The name to give the stream
+        @param sourceStream Another DataStream which will provide the source
+        of data
+        @param freeOnClose If true, the memory associated will be destroyed
+        when the stream is destroyed.
+        */
+        MemoryDataStream(const String& name, const DataStreamPtr& sourceStream, 
+            bool freeOnClose = true);
+
+        /** Create a stream with a brand new empty memory chunk.
+		@param size The size of the memory chunk to create in bytes
+		@param freeOnClose If true, the memory associated will be destroyed
+			when the stream is destroyed.
+		*/
+		MemoryDataStream(size_t size, bool freeOnClose = true);
+		/** Create a named stream with a brand new empty memory chunk.
+		@param name The name to give the stream
+		@param size The size of the memory chunk to create in bytes
+		@param freeOnClose If true, the memory associated will be destroyed
+			when the stream is destroyed.
+		*/
+		MemoryDataStream(const String& name, size_t size, 
+				bool freeOnClose = true);
+
+		~MemoryDataStream();
+
+		/** Get a pointer to the start of the memory block this stream holds. */
+		uchar* getPtr(void) { return mData; }
+		
+		/** Get a pointer to the current position in the memory block this stream holds. */
+		uchar* getCurrentPtr(void) { return mPos; }
+		
+		/** @copydoc DataStream::read
+		*/
+		size_t read(void* buf, size_t count);
+		/** @copydoc DataStream::readLine
+		*/
+		size_t readLine(char* buf, size_t maxCount, const String& delim = "\n");
+		
+		/** @copydoc DataStream::skipLine
+		*/
+		size_t skipLine(const String& delim = "\n");
+
+		/** @copydoc DataStream::skip
+		*/
+		void skip(long count);
+	
+		/** @copydoc DataStream::seek
+		*/
+	    void seek( size_t pos );
+		
+		/** @copydoc DataStream::tell
+		*/
+	    size_t tell(void) const;
+
+		/** @copydoc DataStream::eof
+		*/
+	    bool eof(void) const;
+
+        /** @copydoc DataStream::close
+        */
+        void close(void);
+
+		/** Sets whether or not to free the encapsulated memory on close. */
+		void setFreeOnClose(bool free) { mFreeOnClose = free; }
+	};
+
+    /** Shared pointer to allow memory data streams to be passed around without
+    worrying about deallocation
+    */
+    typedef SharedPtr<MemoryDataStream> MemoryDataStreamPtr;
+
+    /** Common subclass of DataStream for handling data from 
+		std::basic_istream.
+	*/
+	class _OgreExport FileStreamDataStream : public DataStream
+	{
+	protected:
+		/// Reference to source stream
+		std::ifstream* mpStream;
+        bool mFreeOnClose;			
+	public:
+		/** Construct stream from an STL stream
+        @param s Pointer to source stream
+        @param freeOnClose Whether to delete the underlying stream on 
+            destruction of this class
+        */
+		FileStreamDataStream(std::ifstream* s, 
+            bool freeOnClose = true);
+		/** Construct named stream from an STL stream
+        @param name The name to give this stream
+        @param s Pointer to source stream
+        @param freeOnClose Whether to delete the underlying stream on 
+            destruction of this class
+        */
+		FileStreamDataStream(const String& name, 
+            std::ifstream* s, 
+            bool freeOnClose = true);
+
+		/** Construct named stream from an STL stream, and tell it the size
+        @remarks
+            This variant tells the class the size of the stream too, which 
+            means this class does not need to seek to the end of the stream 
+            to determine the size up-front. This can be beneficial if you have
+            metadata about the contents of the stream already.
+        @param name The name to give this stream
+        @param s Pointer to source stream
+        @param size Size of the stream contents in bytes
+        @param freeOnClose Whether to delete the underlying stream on 
+            destruction of this class
+        */
+		FileStreamDataStream(const String& name, 
+            std::ifstream* s, 
+            size_t size, 
+            bool freeOnClose = true);
+
+        ~FileStreamDataStream();
+
+		/** @copydoc DataStream::read
+		*/
+		size_t read(void* buf, size_t count);
+		/** @copydoc DataStream::readLine
+		*/
+        size_t readLine(char* buf, size_t maxCount, const String& delim = "\n");
+		
+		/** @copydoc DataStream::skip
+		*/
+		void skip(long count);
+	
+		/** @copydoc DataStream::seek
+		*/
+	    void seek( size_t pos );
+
+		/** @copydoc DataStream::tell
+		*/
+		size_t tell(void) const;
+
+		/** @copydoc DataStream::eof
+		*/
+	    bool eof(void) const;
+
+        /** @copydoc DataStream::close
+        */
+        void close(void);
+		
+		
+	};
+
+	/** Common subclass of DataStream for handling data from C-style file 
+		handles.
+    @remarks
+        Use of this class is generally discouraged; if you want to wrap file
+        access in a DataStream, you should definitely be using the C++ friendly
+        FileStreamDataStream. However, since there are quite a few applications
+        and libraries still wedded to the old FILE handle access, this stream
+        wrapper provides some backwards compatibility.
+	*/
+	class _OgreExport FileHandleDataStream : public DataStream
+	{
+	protected:
+		FILE* mFileHandle;
+	public:
+		/// Create stream from a C file handle
+		FileHandleDataStream(FILE* handle);
+		/// Create named stream from a C file handle
+		FileHandleDataStream(const String& name, FILE* handle);
+        ~FileHandleDataStream();
+
+		/** @copydoc DataStream::read
+		*/
+		size_t read(void* buf, size_t count);
+
+		/** @copydoc DataStream::skip
+		*/
+		void skip(long count);
+	
+		/** @copydoc DataStream::seek
+		*/
+	    void seek( size_t pos );
+
+		/** @copydoc DataStream::tell
+		*/
+		size_t tell(void) const;
+
+		/** @copydoc DataStream::eof
+		*/
+	    bool eof(void) const;
+
+        /** @copydoc DataStream::close
+        */
+        void close(void);
+
+	};
+}
+#endif
+