ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreDefaultHardwareBufferManager.h

@@ -0,0 +1,140 @@
+/*
+-----------------------------------------------------------------------------
+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 __DefaultHardwareBufferManager_H__
+#define __DefaultHardwareBufferManager_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreHardwareBufferManager.h"
+#include "OgreHardwareVertexBuffer.h"
+#include "OgreHardwareIndexBuffer.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup RenderSystem
+	*  @{
+	*/
+
+    /// Specialisation of HardwareVertexBuffer for emulation
+    class _OgreExport DefaultHardwareVertexBuffer : public HardwareVertexBuffer 
+    {
+	protected:
+		unsigned char* mData;
+        /** See HardwareBuffer. */
+        void* lockImpl(size_t offset, size_t length, LockOptions options);
+        /** See HardwareBuffer. */
+		void unlockImpl(void);
+    public:
+		DefaultHardwareVertexBuffer(size_t vertexSize, size_t numVertices, HardwareBuffer::Usage usage);
+		DefaultHardwareVertexBuffer(HardwareBufferManagerBase* mgr, size_t vertexSize, size_t numVertices, 
+            HardwareBuffer::Usage usage);
+        ~DefaultHardwareVertexBuffer();
+        /** See HardwareBuffer. */
+        void readData(size_t offset, size_t length, void* pDest);
+        /** See HardwareBuffer. */
+        void writeData(size_t offset, size_t length, const void* pSource,
+				bool discardWholeBuffer = false);
+        /** Override HardwareBuffer to turn off all shadowing. */
+        void* lock(size_t offset, size_t length, LockOptions options);
+        /** Override HardwareBuffer to turn off all shadowing. */
+		void unlock(void);
+
+
+    };
+
+	/// Specialisation of HardwareIndexBuffer for emulation
+    class _OgreExport DefaultHardwareIndexBuffer : public HardwareIndexBuffer
+    {
+	protected:
+		unsigned char* mData;
+        /** See HardwareBuffer. */
+        void* lockImpl(size_t offset, size_t length, LockOptions options);
+        /** See HardwareBuffer. */
+		void unlockImpl(void);
+    public:
+		DefaultHardwareIndexBuffer(IndexType idxType, size_t numIndexes, HardwareBuffer::Usage usage);
+        ~DefaultHardwareIndexBuffer();
+        /** See HardwareBuffer. */
+        void readData(size_t offset, size_t length, void* pDest);
+        /** See HardwareBuffer. */
+        void writeData(size_t offset, size_t length, const void* pSource,
+				bool discardWholeBuffer = false);
+        /** Override HardwareBuffer to turn off all shadowing. */
+        void* lock(size_t offset, size_t length, LockOptions options);
+        /** Override HardwareBuffer to turn off all shadowing. */
+		void unlock(void);
+
+    };
+
+	/** Specialisation of HardwareBufferManagerBase to emulate hardware buffers.
+	@remarks
+		You might want to instantiate this class if you want to utilise
+		classes like MeshSerializer without having initialised the 
+		rendering system (which is required to create a 'real' hardware
+		buffer manager.
+	*/
+	class _OgreExport DefaultHardwareBufferManagerBase : public HardwareBufferManagerBase
+	{
+    public:
+        DefaultHardwareBufferManagerBase();
+        ~DefaultHardwareBufferManagerBase();
+        /// Creates a vertex buffer
+		HardwareVertexBufferSharedPtr 
+            createVertexBuffer(size_t vertexSize, size_t numVerts, 
+				HardwareBuffer::Usage usage, bool useShadowBuffer = false);
+		/// Create a hardware vertex buffer
+		HardwareIndexBufferSharedPtr 
+            createIndexBuffer(HardwareIndexBuffer::IndexType itype, size_t numIndexes, 
+				HardwareBuffer::Usage usage, bool useShadowBuffer = false);
+		/// Create a hardware vertex buffer
+		RenderToVertexBufferSharedPtr createRenderToVertexBuffer();
+    };
+
+	/// DefaultHardwareBufferManager as a Singleton
+	class _OgreExport DefaultHardwareBufferManager : public HardwareBufferManager
+	{
+	public:
+		DefaultHardwareBufferManager()
+			: HardwareBufferManager(OGRE_NEW DefaultHardwareBufferManagerBase()) 
+		{
+
+		}
+		~DefaultHardwareBufferManager()
+		{
+			OGRE_DELETE mImpl;
+		}
+	};
+
+	/** @} */
+	/** @} */
+
+}
+
+#endif

data/deps/include/OGRE/OgreDeflate.h

@@ -0,0 +1,133 @@
+/*
+ -----------------------------------------------------------------------------
+ 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 __OGRE_DEFLATE_H__
+#define __OGRE_DEFLATE_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreDataStream.h"
+
+
+/// forward decls
+struct z_stream_s;
+typedef struct z_stream_s z_stream;
+
+namespace Ogre
+{
+	/** Stream which compresses / uncompresses data using the 'deflate' compression
+		algorithm.
+	@remarks
+		This stream is designed to wrap another stream for the actual source / destination
+		of the compressed data, it has no concrete source / data itself. The idea is
+		that you pass uncompressed data through this stream, and the underlying
+		stream reads/writes compressed data to the final source.
+	@note
+		This is an alternative to using a compressed archive since it is able to 
+		compress & decompress regardless of the actual source of the stream.
+		You should avoid using this with already compressed archives.
+		Also note that this cannot be used as a read / write stream, only a read-only
+		or write-only stream.
+	*/
+	class _OgreExport DeflateStream : public DataStream
+	{
+	protected:
+		DataStreamPtr mCompressedStream;
+		DataStreamPtr mTmpWriteStream;
+		String mTempFileName;
+		z_stream* mZStream;
+		size_t mCurrentPos;
+		
+		/// Cache for read data in case skipping around
+		StaticCache<16 * OGRE_STREAM_TEMP_SIZE> mReadCache;
+		
+		/// Intermediate buffer for read / write
+		unsigned char *mTmp;
+		
+		/// Whether the underlying stream is valid compressed data
+		bool mIsCompressedValid;
+		
+		
+		void init();
+		void destroy();
+		void compressFinal();
+	public:
+		/** Constructor for creating unnamed stream wrapping another stream.
+		 @param compressedStream The stream that this stream will use when reading / 
+			writing compressed data. The access mode from this stream will be matched.
+		 @param tmpFileName Path/Filename to be used for temporary storage of incoming data
+		*/
+        DeflateStream(const DataStreamPtr& compressedStream, const String& tmpFileName = "");
+		/** Constructor for creating named stream wrapping another stream.
+		 @param name The name to give this stream
+		 @param compressedStream The stream that this stream will use when reading / 
+			writing compressed data. The access mode from this stream will be matched.
+		 @param tmpFileName Path/Filename to be used for temporary storage of incoming data
+		 */
+		DeflateStream(const String& name, const DataStreamPtr& compressedStream, const String& tmpFileName="");	
+		
+		~DeflateStream();
+		
+		/** Returns whether the compressed stream is valid deflated data.
+		 @remarks
+			If you pass this class a READ stream which is not compressed with the 
+			deflate algorithm, this method returns false and all read commands
+			will actually be executed as passthroughs as a fallback. 
+		*/
+		bool isCompressedStreamValid() const { return mIsCompressedValid; }
+		
+		/** @copydoc DataStream::read
+		 */
+		size_t read(void* buf, size_t count);
+		
+		/** @copydoc DataStream::write
+		 */
+		size_t write(const 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

data/deps/include/OGRE/OgreDepthBuffer.h

@@ -0,0 +1,155 @@
+/*
+-----------------------------------------------------------------------------
+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 __DepthBuffer_H__
+#define __DepthBuffer_H__
+
+#include "OgrePrerequisites.h"
+
+namespace Ogre
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup RenderSystem
+	*  @{
+	*/
+
+	/** An abstract class that contains a depth/stencil buffer.
+		Depth Buffers can be attached to render targets. Note we handle Depth & Stencil together.
+		DepthBuffer sharing is handled automatically for you. However, there are times where you want
+		to specifically control depth buffers to achieve certain effects or increase performance.
+		You can control this by hinting Ogre with POOL IDs. Created depth buffers can live in different
+		pools, or alltoghether in the same one.
+		Usually, a depth buffer can only be attached to a RenderTarget only if it's dimensions are bigger
+		and have the same bit depth and same multisample settings. Depth Buffers are created automatically
+		for new RTs when needed, and stored in the pool where the RenderTarget should have drawn from.
+		By default, all RTs have the Id POOL_DEFAULT, which means all depth buffers are stored by default
+		in that pool. By chosing a different Pool Id for a specific RenderTarget, that RT will only
+		retrieve depth buffers from _that_ pool, therefore not conflicting with sharing depth buffers
+		with other RTs (such as shadows maps).
+		Setting an RT to POOL_MANUAL_USAGE means Ogre won't manage the DepthBuffer for you (not recommended)
+		RTs with POOL_NO_DEPTH are very useful when you don't want to create a DepthBuffer for it. You can
+		still manually attach a depth buffer though as internally POOL_NO_DEPTH & POOL_MANUAL_USAGE are
+		handled in the same way.
+
+		Behavior is consistent across all render systems, if, and only if, the same RSC flags are set
+		RSC flags that affect this class are:
+			* RSC_RTT_SEPARATE_DEPTHBUFFER:
+				The RTT can create a custom depth buffer different from the main depth buffer. This means,
+				an RTT is able to not share it's depth buffer with the main window if it wants to.
+			* RSC_RTT_MAIN_DEPTHBUFFER_ATTACHABLE:
+				When RSC_RTT_SEPARATE_DEPTHBUFFER is set, some APIs (ie. OpenGL w/ FBO) don't allow using
+				the main depth buffer for offscreen RTTs. When this flag is set, the depth buffer can be
+				shared between the main window and an RTT.
+			* RSC_RTT_DEPTHBUFFER_RESOLUTION_LESSEQUAL:
+				When this flag isn't set, the depth buffer can only be shared across RTTs who have the EXACT
+				same resolution. When it's set, it can be shared with RTTs as long as they have a
+				resolution less or equal than the depth buffer's.
+
+        @remarks
+			Design discussion http://www.ogre3d.org/forums/viewtopic.php?f=4&t=53534&p=365582
+        @author
+            Matias N. Goldberg
+        @version
+            1.0
+     */
+	class _OgreExport DepthBuffer : public RenderSysAlloc
+	{
+	public:
+		enum PoolId
+		{
+			POOL_NO_DEPTH		= 0,
+			POOL_MANUAL_USAGE	= 0,
+			POOL_DEFAULT		= 1
+		};
+
+		DepthBuffer( uint16 poolId, uint16 bitDepth, uint32 width, uint32 height,
+					 uint32 fsaa, const String &fsaaHint, bool manual );
+		virtual ~DepthBuffer();
+
+		//Sets the pool id in which this DepthBuffer lives
+		//Note this will detach any render target from this depth buffer
+		void _setPoolId( uint16 poolId );
+
+		//Gets the pool id in which this DepthBuffer lives
+		virtual uint16 getPoolId() const;
+		virtual uint16 getBitDepth() const;
+		virtual uint32 getWidth() const;
+		virtual uint32 getHeight() const;
+		virtual uint32 getFsaa() const;
+		virtual const String& getFsaaHint() const;
+
+		//Manual DepthBuffers are cleared in RenderSystem's destructor. Non-manual ones are released
+		//with it's render target (aka, a backbuffer or similar)
+		bool isManual() const;
+
+		/** Returns whether the specified RenderTarget is compatible with this DepthBuffer
+			That is, this DepthBuffer can be attached to that RenderTarget
+            @remarks
+                Most APIs impose the following restrictions:
+				Width & height must be equal or higher than the render target's
+				They must be of the same bit depth.
+				They need to have the same FSAA setting
+			@param renderTarget The render target to test against
+        */
+		virtual bool isCompatible( RenderTarget *renderTarget ) const;
+
+		/** Called when a RenderTarget is attaches this DepthBuffer
+            @remarks
+                This function doesn't actually attach. It merely informs the DepthBuffer
+				which RenderTarget did attach. The real attachment happens in
+				RenderTarget::attachDepthBuffer()
+			@param renderTarget The RenderTarget that has just been attached
+        */
+		virtual void _notifyRenderTargetAttached( RenderTarget *renderTarget );
+
+		/** Called when a RenderTarget is detaches from this DepthBuffer
+            @remarks
+                Same as DepthBuffer::_notifyRenderTargetAttached()
+			@param renderTarget The RenderTarget that has just been attached
+        */
+		virtual void _notifyRenderTargetDetached( RenderTarget *renderTarget );
+
+	protected:
+		typedef set<RenderTarget*>::type RenderTargetSet;
+
+		uint16						mPoolId;
+		uint16						mBitDepth;
+		uint32						mWidth;
+		uint32						mHeight;
+		uint32						mFsaa;
+		String						mFsaaHint;
+
+		bool						mManual; //We don't Release manual surfaces on destruction
+		RenderTargetSet				mAttachedRenderTargets;
+
+		void detachFromAllRenderTargets();
+	};
+}
+
+#endif

data/deps/include/OGRE/OgreDistanceLodStrategy.h

@@ -0,0 +1,137 @@
+/*
+-----------------------------------------------------------------------------
+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 __Distance_Lod_Strategy_H__
+#define __Distance_Lod_Strategy_H__
+
+#include "OgrePrerequisites.h"
+
+#include "OgreLodStrategy.h"
+#include "OgreSingleton.h"
+#include "OgreNode.h"
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup LOD
+	*  @{
+	*/
+
+    /** Level of detail strategy based on distance from camera. */
+    class _OgreExport DistanceLodStrategy : public LodStrategy, public Singleton<DistanceLodStrategy>
+    {
+    protected:
+        /// @copydoc LodStrategy::getValueImpl
+        virtual Real getValueImpl(const MovableObject *movableObject, const Camera *camera) const;
+
+    public:
+        /** Default constructor. */
+        DistanceLodStrategy();
+
+        /// @copydoc LodStrategy::getBaseValue
+        virtual Real getBaseValue() const;
+
+        /// @copydoc LodStrategy::transformBias
+        virtual Real transformBias(Real factor) const;
+
+        /// @copydoc LodStrategy::transformUserValue
+        virtual Real transformUserValue(Real userValue) const;
+
+        /// @copydoc LodStrategy::getIndex
+        virtual ushort getIndex(Real value, const Mesh::MeshLodUsageList& meshLodUsageList) const;
+
+        /// @copydoc LodStrategy::getIndex
+        virtual ushort getIndex(Real value, const Material::LodValueList& materialLodValueList) const;
+
+        /// @copydoc LodStrategy::sort
+        virtual void sort(Mesh::MeshLodUsageList& meshLodUsageList) const;
+
+        /// @copydoc LodStrategy::isSorted
+        virtual bool isSorted(const Mesh::LodValueList& values) const;
+
+        /** Sets the reference view upon which the distances were based.
+        @note
+            This automatically enables use of the reference view.
+        @note
+            There is no corresponding get method for these values as
+            they are not saved, but used to compute a reference value.
+        */
+        void setReferenceView(Real viewportWidth, Real viewportHeight, Radian fovY);
+
+        /** Enables to disables use of the reference view.
+        @note Do not enable use of the reference view before setting it.
+        */
+        void setReferenceViewEnabled(bool value);
+
+        /** Determine if use of the reference view is enabled */
+        bool getReferenceViewEnabled() const;
+
+        /** Override standard Singleton retrieval.
+        @remarks
+        Why do we do this? Well, it's because the Singleton
+        implementation is in a .h file, which means it gets compiled
+        into anybody who includes it. This is needed for the
+        Singleton template to work, but we actually only want it
+        compiled into the implementation of the class based on the
+        Singleton, not all of them. If we don't change this, we get
+        link errors when trying to use the Singleton-based class from
+        an outside dll.
+        @par
+        This method just delegates to the template version anyway,
+        but the implementation stays in this single compilation unit,
+        preventing link errors.
+        */
+        static DistanceLodStrategy& getSingleton(void);
+        /** Override standard Singleton retrieval.
+        @remarks
+        Why do we do this? Well, it's because the Singleton
+        implementation is in a .h file, which means it gets compiled
+        into anybody who includes it. This is needed for the
+        Singleton template to work, but we actually only want it
+        compiled into the implementation of the class based on the
+        Singleton, not all of them. If we don't change this, we get
+        link errors when trying to use the Singleton-based class from
+        an outside dll.
+        @par
+        This method just delegates to the template version anyway,
+        but the implementation stays in this single compilation unit,
+        preventing link errors.
+        */
+        static DistanceLodStrategy* getSingletonPtr(void);
+
+    private:
+        bool mReferenceViewEnabled;
+        Real mReferenceViewValue;
+
+    };
+	/** @} */
+	/** @} */
+
+} // namespace
+
+#endif