ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/RenderSystems/GL/OgreGLGpuProgram.h

@@ -0,0 +1,120 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLGpuProgram_H__
+#define __GLGpuProgram_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreGpuProgram.h"
+#include "OgreHardwareVertexBuffer.h"
+
+namespace Ogre {
+
+    /** Generalised low-level GL program, can be applied to multiple types (eg ARB and NV) */
+    class _OgreGLExport GLGpuProgram : public GpuProgram
+    {
+    public:
+        GLGpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle,
+            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
+        virtual ~GLGpuProgram();
+
+        /// Execute the binding functions for this program
+        virtual void bindProgram(void) {}
+        /// Execute the binding functions for this program
+        virtual void unbindProgram(void) {}
+
+        /// Execute the param binding functions for this program
+		virtual void bindProgramParameters(GpuProgramParametersSharedPtr params, uint16 mask) {}
+		/// Bind just the pass iteration parameters
+		virtual void bindProgramPassIterationParameters(GpuProgramParametersSharedPtr params) {}
+
+
+        /// Get the assigned GL program id
+        GLuint getProgramID(void) const
+        { return mProgramID; }
+
+		/** Get the attribute index for a given semantic. 
+		@remarks
+			This can be used to identify the attribute index to bind non-builtin
+			attributes like tangent and binormal.
+		*/
+		virtual GLuint getAttributeIndex(VertexElementSemantic semantic, uint index);
+		/** Test whether attribute index for a given semantic is valid. 
+		*/
+		virtual bool isAttributeValid(VertexElementSemantic semantic, uint index);
+
+		/** Get the fixed attribute bindings normally used by GL for a semantic. */
+		static GLuint getFixedAttributeIndex(VertexElementSemantic semantic, uint index);
+
+    protected:
+		/** Overridden from GpuProgram, do nothing */
+		void loadFromSource(void) {}
+        /// @copydoc Resource::unloadImpl
+        void unloadImpl(void) {}
+
+        GLuint mProgramID;
+        GLenum mProgramType;
+    };
+
+    /** Specialisation of the GL low-level program for ARB programs. */
+    class _OgreGLExport GLArbGpuProgram : public GLGpuProgram
+    {
+    public:
+        GLArbGpuProgram(ResourceManager* creator, const String& name, ResourceHandle handle,
+            const String& group, bool isManual = false, ManualResourceLoader* loader = 0);
+        virtual ~GLArbGpuProgram();
+
+        /// @copydoc GpuProgram::setType
+        void setType(GpuProgramType t);
+
+
+        /// Execute the binding functions for this program
+        void bindProgram(void);
+        /// Execute the unbinding functions for this program
+        void unbindProgram(void);
+        /// Execute the param binding functions for this program
+		void bindProgramParameters(GpuProgramParametersSharedPtr params, uint16 mask);
+		/// Bind just the pass iteration parameters
+		void bindProgramPassIterationParameters(GpuProgramParametersSharedPtr params);
+
+        /// Get the GL type for the program
+        GLuint getProgramType(void) const
+        { return mProgramType; }
+
+    protected:
+        void loadFromSource(void);
+        /// @copydoc Resource::unloadImpl
+        void unloadImpl(void);
+
+    };
+
+
+
+} // namespace Ogre
+
+#endif // __GLGpuProgram_H__

data/deps/include/OGRE/RenderSystems/GL/OgreGLGpuProgramManager.h

@@ -0,0 +1,68 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLGpuProgramManager_H__
+#define __GLGpuProgramManager_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreGpuProgramManager.h"
+
+namespace Ogre {
+
+class _OgreGLExport GLGpuProgramManager : public GpuProgramManager
+{
+public:
+    typedef GpuProgram* (*CreateGpuProgramCallback)(ResourceManager* creator, 
+        const String& name, ResourceHandle handle, 
+        const String& group, bool isManual, ManualResourceLoader* loader,
+        GpuProgramType gptype, const String& syntaxCode);
+
+private:
+    typedef map<String, CreateGpuProgramCallback>::type ProgramMap;
+    ProgramMap mProgramMap;
+
+protected:
+    /// @copydoc ResourceManager::createImpl
+    Resource* createImpl(const String& name, ResourceHandle handle, 
+        const String& group, bool isManual, ManualResourceLoader* loader,
+        const NameValuePairList* params);
+    /// Specialised create method with specific parameters
+    Resource* createImpl(const String& name, ResourceHandle handle, 
+        const String& group, bool isManual, ManualResourceLoader* loader,
+        GpuProgramType gptype, const String& syntaxCode);
+
+public:
+    GLGpuProgramManager();
+    ~GLGpuProgramManager();
+    bool registerProgramFactory(const String& syntaxCode, CreateGpuProgramCallback createFn);
+    bool unregisterProgramFactory(const String& syntaxCode);
+};
+
+} //namespace Ogre
+
+#endif //__GLGpuProgramManager_H__

data/deps/include/OGRE/RenderSystems/GL/OgreGLHardwareBufferManager.h

@@ -0,0 +1,141 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLHARWAREBUFFERMANAGER_H__
+#define __GLHARWAREBUFFERMANAGER_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreHardwareBufferManager.h"
+
+namespace Ogre {
+
+// Default threshold at which glMapBuffer becomes more efficient than glBufferSubData (32k?)
+#	define OGRE_GL_DEFAULT_MAP_BUFFER_THRESHOLD (1024 * 32)
+
+
+    /** Implementation of HardwareBufferManager for OpenGL. */
+    class _OgreGLExport GLHardwareBufferManagerBase : public HardwareBufferManagerBase
+    {
+	protected:
+		char* mScratchBufferPool;
+		OGRE_MUTEX(mScratchMutex)
+		size_t mMapBufferThreshold;
+
+    public:
+        GLHardwareBufferManagerBase();
+        ~GLHardwareBufferManagerBase();
+        /// 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 render to vertex buffer
+        RenderToVertexBufferSharedPtr createRenderToVertexBuffer();
+        /// Utility function to get the correct GL usage based on HBU's
+        static GLenum getGLUsage(unsigned int usage);
+
+        /// Utility function to get the correct GL type based on VET's
+        static GLenum getGLType(unsigned int type);
+
+		/** Allocator method to allow us to use a pool of memory as a scratch
+			area for hardware buffers. This is because glMapBuffer is incredibly
+			inefficient, seemingly no matter what options we give it. So for the
+			period of lock/unlock, we will instead allocate a section of a local
+			memory pool, and use glBufferSubDataARB / glGetBufferSubDataARB
+			instead.
+		*/
+		void* allocateScratch(uint32 size);
+
+		/// @see allocateScratch
+		void deallocateScratch(void* ptr);
+
+		/** Threshold after which glMapBuffer is used and not glBufferSubData
+		*/
+		size_t getGLMapBufferThreshold() const;
+		void setGLMapBufferThreshold( const size_t value );
+    };
+
+	/// GLHardwareBufferManagerBase as a Singleton
+	class _OgreGLExport GLHardwareBufferManager : public HardwareBufferManager
+	{
+	public:
+		GLHardwareBufferManager()
+			: HardwareBufferManager(OGRE_NEW GLHardwareBufferManagerBase()) 
+		{
+
+		}
+		~GLHardwareBufferManager()
+		{
+			OGRE_DELETE mImpl;
+		}
+
+
+
+		/// Utility function to get the correct GL usage based on HBU's
+		static GLenum getGLUsage(unsigned int usage) 
+		{ return GLHardwareBufferManagerBase::getGLUsage(usage); }
+
+		/// Utility function to get the correct GL type based on VET's
+		static GLenum getGLType(unsigned int type)
+		{ return GLHardwareBufferManagerBase::getGLType(type); }
+
+		/** Allocator method to allow us to use a pool of memory as a scratch
+		area for hardware buffers. This is because glMapBuffer is incredibly
+		inefficient, seemingly no matter what options we give it. So for the
+		period of lock/unlock, we will instead allocate a section of a local
+		memory pool, and use glBufferSubDataARB / glGetBufferSubDataARB
+		instead.
+		*/
+		void* allocateScratch(uint32 size)
+		{
+			return static_cast<GLHardwareBufferManagerBase*>(mImpl)->allocateScratch(size);
+		}
+
+		/// @see allocateScratch
+		void deallocateScratch(void* ptr)
+		{
+			static_cast<GLHardwareBufferManagerBase*>(mImpl)->deallocateScratch(ptr);
+		}
+
+		/** Threshold after which glMapBuffer is used and not glBufferSubData
+		*/
+		size_t getGLMapBufferThreshold() const
+		{
+			return static_cast<GLHardwareBufferManagerBase*>(mImpl)->getGLMapBufferThreshold();
+		}
+		void setGLMapBufferThreshold( const size_t value )
+		{
+			static_cast<GLHardwareBufferManagerBase*>(mImpl)->setGLMapBufferThreshold(value);
+		}
+
+	};
+
+}
+
+#endif // __GLHARWAREBUFFERMANAGER_H__

data/deps/include/OGRE/RenderSystems/GL/OgreGLHardwareIndexBuffer.h

@@ -0,0 +1,70 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLHARDWAREINDEXBUFFER_H__
+#define __GLHARDWAREINDEXBUFFER_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreHardwareIndexBuffer.h"
+
+namespace Ogre { 
+
+
+    class _OgreGLExport GLHardwareIndexBuffer : public HardwareIndexBuffer
+    {
+    private:
+        GLuint mBufferId;
+		// Scratch buffer handling
+		bool mLockedToScratch;
+		size_t mScratchOffset;
+		size_t mScratchSize;
+		void* mScratchPtr;
+		bool mScratchUploadOnUnlock;
+    protected:
+        /** See HardwareBuffer. */
+        void* lockImpl(size_t offset, size_t length, LockOptions options);
+        /** See HardwareBuffer. */
+        void unlockImpl(void);
+    public:
+        GLHardwareIndexBuffer(HardwareBufferManagerBase* mgr, IndexType idxType, size_t numIndexes, 
+            HardwareBuffer::Usage usage, bool useShadowBuffer); 
+        ~GLHardwareIndexBuffer();
+        /** 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);
+        /** See HardwareBuffer. */
+        void _updateFromShadow(void);
+
+        GLuint getGLBufferId(void) const { return mBufferId; }
+    };
+
+}
+
+#endif // __GLHARDWAREINDEXBUFFER_H__
+

data/deps/include/OGRE/RenderSystems/GL/OgreGLHardwareOcclusionQuery.h

@@ -0,0 +1,108 @@
+/*
+-----------------------------------------------------------------------------
+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.
+-----------------------------------------------------------------------------
+*/
+
+/*
+The nVidia occlusion query extension is defined in glext.h so you don't 
+need anything else. You do need to look up the function, we provide a 
+GLSupport class to do this, which has platform implementations for 
+getProcAddress. Check the way that extensions like glActiveTextureARB are 
+initialised and used in glRenderSystem and copy what is done there.
+
+
+
+  To do: fix so dx7 and DX9 checks and flags if HW Occlusion is supported
+  See the openGl dito for ideas what to do.
+
+*/
+
+
+
+//GL_ActiveTextureARB_Func* glActiveTextureARB_ptr = (GL_ActiveTextureARB_Func)mGLSupport->getProcAddress("glActiveTextureARB");
+
+#ifndef __GLHARDWAREOCCLUSIONQUERY_H__
+#define __GLHARDWAREOCCLUSIONQUERY_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreHardwareOcclusionQuery.h"
+
+
+namespace Ogre { 
+
+
+// If you use multiple rendering passes you can test only the first pass and all other passes don't have to be rendered 
+// if the first pass result has too few pixels visible.
+
+// Be sure to render all occluder first and whats out so the RenderQue don't switch places on 
+// the occluding objects and the tested objects because it thinks it's more effective..
+
+
+/**
+  * This is a class that is the base class of the query class for 
+  * hardware occlusion.
+  *
+  * @author Lee Sandberg email: lee@abcmedia.se
+  * Updated on 13/9/2005 by Tuan Kuranes email: tuan.kuranes@free.fr
+  */
+
+class _OgreGLExport GLHardwareOcclusionQuery : public HardwareOcclusionQuery
+{
+//----------------------------------------------------------------------
+// Public methods
+//--
+public:
+	/**
+	  * Default object constructor
+	  * 
+	  */
+	GLHardwareOcclusionQuery();
+	/**
+	  * Object destructor
+	  */
+	~GLHardwareOcclusionQuery();
+
+	//------------------------------------------------------------------
+	// Occlusion query functions (see base class documentation for this)
+	//--
+	void beginOcclusionQuery();
+	void endOcclusionQuery();
+	bool pullOcclusionQuery( unsigned int* NumOfFragments); 
+	bool isStillOutstanding(void);
+
+
+    //----------------------------------------------------------------------
+    // private members
+    //--
+    private:
+
+	    GLuint			mQueryID;
+};
+
+}
+
+#endif 
+

data/deps/include/OGRE/RenderSystems/GL/OgreGLHardwarePixelBuffer.h

@@ -0,0 +1,138 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLPIXELBUFFER_H__
+#define __GLPIXELBUFFER_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreHardwarePixelBuffer.h"
+
+namespace Ogre {
+	class _OgreGLExport GLHardwarePixelBuffer: public HardwarePixelBuffer
+	{
+	protected:  
+		/// Lock a box
+		PixelBox lockImpl(const Image::Box lockBox,  LockOptions options);
+
+		/// Unlock a box
+		void unlockImpl(void);
+        
+		// Internal buffer; either on-card or in system memory, freed/allocated on demand
+		// depending on buffer usage
+		PixelBox mBuffer;
+        GLenum mGLInternalFormat; // GL internal format
+		LockOptions mCurrentLockOptions;
+		
+		// Buffer allocation/freeage
+		void allocateBuffer();
+		void freeBuffer();
+		// Upload a box of pixels to this buffer on the card
+		virtual void upload(const PixelBox &data, const Image::Box &dest);
+		// Download a box of pixels from the card
+		virtual void download(const PixelBox &data);
+	public:
+        /// Should be called by HardwareBufferManager
+        GLHardwarePixelBuffer(size_t mWidth, size_t mHeight, size_t mDepth,
+                PixelFormat mFormat,
+                HardwareBuffer::Usage usage);
+		
+		/// @copydoc HardwarePixelBuffer::blitFromMemory
+		void blitFromMemory(const PixelBox &src, const Image::Box &dstBox);
+		
+		/// @copydoc HardwarePixelBuffer::blitToMemory
+		void blitToMemory(const Image::Box &srcBox, const PixelBox &dst);
+		
+		~GLHardwarePixelBuffer();
+        
+        /** Bind surface to frame buffer. Needs FBO extension.
+        */
+        virtual void bindToFramebuffer(GLenum attachment, size_t zoffset);
+        GLenum getGLFormat() { return mGLInternalFormat; }
+	};
+
+    /** Texture surface.
+    */
+    class _OgreGLExport GLTextureBuffer: public GLHardwarePixelBuffer
+	{
+    public:
+        /** Texture constructor */
+		GLTextureBuffer(const String &baseName, GLenum target, GLuint id, GLint face, 
+			GLint level, Usage usage, bool softwareMipmap, bool writeGamma, uint fsaa);
+        ~GLTextureBuffer();
+        
+        /// @copydoc HardwarePixelBuffer::bindToFramebuffer
+        virtual void bindToFramebuffer(GLenum attachment, size_t zoffset);
+        /// @copydoc HardwarePixelBuffer::getRenderTarget
+        RenderTexture* getRenderTarget(size_t);
+        /// Upload a box of pixels to this buffer on the card
+		virtual void upload(const PixelBox &data, const Image::Box &dest);
+		/// Download a box of pixels from the card
+		virtual void download(const PixelBox &data);
+  
+        /// Hardware implementation of blitFromMemory
+        virtual void blitFromMemory(const PixelBox &src_orig, const Image::Box &dstBox);
+        
+        /// Notify TextureBuffer of destruction of render target
+        void _clearSliceRTT(size_t zoffset)
+        {
+            mSliceTRT[zoffset] = 0;
+        }
+        /// Copy from framebuffer
+        void copyFromFramebuffer(size_t zoffset);
+        /// @copydoc HardwarePixelBuffer::blit
+        void blit(const HardwarePixelBufferSharedPtr &src, const Image::Box &srcBox, const Image::Box &dstBox);
+        // Blitting implementation
+        void blitFromTexture(GLTextureBuffer *src, const Image::Box &srcBox, const Image::Box &dstBox);
+    protected:
+        // In case this is a texture level
+		GLenum mTarget;
+		GLenum mFaceTarget; // same as mTarget in case of GL_TEXTURE_xD, but cubemap face for cubemaps
+		GLuint mTextureID;
+		GLint mFace;
+		GLint mLevel;
+		bool mSoftwareMipmap;		// Use GLU for mip mapping
+        
+        typedef vector<RenderTexture*>::type SliceTRT;
+        SliceTRT mSliceTRT;
+    };
+     /** Renderbuffer surface.  Needs FBO extension.
+     */
+    class _OgreGLExport GLRenderBuffer: public GLHardwarePixelBuffer
+	{
+    public:
+        GLRenderBuffer(GLenum format, size_t width, size_t height, GLsizei numSamples);
+        ~GLRenderBuffer();
+        
+        /// @copydoc GLHardwarePixelBuffer::bindToFramebuffer
+        virtual void bindToFramebuffer(GLenum attachment, size_t zoffset);
+    protected:
+        // In case this is a render buffer
+        GLuint mRenderbufferID;
+    };
+}
+
+#endif