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

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

@@ -49,10 +49,10 @@ class _OgreRTSSExport ProgramManager : public Singleton<ProgramManager>, public
 public:
 
 	/** Class default constructor */
-	ProgramManager	();
+	ProgramManager();
 
 	/** Class destructor */
-	~ProgramManager	();
+	~ProgramManager();
 
 
 	/** Override standard Singleton retrieval.
@@ -70,7 +70,7 @@ public:
 	but the implementation stays in this single compilation unit,
 	preventing link errors.
 	*/
-	static ProgramManager&			getSingleton	();	
+	static ProgramManager& getSingleton();	
 
 	/** Override standard Singleton retrieval.
 	@remarks
@@ -87,23 +87,23 @@ public:
 	but the implementation stays in this single compilation unit,
 	preventing link errors.
 	*/
-	static ProgramManager*			getSingletonPtr				();
+	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);
+	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);
+	void releasePrograms(Pass* pass, TargetRenderState* renderState);
 
 	/** Flush the local GPU programs cache.
 	*/
-	void							flushGpuProgramsCache	();
+	void flushGpuProgramsCache();
 
 protected:
 
@@ -128,34 +128,34 @@ protected:
 	
 protected:
 	/** Create default program processors. */
-	void			createDefaultProgramProcessors	();
+	void createDefaultProgramProcessors();
 	
 	/** Destroy default program processors. */
-	void			destroyDefaultProgramProcessors	();
+	void destroyDefaultProgramProcessors();
 
 	/** Create default program processors. */
-	void			createDefaultProgramWriterFactories	();
+	void createDefaultProgramWriterFactories();
 
 	/** Destroy default program processors. */
-	void			destroyDefaultProgramWriterFactories();
+	void destroyDefaultProgramWriterFactories();
 
 	/** Destroy all program writers. */
-	void			destroyProgramWriters	();
+	void destroyProgramWriters();
 
 	/** Create CPU program . 	
 	@param type The type of the program to create.
 	*/
-	Program*		createCpuProgram		(GpuProgramType type);
+	Program* createCpuProgram(GpuProgramType type);
 
 	/** Destroy a CPU program by name.
 	@param shaderProgram The CPU program instance to destroy.
 	*/
-	void			destroyCpuProgram		(Program* shaderProgram);
+	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);
+	bool createGpuPrograms(ProgramSet* programSet);
 
 	/** Create GPU program based on the give CPU program.
 	@param shaderProgram The CPU program instance.
@@ -165,7 +165,7 @@ protected:
 	@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, 
+	GpuProgramPtr createGpuProgram(Program* shaderProgram, 
 		ProgramWriter* programWriter,
 		const String& language,
 		const String& profiles,
@@ -176,49 +176,56 @@ protected:
 	Add program processor instance to this manager.
 	@param processor The instance to add.
 	*/
-	void			addProgramProcessor		(ProgramProcessor* processor);
+	void addProgramProcessor(ProgramProcessor* processor);
 
 	/** 
 	Remove program processor instance from this manager. 
 	@param processor The instance to remove.
 	*/
-	void			removeProgramProcessor	(ProgramProcessor* processor);
+	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);
+	void destroyGpuProgram(GpuProgramPtr& gpuProgram);
 
 	/** Flush the local GPU programs cache.
 	@param gpuProgramsMap The GPU programs cache.
 	*/
-	void			flushGpuProgramsCache	(GpuProgramsMap& gpuProgramsMap);
+	void flushGpuProgramsCache(GpuProgramsMap& gpuProgramsMap);
 	
 	/** Return the number of created vertex shaders. */
-	size_t			getVertexShaderCount		() const { return mVertexShaderMap.size(); }
+	size_t getVertexShaderCount() const { return mVertexShaderMap.size(); }
 
 	/** Return the number of created fragment shaders. */
-	size_t			getFragmentShaderCount		() const { return mFragmentShaderMap.size(); }
+	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);
+	void synchronizePixelnToBeVertexOut(ProgramSet* programSet);
 
 	/** Bind the uniform parameters of a given CPU and GPU program set. */
-	void			bindUniformParameters			(Program* pCpuProgram, const GpuProgramParametersSharedPtr& passParams);
+	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.
+	// CPU programs list.					
+	ProgramList mCpuProgramsList;
+	// Map between target language and shader program writer.					
+	ProgramWriterMap mProgramWritersMap;
+	// Map between target language and shader program processor.	
+	ProgramProcessorMap mProgramProcessorsMap;
+	// Holds standard shader writer factories
+	ProgramWriterFactoryList mProgramWriterFactories;
+	// The generated vertex shaders.
+	GpuProgramsMap mVertexShaderMap;
+	// The generated fragment shaders.
+	GpuProgramsMap mFragmentShaderMap;
+	// The default program processors.
+	ProgramProcessorList mDefaultProgramProcessors;
 
 private:
 	friend class ProgramSet;

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

@@ -55,26 +55,26 @@ public:
 	/** Class constructor.
 	@param type The type of this program.
 	*/
-	ProgramProcessor			();
+	ProgramProcessor();
 
 	/** Class destructor */
-	virtual ~ProgramProcessor	();
+	virtual ~ProgramProcessor();
 
 	/** Return the target language of this processor. */
-	virtual const String&		getTargetLanguage	() const = 0;
+	virtual const String& getTargetLanguage() const = 0;
 	
 	/** Called before creation of the GPU programs.
 	Do several preparation operation such as validation, register compaction and specific target language optimizations.
 	@param programSet The program set container.
 	Return true on success.
 	*/
-	virtual bool				preCreateGpuPrograms	(ProgramSet* programSet) = 0;
+	virtual bool preCreateGpuPrograms(ProgramSet* programSet) = 0;
 
 	/** Called after creation of the GPU programs.
 	@param programSet The program set container.
 	Return true on success.
 	*/
-	virtual bool				postCreateGpuPrograms	(ProgramSet* programSet) = 0;
+	virtual bool postCreateGpuPrograms(ProgramSet* programSet) = 0;
  
 // Protected types.
 protected:
@@ -90,42 +90,48 @@ protected:
 
 
 		/** Clear the state of this merge parameter. */
-		void			clear						();
+		void clear();
 		
 		/** Add source parameter to this merged */
-		void			addSourceParameter			(ParameterPtr srcParam, int mask);
+		void addSourceParameter(ParameterPtr srcParam, int mask);
 
 		/** Return the source parameter count. */
-		size_t			getSourceParameterCount		() const { return mSrcParameterCount; }
+		size_t getSourceParameterCount() const { return mSrcParameterCount; }
 
 		/** Return source parameter by index. */
-		ParameterPtr	getSourceParameter			(unsigned int index) { return mSrcParameter[index]; }
+		ParameterPtr getSourceParameter(unsigned int index) { return mSrcParameter[index]; }
 
 		/** Return source parameter mask by index. */
-		int				getSourceParameterMask		(unsigned int index) const { return mSrcParameterMask[index]; }
+		int getSourceParameterMask(unsigned int index) const { return mSrcParameterMask[index]; }
 
 		/** Return destination parameter mask by index. */
-		int				getDestinationParameterMask	(unsigned int index) const { return mDstParameterMask[index]; }
+		int getDestinationParameterMask(unsigned int index) const { return mDstParameterMask[index]; }
 
 		/** Return the number of used floats. */ 
-		int				getUsedFloatCount			();
+		int getUsedFloatCount();
 		
 		/** Return the destination parameter. */
-		ParameterPtr	getDestinationParameter		(int usage, int index);
+		ParameterPtr getDestinationParameter(int usage, int index);
 
 	protected:
 	
 		/** Creates the destination parameter by a given class and index. */
-		void			createDestinationParameter	(int usage, int index);
+		void createDestinationParameter(int usage, int index);
 
 
 	protected:
-		ParameterPtr	mDstParameter;			// Destination merged parameter.
-		ParameterPtr	mSrcParameter[4];		// Source parameters - 4 source at max 1,1,1,1 -> 4.
-		int				mSrcParameterMask[4];	// Source parameters mask. OPM_ALL means all fields used, otherwise it is split source parameter.
-		int				mDstParameterMask[4];	// Destination parameters mask. OPM_ALL means all fields used, otherwise it is split source parameter.
-		size_t			mSrcParameterCount;		// The actual source parameters count.
-		size_t			mUsedFloatCount;		// The number of used floats.
+		// Destination merged parameter.
+		ParameterPtr mDstParameter;
+		// Source parameters - 4 source at max 1,1,1,1 -> 4.
+		ParameterPtr mSrcParameter[4];
+		// Source parameters mask. OPM_ALL means all fields used, otherwise it is split source parameter.
+		int mSrcParameterMask[4];
+		// Destination parameters mask. OPM_ALL means all fields used, otherwise it is split source parameter.
+		int mDstParameterMask[4];
+		// The actual source parameters count.
+		size_t mSrcParameterCount;
+		// The number of used floats.
+		size_t mUsedFloatCount;
 	};
 	typedef vector<MergeParameter>::type	MergeParameterList;
 
@@ -134,8 +140,10 @@ protected:
 	// A struct that defines merge parameters combination.
 	struct _OgreRTSSExport MergeCombination
 	{		
-		size_t			srcParamterTypeCount[4];	// The count of each source type. I.E (1 FLOAT1, 0 FLOAT2, 1 FLOAT3, 0 FLOAT4).
-		int				srcParameterMask[4];		// Source parameters mask. OPM_ALL means all fields used, otherwise it is split source parameter.
+		// The count of each source type. I.E (1 FLOAT1, 0 FLOAT2, 1 FLOAT3, 0 FLOAT4).
+		size_t srcParamterTypeCount[4];
+		// Source parameters mask. OPM_ALL means all fields used, otherwise it is split source parameter.
+		int srcParameterMask[4];
 
 		MergeCombination(
 			int float1Count, int float1Mask,
@@ -164,48 +172,48 @@ protected:
 protected:
 
 	/** Build parameter merging combinations. */
-	void			buildMergeCombinations			();
+	void buildMergeCombinations();
 
 	/** Compact the vertex shader output registers.
 	@param vsMain The vertex shader entry function.
 	@param fsMain The fragment shader entry function.
 	Return true on success.
 	*/
-	virtual bool	compactVsOutputs				(Function* vsMain, Function* fsMain);
+	virtual bool compactVsOutputs(Function* vsMain, Function* fsMain);
 
 	/** Internal method that counts vertex shader texcoord output slots and output floats.
 	@param vsMain The vertex shader entry function.
 	@param outTexCoordSlots Will hold the number of used output texcoord slots.
 	@param outTexCoordFloats Will hold the total number of floats used by output texcoord slots.
 	*/
-	void			countVsTexcoordOutputs			(Function* vsMain, int& outTexCoordSlots, int& outTexCoordFloats);
+	void countVsTexcoordOutputs(Function* vsMain, int& outTexCoordSlots, int& outTexCoordFloats);
 
 	/** Internal function that builds parameters table.
 	@param paramList The parameter list.
 	@param outParamsTable Will hold the texcoord params sorted by types in each row.
 	*/
-	void			buildTexcoordTable				(const ShaderParameterList& paramList, ShaderParameterList outParamsTable[4]);
+	void buildTexcoordTable(const ShaderParameterList& paramList, ShaderParameterList outParamsTable[4]);
 
 
 	/** Merge the parameters from the given table. 
 	@param paramsTable Source parameters table.
 	@param mergedParams Will hold the merged parameters list.
 	*/
-	void			mergeParameters					(ShaderParameterList paramsTable[4], MergeParameterList& mergedParams, ShaderParameterList& splitParams);
+	void mergeParameters(ShaderParameterList paramsTable[4], MergeParameterList& mergedParams, ShaderParameterList& splitParams);
 
 
 	/** Internal function that creates merged parameter using pre defined combinations. 
 	@param paramsTable Source parameters table.
 	@param mergedParams The merged parameters list.
 	*/
-	void			mergeParametersByPredefinedCombinations(ShaderParameterList paramsTable[4], MergeParameterList& mergedParams);
+	void mergeParametersByPredefinedCombinations(ShaderParameterList paramsTable[4], MergeParameterList& mergedParams);
 
 	/** Internal function that creates merged parameter from given combination.
 	@param combination The merge combination to try.
 	@param paramsTable The params table sorted by types in each row.	
 	@param mergedParameter Will hold the merged parameter.
 	*/
-	bool			mergeParametersByCombination			(const MergeCombination& combination, ShaderParameterList paramsTable[4], 
+	bool mergeParametersByCombination(const MergeCombination& combination, ShaderParameterList paramsTable[4], 
 																 MergeParameter* mergedParameter);
 
 	/** Merge reminders parameters that could not be merged into one slot using the predefined combinations.
@@ -213,44 +221,47 @@ protected:
 	@param mergedParams The merged parameters list.
 	@param splitParams The split parameters list.
 	*/
-	void			mergeParametersReminders				(ShaderParameterList paramsTable[4], MergeParameterList& mergedParams, ShaderParameterList& splitParams);
+	void mergeParametersReminders(ShaderParameterList paramsTable[4], MergeParameterList& mergedParams, ShaderParameterList& splitParams);
 
 
 	/** Generates local parameters for the split parameters and perform packing/unpacking operation using them. */
-	void			generateLocalSplitParameters				(Function* func, GpuProgramType progType, MergeParameterList& mergedParams, ShaderParameterList& splitParams, LocalParameterMap& localParamsMap);
+	void generateLocalSplitParameters(Function* func, GpuProgramType progType, MergeParameterList& mergedParams, ShaderParameterList& splitParams, LocalParameterMap& localParamsMap);
 	
 	/** Rebuild the given parameters list using the merged parameters.	
 	*/
-	void			rebuildParameterList				(Function* func, int paramsUsage, MergeParameterList& mergedParams);
+	void rebuildParameterList(Function* func, int paramsUsage, MergeParameterList& mergedParams);
 
 	/** Rebuild function invocations by replacing references to old source parameters with the matching merged parameters components. */
-	void			rebuildFunctionInvocations			(FunctionAtomInstanceList& funcAtomList, MergeParameterList& mergedParams, LocalParameterMap& localParamsMap);
+	void rebuildFunctionInvocations(FunctionAtomInstanceList& funcAtomList, MergeParameterList& mergedParams, LocalParameterMap& localParamsMap);
 
 	/** Builds a map between parameter and all the references to it. */
-	void			buildParameterReferenceMap			(FunctionAtomInstanceList& funcAtomList, ParameterOperandMap& paramsRefMap);
+	void buildParameterReferenceMap(FunctionAtomInstanceList& funcAtomList, ParameterOperandMap& paramsRefMap);
 
 	/** Replace references to old parameters with the new merged parameters. */
-	void			replaceParametersReferences			(MergeParameterList& mergedParams, ParameterOperandMap& paramsRefMap);
+	void replaceParametersReferences(MergeParameterList& mergedParams, ParameterOperandMap& paramsRefMap);
 
 	/** Replace references to old parameters that have been split with the new local parameters that represents them. */
-	void			replaceSplitParametersReferences	(LocalParameterMap& localParamsMap, ParameterOperandMap& paramsRefMap);
+	void replaceSplitParametersReferences(LocalParameterMap& localParamsMap, ParameterOperandMap& paramsRefMap);
 
 	/** Return number of floats needed by the given type. */
-	static int		getParameterFloatCount				(GpuConstantType type);		
+	static int getParameterFloatCount(GpuConstantType type);		
 
 	/** Return the parameter mask of by the given parameter type (I.E: X|Y for FLOAT2 etc..) */
-	static int		getParameterMaskByType				(GpuConstantType type);
+	static int getParameterMaskByType(GpuConstantType type);
 	
 	/** Return the parameter mask of by the float count type (I.E: X|Y for 2 etc..) */
-	static int		getParameterMaskByFloatCount		(int floatCount);
+	static int getParameterMaskByFloatCount(int floatCount);
 	
 	/** Bind the auto parameters for a given CPU and GPU program set. */
-	void			bindAutoParameters					(Program* pCpuProgram, GpuProgramPtr pGpuProgram);
+	void bindAutoParameters(Program* pCpuProgram, GpuProgramPtr pGpuProgram);
 
 protected:
-	MergeCombinationList	mParamMergeCombinations;		// Merging combinations defs.
-	int						mMaxTexCoordSlots;				// Maximum texcoord slots.
-	int						mMaxTexCoordFloats;				// Maximum texcoord floats count.
+	// Merging combinations defs.
+	MergeCombinationList mParamMergeCombinations;
+	// Maximum texcoord slots.
+	int mMaxTexCoordSlots;
+	// Maximum texcoord floats count.
+	int mMaxTexCoordFloats;
     std::map<Function *, String *>  mFunctionMap;           // Map between function signatures and source code
 
 };

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

@@ -49,38 +49,42 @@ class _OgreRTSSExport ProgramSet : public RTShaderSystemAlloc
 	// Interface.
 public:
 	/** Class default constructor */
-	ProgramSet	();
+	ProgramSet();
 
 	/** Class destructor */
-	~ProgramSet	();
+	~ProgramSet();
 
 	/** Get the vertex shader CPU program. */
-	Program*		getCpuVertexProgram		();
+	Program* getCpuVertexProgram();
 
 	/** Get the fragment shader CPU program. */
-	Program*		getCpuFragmentProgram	();
+	Program* getCpuFragmentProgram();
 
 	/** Get the vertex shader GPU program. */
-	GpuProgramPtr	getGpuVertexProgram		();
+	GpuProgramPtr getGpuVertexProgram();
 
 	/** Get the fragment shader GPU program. */
-	GpuProgramPtr	getGpuFragmentProgram	();
+	GpuProgramPtr getGpuFragmentProgram();
 
 	// Protected methods.
 protected:
-	void			setCpuVertexProgram		(Program* vsCpuProgram);
-	void			setCpuFragmentProgram	(Program* psCpuProgram);
+	void setCpuVertexProgram(Program* vsCpuProgram);
+	void setCpuFragmentProgram(Program* psCpuProgram);
 
-	void			setGpuVertexProgram		(GpuProgramPtr vsGpuProgram);
-	void			setGpuFragmentProgram	(GpuProgramPtr psGpuProgram);
+	void setGpuVertexProgram(GpuProgramPtr vsGpuProgram);
+	void setGpuFragmentProgram(GpuProgramPtr psGpuProgram);
 
 
 	// Attributes.
 protected:
-	Program*		mVSCpuProgram;		// Vertex shader CPU program.
-	Program*		mPSCpuProgram;		// Fragment shader CPU program.
-	GpuProgramPtr	mVSGpuProgram;		// Vertex shader GPU program.
-	GpuProgramPtr	mPSGpuProgram;		// Fragment shader CPU program.
+	// Vertex shader CPU program.
+	Program* mVSCpuProgram;
+	// Fragment shader CPU program.
+	Program* mPSCpuProgram;
+	// Vertex shader GPU program.
+	GpuProgramPtr mVSGpuProgram;
+	// Fragment shader CPU program.
+	GpuProgramPtr mPSGpuProgram;
 
 private:
 	friend class ProgramManager;

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

@@ -59,7 +59,7 @@ class _OgreRTSSExport ProgramWriter : public RTShaderSystemAlloc
 public:
 
 	/** Class destructor */
-	virtual ~ProgramWriter	() {}
+	virtual ~ProgramWriter() {}
 
 
 	/** Write the program shader source code.
@@ -67,35 +67,35 @@ public:
 	@param program The source CPU program for the GPU program code.
 	*/
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-	virtual void				writeSourceCode			(StringSerialiser& os, Program* program) = 0;
+	virtual void writeSourceCode(StringSerialiser& os, Program* program) = 0;
 #else
-	virtual void				writeSourceCode			(std::ostream& os, Program* program) = 0;
+	virtual void writeSourceCode(std::ostream& os, Program* program) = 0;
 #endif
 
 	/** Return the target language of this writer. */
-	virtual const String&		getTargetLanguage	() const = 0;
+	virtual const String& getTargetLanguage() const = 0;
 
 // Protected methods.
 protected:
 	/** Write the program title. */
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-	void				writeProgramTitle			(StringSerialiser& os, Program* program);
+	void writeProgramTitle(StringSerialiser& os, Program* program);
 #else
-	void				writeProgramTitle			(std::ostream& os, Program* program);
+	void writeProgramTitle(std::ostream& os, Program* program);
 #endif
 
 	/** Write the uniform parameters title. */
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-	void				writeUniformParametersTitle	(StringSerialiser& os, Program* program);
+	void writeUniformParametersTitle(StringSerialiser& os, Program* program);
 #else
-	void				writeUniformParametersTitle	(std::ostream& os, Program* program);
+	void writeUniformParametersTitle(std::ostream& os, Program* program);
 #endif
 
 	/** Write a function title. */
 #if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
-	void				writeFunctionTitle			(StringSerialiser& os, Function* function);
+	void writeFunctionTitle(StringSerialiser& os, Function* function);
 #else
-	void				writeFunctionTitle			(std::ostream& os, Function* function);
+	void writeFunctionTitle(std::ostream& os, Function* function);
 #endif
 };
 

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

@@ -60,20 +60,20 @@ public:
 	virtual ~RenderState();
 
 	/** Reset this render state */
-	void		reset						();
+	void reset();
 
 	/** Add a template sub render state to this render state.
 	@param subRenderState The sub render state template to add.
 	*/
-	void		addTemplateSubRenderState	(SubRenderState* subRenderState);
+	void addTemplateSubRenderState(SubRenderState* subRenderState);
 
 	/** Remove a template sub render state from this render state.
 	@param subRenderState The sub render state to remove.
 	*/
-	void		removeTemplateSubRenderState (SubRenderState* subRenderState);
+	void removeTemplateSubRenderState(SubRenderState* subRenderState);
 
 	/** Get the list of the template sub render states composing this render state. */
-	const SubRenderStateList&	getTemplateSubRenderStateList() const { return mSubRenderStateList; }
+	const SubRenderStateList& getTemplateSubRenderStateList() const { return mSubRenderStateList; }
 
 	/** 
 	Set the light count per light type.
@@ -83,7 +83,7 @@ public:
 	lightCount[1] defines the directional light count.
 	lightCount[2] defines the spot light count.
 	*/
-	void			setLightCount			(const int lightCount[3]);
+	void setLightCount(const int lightCount[3]);
 
 	/** 
 	Get the light count per light type.
@@ -93,7 +93,7 @@ public:
 	lightCount[1] defines the directional light count.
 	lightCount[2] defines the spot light count.
 	*/
-	void			getLightCount			(int lightCount[3]) const;
+	void getLightCount(int lightCount[3]) const;
 
 	/** 
 	Set the light count auto update state.
@@ -101,22 +101,25 @@ public:
 	If the value is true the light count will be updated from the owner shader generator scheme based on current scene lights.
 	The default is true.
 	*/
-	void			setLightCountAutoUpdate	(bool autoUpdate) { mLightCountAutoUpdate = autoUpdate; }
+	void setLightCountAutoUpdate(bool autoUpdate) { mLightCountAutoUpdate = autoUpdate; }
 
 	/** 
 	Return true if this render state override the light count. 
 	If light count is not overridden it will be updated from the shader generator based on current scene lights.
 	*/
-	bool			getLightCountAutoUpdate	() const { return mLightCountAutoUpdate; }
+	bool getLightCountAutoUpdate() const { return mLightCountAutoUpdate; }
 
 	
 
 
 	// Attributes.
 protected:
-	SubRenderStateList	mSubRenderStateList;			// The sub render states list.	
-	int					mLightCount[3];					// The light count per light type definition.
-	bool				mLightCountAutoUpdate;			// True if light count was explicitly set.
+	// The sub render states list.	
+	SubRenderStateList mSubRenderStateList;
+	// The light count per light type definition.
+	int mLightCount[3];
+	// True if light count was explicitly set.
+	bool mLightCountAutoUpdate;
 
 private:
 	friend class ProgramManager;
@@ -151,7 +154,7 @@ public:
 	@param srcPass The source pass that this render state is constructed from.
 	@param dstPass The destination pass that constructed from this render state.
 	*/
-	void		link				(const RenderState& other, Pass* srcPass, Pass* dstPass);
+	void link(const RenderState& other, Pass* srcPass, Pass* dstPass);
 
 	/** Update the GPU programs constant parameters before a renderable is rendered.
 	@param rend The renderable object that is going to be rendered.
@@ -159,48 +162,50 @@ public:
 	@param source The auto parameter auto source instance.
 	@param pLightList The light list used for the current rendering operation.
 	*/
-	void	updateGpuProgramsParams	(Renderable* rend, Pass* pass, const AutoParamDataSource* source, const LightList* pLightList);
+	void updateGpuProgramsParams(Renderable* rend, Pass* pass, const AutoParamDataSource* source, const LightList* pLightList);
 	
 // Protected methods
 protected:
 
 	/** Sort the sub render states composing this render state. */
-	void			sortSubRenderStates		();
+	void sortSubRenderStates();
 
 	/** Comparison function of the sub render states. */
-	static int		sSubRenderStateCompare	(const void * p0, const void *p1);
+	static int sSubRenderStateCompare(const void * p0, const void *p1);
 
 	
 	/** Create CPU programs that represent this render state. 	
 	*/
-	bool		createCpuPrograms		();
+	bool createCpuPrograms();
 
 	/** Create the program set of this render state.
 	*/
-	ProgramSet*	createProgramSet			();
+	ProgramSet* createProgramSet();
 
 	/* Destroy the program set of this render state. */
-	void		destroyProgramSet			();
+	void destroyProgramSet();
 
 	/** Return the program set of this render state.
 	*/
-	ProgramSet*	getProgramSet				() { return mProgramSet; }
+	ProgramSet* getProgramSet() { return mProgramSet; }
 
 	/** Add sub render state to this render state.
 	@param subRenderState The sub render state to add.
 	*/
-	void		addSubRenderStateInstance			(SubRenderState* subRenderState);
+	void addSubRenderStateInstance(SubRenderState* subRenderState);
 
 	/** Remove sub render state from this render state.
 	@param subRenderState The sub render state to remove.
 	*/
-	void		removeSubRenderStateInstance		(SubRenderState* subRenderState);
+	void removeSubRenderStateInstance(SubRenderState* subRenderState);
 
 	
 // Attributes.
 protected:
-	bool				mSubRenderStateSortValid;		// Tells if the list of the sub render states is sorted.
-	ProgramSet*			mProgramSet;					// The program set of this RenderState.
+	// Tells if the list of the sub render states is sorted.
+	bool mSubRenderStateSortValid;
+	// The program set of this RenderState.
+	ProgramSet* mProgramSet;
 	
 
 private: