ruby-ogre 0.0.1-x86-linux

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

@@ -0,0 +1,72 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLRenderToVertexBuffer_H__
+#define __GLRenderToVertexBuffer_H__
+
+#include "OgreRenderToVertexBuffer.h"
+#include "OgreGLPrerequisites.h"
+
+namespace Ogre {
+    /**
+        An object which renders geometry to a vertex.
+    @remarks
+        This is especially useful together with geometry shaders, as you can
+        render procedural geometry which will get saved to a vertex buffer for
+        reuse later, without regenerating it again. You can also create shaders
+        that run on previous results of those shaders, creating stateful 
+        shaders.
+    */
+	class _OgreGLExport GLRenderToVertexBuffer : public RenderToVertexBuffer
+    {    
+    public:
+		/** C'tor */
+		GLRenderToVertexBuffer();
+		/** D'tor */
+        virtual ~GLRenderToVertexBuffer();
+
+        /**
+            Get the render operation for this buffer 
+        */
+        virtual void getRenderOperation(RenderOperation& op);
+
+        /**
+            Update the contents of this vertex buffer by rendering
+        */
+        virtual void update(SceneManager* sceneMgr);
+	protected:
+		void reallocateBuffer(size_t index);
+		void bindVerticesOutput(Pass* pass);
+		GLint getGLSemanticType(VertexElementSemantic semantic);
+		String getSemanticVaryingName(VertexElementSemantic semantic, unsigned short index);
+		HardwareVertexBufferSharedPtr mVertexBuffers[2];
+		size_t mFrontBufferIndex;
+		GLuint mPrimitivesDrawnQuery;
+    };
+}
+
+#endif

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

@@ -0,0 +1,66 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLSLExtSupport_H__
+#define __GLSLExtSupport_H__
+
+#include "OgreGLPrerequisites.h"
+
+//
+// OpenGL Shading Language entry points
+//
+namespace Ogre
+{
+
+	// forward declarations
+	class GLSLProgram;
+	class GLSLGpuProgram;
+	class GLSLLinkProgram;
+	class GLSLLinkProgramManager;
+	class GLSLProgramFactory;
+
+
+	/** Check for GL errors and report them in the Ogre Log.
+
+	@param forceInfoLog if true then message from GL info log is obtained
+	@param forceException if true then exception is generated if a GL error found
+	*/
+    void reportGLSLError(GLenum glErr, const String& ogreMethod, const String& errorTextPrefix, const GLhandleARB obj, const bool forceInfoLog = false, const bool forceException = false);
+
+	/** if there is a message in GL info log then post it in the Ogre Log
+	@param msg the info log message string is appended to this string
+	@param obj the GL object that is used to retrieve the info log
+	*/
+	String logObjectInfo(const String& msg, const GLhandleARB obj);
+
+
+} // namespace Ogre
+
+#endif // __GLSLExtSupport_H__

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

@@ -0,0 +1,104 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLSLGpuProgram_H__
+#define __GLSLGpuProgram_H__
+
+// Precompiler options
+#include "OgreGLSLExtSupport.h"
+#include "OgreGLGpuProgram.h"
+
+
+namespace Ogre {
+
+    /** GLSL low level compiled shader object - this class is used to get at the linked program object 
+		and provide an interface for GLRenderSystem calls.  GLSL does not provide access to the
+		low level code of the shader so this class is really just a dummy place holder.
+		GLSL uses a program object to represent the active vertex and fragment programs used
+		but Ogre materials maintain separate instances of the active vertex and fragment programs
+		which creates a small problem for GLSL integration.  The GLSLGpuProgram class provides the
+		interface between the GLSLLinkProgramManager , GLRenderSystem, and the active GLSLProgram
+		instances.
+	*/
+    class _OgreGLExport GLSLGpuProgram : public GLGpuProgram
+    {
+    private:
+		/// GL Handle for the shader object
+		GLSLProgram* mGLSLProgram;
+
+		/// Keep track of the number of vertex shaders created
+		static GLuint mVertexShaderCount;
+		/// Keep track of the number of fragment shaders created
+		static GLuint mFragmentShaderCount;
+		/// keep track of the number of geometry shaders created
+		static GLuint mGeometryShaderCount;
+
+	public:
+        GLSLGpuProgram(GLSLProgram* parent);
+		~GLSLGpuProgram();
+
+
+		/// 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);
+		/// Execute the pass iteration param binding functions for this program
+		void bindProgramPassIterationParameters(GpuProgramParametersSharedPtr params);
+
+		/// Get the assigned GL program id
+		GLuint getProgramID(void) const
+		{ return mProgramID; }
+
+		/// Get the GLSLProgram for the shader object
+		GLSLProgram* getGLSLProgram(void) const { return mGLSLProgram; }
+
+		/// @copydoc GLGpuProgram::getAttributeIndex
+		GLuint getAttributeIndex(VertexElementSemantic semantic, uint index);
+		
+		/// @copydoc GLGpuProgram::isAttributeValid
+		bool isAttributeValid(VertexElementSemantic semantic, uint index);
+		
+
+    protected:
+        /// Overridden from GpuProgram
+        void loadFromSource(void);
+		/// @copydoc Resource::unloadImpl
+		void unloadImpl(void);
+		/// @copydoc Resource::loadImpl
+		void loadImpl(void);
+
+
+    };
+
+
+}
+
+
+#endif // __GLSLGpuProgram_H__

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

@@ -0,0 +1,149 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLSLLinkProgram_H__
+#define __GLSLLinkProgram_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreGpuProgram.h"
+#include "OgreHardwareVertexBuffer.h"
+
+namespace Ogre {
+	/// Structure used to keep track of named uniforms in the linked program object
+	struct GLUniformReference
+	{
+		/// GL location handle
+		GLint  mLocation;
+		/// Which type of program params will this value come from?
+		GpuProgramType mSourceProgType;
+		/// The constant definition it relates to
+		const GpuConstantDefinition* mConstantDef;
+	};
+
+	typedef vector<GLUniformReference>::type GLUniformReferenceList;
+	typedef GLUniformReferenceList::iterator GLUniformReferenceIterator;
+
+	/** C++ encapsulation of GLSL Program Object
+
+	*/
+
+	class _OgreGLExport GLSLLinkProgram
+	{
+	private:
+		/// Container of uniform references that are active in the program object
+		GLUniformReferenceList mGLUniformReferences;
+
+		/// Linked vertex program
+		GLSLGpuProgram* mVertexProgram;
+		/// Linked geometry program
+		GLSLGpuProgram* mGeometryProgram;
+		/// Linked fragment program
+		GLSLGpuProgram* mFragmentProgram;
+
+		/// Flag to indicate that uniform references have already been built
+		bool		mUniformRefsBuilt;
+		/// GL handle for the program object
+		GLhandleARB mGLHandle;
+		/// Flag indicating that the program object has been successfully linked
+		GLint		mLinked;
+		/// Flag indicating that the program object has tried to link and failed
+		bool		mTriedToLinkAndFailed;
+		/// Flag indicating skeletal animation is being performed
+		bool mSkeletalAnimation;
+
+		/// Build uniform references from active named uniforms
+		void buildGLUniformReferences(void);
+		/// Extract attributes
+		void extractAttributes(void);
+
+		typedef set<GLuint>::type AttributeSet;
+		/// Custom attribute bindings
+		AttributeSet mValidAttributes;
+
+		/// Name / attribute list
+		struct CustomAttribute
+		{
+			String name;
+			GLuint attrib;
+			CustomAttribute(const String& _name, GLuint _attrib)
+				:name(_name), attrib(_attrib) {}
+		};
+
+		static CustomAttribute msCustomAttributes[];
+
+		String getCombinedName();		
+		/// Compiles and links the the vertex and fragment programs
+		void compileAndLink();
+		/// Get the the binary data of a program from the microcode cache
+		void getMicrocodeFromCache();
+	public:
+		/// Constructor should only be used by GLSLLinkProgramManager
+		GLSLLinkProgram(GLSLGpuProgram* vertexProgram, GLSLGpuProgram* geometryProgram, GLSLGpuProgram* fragmentProgram);
+		~GLSLLinkProgram(void);
+
+		/** Makes a program object active by making sure it is linked and then putting it in use.
+
+		*/
+		void activate(void);
+
+		/** Updates program object uniforms using data from GpuProgramParameters.
+		normally called by GLSLGpuProgram::bindParameters() just before rendering occurs.
+		*/
+		void updateUniforms(GpuProgramParametersSharedPtr params, uint16 mask, GpuProgramType fromProgType);
+		/** Updates program object uniforms using data from pass iteration GpuProgramParameters.
+		normally called by GLSLGpuProgram::bindMultiPassParameters() just before multi pass rendering occurs.
+		*/
+		void updatePassIterationUniforms(GpuProgramParametersSharedPtr params);
+		/// Get the GL Handle for the program object
+		GLhandleARB getGLHandle(void) const { return mGLHandle; }
+        /** Sets whether the linked program includes the required instructions
+        to perform skeletal animation. 
+        @remarks
+        If this is set to true, OGRE will not blend the geometry according to 
+        skeletal animation, it will expect the vertex program to do it.
+        */
+        void setSkeletalAnimationIncluded(bool included) 
+        { mSkeletalAnimation = included; }
+
+        /** Returns whether the linked program includes the required instructions
+            to perform skeletal animation. 
+        @remarks
+            If this returns true, OGRE will not blend the geometry according to 
+            skeletal animation, it will expect the vertex program to do it.
+        */
+        bool isSkeletalAnimationIncluded(void) const { return mSkeletalAnimation; }
+
+		/// Get the index of a non-standard attribute bound in the linked code
+		GLuint getAttributeIndex(VertexElementSemantic semantic, uint index);
+		/// Is a non-standard attribute bound in the linked code?
+		bool isAttributeValid(VertexElementSemantic semantic, uint index);
+
+	};
+
+}
+
+#endif // __GLSLLinkProgram_H__

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

@@ -0,0 +1,144 @@
+/*
+-----------------------------------------------------------------------------
+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 __GLSLLinkProgramManager_H__
+#define __GLSLLinkProgramManager_H__
+
+#include "OgreGLPrerequisites.h"
+#include "OgreSingleton.h"
+
+#include "OgreGLSLExtSupport.h"
+#include "OgreGLSLLinkProgram.h"
+
+namespace Ogre {
+
+
+	/** Ogre assumes that there are separate vertex and fragment programs to deal with but
+		GLSL has one program object that represents the active vertex and fragment shader objects
+		during a rendering state.  GLSL Vertex and fragment 
+		shader objects are compiled separately and then attached to a program object and then the
+		program object is linked.  Since Ogre can only handle one vertex program and one fragment
+		program being active in a pass, the GLSL Link Program Manager does the same.  The GLSL Link
+		program manager acts as a state machine and activates a program object based on the active
+		vertex and fragment program.  Previously created program objects are stored along with a unique
+		key in a hash_map for quick retrieval the next time the program object is required.
+
+	*/
+
+	class _OgreGLExport GLSLLinkProgramManager : public Singleton<GLSLLinkProgramManager>
+	{
+
+	private:
+	
+		typedef map<uint64, GLSLLinkProgram*>::type LinkProgramMap;
+		typedef LinkProgramMap::iterator LinkProgramIterator;
+
+		/// container holding previously created program objects 
+		LinkProgramMap mLinkPrograms; 
+
+		/// active objects defining the active rendering gpu state
+		GLSLGpuProgram* mActiveVertexGpuProgram;
+		GLSLGpuProgram* mActiveGeometryGpuProgram;
+		GLSLGpuProgram* mActiveFragmentGpuProgram;
+		GLSLLinkProgram* mActiveLinkProgram;
+
+		typedef map<String, GLenum>::type StringToEnumMap;
+		StringToEnumMap mTypeEnumMap;
+
+		/// Use type to complete other information
+		void completeDefInfo(GLenum gltype, GpuConstantDefinition& defToUpdate);
+		/// Find where the data for a specific uniform should come from, populate
+		bool completeParamSource(const String& paramName,
+			const GpuConstantDefinitionMap* vertexConstantDefs, 
+			const GpuConstantDefinitionMap* geometryConstantDefs,
+			const GpuConstantDefinitionMap* fragmentConstantDefs,
+			GLUniformReference& refToUpdate);
+
+	public:
+
+		GLSLLinkProgramManager(void);
+
+		~GLSLLinkProgramManager(void);
+
+		/**
+			Get the program object that links the two active shader objects together
+			if a program object was not already created and linked a new one is created and linked
+		*/
+		GLSLLinkProgram* getActiveLinkProgram(void);
+
+		/** Set the active fragment shader for the next rendering state.
+			The active program object will be cleared.
+			Normally called from the GLSLGpuProgram::bindProgram and unbindProgram methods
+		*/
+		void setActiveFragmentShader(GLSLGpuProgram* fragmentGpuProgram);
+		/** Set the active geometry shader for the next rendering state.
+			The active program object will be cleared.
+			Normally called from the GLSLGpuProgram::bindProgram and unbindProgram methods
+		*/
+		void setActiveGeometryShader(GLSLGpuProgram* geometryGpuProgram);
+		/** Set the active vertex shader for the next rendering state.
+			The active program object will be cleared.
+			Normally called from the GLSLGpuProgram::bindProgram and unbindProgram methods
+		*/
+		void setActiveVertexShader(GLSLGpuProgram* vertexGpuProgram);
+
+		/** Populate a list of uniforms based on a program object.
+		@param programObject Handle to the program object to query
+		@param vertexConstantDefs Definition of the constants extracted from the
+			vertex program, used to match up physical buffer indexes with program
+			uniforms. May be null if there is no vertex program.
+		@param geometryConstantDefs Definition of the constants extracted from the
+			geometry program, used to match up physical buffer indexes with program
+			uniforms. May be null if there is no geometry program.
+		@param fragmentConstantDefs Definition of the constants extracted from the
+			fragment program, used to match up physical buffer indexes with program
+			uniforms. May be null if there is no fragment program.
+		@param list The list to populate (will not be cleared before adding, clear
+		it yourself before calling this if that's what you want).
+		*/
+		void extractUniforms(GLhandleARB programObject, 
+			const GpuConstantDefinitionMap* vertexConstantDefs, 
+			const GpuConstantDefinitionMap* geometryConstantDefs,
+			const GpuConstantDefinitionMap* fragmentConstantDefs,
+			GLUniformReferenceList& list);
+		/** Populate a list of uniforms based on GLSL source.
+		@param src Reference to the source code
+		@param list The defs to populate (will not be cleared before adding, clear
+		it yourself before calling this if that's what you want).
+		@param filename The file name this came from, for logging errors.
+		*/
+		void extractConstantDefs(const String& src, GpuNamedConstants& constantDefs, 
+			const String& filename);
+
+		static GLSLLinkProgramManager& getSingleton(void);
+        static GLSLLinkProgramManager* getSingletonPtr(void);
+
+	};
+
+}
+
+#endif // __GLSLLinkProgramManager_H__