ruby-ogre 0.0.3-x86-linux → 0.0.4-x86-linux

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

@@ -58,10 +58,10 @@ public:
 	};
 
 	/** Get the name of this function */
-	const String&				getName					() const { return mName; }
+	const String& getName() const { return mName; }
 
 	/** Get the description of this function */
-	const String&				getDescription			() const { return mDescription; }
+	const String& getDescription() const { return mDescription; }
 
 	/** Resolve input parameter of this function
 	@param semantic The desired parameter semantic.
@@ -71,7 +71,7 @@ public:
 	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);
+	ParameterPtr resolveInputParameter(Parameter::Semantic semantic, int index,  const Parameter::Content content, GpuConstantType type);
 
 
 	/** Resolve output parameter of this function
@@ -82,7 +82,7 @@ public:
 	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);
+	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.	
@@ -91,7 +91,7 @@ public:
 	@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);
+	ParameterPtr resolveLocalParameter(Parameter::Semantic semantic, int index, const String& name, GpuConstantType type);
 
 	/** Resolve local parameter of this function	
 	@param semantic The desired parameter semantic.	
@@ -100,7 +100,7 @@ public:
 	@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);
+	ParameterPtr resolveLocalParameter(Parameter::Semantic semantic, int index, const Parameter::Content content, GpuConstantType type);
 	
 
 	/** 
@@ -109,7 +109,7 @@ public:
 	@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);
+	static ParameterPtr getParameterByName(const ShaderParameterList& parameterList, const String& name);
 
 	/** 
 	Get parameter by a given semantic and index from the given parameter list.
@@ -118,7 +118,7 @@ public:
 	@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);
+	static ParameterPtr getParameterBySemantic(const ShaderParameterList& parameterList, const Parameter::Semantic semantic, int index);
 
 
 	/** 
@@ -128,53 +128,53 @@ public:
 	@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);
+	ParameterPtr getParameterByContent(const ShaderParameterList& parameterList, const Parameter::Content content, GpuConstantType type);
 
 	/** Return a list of input parameters. */
-	const ShaderParameterList&		getInputParameters		() const { return mInputParameters; }	
+	const ShaderParameterList& getInputParameters() const { return mInputParameters; }	
 
 	/** Return a list of output parameters. */
-	const ShaderParameterList&		getOutputParameters		() const { return mOutputParameters; }
+	const ShaderParameterList& getOutputParameters() const { return mOutputParameters; }
 
 	/** Return a list of local parameters. */
-	const ShaderParameterList&		getLocalParameters		() const { return mLocalParameters; }	
+	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);
+	void addAtomInstance(FunctionAtom* atomInstance);
 
 	/** Delete a function atom instance from this function. 
 	@param atomInstance The atom instance to OGRE_DELETE.
 	*/
-	bool							deleteAtomInstance		(FunctionAtom* atomInstance);
+	bool deleteAtomInstance(FunctionAtom* atomInstance);
 
 	/** Sort all atom instances of this function. */
-	void							sortAtomInstances		();
+	void sortAtomInstances();
 
 	/** Return list of atom instances composing this function. */
-	FunctionAtomInstanceList&		getAtomInstances		() { return mAtomInstances; }
+	FunctionAtomInstanceList& getAtomInstances() { return mAtomInstances; }
 
 	/** Return list of atom instances composing this function. (Const version) */
-	const FunctionAtomInstanceList&	getAtomInstances		() const { return mAtomInstances; }
+	const FunctionAtomInstanceList& getAtomInstances() const { return mAtomInstances; }
 
 	/** Add input parameter to this function. */
-	void						addInputParameter			(ParameterPtr parameter);
+	void addInputParameter(ParameterPtr parameter);
 
 	/** Add output parameter to this function. */
-	void						addOutputParameter			(ParameterPtr parameter);
+	void addOutputParameter(ParameterPtr parameter);
 
 	/** Delete input parameter from this function. */
-	void						deleteInputParameter		(ParameterPtr parameter);
+	void deleteInputParameter(ParameterPtr parameter);
 
 	/** Delete output parameter from this function. */
-	void						deleteOutputParameter		(ParameterPtr parameter);
+	void deleteOutputParameter(ParameterPtr parameter);
 
 	/** Delete all input parameters from this function. */
-	void						deleteAllInputParameters	();
+	void deleteAllInputParameters();
 
 	/** Delete all output parameters from this function. */
-	void						deleteAllOutputParameters	();
+	void deleteAllOutputParameters();
 
 	/** get function type. */
 	FunctionType getFunctionType() const;
@@ -187,28 +187,35 @@ protected:
 	@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);
+	Function(const String& name, const String& desc, const FunctionType functionType);
 
 	/** Class destructor */
-	~Function			();
+	~Function();
 
 	/** Add parameter to given list */
-	void						addParameter				(ShaderParameterList& parameterList, ParameterPtr parameter);
+	void addParameter(ShaderParameterList& parameterList, ParameterPtr parameter);
 
 	/** Delete parameter from a given list */
-	void						deleteParameter				(ShaderParameterList& parameterList, ParameterPtr parameter);
+	void deleteParameter(ShaderParameterList& parameterList, ParameterPtr parameter);
 
 	/** Function atom comparison function used to sort atoms. */
-	static int					sAtomInstanceCompare		(const void * p0, const void *p1);
+	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
+	// Function name.
+	String mName;
+	// Function description.
+	String mDescription;
+	// Input parameters.
+	ShaderParameterList mInputParameters;
+	// Output parameters.
+	ShaderParameterList mOutputParameters;
+	// Local parameters.
+	ShaderParameterList mLocalParameters;
+	// Atom instances composing this function.
+	FunctionAtomInstanceList mAtomInstances;
+	// Function type
+	FunctionType mFunctionType;
 	
 private:
 	friend class Program;

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

@@ -50,27 +50,29 @@ class _OgreRTSSExport FunctionAtom : public RTShaderSystemAlloc
 // Interface.
 public:
 	/** Class default constructor. */
-	FunctionAtom			();
+	FunctionAtom();
 
 	/** Class default destructor. */
-	virtual ~FunctionAtom	() {}
+	virtual ~FunctionAtom() {}
 
 	/** Get the group execution order of this function atom. */
-	int						getGroupExecutionOrder		() const;
+	int getGroupExecutionOrder() const;
 	
 	/** Get an internal execution order within a group of this function atom. */
-	int						getInternalExecutionOrder	() const;
+	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;
+	virtual void writeSourceCode(std::ostream& os, const String& targetLanguage) const = 0;
 	
 	/** Return the type of this atom instance implementation. */
-	virtual const String&	getFunctionAtomType			() = 0;
+	virtual const String& getFunctionAtomType() = 0;
 
 // Attributes.
 protected:
-	int			mGroupExecutionOrder;		// The owner group execution order.	
-	int			mInternalExecutionOrder;		// The execution order within the group.		
+	// The owner group execution order.	
+	int mGroupExecutionOrder;
+	// The execution order within the group.		
+	int mInternalExecutionOrder;
 };
 
 /** A class that represents a function operand (its the combination of a parameter the in/out semantic and the used fields)
@@ -119,41 +121,45 @@ public:
 	~Operand();
 
 	/** Returns the parameter object as weak reference */
-	const ParameterPtr& getParameter	()	const { return mParameter; }
+	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))); }
+	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; }
+	int getMask()	const { return mMask; }
 
 	/** Returns the operand semantic (do we read/write or both with the parameter). */
-	OpSemantic			getSemantic		()	const { return mSemantic; }
+	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; }
+	ushort getIndirectionLevel()	const { return mIndirectionLevel; }
 
 	/** Returns the parameter name and the usage mask like this 'color.xyz' */
-	String				toString		()	const;
+	String toString()	const;
 
 	/** Returns the given mask as string representation. */
-	static String				getMaskAsString		(int mask);
+	static String getMaskAsString(int mask);
 
 	/** Return the float count of the given mask. */
-	static int					getFloatCount		(int mask);
+	static int getFloatCount(int mask);
 
 	/** Return the gpu constant type of the given mask. */
-	static GpuConstantType		getGpuConstantType	(int 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
+	/// The parameter being carried by the operand
+	ParameterPtr mParameter;
+	/// Tells if the parameter is of type input,output or both
+	OpSemantic mSemantic;
+	/// Which part of the parameter should be passed (x,y,z,w)
+	int mMask;
+	/// The level of indirection. @see getIndirectionLevel
+	ushort mIndirectionLevel;
 };
 
 /** A class that represents function invocation code from shader based program function.
@@ -178,15 +184,15 @@ public:
 	/** 
 	@see FunctionAtom::writeSourceCode
 	*/
-	virtual void			writeSourceCode	(std::ostream& os, const String& targetLanguage) const;
+	virtual void writeSourceCode(std::ostream& os, const String& targetLanguage) const;
 
 	/** 
 	@see FunctionAtom::getFunctionAtomType
 	*/
-	virtual const String&	getFunctionAtomType () { return Type; }
+	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; }
+	OperandVector& getOperandList() { return mOperands; }
 	
 	/** Push a new operand (on the end) to the function. 
 	@param parameter A function parameter.
@@ -194,13 +200,13 @@ public:
 	@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);
+	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; }
+	const String& getFunctionName() const { return mFunctionName; }
 
 	/** Return the return type */
-	const String&			getReturnType	() const { return mReturnType; }
+	const String& getReturnType() const { return mReturnType; }
 
     /** Determines if the current object is equal to the compared one. */
     bool operator == ( const FunctionInvocation& rhs ) const;
@@ -216,7 +222,7 @@ public:
     */
     struct FunctionInvocationLessThan
     {
-        bool operator ()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const;
+        bool operator()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const;
     };
 
     /** Comparator function to be used for comparisons.
@@ -224,7 +230,7 @@ public:
     */
     struct FunctionInvocationCompare
     {
-        bool operator ()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const;
+        bool operator()(FunctionInvocation const& lhs, FunctionInvocation const& rhs) const;
     };
 
 	/// The type of this class.
@@ -232,9 +238,9 @@ public:
 
 	// Attributes.
 protected:	
-	String				mFunctionName;
-	String				mReturnType;
-	OperandVector		mOperands;	
+	String mFunctionName;
+	String mReturnType;
+	OperandVector mOperands;	
 };
 
 typedef vector<FunctionAtom*>::type					FunctionAtomInstanceList;

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

@@ -52,33 +52,34 @@ public:
 	/** Class constructor.
 	@param type The type of this program.
 	*/
-	GLSLESProgramProcessor			();
+	GLSLESProgramProcessor();
 
 	/** Class destructor */
-	virtual ~GLSLESProgramProcessor ();
+	virtual ~GLSLESProgramProcessor();
 
 	/** Return the target language of this processor. */
-	virtual const String&           getTargetLanguage	() const { return TargetLanguage; }
+	virtual const String& getTargetLanguage() const { return TargetLanguage; }
 
 	/** 
 	@see ProgramProcessor::preCreateGpuPrograms
     */
-	virtual bool                    preCreateGpuPrograms			(ProgramSet* programSet);
+	virtual bool preCreateGpuPrograms(ProgramSet* programSet);
 
 	/** 
 	@see ProgramProcessor::postCreateGpuPrograms
 	*/
-	virtual bool                    postCreateGpuPrograms			(ProgramSet* programSet);
+	virtual bool postCreateGpuPrograms(ProgramSet* programSet);
 
 
 private:
 
 	/** Bind texture samplers. */
-	void                            bindTextureSamplers				(Program* pCpuProgram, GpuProgramPtr pGpuProgram);
+	void bindTextureSamplers(Program* pCpuProgram, GpuProgramPtr pGpuProgram);
 
-	static String                   TargetLanguage;
+	static String TargetLanguage;
 
-	StringVector                    mLibraryPrograms;		// The list of created library shaders.
+	// The list of created library shaders.
+	StringVector mLibraryPrograms;
 };
 
 

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

@@ -50,47 +50,47 @@ public:
 	/** Class constructor. 
 	@param language The target shader language.
 	*/
-	GLSLESProgramWriter	();
+	GLSLESProgramWriter();
 
 	/** Class destructor */
-	virtual ~GLSLESProgramWriter	();
+	virtual ~GLSLESProgramWriter();
 
 
 	/** 
 	@see ProgramWriter::writeSourceCode.
 	*/
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-	virtual void            writeSourceCode			(StringSerialiser& os, Program* program);
+	virtual void writeSourceCode(StringSerialiser& os, Program* program);
 #else
-	virtual void            writeSourceCode			(std::ostream& os, Program* program);
+	virtual void writeSourceCode(std::ostream& os, Program* program);
 #endif
 
 	/** 
 	@see ProgramWriter::getTargetLanguage.
 	*/
-	virtual const String&   getTargetLanguage		() const { return TargetLanguage; }
+	virtual const String& getTargetLanguage() const { return TargetLanguage; }
 
 	static String TargetLanguage;
 
     protected:
-	typedef		std::map<GpuConstantType, const char*>		GpuConstTypeToStringMap;
-	typedef		std::map<Parameter::Semantic, const char*>	ParamSemanticToStringMap;
-	typedef		std::map<Parameter::Content, const char*>	ParamContentToStringMap;
-	typedef		std::map<String, String>					StringMap;
-	typedef		std::map<FunctionInvocation, String>		FunctionMap;
-	typedef		std::vector<FunctionInvocation>             FunctionVector;
-    typedef     FunctionMap::const_iterator                 FunctionMapIterator;
-    typedef     FunctionVector::const_iterator              FunctionVectorIterator;
-    typedef     GpuConstTypeToStringMap::const_iterator     GpuConstTypeToStringMapIterator;
+	typedef	std::map<GpuConstantType, const char*>		GpuConstTypeToStringMap;
+	typedef	std::map<Parameter::Semantic, const char*>	ParamSemanticToStringMap;
+	typedef	std::map<Parameter::Content, const char*>	ParamContentToStringMap;
+	typedef	std::map<String, String>					StringMap;
+	typedef	std::map<FunctionInvocation, String>		FunctionMap;
+	typedef	std::vector<FunctionInvocation>             FunctionVector;
+    typedef FunctionMap::const_iterator                 FunctionMapIterator;
+    typedef FunctionVector::const_iterator              FunctionVectorIterator;
+    typedef GpuConstTypeToStringMap::const_iterator     GpuConstTypeToStringMapIterator;
 
 	// Protected methods.
 protected:
 
 	/** Initialize string maps. */
-	void				initializeStringMaps		();
+	void initializeStringMaps();
 
     /** Cache functions of a dependency */
-    virtual void        cacheDependencyFunctions(const String & libName);
+    virtual void cacheDependencyFunctions(const String & libName);
 
 
     /** Create a FunctionInvocation object from a string taken out of a shader library. */
@@ -98,30 +98,30 @@ protected:
 
     /** Write the program dependencies. */
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-	void                writeProgramDependencies	(StringSerialiser& os, Program* program);
+	void writeProgramDependencies(StringSerialiser& os, Program* program);
 #else
-	void                writeProgramDependencies	(std::ostream& os, Program* program);
+	void writeProgramDependencies(std::ostream& os, Program* program);
 #endif
 
 	/** Write a local parameter. */
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-	void				writeLocalParameter			(StringSerialiser& os, ParameterPtr parameter);
+	void writeLocalParameter(StringSerialiser& os, ParameterPtr parameter);
 #else
-	void				writeLocalParameter			(std::ostream& os, ParameterPtr parameter);
+	void writeLocalParameter(std::ostream& os, ParameterPtr parameter);
 #endif
 
 	/** Write the input params of the function */
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-	void				writeInputParameters		(StringSerialiser& os, Function* function, GpuProgramType gpuType);
+	void writeInputParameters(StringSerialiser& os, Function* function, GpuProgramType gpuType);
 #else
-	void				writeInputParameters		(std::ostream& os, Function* function, GpuProgramType gpuType);
+	void writeInputParameters(std::ostream& os, Function* function, GpuProgramType gpuType);
 #endif
 	
 	/** Write the output params of the function */
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-	void				writeOutParameters			(StringSerialiser& os, Function* function, GpuProgramType gpuType);
+	void writeOutParameters(StringSerialiser& os, Function* function, GpuProgramType gpuType);
 #else
-	void				writeOutParameters			(std::ostream& os, Function* function, GpuProgramType gpuType);
+	void writeOutParameters(std::ostream& os, Function* function, GpuProgramType gpuType);
 #endif
 
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
@@ -133,23 +133,32 @@ protected:
 	String processOperand(Operand op, GpuProgramType gpuType);
 	
     /** Check if a string matches one of the GLSL ES basic types */
-    bool                isBasicType(String &type);
+    bool isBasicType(String &type);
     
     /** Search within a function body for non-builtin functions that a given function invocation depends on. */
-    void                discoverFunctionDependencies(const FunctionInvocation &invoc, FunctionVector &depVector);
+    void discoverFunctionDependencies(const FunctionInvocation &invoc, FunctionVector &depVector);
 
 	// Attributes.
 protected:
-	GpuConstTypeToStringMap		mGpuConstTypeMap;				// Map between GPU constant type to string value.
-	ParamSemanticToStringMap	mParamSemanticMap;				// Map between parameter semantic to string value.
-
-	StringMap					mInputToGLStatesMap;			// Map parameter name to a new parameter name (sometimes renaming is required to match names between vertex and fragment shader)
-	FunctionMap                 mFunctionCacheMap;              // Map function invocation to body.  Used as a cache to reduce library file reads and for inlining
-    StringMap                   mDefinesMap;                    // Map of #defines and the function library that contains them
-	ParamContentToStringMap		mContentToPerVertexAttributes;	// Map parameter content to vertex attributes
-	int							mGLSLVersion;					// Holds the current glsl es version
-	StringVector				mFragInputParams;				// Holds the fragment input params 
-    StringMap                   mCachedFunctionLibraries;       // Holds the cached function libraries
+	// Map between GPU constant type to string value.
+	GpuConstTypeToStringMap mGpuConstTypeMap;
+	// Map between parameter semantic to string value.
+	ParamSemanticToStringMap mParamSemanticMap;
+
+	// Map parameter name to a new parameter name (sometimes renaming is required to match names between vertex and fragment shader)
+	StringMap mInputToGLStatesMap;
+	// Map function invocation to body.  Used as a cache to reduce library file reads and for inlining
+	FunctionMap mFunctionCacheMap;
+    // Map of #defines and the function library that contains them
+    StringMap mDefinesMap;
+	// Map parameter content to vertex attributes
+	ParamContentToStringMap mContentToPerVertexAttributes;
+	// Holds the current glsl es version
+	int mGLSLVersion;
+	// Holds the fragment input params 
+	StringVector mFragInputParams;
+    // Holds the cached function libraries
+    StringMap mCachedFunctionLibraries;
 };
 
 /** GLSL ES program writer factory implementation.

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

@@ -53,36 +53,37 @@ public:
 	/** Class constructor.
 	@param type The type of this program.
 	*/
-	GLSLProgramProcessor			();
+	GLSLProgramProcessor();
 
 	/** Class destructor */
-	virtual ~GLSLProgramProcessor	();
+	virtual ~GLSLProgramProcessor();
 
 	/** Return the target language of this processor. */
-	virtual const String&		getTargetLanguage	() const { return TargetLanguage; }
+	virtual const String& getTargetLanguage() const { return TargetLanguage; }
 
 	/** 
 	@see ProgramProcessor::preCreateGpuPrograms
 	*/
-	virtual bool				preCreateGpuPrograms			(ProgramSet* programSet);
+	virtual bool preCreateGpuPrograms(ProgramSet* programSet);
 
 	/** 
 	@see ProgramProcessor::postCreateGpuPrograms
 	*/
-	virtual bool				postCreateGpuPrograms			(ProgramSet* programSet);
+	virtual bool postCreateGpuPrograms(ProgramSet* programSet);
 
 
 private:
 
 	/** Bind texture samplers. */
-	void						bindTextureSamplers				(Program* pCpuProgram, GpuProgramPtr pGpuProgram);
+	void bindTextureSamplers(Program* pCpuProgram, GpuProgramPtr pGpuProgram);
 
 	/** Compiles sub shaders (only if the not exists) and attach them to the main gpu program. */
-	void						bindSubShaders					(Program* program, GpuProgramPtr pGpuProgram);
+	void bindSubShaders(Program* program, GpuProgramPtr pGpuProgram);
 
 	static String TargetLanguage;
 
-	StringVector	mLibraryPrograms;		// The list of created library shaders.
+	// The list of created library shaders.
+	StringVector mLibraryPrograms;
 
 };