ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/RTShaderSystem/OgreShaderPrerequisites.h

@@ -0,0 +1,120 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+#ifndef __ShaderPrerequisites_H__
+#define __ShaderPrerequisites_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreCommon.h"
+
+namespace Ogre 
+{
+
+/// Forward declarations from Ogre namespace.
+class Technique;
+class Pass;
+class Renderable;
+class Viewport;
+class RenderObjectListener;
+class TextureUnitState;
+class Frustum;
+class ScriptTranslator;
+class ScriptCompiler;
+class PropertyAbstractNode;
+class MaterialSerializer;
+
+typedef GeneralAllocatedObject	RTShaderSystemAlloc;
+
+namespace RTShader 
+{
+
+/// Forward declarations from RTShader namespace.
+class RenderState;
+class TargetRenderState;
+class SubRenderState;
+class SubRenderStateAccessor;
+class SubRenderStateFactory;
+class ProgramManager;
+class Program;
+class ProgramProcessor;
+class ProgramSet;
+class RenderState;
+class Parameter;
+class Function;
+class FFPRenderStateBuilder;
+class ShaderGenerator;
+class SGMaterialSerializerListener;
+class ProgramWriterFactory;
+class ProgramWriterManager;
+
+/// Utility function with same style as boost::hash_combine
+template <class T>
+inline void sh_hash_combine(uint32& seed, T const& v)
+{
+	seed ^= FastHash((const char*)&v, sizeof(T)) + 0x9e3779b9 + (seed<<6) + (seed>>2);
+}
+
+// Vertex shader output parameters compact policy.
+enum VSOutputCompactPolicy
+{	
+	VSOCP_LOW		= 0,		// VS Outputs will be compacted just in case the maximum slot count exceeded.
+	VSOCP_MEDIUM	= 1,		// VS Outputs will be compacted always without parameter splits.
+	VSOCP_HIGH		= 2			// VS Outputs will be compacted always including parameter splits.
+};
+
+enum SkinningType
+{
+	ST_LINEAR,
+	ST_DUAL_QUATERNION
+};
+
+
+}
+}
+
+#if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
+#	if defined( OGRE_STATIC_LIB )
+#   	define _OgreRTSSExport
+#   else
+#   	if defined( OgreRTShaderSystem_EXPORTS )
+#       	define _OgreRTSSExport __declspec( dllexport )
+#   	else
+#           if defined( __MINGW32__ )
+#               define _OgreRTSSExport
+#           else
+#       	    define _OgreRTSSExport __declspec( dllimport )
+#           endif
+#   	endif
+#	endif
+#elif defined ( OGRE_GCC_VISIBILITY )
+#   define _OgreRTSSExport __attribute__ ((visibility("default")))
+#else
+#	define _OgreRTSSExport
+#endif 
+
+
+#endif
+

data/deps/include/OGRE/RTShaderSystem/OgreShaderProgram.h

@@ -0,0 +1,218 @@
+/*
+-----------------------------------------------------------------------------
+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 _ShaderProgram_
+#define _ShaderProgram_
+
+#include "OgreShaderPrerequisites.h"
+#include "OgreGpuProgram.h"
+#include "OgreSingleton.h"
+#include "OgreShaderParameter.h"
+#include "OgreShaderFunction.h"
+#include "OgreShaderFunctionAtom.h"
+#include "OgreStringVector.h"
+
+namespace Ogre {
+namespace RTShader {
+
+/** \addtogroup Core
+*  @{
+*/
+/** \addtogroup RTShader
+*  @{
+*/
+
+/** A class that represents a shader based program.
+*/
+class _OgreRTSSExport Program : public RTShaderSystemAlloc
+{
+
+// Interface.
+public:	
+	/** Get the type of this program. */
+	GpuProgramType				getType						() const;
+
+	/** Resolve uniform auto constant parameter with associated real data of this program.
+	@param autoType The auto type of the desired parameter.	
+	@param data The data to associate with the auto parameter.
+	@param size number of elements in the parameter.	
+	Return parameter instance in case of that resolve operation succeeded.	
+	*/
+	UniformParameterPtr		resolveAutoParameterReal	(GpuProgramParameters::AutoConstantType autoType, Real data, size_t size = 0);
+	
+	/** Resolve uniform auto constant parameter with associated real data of this program.
+	@param autoType The auto type of the desired parameter.	
+	@param type The desired data type of the auto parameter.
+	@param data The data to associate with the auto parameter.
+	@param size number of elements in the parameter.	
+	Return parameter instance in case of that resolve operation succeeded.	
+	*/
+	UniformParameterPtr		resolveAutoParameterReal	(GpuProgramParameters::AutoConstantType autoType, GpuConstantType type, Real data, size_t size = 0);
+
+	/** Resolve uniform auto constant parameter with associated int data of this program.
+	@param autoType The auto type of the desired parameter.	
+	@param data The data to associate with the auto parameter.
+	@param size number of elements in the parameter.	
+	Return parameter instance in case of that resolve operation succeeded.	
+	*/
+	UniformParameterPtr		resolveAutoParameterInt		(GpuProgramParameters::AutoConstantType autoType, size_t data, size_t size = 0);
+	
+	/** Resolve uniform auto constant parameter with associated int data of this program.
+	@param autoType The auto type of the desired parameter.
+	@param type The desired data type of the auto parameter.
+	@param data The data to associate with the auto parameter.
+	@param size number of elements in the parameter.
+	Return parameter instance in case of that resolve operation succeeded.	
+	*/
+	UniformParameterPtr		resolveAutoParameterInt		(GpuProgramParameters::AutoConstantType autoType, GpuConstantType type, size_t data, size_t size = 0);
+
+	/** Resolve uniform parameter of this program.
+	@param type The type of the desired parameter.
+	@param index The index of the desired parameter.
+	@param suggestedName The suggested name for the parameter in case new one should be create.	
+	@param variability How this parameter varies (bitwise combination of GpuProgramVariability).
+	@param size number of elements in the parameter.	
+	Return parameter instance in case of that resolve operation succeeded.
+	@remarks Pass -1 as index parameter to create a new parameter with the desired type and index.
+	*/
+	UniformParameterPtr		resolveParameter			(GpuConstantType type, int index, uint16 variability, const String& suggestedName, size_t size = 0);
+	
+	/** Get parameter by a given name.	
+	@param name The name of the parameter to search for.
+	@remarks Return NULL if no matching parameter found.
+	*/
+	UniformParameterPtr		getParameterByName			(const String& name);
+
+	/** Get parameter by a given auto constant type.	
+	@param autoType The auto type of the parameter to search for.
+	@remarks Return NULL if no matching parameter found.
+	*/
+	UniformParameterPtr		getParameterByAutoType		(GpuProgramParameters::AutoConstantType autoType);
+
+	/** Get parameter by a given type and index.	
+	@param type The type of the parameter to search for.
+	@param index The index of the parameter to search for.
+	@remarks Return NULL if no matching parameter found.
+	*/
+	UniformParameterPtr		getParameterByType			(GpuConstantType type, int index);
+
+	/** Get the list of uniform parameters of this program.
+	*/
+	const UniformParameterList&	getParameters		() const { return mParameters; };
+
+	/** Create new function in this program. Return the newly created function instance.
+	@param name The name of the function to create.
+	@param desc The description of the function.
+	*/
+	Function*					createFunction				(const String& name, const String& desc, const Function::FunctionType functionType);
+
+	/** Get a function by a given name. Return NULL if no matching function found.
+	@param name The name of the function to search for.
+	*/
+	Function*					getFunctionByName			(const String& name);
+
+	/** Get the function list of this program.
+	*/
+	const ShaderFunctionList&	getFunctions				() const { return mFunctions; };
+
+	/** Set the entry point function.
+	@param function The function that will use as entry point of this program.
+	*/
+	void						setEntryPointFunction		(Function* function) { mEntryPointFunction = function; }
+
+	/** Get the entry point function of this program.*/
+	Function*					getEntryPointFunction		()					 { return mEntryPointFunction; }
+
+	/** Add dependency for this program. Basically a filename that will be included in this
+	program and provide predefined shader functions code.
+	One should verify that the given library file he provides can be reached by the resource manager.
+	This step can be achieved using the ResourceGroupManager::addResourceLocation method.
+	*/
+	void						addDependency				(const String& libFileName);
+
+	/** Get the number of external libs this program depends on */
+	size_t						getDependencyCount			() const;
+
+	/** Get the library name of the given index dependency.
+	@param index The index of the dependecy.
+	*/
+	const String&				getDependency				(unsigned int index) const;
+	
+
+	/** Sets whether a vertex program includes the required instructions
+        to perform skeletal animation. 
+    */
+ 	void setSkeletalAnimationIncluded(bool value) { mSkeletalAnimation = value; }
+ 
+	/** Returns whether a vertex program includes the required instructions
+        to perform skeletal animation. 
+    */
+    bool getSkeletalAnimationIncluded() const { return mSkeletalAnimation; }
+
+// Protected methods.
+protected:
+
+	/** Class constructor.
+	@param type The type of this program.
+	*/
+	Program			(GpuProgramType type);
+
+	/** Class destructor */
+	~Program		();
+
+	/** Destroy all parameters of this program. */
+	void						destroyParameters	();
+
+	/** Destroy all functions of this program. */
+	void						destroyFunctions	();
+
+	/** Add parameter to this program. */
+	void						addParameter				(UniformParameterPtr parameter);
+		
+	/** Remove parameter from this program. */
+	void						removeParameter				(UniformParameterPtr parameter);
+
+
+// Attributes.
+protected:
+	GpuProgramType					mType;						// Program type. (Vertex, Fragment, Geometry).
+	UniformParameterList			mParameters;				// Program uniform parameters.	
+	ShaderFunctionList				mFunctions;					// Function list.
+	Function*						mEntryPointFunction;		// Entry point function for this program.	
+	StringVector					mDependencies;				// Program dependencies.
+	bool							mSkeletalAnimation;			// Skeletal animation calculation
+private:
+	friend class ProgramManager;
+};
+
+/** @} */
+/** @} */
+
+}
+}
+
+#endif
+

data/deps/include/OGRE/RTShaderSystem/OgreShaderProgramManager.h

@@ -0,0 +1,236 @@
+/*
+-----------------------------------------------------------------------------
+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 _ShaderProgramManager_
+#define _ShaderProgramManager_
+
+#include "OgreShaderPrerequisites.h"
+#include "OgreShaderProgram.h"
+#include "OgreShaderProgramWriter.h"
+
+namespace Ogre {	
+namespace RTShader {
+
+/** \addtogroup Core
+*  @{
+*/
+/** \addtogroup RTShader
+*  @{
+*/
+
+/** A singleton manager class that manages shader based programs.
+*/
+class _OgreRTSSExport ProgramManager : public Singleton<ProgramManager>, public RTShaderSystemAlloc
+{
+// Interface.
+public:
+
+	/** Class default constructor */
+	ProgramManager	();
+
+	/** Class destructor */
+	~ProgramManager	();
+
+
+	/** Override standard Singleton retrieval.
+	@remarks
+	Why do we do this? Well, it's because the Singleton
+	implementation is in a .h file, which means it gets compiled
+	into anybody who includes it. This is needed for the
+	Singleton template to work, but we actually only want it
+	compiled into the implementation of the class based on the
+	Singleton, not all of them. If we don't change this, we get
+	link errors when trying to use the Singleton-based class from
+	an outside dll.
+	@par
+	This method just delegates to the template version anyway,
+	but the implementation stays in this single compilation unit,
+	preventing link errors.
+	*/
+	static ProgramManager&			getSingleton	();	
+
+	/** Override standard Singleton retrieval.
+	@remarks
+	Why do we do this? Well, it's because the Singleton
+	implementation is in a .h file, which means it gets compiled
+	into anybody who includes it. This is needed for the
+	Singleton template to work, but we actually only want it
+	compiled into the implementation of the class based on the
+	Singleton, not all of them. If we don't change this, we get
+	link errors when trying to use the Singleton-based class from
+	an outside dll.
+	@par
+	This method just delegates to the template version anyway,
+	but the implementation stays in this single compilation unit,
+	preventing link errors.
+	*/
+	static ProgramManager*			getSingletonPtr				();
+
+	/** Acquire CPU/GPU programs set associated with the given render state and bind them to the pass.
+	@param pass The pass to bind the programs to.
+	@param renderState The render state that describes the program that need to be generated.
+	*/
+	void							acquirePrograms			(Pass* pass, TargetRenderState* renderState);
+
+	/** Release CPU/GPU programs set associated with the given render state and pass.
+	@param pass The pass to release the programs from.
+	@param renderState The render state holds the programs.
+	*/
+	void							releasePrograms			(Pass* pass, TargetRenderState* renderState);
+
+	/** Flush the local GPU programs cache.
+	*/
+	void							flushGpuProgramsCache	();
+
+protected:
+
+	//-----------------------------------------------------------------------------
+	typedef map<String, GpuProgramPtr>::type			GpuProgramsMap;
+	typedef GpuProgramsMap::iterator					GpuProgramsMapIterator;
+	typedef GpuProgramsMap::const_iterator				GpuProgramsMapConstIterator;
+
+	//-----------------------------------------------------------------------------
+	typedef set<Program*>::type							ProgramList;
+	typedef ProgramList::iterator						ProgramListIterator;
+	typedef map<String, ProgramWriter*>::type			ProgramWriterMap;
+	typedef ProgramWriterMap::iterator					ProgramWriterIterator;
+	typedef vector<ProgramWriterFactory*>::type			ProgramWriterFactoryList;
+	
+	//-----------------------------------------------------------------------------
+	typedef map<String, ProgramProcessor*>::type 		ProgramProcessorMap;
+	typedef ProgramProcessorMap::iterator 				ProgramProcessorIterator;
+	typedef ProgramProcessorMap::const_iterator			ProgramProcessorConstIterator;
+	typedef vector<ProgramProcessor*>::type 			ProgramProcessorList;
+
+	
+protected:
+	/** Create default program processors. */
+	void			createDefaultProgramProcessors	();
+	
+	/** Destroy default program processors. */
+	void			destroyDefaultProgramProcessors	();
+
+	/** Create default program processors. */
+	void			createDefaultProgramWriterFactories	();
+
+	/** Destroy default program processors. */
+	void			destroyDefaultProgramWriterFactories();
+
+	/** Destroy all program writers. */
+	void			destroyProgramWriters	();
+
+	/** Create CPU program . 	
+	@param type The type of the program to create.
+	*/
+	Program*		createCpuProgram		(GpuProgramType type);
+
+	/** Destroy a CPU program by name.
+	@param shaderProgram The CPU program instance to destroy.
+	*/
+	void			destroyCpuProgram		(Program* shaderProgram);
+
+	/** Create GPU programs for the given program set based on the CPU programs it contains.
+	@param programSet The program set container.
+	*/
+	bool			createGpuPrograms		(ProgramSet* programSet);
+
+	/** Create GPU program based on the give CPU program.
+	@param shaderProgram The CPU program instance.
+	@param programWriter The program writer instance.
+	@param language The target shader language.
+	@param profiles The profiles string for program compilation.
+	@param profiles The profiles string for program compilation as string list.
+	@param cachePath The output path to write the program into.
+	*/
+	GpuProgramPtr	createGpuProgram		(Program* shaderProgram, 
+		ProgramWriter* programWriter,
+		const String& language,
+		const String& profiles,
+		const StringVector& profilesList,
+		const String& cachePath);
+
+	/** 
+	Add program processor instance to this manager.
+	@param processor The instance to add.
+	*/
+	void			addProgramProcessor		(ProgramProcessor* processor);
+
+	/** 
+	Remove program processor instance from this manager. 
+	@param processor The instance to remove.
+	*/
+	void			removeProgramProcessor	(ProgramProcessor* processor);
+
+	/** Destroy a GPU program by name.
+	@param name The name of the program to destroy.
+	@param type The type of the program to destroy.
+	*/
+	void			destroyGpuProgram		(GpuProgramPtr& gpuProgram);
+
+	/** Flush the local GPU programs cache.
+	@param gpuProgramsMap The GPU programs cache.
+	*/
+	void			flushGpuProgramsCache	(GpuProgramsMap& gpuProgramsMap);
+	
+	/** Return the number of created vertex shaders. */
+	size_t			getVertexShaderCount		() const { return mVertexShaderMap.size(); }
+
+	/** Return the number of created fragment shaders. */
+	size_t			getFragmentShaderCount		() const { return mFragmentShaderMap.size(); }
+
+	/** Fix the input of the pixel shader to be the same as the output of the vertex shader */
+	void			synchronizePixelnToBeVertexOut	(ProgramSet* programSet);
+
+	/** Bind the uniform parameters of a given CPU and GPU program set. */
+	void			bindUniformParameters			(Program* pCpuProgram, const GpuProgramParametersSharedPtr& passParams);
+
+
+protected:
+	
+
+protected:
+	ProgramList					mCpuProgramsList;				// CPU programs list.					
+	ProgramWriterMap			mProgramWritersMap;				// Map between target language and shader program writer.					
+	ProgramProcessorMap			mProgramProcessorsMap;			// Map between target language and shader program processor.	
+	ProgramWriterFactoryList	mProgramWriterFactories;		// Holds standard shader writer factories
+	GpuProgramsMap				mVertexShaderMap;				// The generated vertex shaders.
+	GpuProgramsMap				mFragmentShaderMap;				// The generated fragment shaders.
+	ProgramProcessorList		mDefaultProgramProcessors;		// The default program processors.
+
+private:
+	friend class ProgramSet;
+	friend class TargetRenderState;
+	friend class ShaderGenerator;
+};
+
+/** @} */
+/** @} */
+
+}
+}
+
+#endif
+