ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/RenderSystems/GL/OgreGLSLProgram.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 __GLSLProgram_H__
+#define __GLSLProgram_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreHighLevelGpuProgram.h"
+
+namespace Ogre {
+    /** Specialisation of HighLevelGpuProgram to provide support for OpenGL 
+        Shader Language (GLSL).
+    @remarks
+		GLSL has no target assembler or entry point specification like DirectX 9 HLSL.
+		Vertex and Fragment shaders only have one entry point called "main".  
+		When a shader is compiled, microcode is generated but can not be accessed by
+		the application.
+		GLSL also does not provide assembler low level output after compiling.  The GL Render
+		system assumes that the Gpu program is a GL Gpu program so GLSLProgram will create a 
+		GLSLGpuProgram that is subclassed from GLGpuProgram for the low level implementation.
+		The GLSLProgram class will create a shader object and compile the source but will
+		not create a program object.  It's up to GLSLGpuProgram class to request a program object
+		to link the shader object to.
+
+	@note
+		GLSL supports multiple modular shader objects that can be attached to one program
+		object to form a single shader.  This is supported through the "attach" material script
+		command.  All the modules to be attached are listed on the same line as the attach command
+		separated by white space.
+        
+    */
+    class _OgreGLExport GLSLProgram : public HighLevelGpuProgram
+    {
+    public:
+        /// Command object for attaching another GLSL Program 
+        class CmdAttach : public ParamCommand
+        {
+        public:
+            String doGet(const void* target) const;
+            void doSet(void* target, const String& shaderNames);
+        };
+
+        GLSLProgram(ResourceManager* creator, 
+            const String& name, ResourceHandle handle,
+            const String& group, bool isManual, ManualResourceLoader* loader);
+		~GLSLProgram();
+
+		GLhandleARB getGLHandle() const { return mGLHandle; }
+		void attachToProgramObject( const GLhandleARB programObject );
+		void detachFromProgramObject( const GLhandleARB programObject );
+		String getAttachedShaderNames() const { return mAttachedShaderNames; }
+
+		/// Overridden
+		bool getPassTransformStates(void) const;
+		bool getPassSurfaceAndLightStates(void) const;
+
+        /** Attach another GLSL Shader to this one. */
+        void attachChildShader(const String& name);
+
+		/** Sets the preprocessor defines use to compile the program. */
+		void setPreprocessorDefines(const String& defines) { mPreprocessorDefines = defines; }
+		/** Sets the preprocessor defines use to compile the program. */
+		const String& getPreprocessorDefines(void) const { return mPreprocessorDefines; }
+
+        /// Overridden from GpuProgram
+        const String& getLanguage(void) const;
+
+		/** Returns the operation type that this geometry program expects to
+			receive as input
+		*/
+		virtual RenderOperation::OperationType getInputOperationType(void) const 
+		{ return mInputOperationType; }
+		/** Returns the operation type that this geometry program will emit
+		*/
+		virtual RenderOperation::OperationType getOutputOperationType(void) const 
+		{ return mOutputOperationType; }
+		/** Returns the maximum number of vertices that this geometry program can
+			output in a single run
+		*/
+		virtual int getMaxOutputVertices(void) const { return mMaxOutputVertices; }
+
+		/** Sets the operation type that this geometry program expects to receive
+		*/
+		virtual void setInputOperationType(RenderOperation::OperationType operationType) 
+		{ mInputOperationType = operationType; }
+		/** Set the operation type that this geometry program will emit
+		*/
+		virtual void setOutputOperationType(RenderOperation::OperationType operationType) 
+		{ mOutputOperationType = operationType; }
+		/** Set the maximum number of vertices that a single run of this geometry program
+			can emit.
+		*/
+		virtual void setMaxOutputVertices(int maxOutputVertices) 
+		{ mMaxOutputVertices = maxOutputVertices; }
+
+		/// compile source into shader object
+		bool compile( const bool checkErrors = true);
+
+		/// Command object for setting macro defines
+		class CmdPreprocessorDefines : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		/// Command object for setting the input operation type (geometry shader only)
+		class _OgreGLExport CmdInputOperationType : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		/// Command object for setting the output operation type (geometry shader only)
+		class _OgreGLExport CmdOutputOperationType : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+		/// Command object for setting the maximum output vertices (geometry shader only)
+		class _OgreGLExport CmdMaxOutputVertices : public ParamCommand
+		{
+		public:
+			String doGet(const void* target) const;
+			void doSet(void* target, const String& val);
+		};
+	protected:
+		static CmdPreprocessorDefines msCmdPreprocessorDefines;
+        static CmdAttach msCmdAttach;
+		static CmdInputOperationType msInputOperationTypeCmd;
+		static CmdOutputOperationType msOutputOperationTypeCmd;
+		static CmdMaxOutputVertices msMaxOutputVerticesCmd;
+
+        /** Internal load implementation, must be implemented by subclasses.
+        */
+        void loadFromSource(void);
+        /** Internal method for creating a dummy low-level program for this
+        high-level program.	GLSL does not give access to the low level implementation of the
+		shader so this method creates an object sub-classed from GLGpuProgram just to be
+		compatible with	GLRenderSystem.
+		*/
+		void createLowLevelImpl(void);
+        /// Internal unload implementation, must be implemented by subclasses
+        void unloadHighLevelImpl(void);
+		/// Overridden from HighLevelGpuProgram
+		void unloadImpl(void);
+
+        /// Populate the passed parameters with name->index map
+        void populateParameterNames(GpuProgramParametersSharedPtr params);
+        /// Populate the passed parameters with name->index map, must be overridden
+        void buildConstantDefinitions() const;
+
+	private:
+		/// GL handle for shader object
+		GLhandleARB mGLHandle;
+		/// Flag indicating if shader object successfully compiled
+		GLint mCompiled;
+		/// The input operation type for this (geometry) program
+		RenderOperation::OperationType mInputOperationType;
+		/// The output operation type for this (geometry) program
+		RenderOperation::OperationType mOutputOperationType;
+		/// The maximum amount of vertices that this (geometry) program can output
+		int mMaxOutputVertices;
+		/// attached Shader names
+		String mAttachedShaderNames;
+		/// Preprocessor options
+		String mPreprocessorDefines;
+		/// container of attached programs
+		typedef vector< GLSLProgram* >::type GLSLProgramContainer;
+		typedef GLSLProgramContainer::iterator GLSLProgramContainerIterator;
+		GLSLProgramContainer mAttachedGLSLPrograms;
+
+    };
+}
+
+#endif // __GLSLProgram_H__

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

@@ -0,0 +1,60 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLSLProgramFactory_H__
+#define __GLSLProgramFactory_H__
+
+#include "OgreHighLevelGpuProgramManager.h"
+#include "OgreGLSLExtSupport.h"
+
+namespace Ogre
+{
+    /** Factory class for GLSL programs. */
+    class _OgreGLExport GLSLProgramFactory : public HighLevelGpuProgramFactory
+    {
+    protected:
+		static String sLanguageName;
+    public:
+        GLSLProgramFactory(void);
+        ~GLSLProgramFactory(void);
+		/// Get the name of the language this factory creates programs for
+		const String& getLanguage(void) const;
+		/// Create an instance of GLSLProgram
+        HighLevelGpuProgram* create(ResourceManager* creator, 
+            const String& name, ResourceHandle handle,
+            const String& group, bool isManual, ManualResourceLoader* loader);
+		void destroy(HighLevelGpuProgram* prog);
+
+	private:
+		GLSLLinkProgramManager* mLinkProgramManager;
+
+    };
+}
+
+#endif // __GLSLProgramFactory_H__

data/deps/include/OGRE/RenderSystems/GL/OgreGLSupport.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 OGRE_GLSUPPORT_H
+#define OGRE_GLSUPPORT_H
+
+#include "OgreGLPrerequisites.h"
+#include "OgreGLRenderSystem.h"
+
+#include "OgreRenderWindow.h"
+#include "OgreConfigOptionMap.h"
+#include "OgreGLPBuffer.h"
+
+namespace Ogre
+{
+    
+class _OgreGLExport GLSupport
+{
+public:
+    GLSupport() { }
+    virtual ~GLSupport() { }
+
+    /**
+    * Add any special config values to the system.
+    * Must have a "Full Screen" value that is a bool and a "Video Mode" value
+    * that is a string in the form of wxh
+    */
+    virtual void addConfig() = 0;
+
+	virtual void setConfigOption(const String &name, const String &value);
+
+    /**
+    * Make sure all the extra options are valid
+    * @return string with error message
+    */
+    virtual String validateConfig() = 0;
+
+	virtual ConfigOptionMap& getConfigOptions(void);
+
+	virtual RenderWindow* createWindow(bool autoCreateWindow, GLRenderSystem* renderSystem, const String& windowTitle) = 0;
+
+	/// @copydoc RenderSystem::_createRenderWindow
+	virtual RenderWindow* newWindow(const String &name, unsigned int width, unsigned int height, 
+		bool fullScreen, const NameValuePairList *miscParams = 0) = 0;
+
+    virtual bool supportsPBuffers();
+    virtual GLPBuffer *createPBuffer(PixelComponentType format, size_t width, size_t height);
+
+    /**
+    * Start anything special
+    */
+    virtual void start() = 0;
+    /**
+    * Stop anything special
+    */
+    virtual void stop() = 0;
+
+    /**
+    * Get vendor information
+    */
+    const String& getGLVendor(void) const
+    {
+        return mVendor;
+    }
+
+    /**
+    * Get version information
+    */
+    const String& getGLVersion(void) const
+    {
+        return mVersion;
+    }
+
+    /**
+    * Compare GL version numbers
+    */
+    bool checkMinGLVersion(const String& v) const;
+
+    /**
+    * Check if an extension is available
+    */
+    virtual bool checkExtension(const String& ext) const;
+    /**
+    * Get the address of a function
+    */
+    virtual void* getProcAddress(const String& procname) = 0;
+
+    /** Initialises GL extensions, must be done AFTER the GL context has been
+        established.
+    */
+    virtual void initialiseExtensions();
+
+	/// @copydoc RenderSystem::getDisplayMonitorCount
+	virtual unsigned int getDisplayMonitorCount() const
+	{
+		return 1;
+	}
+
+protected:
+	// Stored options
+    ConfigOptionMap mOptions;
+
+	// This contains the complete list of supported extensions
+    set<String>::type extensionList;
+private:
+    String mVersion;
+    String mVendor;
+
+}; // class GLSupport
+
+} // namespace Ogre
+
+#endif // OGRE_GLSUPPORT_H

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

@@ -0,0 +1,191 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLTEXTURE_H__
+#define __GLTEXTURE_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgrePlatform.h"
+#include "OgreRenderTexture.h"
+#include "OgreTexture.h"
+#include "OgreGLSupport.h"
+#include "OgreHardwarePixelBuffer.h"
+
+namespace Ogre {
+
+    class _OgreGLExport GLTexture : public Texture
+    {
+    public:
+        // Constructor
+        GLTexture(ResourceManager* creator, const String& name, ResourceHandle handle,
+            const String& group, bool isManual, ManualResourceLoader* loader, 
+            GLSupport& support);
+
+        virtual ~GLTexture();      
+
+        void createRenderTexture();
+			
+		/// @copydoc Texture::getBuffer
+		HardwarePixelBufferSharedPtr getBuffer(size_t face, size_t mipmap);
+
+        // Takes the OGRE texture type (1d/2d/3d/cube) and returns the appropriate GL one
+        GLenum getGLTextureTarget(void) const;
+
+        GLuint getGLID() const
+        {
+            return mTextureID;
+        }
+		
+		void getCustomAttribute(const String& name, void* pData);
+
+    protected:
+		/// @copydoc Texture::createInternalResourcesImpl
+		void createInternalResourcesImpl(void);
+        /// @copydoc Resource::prepareImpl
+        void prepareImpl(void);
+        /// @copydoc Resource::unprepareImpl
+        void unprepareImpl(void);
+        /// @copydoc Resource::loadImpl
+        void loadImpl(void);
+        /// @copydoc Resource::freeInternalResourcesImpl
+        void freeInternalResourcesImpl(void);
+
+		/** internal method, create GLHardwarePixelBuffers for every face and
+			 mipmap level. This method must be called after the GL texture object was created,
+			the number of mipmaps was set (GL_TEXTURE_MAX_LEVEL) and glTexImageXD was called to
+			actually allocate the buffer
+		*/
+		void _createSurfaceList();
+
+        /// Used to hold images between calls to prepare and load.
+        typedef SharedPtr<vector<Image>::type > LoadedImages;
+
+        /** Vector of images that were pulled from disk by
+            prepareLoad but have yet to be pushed into texture memory
+            by loadImpl.  Images should be deleted by loadImpl and unprepareImpl.
+        */
+        LoadedImages mLoadedImages;
+
+
+    private:
+        GLuint mTextureID;
+        GLSupport& mGLSupport;
+		
+		/// Vector of pointers to subsurfaces
+		typedef vector<HardwarePixelBufferSharedPtr>::type SurfaceList;
+		SurfaceList	mSurfaceList;
+    };
+
+    /** Specialisation of SharedPtr to allow SharedPtr to be assigned to GLTexturePtr 
+    @note Has to be a subclass since we need operator=.
+    We could templatise this instead of repeating per Resource subclass, 
+    except to do so requires a form VC6 does not support i.e.
+    ResourceSubclassPtr<T> : public SharedPtr<T>
+    */
+    class _OgreGLExport GLTexturePtr : public SharedPtr<GLTexture> 
+    {
+    public:
+        GLTexturePtr() : SharedPtr<GLTexture>() {}
+        explicit GLTexturePtr(GLTexture* rep) : SharedPtr<GLTexture>(rep) {}
+        GLTexturePtr(const GLTexturePtr& r) : SharedPtr<GLTexture>(r) {} 
+        GLTexturePtr(const ResourcePtr& r) : SharedPtr<GLTexture>()
+        {
+			// lock & copy other mutex pointer
+            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
+            {
+			    OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+			    OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+                pRep = static_cast<GLTexture*>(r.getPointer());
+                pUseCount = r.useCountPointer();
+                if (pUseCount)
+                {
+                    ++(*pUseCount);
+                }
+            }
+        }
+		GLTexturePtr(const TexturePtr& r) : SharedPtr<GLTexture>()
+		{
+			*this = r;
+		}
+
+        /// Operator used to convert a ResourcePtr to a GLTexturePtr
+        GLTexturePtr& operator=(const ResourcePtr& r)
+        {
+            if (pRep == static_cast<GLTexture*>(r.getPointer()))
+                return *this;
+            release();
+			// lock & copy other mutex pointer
+            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
+            {
+			    OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+			    OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+                pRep = static_cast<GLTexture*>(r.getPointer());
+                pUseCount = r.useCountPointer();
+                if (pUseCount)
+                {
+                    ++(*pUseCount);
+                }
+            }
+			else
+			{
+				// RHS must be a null pointer
+				assert(r.isNull() && "RHS must be null if it has no mutex!");
+				setNull();
+			}
+            return *this;
+        }
+        /// Operator used to convert a TexturePtr to a GLTexturePtr
+        GLTexturePtr& operator=(const TexturePtr& r)
+        {
+            if (pRep == static_cast<GLTexture*>(r.getPointer()))
+                return *this;
+            release();
+			// lock & copy other mutex pointer
+            OGRE_MUTEX_CONDITIONAL(r.OGRE_AUTO_MUTEX_NAME)
+            {
+			    OGRE_LOCK_MUTEX(*r.OGRE_AUTO_MUTEX_NAME)
+			    OGRE_COPY_AUTO_SHARED_MUTEX(r.OGRE_AUTO_MUTEX_NAME)
+                pRep = static_cast<GLTexture*>(r.getPointer());
+                pUseCount = r.useCountPointer();
+                if (pUseCount)
+                {
+                    ++(*pUseCount);
+                }
+            }
+			else
+			{
+				// RHS must be a null pointer
+				assert(r.isNull() && "RHS must be null if it has no mutex!");
+				setNull();
+			}
+            return *this;
+        }
+    };
+}
+
+#endif // __GLTEXTURE_H__

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

@@ -0,0 +1,67 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLTextureManager_H__
+#define __GLTextureManager_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreTextureManager.h"
+#include "OgreGLTexture.h"
+#include "OgreGLSupport.h"
+
+namespace Ogre {
+    /** GL-specific implementation of a TextureManager */
+    class _OgreGLExport GLTextureManager : public TextureManager
+    {
+    public:
+        GLTextureManager(GLSupport& support);
+        virtual ~GLTextureManager();
+
+		GLuint getWarningTextureID() { return mWarningTextureID; }
+
+		/// @copydoc TextureManager::getNativeFormat
+		PixelFormat getNativeFormat(TextureType ttype, PixelFormat format, int usage);
+
+        /// @copydoc TextureManager::isHardwareFilteringSupported
+        bool isHardwareFilteringSupported(TextureType ttype, PixelFormat format, int usage,
+            bool preciseFormatOnly = false);
+
+    protected:
+        /// @copydoc ResourceManager::createImpl
+        Resource* createImpl(const String& name, ResourceHandle handle, 
+            const String& group, bool isManual, ManualResourceLoader* loader, 
+            const NameValuePairList* createParams);
+
+		/// Internal method to create a warning texture (bound when a texture unit is blank)
+		void createWarningTexture();
+
+        GLSupport& mGLSupport;
+		GLuint mWarningTextureID;
+    };
+}
+#endif