ruby-ogre 0.0.1-x86-linux

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

@@ -0,0 +1,135 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLDefaultHardwareBufferManager_H__
+#define __GLDefaultHardwareBufferManager_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreHardwareBufferManager.h"
+#include "OgreHardwareVertexBuffer.h"
+#include "OgreHardwareIndexBuffer.h"
+
+namespace Ogre {
+
+    /// Specialisation of HardwareVertexBuffer for emulation
+    class _OgreGLExport GLDefaultHardwareVertexBuffer : public HardwareVertexBuffer 
+    {
+	protected:
+		unsigned char* mData;
+        /// @copydoc HardwareBuffer::lock
+        void* lockImpl(size_t offset, size_t length, LockOptions options);
+        /// @copydoc HardwareBuffer::unlock
+        void unlockImpl(void);
+
+    public:
+		GLDefaultHardwareVertexBuffer(size_t vertexSize, size_t numVertices, HardwareBuffer::Usage usage);
+		GLDefaultHardwareVertexBuffer(HardwareBufferManagerBase* mgr, size_t vertexSize, size_t numVertices, 
+            HardwareBuffer::Usage usage);
+        ~GLDefaultHardwareVertexBuffer();
+        /// @copydoc HardwareBuffer::readData
+        void readData(size_t offset, size_t length, void* pDest);
+        /// @copydoc HardwareBuffer::writeData
+
+        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);
+
+        //void* getDataPtr(void) const { return (void*)mData; }
+        void* getDataPtr(size_t offset) const { return (void*)(mData + offset); }
+    };
+
+	/// Specialisation of HardwareIndexBuffer for emulation
+    class _OgreGLExport GLDefaultHardwareIndexBuffer : public HardwareIndexBuffer
+    {
+	protected:
+		unsigned char* mData;
+        /// @copydoc HardwareBuffer::lock
+        void* lockImpl(size_t offset, size_t length, LockOptions options);
+        /// @copydoc HardwareBuffer::unlock
+        void unlockImpl(void);
+    public:
+		GLDefaultHardwareIndexBuffer(IndexType idxType, size_t numIndexes, HardwareBuffer::Usage usage);
+        ~GLDefaultHardwareIndexBuffer();
+        /// @copydoc HardwareBuffer::readData
+        void readData(size_t offset, size_t length, void* pDest);
+        /// @copydoc HardwareBuffer::writeData
+        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);
+
+        void* getDataPtr(size_t offset) const { return (void*)(mData + offset); }
+    };
+
+	/** Specialisation of HardwareBufferManager 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 _OgreGLExport GLDefaultHardwareBufferManagerBase : public HardwareBufferManagerBase
+	{
+    public:
+        GLDefaultHardwareBufferManagerBase();
+        ~GLDefaultHardwareBufferManagerBase();
+        /// Creates a vertex buffer
+		HardwareVertexBufferSharedPtr 
+            createVertexBuffer(size_t vertexSize, size_t numVerts, 
+				HardwareBuffer::Usage usage, bool useShadowBuffer = false);
+		/// Create a hardware index buffer
+		HardwareIndexBufferSharedPtr 
+            createIndexBuffer(HardwareIndexBuffer::IndexType itype, size_t numIndexes, 
+				HardwareBuffer::Usage usage, bool useShadowBuffer = false);
+		/// Create a render to vertex buffer
+		RenderToVertexBufferSharedPtr createRenderToVertexBuffer();
+
+    };
+
+	/// GLDefaultHardwareBufferManagerBase as a Singleton
+	class _OgreGLExport GLDefaultHardwareBufferManager : public HardwareBufferManager
+	{
+	public:
+		GLDefaultHardwareBufferManager()
+			: HardwareBufferManager(OGRE_NEW GLDefaultHardwareBufferManagerBase()) 
+		{
+
+		}
+		~GLDefaultHardwareBufferManager()
+		{
+			OGRE_DELETE mImpl;
+		}
+	};
+}
+
+#endif

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

@@ -0,0 +1,71 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLDepthBuffer_H__
+#define __GLDepthBuffer_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreDepthBuffer.h"
+
+namespace Ogre 
+{
+	/**
+		@copydoc DepthBuffer
+
+		OpenGL supports 3 different methods: FBO, pbuffer & Copy.
+		Each one has it's own limitations. Non-FBO methods are solved using "dummy" DepthBuffers.
+		That is, a DepthBuffer pointer is attached to the RenderTarget (for the sake of consistency)
+		but it doesn't actually contain a Depth surface/renderbuffer (mDepthBuffer & mStencilBuffer are
+		null pointers all the time) Those dummy DepthBuffers are identified thanks to their GL context.
+		Note that FBOs don't allow sharing with the main window's depth buffer. Therefore even
+		when FBO is enabled, a dummy DepthBuffer is still used to manage the windows.
+	*/
+	class GLDepthBuffer : public DepthBuffer
+	{
+	public:
+		GLDepthBuffer( uint16 poolId, GLRenderSystem *renderSystem, GLContext *creatorContext,
+						GLRenderBuffer *depth, GLRenderBuffer *stencil,
+						uint32 width, uint32 height, uint32 fsaa, uint32 multiSampleQuality,
+						bool isManual );
+		~GLDepthBuffer();
+
+		/// @copydoc DepthBuffer::isCompatible
+		virtual bool isCompatible( RenderTarget *renderTarget ) const;
+
+		GLContext* getGLContext() const { return mCreatorContext; }
+		GLRenderBuffer* getDepthBuffer() const  { return mDepthBuffer; }
+		GLRenderBuffer* getStencilBuffer() const { return mStencilBuffer; }
+
+	protected:
+		uint32						mMultiSampleQuality;
+		GLContext					*mCreatorContext;
+		GLRenderBuffer				*mDepthBuffer;
+		GLRenderBuffer				*mStencilBuffer;
+		GLRenderSystem				*mRenderSystem;
+	};
+}
+#endif

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

@@ -0,0 +1,59 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLMULTIRENDERTARGET_H__
+#define __GLMULTIRENDERTARGET_H__
+
+#include "OgreGLFrameBufferObject.h"
+
+namespace Ogre {
+	/** MultiRenderTarget for GL. Requires the FBO extension.
+	*/
+	class _OgreGLExport GLFBOMultiRenderTarget : public MultiRenderTarget
+	{
+	public:
+		GLFBOMultiRenderTarget(GLFBOManager *manager, const String &name);
+		~GLFBOMultiRenderTarget();
+
+		virtual void getCustomAttribute( const String& name, void *pData );
+
+		bool requiresTextureFlipping() const { return true; }
+
+		/// Override so we can attach the depth buffer to the FBO
+		virtual bool attachDepthBuffer( DepthBuffer *depthBuffer );
+		virtual void detachDepthBuffer();
+		virtual void _detachDepthBuffer();
+	private:
+		virtual void bindSurfaceImpl(size_t attachment, RenderTexture *target);
+		virtual void unbindSurfaceImpl(size_t attachment); 
+		GLFrameBufferObject fbo;
+	};
+
+}
+
+#endif // __GLMULTIRENDERTARGET_H__

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

@@ -0,0 +1,200 @@
+/*
+-----------------------------------------------------------------------------
+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 __OgreGLFBORTT_H__
+#define __OgreGLFBORTT_H__
+
+#include "OgreGLRenderTexture.h"
+#include "OgreGLContext.h"
+#include "OgreGLFrameBufferObject.h"
+
+/// Extra GL constants
+#define GL_DEPTH24_STENCIL8_EXT                           0x88F0
+
+
+namespace Ogre {
+    class GLFBOManager;
+
+    /** RenderTexture for GL FBO
+    */
+    class _OgreGLExport GLFBORenderTexture: public GLRenderTexture
+    {
+    public:
+        GLFBORenderTexture(GLFBOManager *manager, const String &name, const GLSurfaceDesc &target, bool writeGamma, uint fsaa);
+
+        virtual void getCustomAttribute(const String& name, void* pData);
+
+		/// Override needed to deal with multisample buffers
+		virtual void swapBuffers(bool waitForVSync = true);
+
+		/// Override so we can attach the depth buffer to the FBO
+		virtual bool attachDepthBuffer( DepthBuffer *depthBuffer );
+		virtual void detachDepthBuffer();
+		virtual void _detachDepthBuffer();
+    protected:
+        GLFrameBufferObject mFB;
+    };
+    
+    /** Factory for GL Frame Buffer Objects, and related things.
+    */
+    class _OgreGLExport GLFBOManager: public GLRTTManager
+    {
+    public:
+        GLFBOManager(bool atimode);
+		~GLFBOManager();
+        
+        /** Bind a certain render target if it is a FBO. If it is not a FBO, bind the
+            main frame buffer.
+        */
+        void bind(RenderTarget *target);
+        
+        /** Unbind a certain render target. No-op for FBOs.
+        */
+        void unbind(RenderTarget *target) {};
+        
+        /** Get best depth and stencil supported for given internalFormat
+        */
+        void getBestDepthStencil(GLenum internalFormat, GLenum *depthFormat, GLenum *stencilFormat);
+        
+        /** Create a texture rendertarget object
+        */
+        virtual GLFBORenderTexture *createRenderTexture(const String &name, 
+			const GLSurfaceDesc &target, bool writeGamma, uint fsaa);
+
+		/** Create a multi render target 
+		*/
+		virtual MultiRenderTarget* createMultiRenderTarget(const String & name);
+        
+        /** Request a render buffer. If format is GL_NONE, return a zero buffer.
+        */
+        GLSurfaceDesc requestRenderBuffer(GLenum format, size_t width, size_t height, uint fsaa);
+        /** Request the specify render buffer in case shared somewhere. Ignore
+            silently if surface.buffer is 0.
+        */
+        void requestRenderBuffer(const GLSurfaceDesc &surface);
+        /** Release a render buffer. Ignore silently if surface.buffer is 0.
+        */
+        void releaseRenderBuffer(const GLSurfaceDesc &surface);
+        
+        /** Check if a certain format is usable as FBO rendertarget format
+        */
+        bool checkFormat(PixelFormat format) { return mProps[format].valid; }
+        
+        /** Get a FBO without depth/stencil for temporary use, like blitting between textures.
+        */
+        GLuint getTemporaryFBO() { return mTempFBO; }
+    private:
+        /** Frame Buffer Object properties for a certain texture format.
+        */
+        struct FormatProperties
+        {
+            bool valid; // This format can be used as RTT (FBO)
+            
+            /** Allowed modes/properties for this pixel format
+            */
+            struct Mode
+            {
+                size_t depth;     // Depth format (0=no depth)
+                size_t stencil;   // Stencil format (0=no stencil)
+            };
+            
+            vector<Mode>::type modes;
+        };
+        /** Properties for all internal formats defined by OGRE
+        */
+        FormatProperties mProps[PF_COUNT];
+        
+        /** Stencil and depth renderbuffers of the same format are re-used between surfaces of the 
+            same size and format. This can save a lot of memory when a large amount of rendertargets
+            are used.
+        */
+        struct RBFormat
+        {
+            RBFormat(GLenum inFormat, size_t inWidth, size_t inHeight, uint fsaa):
+                format(inFormat), width(inWidth), height(inHeight), samples(fsaa)
+            {}
+            GLenum format;
+            size_t width;
+            size_t height;
+			uint samples;
+            // Overloaded comparison operator for usage in map
+            bool operator < (const RBFormat &other) const
+            {
+                if(format < other.format)
+                {
+                    return true;
+                }
+                else if(format == other.format)
+                {
+                    if(width < other.width)
+                    {
+                        return true;
+                    }
+                    else if(width == other.width)
+                    {
+                        if(height < other.height)
+                            return true;
+						else if (height == other.height)
+						{
+							if (samples < other.samples)
+								return true;
+						}
+                    }
+                }
+                return false;
+            }
+        };
+        struct RBRef
+        {
+            RBRef(){}
+            RBRef(GLRenderBuffer *inBuffer):
+                buffer(inBuffer), refcount(1)
+            { }
+            GLRenderBuffer *buffer;
+            size_t refcount;
+        };
+        typedef map<RBFormat, RBRef>::type RenderBufferMap;
+        RenderBufferMap mRenderBufferMap;
+        // map(format, sizex, sizey) -> [GLSurface*,refcount]
+        
+        /** Temporary FBO identifier
+         */
+        GLuint mTempFBO;
+        
+		/// Buggy ATI driver?
+		bool mATIMode;
+        
+        /** Detect allowed FBO formats */
+        void detectFBOFormats();
+        GLuint _tryFormat(GLenum depthFormat, GLenum stencilFormat);
+        bool _tryPackedFormat(GLenum packedFormat);
+    };
+    
+
+}
+
+#endif

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

@@ -0,0 +1,105 @@
+/*
+-----------------------------------------------------------------------------
+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 __OgreGLFBO_H__
+#define __OgreGLFBO_H__
+
+#include "OgreGLRenderTexture.h"
+#include "OgreGLContext.h"
+
+namespace Ogre {
+    
+    /** Frame Buffer Object abstraction.
+    */
+    class _OgreGLExport GLFrameBufferObject
+    {
+    public:
+        GLFrameBufferObject(GLFBOManager *manager, uint fsaa);
+        ~GLFrameBufferObject();
+
+        /** Bind a surface to a certain attachment point.
+            attachment: 0..OGRE_MAX_MULTIPLE_RENDER_TARGETS-1
+        */
+        void bindSurface(size_t attachment, const GLSurfaceDesc &target);
+        /** Unbind attachment
+        */
+        void unbindSurface(size_t attachment);
+        
+        /** Bind FrameBufferObject
+        */
+        void bind();
+
+		/** Swap buffers - only useful when using multisample buffers.
+		*/
+		void swapBuffers();
+
+		/** This function acts very similar to @see GLFBORenderTexture::attachDepthBuffer
+			The difference between D3D & OGL is that D3D setups the DepthBuffer before rendering,
+			while OGL setups the DepthBuffer per FBO. So the DepthBuffer (RenderBuffer) needs to
+			be attached for OGL.
+		*/
+		void attachDepthBuffer( DepthBuffer *depthBuffer );
+		void detachDepthBuffer();
+		
+		/// Get the GL id for the FBO
+		GLuint getGLFBOID() const { return mFB; }
+		/// Get the GL id for the multisample FBO
+		GLuint getGLMultisampleFBOID() const { return mMultisampleFB; }
+        
+        /// Accessors
+        size_t getWidth();
+        size_t getHeight();
+        PixelFormat getFormat();
+		GLsizei getFSAA();
+        
+        GLFBOManager *getManager() { return mManager; }
+		const GLSurfaceDesc &getSurface(size_t attachment) { return mColour[attachment]; }
+    private:
+        GLFBOManager *mManager;
+		GLsizei mNumSamples;
+        GLuint mFB;
+		GLuint mMultisampleFB;
+		GLSurfaceDesc mMultisampleColourBuffer;
+        GLSurfaceDesc mDepth;
+        GLSurfaceDesc mStencil;
+        // Arbitrary number of texture surfaces
+        GLSurfaceDesc mColour[OGRE_MAX_MULTIPLE_RENDER_TARGETS];
+
+
+		/** Initialise object (find suitable depth and stencil format).
+            Must be called every time the bindings change.
+            It fails with an exception (ERR_INVALIDPARAMS) if:
+            - Attachment point 0 has no binding
+            - Not all bound surfaces have the same size
+            - Not all bound surfaces have the same internal format
+        */
+        void initialise();
+    };
+
+}
+
+#endif

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

@@ -0,0 +1,69 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLGpuNvparseProgram_H__
+#define __GLGpuNvparseProgram_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreGLGpuProgram.h"
+
+namespace Ogre {
+
+class _OgreGLExport GLGpuNvparseProgram : public GLGpuProgram
+{
+public:
+    GLGpuNvparseProgram(ResourceManager* creator, 
+        const String& name, ResourceHandle handle, 
+        const String& group, bool isManual, ManualResourceLoader* loader);
+    virtual ~GLGpuNvparseProgram();
+
+
+    /// 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);
+
+    /// Get the assigned GL program id
+    GLuint getProgramID(void) const
+    { return mProgramID; }
+
+protected:
+    /// @copydoc Resource::unload
+    void unloadImpl(void);
+    void loadFromSource(void);
+
+private:
+    GLuint mProgramID;
+    GLenum mProgramType;
+};
+
+} // namespace Ogre
+
+#endif // __GLGpuNvparseProgram_H__