ruby-ogre 0.0.1-x86-linux

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

@@ -0,0 +1,227 @@
+/*
+-----------------------------------------------------------------------------
+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 _ShaderProgramFunction_
+#define _ShaderProgramFunction_
+
+#include "OgreShaderPrerequisites.h"
+#include "OgreShaderParameter.h"
+#include "OgreShaderFunctionAtom.h"
+
+namespace Ogre {
+namespace RTShader {
+
+/** \addtogroup Core
+*  @{
+*/
+/** \addtogroup RTShader
+*  @{
+*/
+
+/** A class that represents a shader based program function.
+*/
+class _OgreRTSSExport Function : public RTShaderSystemAlloc
+{
+// Interface.
+public:
+	enum FunctionType
+	{
+		// internal function (default)
+		FFT_INTERNAL,
+		// Vertex program main
+		FFT_VS_MAIN,
+		// Pixel shader main
+		FFT_PS_MAIN
+	};
+
+	/** Get the name of this function */
+	const String&				getName					() const { return mName; }
+
+	/** Get the description of this function */
+	const String&				getDescription			() const { return mDescription; }
+
+	/** Resolve input parameter of this function
+	@param semantic The desired parameter semantic.
+	@param index The index of the desired parameter.
+	@param content The content of the parameter.
+	@param type The type of the desired 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 semantic and type.
+	*/
+	ParameterPtr				resolveInputParameter	(Parameter::Semantic semantic, int index,  const Parameter::Content content, GpuConstantType type);
+
+
+	/** Resolve output parameter of this function
+	@param semantic The desired parameter semantic.	
+	@param index The index of the desired parameter.
+	@param content The content of the parameter.
+	@param type The type of the desired 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 semantic and type.
+	*/
+	ParameterPtr				resolveOutputParameter	(Parameter::Semantic semantic, int index,  const Parameter::Content content, GpuConstantType type);
+
+	/** Resolve local parameter of this function	
+	@param semantic The desired parameter semantic.	
+	@param index The index of the desired parameter.
+	@param name The name of the parameter.
+	@param type The type of the desired parameter.	
+	Return parameter instance in case of that resolve operation succeeded.
+	*/
+	ParameterPtr				resolveLocalParameter	(Parameter::Semantic semantic, int index, const String& name, GpuConstantType type);
+
+	/** Resolve local parameter of this function	
+	@param semantic The desired parameter semantic.	
+	@param index The index of the desired parameter.
+	@param content The content of the parameter.
+	@param type The type of the desired parameter.	
+	Return parameter instance in case of that resolve operation succeeded.
+	*/
+	ParameterPtr				resolveLocalParameter	(Parameter::Semantic semantic, int index, const Parameter::Content content, GpuConstantType type);
+	
+
+	/** 
+	Get parameter by a given name from the given parameter list.
+	@param parameterList The parameters list to look in.
+	@param name The name of the parameter to search in the list.
+	@remarks Return NULL if no matching parameter found.
+	*/
+	static ParameterPtr				getParameterByName		(const ShaderParameterList& parameterList, const String& name);
+
+	/** 
+	Get parameter by a given semantic and index from the given parameter list.
+	@param parameterList The parameters list to look in.
+	@param semantic The semantic of the parameter to search in the list.
+	@param index The index of the parameter to search in the list.
+	@remarks Return NULL if no matching parameter found.
+	*/
+	static ParameterPtr				getParameterBySemantic	(const ShaderParameterList& parameterList, const Parameter::Semantic semantic, int index);
+
+
+	/** 
+	Get parameter by a given content and type from the given parameter list.
+	@param parameterList The parameters list to look in.
+	@param content The content of the parameter to search in the list.
+	@param type The type of the parameter to search in the list.
+	@remarks Return NULL if no matching parameter found.
+	*/
+	ParameterPtr					getParameterByContent	(const ShaderParameterList& parameterList, const Parameter::Content content, GpuConstantType type);
+
+	/** Return a list of input parameters. */
+	const ShaderParameterList&		getInputParameters		() const { return mInputParameters; }	
+
+	/** Return a list of output parameters. */
+	const ShaderParameterList&		getOutputParameters		() const { return mOutputParameters; }
+
+	/** Return a list of local parameters. */
+	const ShaderParameterList&		getLocalParameters		() const { return mLocalParameters; }	
+	
+	/** Add a function atom instance to this function. 
+	@param atomInstance The atom instance to add.
+	*/
+	void							addAtomInstance			(FunctionAtom* atomInstance);
+
+	/** Delete a function atom instance from this function. 
+	@param atomInstance The atom instance to OGRE_DELETE.
+	*/
+	bool							deleteAtomInstance		(FunctionAtom* atomInstance);
+
+	/** Sort all atom instances of this function. */
+	void							sortAtomInstances		();
+
+	/** Return list of atom instances composing this function. */
+	FunctionAtomInstanceList&		getAtomInstances		() { return mAtomInstances; }
+
+	/** Return list of atom instances composing this function. (Const version) */
+	const FunctionAtomInstanceList&	getAtomInstances		() const { return mAtomInstances; }
+
+	/** Add input parameter to this function. */
+	void						addInputParameter			(ParameterPtr parameter);
+
+	/** Add output parameter to this function. */
+	void						addOutputParameter			(ParameterPtr parameter);
+
+	/** Delete input parameter from this function. */
+	void						deleteInputParameter		(ParameterPtr parameter);
+
+	/** Delete output parameter from this function. */
+	void						deleteOutputParameter		(ParameterPtr parameter);
+
+	/** Delete all input parameters from this function. */
+	void						deleteAllInputParameters	();
+
+	/** Delete all output parameters from this function. */
+	void						deleteAllOutputParameters	();
+
+	/** get function type. */
+	FunctionType getFunctionType() const;
+
+
+protected:
+
+	/** Class constructor.
+	@param name The name of this function.
+	@param desc The description of this function.
+	@remarks This class is allocated via an instance of Program class. 
+	*/
+	Function			(const String& name, const String& desc, const FunctionType functionType);
+
+	/** Class destructor */
+	~Function			();
+
+	/** Add parameter to given list */
+	void						addParameter				(ShaderParameterList& parameterList, ParameterPtr parameter);
+
+	/** Delete parameter from a given list */
+	void						deleteParameter				(ShaderParameterList& parameterList, ParameterPtr parameter);
+
+	/** Function atom comparison function used to sort atoms. */
+	static int					sAtomInstanceCompare		(const void * p0, const void *p1);
+
+protected:
+	String						mName;						// Function name.
+	String						mDescription;				// Function description.
+	ShaderParameterList			mInputParameters;			// Input parameters.
+	ShaderParameterList			mOutputParameters;			// Output parameters.
+	ShaderParameterList			mLocalParameters;			// Local parameters.
+	FunctionAtomInstanceList	mAtomInstances;				// Atom instances composing this function.
+	FunctionType				mFunctionType;				// Function type
+	
+private:
+	friend class Program;
+};
+
+typedef vector<Function*>::type						ShaderFunctionList;
+typedef ShaderFunctionList::iterator 				ShaderFunctionIterator;
+typedef ShaderFunctionList::const_iterator			ShaderFunctionConstIterator;
+
+/** @} */
+/** @} */
+
+}
+}
+
+#endif

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

@@ -0,0 +1,250 @@
+/*
+-----------------------------------------------------------------------------
+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 _ShaderFunctionAtom_
+#define _ShaderFunctionAtom_
+
+#include "OgreShaderPrerequisites.h"
+#include "OgreGpuProgram.h"
+#include "OgreSingleton.h"
+#include "OgreShaderParameter.h"
+#include "OgreStringVector.h"
+
+namespace Ogre {
+namespace RTShader {
+
+/** \addtogroup Core
+*  @{
+*/
+/** \addtogroup RTShader
+*  @{
+*/
+
+/** A class that represents an atomic code section of shader based program function.
+*/
+class _OgreRTSSExport FunctionAtom : public RTShaderSystemAlloc
+{
+// Interface.
+public:
+	/** Class default constructor. */
+	FunctionAtom			();
+
+	/** Class default destructor. */
+	virtual ~FunctionAtom	() {}
+
+	/** Get the group execution order of this function atom. */
+	int						getGroupExecutionOrder		() const;
+	
+	/** Get an internal execution order within a group of this function atom. */
+	int						getInternalExecutionOrder	() const;
+	
+	/** Abstract method that writes a source code to the given output stream in the target shader language. */
+	virtual void			writeSourceCode				(std::ostream& os, const String& targetLanguage) const = 0;
+	
+	/** Return the type of this atom instance implementation. */
+	virtual const String&	getFunctionAtomType			() = 0;
+
+// Attributes.
+protected:
+	int			mGroupExecutionOrder;		// The owner group execution order.	
+	int			mInternalExecutionOrder;		// The execution order within the group.		
+};
+
+/** A class that represents a function operand (its the combination of a parameter the in/out semantic and the used fields)
+*/
+class _OgreRTSSExport Operand : public RTShaderSystemAlloc
+{
+public:
+
+	// InOut semantic
+	enum OpSemantic
+	{
+		/// The parameter is a input parameter
+		OPS_IN, 
+		/// The parameter is a output parameter
+		OPS_OUT,
+		/// The parameter is a input/output parameter
+		OPS_INOUT
+	};
+
+	// Used field mask
+	enum OpMask
+	{
+		OPM_ALL = 1 << 0,
+		OPM_X	= 1 << 1,
+		OPM_Y	= 1 << 2,
+		OPM_Z	= 1 << 3,
+		OPM_W	= 1 << 4
+	};
+
+	/** Class constructor 
+	@param parameter A function parameter.
+	@param opSemantic The in/out semantic of the parameter.
+	@param opMask The field mask of the parameter.
+	*/
+	Operand(ParameterPtr parameter, Operand::OpSemantic opSemantic, int opMask = Operand::OPM_ALL, ushort indirectionLevel = 0);
+
+	/** Copy constructor */
+	Operand(const Operand& rhs);
+
+	/** Copy the given Operand to this Operand.
+	@param rhs The other Operand to copy to this state.
+	*/
+	Operand& operator= (const Operand & rhs);
+
+	/** Class destructor */
+	~Operand();
+
+	/** Returns the parameter object as weak reference */
+	const ParameterPtr& getParameter	()	const { return mParameter; }
+
+	/** Returns true if not all fields used. (usage is described through semantic)*/
+	bool				hasFreeFields	()	const { return ((mMask & ~OPM_ALL) && ((mMask & ~OPM_X) || (mMask & ~OPM_Y) || (mMask & ~OPM_Z) || (mMask & ~OPM_W))); }
+	
+	/** Returns the mask bitfield. */
+	int					getMask			()	const { return mMask; }
+
+	/** Returns the operand semantic (do we read/write or both with the parameter). */
+	OpSemantic			getSemantic		()	const { return mSemantic; }
+
+	/** Returns the level of indirection. 
+	The greater the indirection level the more the parameter needs to be nested in brackets.
+	For example given 4 parameters x1...x4 with the indirections levels 0,1,1,2 
+	respectively. The parameters should form the following string: x1[x2][x3[x4]].
+	*/
+	ushort				getIndirectionLevel()	const { return mIndirectionLevel; }
+
+	/** Returns the parameter name and the usage mask like this 'color.xyz' */
+	String				toString		()	const;
+
+	/** Returns the given mask as string representation. */
+	static String				getMaskAsString		(int mask);
+
+	/** Return the float count of the given mask. */
+	static int					getFloatCount		(int mask);
+
+	/** Return the gpu constant type of the given mask. */
+	static GpuConstantType		getGpuConstantType	(int mask);
+
+protected:
+	ParameterPtr	mParameter;			/// The parameter being carried by the operand
+	OpSemantic		mSemantic;			/// Tells if the parameter is of type input,output or both
+	int				mMask;				/// Which part of the parameter should be passed (x,y,z,w)
+	ushort			mIndirectionLevel;  /// The level of indirection. @see getIndirectionLevel
+};
+
+/** A class that represents function invocation code from shader based program function.
+*/
+class _OgreRTSSExport FunctionInvocation : public FunctionAtom
+{
+	// Interface.
+public:	
+	typedef vector<Operand>::type OperandVector;
+
+	/** Class constructor 
+	@param functionName The name of the function to invoke.
+	@param groupOrder The group order of this invocation.
+	@param internalOrder The internal order of this invocation.
+	@param returnType The return type of the used function.
+	*/
+	FunctionInvocation(const String& functionName, int groupOrder, int internalOrder, String returnType = "void");
+
+    /** Copy constructor */
+	FunctionInvocation(const FunctionInvocation& rhs);
+
+	/** 
+	@see FunctionAtom::writeSourceCode
+	*/
+	virtual void			writeSourceCode	(std::ostream& os, const String& targetLanguage) const;
+
+	/** 
+	@see FunctionAtom::getFunctionAtomType
+	*/
+	virtual const String&	getFunctionAtomType () { return Type; }
+
+	/** Get a list of parameters this function invocation will use in the function call as arguments. */
+	OperandVector&			getOperandList	() { return mOperands; }
+	
+	/** Push a new operand (on the end) to the function. 
+	@param parameter A function parameter.
+	@param opSemantic The in/out semantic of the parameter.
+	@param opMask The field mask of the parameter.
+	@param indirectionLevel The level of nesting inside brackets
+	*/
+	void					pushOperand(ParameterPtr parameter, Operand::OpSemantic opSemantic, int opMask = Operand::OPM_ALL, int indirectionLevel = 0);
+
+	/** Return the function name */
+	const String&			getFunctionName	() const { return mFunctionName; }
+
+	/** Return the return type */
+	const String&			getReturnType	() const { return mReturnType; }
+
+    /** Determines if the current object is equal to the compared one. */
+    bool operator == ( const FunctionInvocation& rhs ) const;
+
+    /** Determines if the current object is not equal to the compared one. */
+    bool operator != ( const FunctionInvocation& rhs ) const;
+
+    /** Determines if the current object is less than the compared one. */
+    bool operator <  ( const FunctionInvocation& rhs ) const;
+
+    /** Comparator function to be used for sorting.
+        Implemented as a struct to make it easier for the compiler to inline
+    */
+    struct FunctionInvocationLessThan
+    {
+        bool operator ()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const;
+    };
+
+    /** Comparator function to be used for comparisons.
+        Implemented as a struct to make it easier for the compiler to inline
+    */
+    struct FunctionInvocationCompare
+    {
+        bool operator ()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const;
+    };
+
+	/// The type of this class.
+	static String Type;
+
+	// Attributes.
+protected:	
+	String				mFunctionName;
+	String				mReturnType;
+	OperandVector		mOperands;	
+};
+
+typedef vector<FunctionAtom*>::type					FunctionAtomInstanceList;
+typedef FunctionAtomInstanceList::iterator 			FunctionAtomInstanceIterator;
+typedef FunctionAtomInstanceList::const_iterator	FunctionAtomInstanceConstIterator;
+
+/** @} */
+/** @} */
+
+}
+}
+
+#endif

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

@@ -0,0 +1,92 @@
+/*
+-----------------------------------------------------------------------------
+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 _ShaderGLSLESProgramProcessor_
+#define _ShaderGLSLESProgramProcessor_
+
+#include "OgreShaderPrerequisites.h"
+#include "OgreShaderProgramProcessor.h"
+#include "OgreStringVector.h"
+
+namespace Ogre {
+namespace RTShader {
+
+/** \addtogroup Core
+*  @{
+*/
+/** \addtogroup RTShader
+*  @{
+*/
+
+/** GLSL ES Language program processor class.
+*/
+class GLSLESProgramProcessor : public ProgramProcessor
+{
+
+// Interface.
+public:	
+
+	/** Class constructor.
+	@param type The type of this program.
+	*/
+	GLSLESProgramProcessor			();
+
+	/** Class destructor */
+	virtual ~GLSLESProgramProcessor ();
+
+	/** Return the target language of this processor. */
+	virtual const String&           getTargetLanguage	() const { return TargetLanguage; }
+
+	/** 
+	@see ProgramProcessor::preCreateGpuPrograms
+    */
+	virtual bool                    preCreateGpuPrograms			(ProgramSet* programSet);
+
+	/** 
+	@see ProgramProcessor::postCreateGpuPrograms
+	*/
+	virtual bool                    postCreateGpuPrograms			(ProgramSet* programSet);
+
+
+private:
+
+	/** Bind texture samplers. */
+	void                            bindTextureSamplers				(Program* pCpuProgram, GpuProgramPtr pGpuProgram);
+
+	static String                   TargetLanguage;
+
+	StringVector                    mLibraryPrograms;		// The list of created library shaders.
+};
+
+
+/** @} */
+/** @} */
+
+}
+}
+
+#endif
+