ruby-ogre 0.0.1-x86-linux

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

@@ -0,0 +1,521 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLRenderSystem_H__
+#define __GLRenderSystem_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgrePlatform.h"
+#include "OgreRenderSystem.h"
+#include "OgreGLHardwareBufferManager.h"
+#include "OgreGLGpuProgramManager.h"
+#include "OgreVector4.h"
+
+
+namespace Ogre {
+    
+	class GLSLProgramFactory;
+
+	/**
+      Implementation of GL as a rendering system.
+     */
+    class _OgreGLExport GLRenderSystem : public RenderSystem
+    {
+    private:
+        /// Rendering loop control
+        bool mStopRendering;
+
+        /** Array of up to 8 lights, indexed as per API
+            Note that a null value indicates a free slot
+          */ 
+        #define MAX_LIGHTS 8
+        Light* mLights[MAX_LIGHTS];
+
+        /// View matrix to set world against
+        Matrix4 mViewMatrix;
+        Matrix4 mWorldMatrix;
+        Matrix4 mTextureMatrix;
+
+        /// Last min & mip filtering options, so we can combine them
+        FilterOptions mMinFilter;
+        FilterOptions mMipFilter;
+
+        /// What texture coord set each texture unit is using
+        size_t mTextureCoordIndex[OGRE_MAX_TEXTURE_LAYERS];
+
+        /// Holds texture type settings for every stage
+        GLenum mTextureTypes[OGRE_MAX_TEXTURE_LAYERS];
+
+		/// Number of fixed-function texture units
+		unsigned short mFixedFunctionTextureUnits;
+
+        void initConfigOptions(void);
+        void initInputDevices(void);
+        void processInputDevices(void);
+
+        void setGLLight(size_t index, Light* lt);
+        void makeGLMatrix(GLfloat gl_matrix[16], const Matrix4& m);
+ 
+        GLint getBlendMode(SceneBlendFactor ogreBlend) const;
+		GLint getTextureAddressingMode(TextureUnitState::TextureAddressingMode tam) const;
+				void initialiseContext(RenderWindow* primary);
+
+        void setLights();
+
+        /// Store last depth write state
+        bool mDepthWrite;
+		/// Store last stencil mask state
+		uint32 mStencilMask;
+		/// Store last colour write state
+		bool mColourWrite[4];
+
+        GLint convertCompareFunction(CompareFunction func) const;
+        GLint convertStencilOp(StencilOperation op, bool invert = false) const;
+
+		/// Internal method for anisotropy validation
+		GLfloat _getCurrentAnisotropy(size_t unit);
+		
+        /// GL support class, used for creating windows etc.
+        GLSupport* mGLSupport;
+        
+        /// Internal method to set pos / direction of a light
+        void setGLLightPositionDirection(Light* lt, GLenum lightindex);
+
+        bool mUseAutoTextureMatrix;
+        GLfloat mAutoTextureMatrix[16];
+
+        /// Check if the GL system has already been initialised
+        bool mGLInitialised;
+
+        HardwareBufferManager* mHardwareBufferManager;
+        GLGpuProgramManager* mGpuProgramManager;
+		GLSLProgramFactory* mGLSLProgramFactory;
+
+        unsigned short mCurrentLights;
+
+        GLuint getCombinedMinMipFilter(void) const;
+
+        GLGpuProgram* mCurrentVertexProgram;
+        GLGpuProgram* mCurrentFragmentProgram;
+		GLGpuProgram* mCurrentGeometryProgram;
+
+		/* The main GL context - main thread only */
+        GLContext *mMainContext;
+        /* The current GL context  - main thread only */
+        GLContext *mCurrentContext;
+		typedef list<GLContext*>::type GLContextList;
+		/// List of background thread contexts
+		GLContextList mBackgroundContextList;
+
+        /** Manager object for creating render textures.
+            Direct render to texture via GL_EXT_framebuffer_object is preferable 
+			to pbuffers, which depend on the GL support used and are generally 
+			unwieldy and slow. However, FBO support for stencil buffers is poor.
+        */
+        GLRTTManager *mRTTManager;
+
+		ushort mActiveTextureUnit;
+
+        // local data members of _render that were moved here to improve performance
+        // (save allocations)
+        vector<GLuint>::type mRenderAttribsBound;
+        vector<GLuint>::type mRenderInstanceAttribsBound;
+
+
+	protected:
+		void setClipPlanesImpl(const PlaneList& clipPlanes);
+		bool activateGLTextureUnit(size_t unit);
+        void bindVertexElementToGpu( const VertexElement &elem, HardwareVertexBufferSharedPtr vertexBuffer,
+                const size_t vertexStart, 
+                vector<GLuint>::type &attribsBound, vector<GLuint>::type &instanceAttribsBound );
+    public:
+        // Default constructor / destructor
+        GLRenderSystem();
+        ~GLRenderSystem();
+
+        // ----------------------------------
+        // Overridden RenderSystem functions
+        // ----------------------------------
+        /** See
+          RenderSystem
+         */
+        const String& getName(void) const;
+        /** See
+          RenderSystem
+         */
+        ConfigOptionMap& getConfigOptions(void);
+        /** See
+          RenderSystem
+         */
+        void setConfigOption(const String &name, const String &value);
+        /** See
+          RenderSystem
+         */
+        String validateConfigOptions(void);
+        /** See
+          RenderSystem
+         */
+        RenderWindow* _initialise(bool autoCreateWindow, const String& windowTitle = "OGRE Render Window");
+        /** See
+          RenderSystem
+         */
+				virtual RenderSystemCapabilities* createRenderSystemCapabilities() const;
+        /** See
+          RenderSystem
+         */
+				void initialiseFromRenderSystemCapabilities(RenderSystemCapabilities* caps, RenderTarget* primary);
+        /** See
+          RenderSystem
+         */
+        void reinitialise(void); // Used if settings changed mid-rendering
+        /** See
+          RenderSystem
+         */
+        void shutdown(void);
+
+        /** See
+          RenderSystem
+         */
+        void setAmbientLight(float r, float g, float b);
+        /** See
+          RenderSystem
+         */
+        void setShadingType(ShadeOptions so);
+        /** See
+          RenderSystem
+         */
+        void setLightingEnabled(bool enabled);
+        
+		/// @copydoc RenderSystem::_createRenderWindow
+		RenderWindow* _createRenderWindow(const String &name, unsigned int width, unsigned int height, 
+			bool fullScreen, const NameValuePairList *miscParams = 0);
+
+		/// @copydoc RenderSystem::_createRenderWindows
+		bool _createRenderWindows(const RenderWindowDescriptionList& renderWindowDescriptions, 
+			RenderWindowList& createdWindows);
+
+		/// @copydoc RenderSystem::_createDepthBufferFor
+		DepthBuffer* _createDepthBufferFor( RenderTarget *renderTarget );
+
+		/// Mimics D3D9RenderSystem::_getDepthStencilFormatFor, if no FBO RTT manager, outputs GL_NONE
+		void _getDepthStencilFormatFor( GLenum internalColourFormat, GLenum *depthFormat,
+										GLenum *stencilFormat );
+		
+		/// @copydoc RenderSystem::createMultiRenderTarget
+		virtual MultiRenderTarget * createMultiRenderTarget(const String & name); 
+		
+        /** See
+          RenderSystem
+         */
+        void destroyRenderWindow(RenderWindow* pWin);
+        /** See
+          RenderSystem
+         */
+        String getErrorDescription(long errorNumber) const;
+
+        /** See
+          RenderSystem
+         */
+        VertexElementType getColourVertexElementType(void) const;
+        /** See
+          RenderSystem
+         */
+        void setNormaliseNormals(bool normalise);
+
+        // -----------------------------
+        // Low-level overridden members
+        // -----------------------------
+        /** See
+          RenderSystem
+         */
+        void _useLights(const LightList& lights, unsigned short limit);
+        /** See
+          RenderSystem
+         */
+		bool areFixedFunctionLightsInViewSpace() const { return true; }
+        /** See
+          RenderSystem
+         */
+        void _setWorldMatrix(const Matrix4 &m);
+        /** See
+          RenderSystem
+         */
+        void _setViewMatrix(const Matrix4 &m);
+        /** See
+          RenderSystem
+         */
+        void _setProjectionMatrix(const Matrix4 &m);
+        /** See
+          RenderSystem
+         */
+        void _setSurfaceParams(const ColourValue &ambient,
+            const ColourValue &diffuse, const ColourValue &specular,
+            const ColourValue &emissive, Real shininess,
+            TrackVertexColourType tracking);
+        /** See
+          RenderSystem
+         */
+		void _setPointParameters(Real size, bool attenuationEnabled, 
+			Real constant, Real linear, Real quadratic, Real minSize, Real maxSize);
+        /** See
+          RenderSystem
+         */
+		void _setPointSpritesEnabled(bool enabled);
+		/** See
+          RenderSystem
+         */
+        void _setTexture(size_t unit, bool enabled, const TexturePtr &tex);
+        /** See
+          RenderSystem
+         */
+        void _setTextureCoordSet(size_t stage, size_t index);
+        /** See
+          RenderSystem
+         */
+        void _setTextureCoordCalculation(size_t stage, TexCoordCalcMethod m, 
+            const Frustum* frustum = 0);
+        /** See
+          RenderSystem
+         */
+        void _setTextureBlendMode(size_t stage, const LayerBlendModeEx& bm);
+        /** See
+          RenderSystem
+         */
+        void _setTextureAddressingMode(size_t stage, const TextureUnitState::UVWAddressingMode& uvw);
+        /** See
+          RenderSystem
+         */
+        void _setTextureBorderColour(size_t stage, const ColourValue& colour);
+		/** See
+		  RenderSystem
+		 */
+		void _setTextureMipmapBias(size_t unit, float bias);
+        /** See
+          RenderSystem
+         */
+        void _setTextureMatrix(size_t stage, const Matrix4& xform);
+        /** See
+          RenderSystem
+         */
+        void _setSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendOperation op );
+        /** See
+          RenderSystem
+         */
+		void _setSeparateSceneBlending(SceneBlendFactor sourceFactor, SceneBlendFactor destFactor, SceneBlendFactor sourceFactorAlpha, SceneBlendFactor destFactorAlpha, SceneBlendOperation op, SceneBlendOperation alphaOp );
+        /** See
+          RenderSystem
+         */
+		void _setSceneBlendingOperation(SceneBlendOperation op);
+		/** See
+          RenderSystem
+         */
+		void _setSeparateSceneBlendingOperation(SceneBlendOperation op, SceneBlendOperation alphaOp);
+		/** See
+          RenderSystem
+         */
+        void _setAlphaRejectSettings(CompareFunction func, unsigned char value, bool alphaToCoverage);
+        /** See
+          RenderSystem
+         */
+        void _setViewport(Viewport *vp);
+        /** See
+          RenderSystem
+         */
+        void _beginFrame(void);
+        /** See
+          RenderSystem
+         */
+        void _endFrame(void);
+        /** See
+          RenderSystem
+         */
+        void _setCullingMode(CullingMode mode);
+        /** See
+          RenderSystem
+         */
+        void _setDepthBufferParams(bool depthTest = true, bool depthWrite = true, CompareFunction depthFunction = CMPF_LESS_EQUAL);
+        /** See
+          RenderSystem
+         */
+        void _setDepthBufferCheckEnabled(bool enabled = true);
+        /** See
+          RenderSystem
+         */
+        void _setDepthBufferWriteEnabled(bool enabled = true);
+        /** See
+          RenderSystem
+         */
+        void _setDepthBufferFunction(CompareFunction func = CMPF_LESS_EQUAL);
+        /** See
+          RenderSystem
+         */
+        void _setDepthBias(float constantBias, float slopeScaleBias);
+        /** See
+          RenderSystem
+         */
+        void _setColourBufferWriteEnabled(bool red, bool green, bool blue, bool alpha);
+		/** See
+          RenderSystem
+         */
+        void _setFog(FogMode mode, const ColourValue& colour, Real density, Real start, Real end);
+        /** See
+          RenderSystem
+         */
+        void _convertProjectionMatrix(const Matrix4& matrix,
+            Matrix4& dest, bool forGpuProgram = false);
+        /** See
+          RenderSystem
+         */
+        void _makeProjectionMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane, 
+            Matrix4& dest, bool forGpuProgram = false);
+        /** See
+          RenderSystem
+         */
+        void _makeProjectionMatrix(Real left, Real right, Real bottom, Real top, 
+            Real nearPlane, Real farPlane, Matrix4& dest, bool forGpuProgram = false);
+        /** See
+          RenderSystem
+         */
+		void _makeOrthoMatrix(const Radian& fovy, Real aspect, Real nearPlane, Real farPlane, 
+            Matrix4& dest, bool forGpuProgram = false);
+        /** See
+        RenderSystem
+        */
+        void _applyObliqueDepthProjection(Matrix4& matrix, const Plane& plane, 
+            bool forGpuProgram);
+        /** See
+          RenderSystem
+         */
+        void setClipPlane (ushort index, Real A, Real B, Real C, Real D);
+        /** See
+          RenderSystem
+         */
+        void enableClipPlane (ushort index, bool enable);
+        /** See
+          RenderSystem
+         */
+        void _setPolygonMode(PolygonMode level);
+        /** See
+          RenderSystem
+         */
+        void setStencilCheckEnabled(bool enabled);
+        /** See
+          RenderSystem.
+         */
+        void setStencilBufferParams(CompareFunction func = CMPF_ALWAYS_PASS, 
+            uint32 refValue = 0, uint32 mask = 0xFFFFFFFF, 
+            StencilOperation stencilFailOp = SOP_KEEP, 
+            StencilOperation depthFailOp = SOP_KEEP,
+            StencilOperation passOp = SOP_KEEP, 
+            bool twoSidedOperation = false);
+        /** See
+          RenderSystem
+         */
+        void _setTextureUnitFiltering(size_t unit, FilterType ftype, FilterOptions filter);
+        /** See
+          RenderSystem
+         */
+		void _setTextureLayerAnisotropy(size_t unit, unsigned int maxAnisotropy);
+        /** See
+          RenderSystem
+         */
+		void setVertexDeclaration(VertexDeclaration* decl);
+        /** See
+          RenderSystem
+         */
+		void setVertexBufferBinding(VertexBufferBinding* binding);
+        /** See
+          RenderSystem
+         */
+        void _render(const RenderOperation& op);
+
+        /** See
+          RenderSystem
+         */
+        void bindGpuProgram(GpuProgram* prg);
+        /** See
+          RenderSystem
+         */
+        void unbindGpuProgram(GpuProgramType gptype);
+        /** See
+          RenderSystem
+         */
+		void bindGpuProgramParameters(GpuProgramType gptype, 
+			GpuProgramParametersSharedPtr params, uint16 variabilityMask);
+		/** See
+		  RenderSystem
+		 */
+		void bindGpuProgramPassIterationParameters(GpuProgramType gptype);
+        /** See
+          RenderSystem
+         */
+        void setScissorTest(bool enabled, size_t left = 0, size_t top = 0, size_t right = 800, size_t bottom = 600) ;
+        void clearFrameBuffer(unsigned int buffers, 
+            const ColourValue& colour = ColourValue::Black, 
+            Real depth = 1.0f, unsigned short stencil = 0);
+        HardwareOcclusionQuery* createHardwareOcclusionQuery(void);
+        Real getHorizontalTexelOffset(void);
+        Real getVerticalTexelOffset(void);
+        Real getMinimumDepthInputValue(void);
+        Real getMaximumDepthInputValue(void);
+		OGRE_MUTEX(mThreadInitMutex)
+		void registerThread();
+		void unregisterThread();
+		void preExtraThreadsStarted();
+		void postExtraThreadsStarted();
+
+        // ----------------------------------
+        // GLRenderSystem specific members
+        // ----------------------------------
+        /** One time initialization for the RenderState of a context. Things that
+            only need to be set once, like the LightingModel can be defined here.
+         */
+        void _oneTimeContextInitialization();
+        /** Switch GL context, dealing with involved internal cached states too
+        */
+        void _switchContext(GLContext *context);
+        /**
+         * Set current render target to target, enabling its GL context if needed
+         */
+        void _setRenderTarget(RenderTarget *target);
+        /** Unregister a render target->context mapping. If the context of target 
+            is the current context, change the context to the main context so it
+            can be destroyed safely. 
+            
+            @note This is automatically called by the destructor of 
+            GLContext.
+         */
+        void _unregisterContext(GLContext *context);
+		/** Returns the main context */
+		GLContext* _getMainContext() {return mMainContext;} 
+
+		/// @copydoc RenderSystem::getDisplayMonitorCount
+		unsigned int getDisplayMonitorCount() const;
+    };
+}
+#endif
+

data/deps/include/OGRE/RenderSystems/GL/OgreGLRenderTexture.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 __GLRENDERTEXTURE_H__
+#define __GLRENDERTEXTURE_H__
+
+#include "OgreGLTexture.h"
+
+namespace Ogre {
+    /** GL surface descriptor. Points to a 2D surface that can be rendered to. 
+    */
+    struct _OgrePrivate GLSurfaceDesc
+    {
+    public:
+        GLHardwarePixelBuffer *buffer;
+        size_t zoffset;
+		uint numSamples;
+
+		GLSurfaceDesc() :buffer(0), zoffset(0), numSamples(0) {}
+    };
+    
+    /** Base class for GL Render Textures
+    */
+    class _OgreGLExport GLRenderTexture: public RenderTexture
+    {
+    public:
+        GLRenderTexture(const String &name, const GLSurfaceDesc &target, bool writeGamma, uint fsaa);
+        virtual ~GLRenderTexture();
+        
+        bool requiresTextureFlipping() const { return true; }
+
+        static const String CustomAttributeString_FBO;
+        static const String CustomAttributeString_TARGET;
+        static const String CustomAttributeString_GLCONTEXT;
+    };
+    
+    /** Manager/factory for RenderTextures.
+    */
+    class _OgreGLExport GLRTTManager: public Singleton<GLRTTManager>
+    {
+    public:
+        virtual ~GLRTTManager();
+        
+        /** Create a texture rendertarget object
+        */
+        virtual RenderTexture *createRenderTexture(const String &name, const GLSurfaceDesc &target, bool writeGamma, uint fsaa) = 0;
+        
+         /** Check if a certain format is usable as rendertexture format
+        */
+        virtual bool checkFormat(PixelFormat format) = 0;
+        
+        /** Bind a certain render target.
+        */
+        virtual void bind(RenderTarget *target) = 0;
+        
+        /** Unbind a certain render target. This is called before binding another RenderTarget, and
+            before the context is switched. It can be used to do a copy, or just be a noop if direct
+            binding is used.
+        */
+        virtual void unbind(RenderTarget *target) = 0;
+
+		virtual void getBestDepthStencil(GLenum internalFormat, GLenum *depthFormat, GLenum *stencilFormat)
+		{
+			*depthFormat = GL_NONE;
+			*stencilFormat = GL_NONE;
+		}
+
+		/** Create a multi render target 
+		*/
+		virtual MultiRenderTarget* createMultiRenderTarget(const String & name);
+        
+        /** Get the closest supported alternative format. If format is supported, returns format.
+        */
+        virtual PixelFormat getSupportedAlternative(PixelFormat format);
+    };
+    
+    /** RenderTexture for simple copying from frame buffer
+    */
+    class GLCopyingRTTManager;
+    class _OgreGLExport GLCopyingRenderTexture: public GLRenderTexture
+    {
+    public:
+        GLCopyingRenderTexture(GLCopyingRTTManager *manager, const String &name, const GLSurfaceDesc &target, 
+			bool writeGamma, uint fsaa);
+        
+        virtual void getCustomAttribute(const String& name, void* pData);
+    };
+    
+    /** Simple, copying manager/factory for RenderTextures. This is only used as the last fallback if
+        both PBuffers and FBOs aren't supported.
+    */
+    class _OgreGLExport GLCopyingRTTManager: public GLRTTManager
+    {
+    public:
+        GLCopyingRTTManager();
+        virtual ~GLCopyingRTTManager();
+        
+        /** @copydoc GLRTTManager::createRenderTexture
+        */
+        virtual RenderTexture *createRenderTexture(const String &name, const GLSurfaceDesc &target, bool writeGamma, uint fsaa);
+        
+        /** @copydoc GLRTTManager::checkFormat
+        */
+        virtual bool checkFormat(PixelFormat format);
+        
+        /** @copydoc GLRTTManager::bind
+        */
+        virtual void bind(RenderTarget *target);
+        
+        /** @copydoc GLRTTManager::unbind
+        */
+        virtual void unbind(RenderTarget *target);
+    };
+}
+
+#endif // __GLTEXTURE_H__