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

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

@@ -52,22 +52,22 @@ public:
 	/** Class constructor.
 	@param type The type of this program.
 	*/
-	HLSLProgramProcessor			();
+	HLSLProgramProcessor();
 
 	/** Class destructor */
-	virtual ~HLSLProgramProcessor	();
+	virtual ~HLSLProgramProcessor();
 
 	/** 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);
 
 	static String TargetLanguage;
 

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

@@ -52,20 +52,20 @@ public:
 	/** Class constructor. 
 	@param language The target shader language.
 	*/
-	HLSLProgramWriter	();
+	HLSLProgramWriter();
 
 	/** Class destructor */
-	virtual ~HLSLProgramWriter ();
+	virtual ~HLSLProgramWriter();
 
 	/** 
 	@see ProgramWriter::writeSourceCode.
 	*/
-	virtual void			writeSourceCode			(std::ostream& os, Program* program);
+	virtual void writeSourceCode(std::ostream& os, Program* program);
 
 	/** 
 	@see ProgramWriter::getTargetLanguage.
 	*/
-	virtual const String&  getTargetLanguage			() const { return TargetLanguage; }
+	virtual const String& getTargetLanguage() const { return TargetLanguage; }
 
 	static String TargetLanguage;
 
@@ -73,34 +73,36 @@ public:
 protected:
 
 	/** Initialize string maps. */
-	void		initializeStringMaps		();
+	void initializeStringMaps();
 
 	/** Write the program dependencies. */
-	void		writeProgramDependencies	(std::ostream& os, Program* program);
+	void writeProgramDependencies(std::ostream& os, Program* program);
 
 	/** Write a uniform parameter. */
-	void		writeUniformParameter		(std::ostream& os, UniformParameterPtr parameter);
+	void writeUniformParameter(std::ostream& os, UniformParameterPtr parameter);
 
 	/** Write a function parameter. */
-	void		writeFunctionParameter		(std::ostream& os, ParameterPtr parameter);
+	void writeFunctionParameter(std::ostream& os, ParameterPtr parameter);
 
 	/** Write a local parameter. */
-	void		writeLocalParameter			(std::ostream& os, ParameterPtr parameter);
+	void writeLocalParameter(std::ostream& os, ParameterPtr parameter);
 
 	/** Write a function declaration. */
-	void		writeFunctionDeclaration	(std::ostream& os, Function* function, bool & needToTranslateHlsl4Color, ParameterPtr & colorParameter);
+	void writeFunctionDeclaration(std::ostream& os, Function* function, bool & needToTranslateHlsl4Color, ParameterPtr & colorParameter);
 
 	/** Write function atom instance. */
-	void		writeAtomInstance			(std::ostream& os, FunctionAtom* atom);	
+	void writeAtomInstance(std::ostream& os, FunctionAtom* atom);	
 
 protected:
-	typedef		map<GpuConstantType, const char*>::type		GpuConstTypeToStringMap;
-	typedef		map<Parameter::Semantic, const char*>::type	ParamSemanticToStringMap;
+	typedef	map<GpuConstantType, const char*>::type		GpuConstTypeToStringMap;
+	typedef	map<Parameter::Semantic, const char*>::type	ParamSemanticToStringMap;
 
 	// Attributes.
 protected:
-	GpuConstTypeToStringMap		mGpuConstTypeMap;		// Map between GPU constant type to string value.
-	ParamSemanticToStringMap	mParamSemanticMap;		// Map between parameter semantic to string value.
+	// Map between GPU constant type to string value.
+	GpuConstTypeToStringMap mGpuConstTypeMap;
+	// Map between parameter semantic to string value.
+	ParamSemanticToStringMap mParamSemanticMap;
 };
 
 /** HLSL program writer factory implementation.

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

@@ -87,7 +87,7 @@ protected:
 	~SGMaterialSerializerListener();
 
 	/** Internal method that creates list of SGPass instances composing the given material. */
-	void						createSGPassList		(Material* mat, SGPassList& passList);
+	void createSGPassList(Material* mat, SGPassList& passList);
 
 	/** Internal method that returns SGPass instance from a given source pass. */
 	ShaderGenerator::SGPass*	getShaderGeneratedPass	(const Pass* srcPass);
@@ -95,8 +95,10 @@ protected:
 
 // Attributes.
 protected:	
-	Material*		mSourceMaterial;		// The current source material that is being written.
-	SGPassList		mSGPassList;			// List of SGPass instances composing this material.
+	// The current source material that is being written.
+	Material* mSourceMaterial;
+	// List of SGPass instances composing this material.
+	SGPassList mSGPassList;
 	
 	
 private:

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

@@ -321,43 +321,49 @@ public:
 	virtual ~Parameter() {};
 
 	/** Get the name of this parameter. */
-	const String&			getName							() const { return mName; }
+	const String& getName() const { return mName; }
 
 	/** Get the type of this parameter. */
-	GpuConstantType			getType							() const { return mType; }
+	GpuConstantType getType() const { return mType; }
 
 	/** Get the semantic of this parameter. */
-	const Semantic&			getSemantic						() const { return mSemantic; }
+	const Semantic& getSemantic() const { return mSemantic; }
 
 	/** Get the index of this parameter. */
-	int						getIndex						() const { return mIndex; }	
+	int getIndex() const { return mIndex; }	
 
 	/** Return the content of this parameter. */
-	Content					getContent							() const { return mContent; }
+	Content getContent() const { return mContent; }
 
 	/** Returns true if this instance is a ConstParameter otherwise false. */
-	virtual bool			isConstParameter					() const { return false; }
+	virtual bool isConstParameter() const { return false; }
 
 	/** Returns the string representation of this parameter. */
-	virtual String			toString							() const { return mName; }
+	virtual String toString() const { return mName; }
 	
 	/** Returns Whether this parameter is an array. */
-	bool					isArray								() const { return mSize > 0; }
+	bool isArray() const { return mSize > 0; }
 
 	/** Returns the number of elements in the parameter (for arrays). */
-	size_t					getSize								() const { return mSize; }
+	size_t getSize() const { return mSize; }
 	
 	/** Sets the number of elements in the parameter (for arrays). */
-	void					setSize								(size_t size) { mSize = size; }
+	void setSize(size_t size) { mSize = size; }
 
 // Attributes.
 protected:
-	String									mName;					// Name of this parameter.
-	GpuConstantType							mType;					// Type of this parameter.
-	Semantic								mSemantic;				// Semantic of this parameter.
-	int										mIndex;					// Index of this parameter.
-	Content									mContent;				// The content of this parameter.
-	size_t									mSize;					// Number of elements in the parameter (for arrays)
+	// Name of this parameter.
+	String mName;
+	// Type of this parameter.
+	GpuConstantType mType;
+	// Semantic of this parameter.
+	Semantic mSemantic;
+	// Index of this parameter.
+	int mIndex;
+	// The content of this parameter.
+	Content mContent;
+	// Number of elements in the parameter (for arrays)
+	size_t mSize;
 	
 };
 
@@ -418,34 +424,34 @@ public:
 
 	
 	/** Get auto constant int data of this parameter, in case it is auto constant parameter. */
-	size_t					getAutoConstantIntData			() const { return mAutoConstantIntData; }	
+	size_t getAutoConstantIntData() const { return mAutoConstantIntData; }	
 
 	/** Get auto constant real data of this parameter, in case it is auto constant parameter. */
-	Real					getAutoConstantRealData			() const { return mAutoConstantRealData; }	
+	Real getAutoConstantRealData() const { return mAutoConstantRealData; }	
 
 	/** Return true if this parameter is a floating point type, false otherwise. */
-	bool					isFloat							() const;
+	bool isFloat() const;
 
 	/** Return true if this parameter is a texture sampler type, false otherwise. */
-	bool					isSampler						() const;
+	bool isSampler() const;
 
 	/** Return true if this parameter is an auto constant parameter, false otherwise. */
-	bool					isAutoConstantParameter				() const { return mIsAutoConstantReal || mIsAutoConstantInt; }
+	bool isAutoConstantParameter() const { return mIsAutoConstantReal || mIsAutoConstantInt; }
 
 	/** Return true if this parameter an auto constant with int data type, false otherwise. */
-	bool					isAutoConstantIntParameter			() const { return mIsAutoConstantInt; }
+	bool isAutoConstantIntParameter() const { return mIsAutoConstantInt; }
 
 	/** Return true if this parameter an auto constant with real data type, false otherwise. */
-	bool					isAutoConstantRealParameter			() const { return mIsAutoConstantReal; }
+	bool isAutoConstantRealParameter() const { return mIsAutoConstantReal; }
 
 	/** Return the auto constant type of this parameter. */
 	GpuProgramParameters::AutoConstantType getAutoConstantType	() const { return mAutoConstantType; }
 
 	/** Return the variability of this parameter. */
-	uint16					getVariability						() const { return mVariability; }
+	uint16 getVariability() const { return mVariability; }
 
 	/** Bind this parameter to the corresponding GPU parameter. */
-	void					bind								(GpuProgramParametersSharedPtr paramsPtr);
+	void bind(GpuProgramParametersSharedPtr paramsPtr);
 
 public:
 
@@ -540,17 +546,24 @@ public:
 	}
 
 protected:
-	bool									mIsAutoConstantReal;	// Is it auto constant real based parameter.
-	bool									mIsAutoConstantInt;		// Is it auto constant int based parameter.
+	// Is it auto constant real based parameter.
+	bool mIsAutoConstantReal;
+	// Is it auto constant int based parameter.
+	bool mIsAutoConstantInt;
 	GpuProgramParameters::AutoConstantType	mAutoConstantType;		// The auto constant type of this parameter.
 	union
 	{
-		size_t	mAutoConstantIntData;								// Auto constant int data.
-		Real	mAutoConstantRealData;								// Auto constant real data.
+		// Auto constant int data.
+		size_t mAutoConstantIntData;
+		// Auto constant real data.
+		Real mAutoConstantRealData;
 	};		
-	uint16									mVariability;			// How this parameter varies (bitwise combination of GpuProgramVariability).
-	GpuProgramParameters*					mParamsPtr;				// The actual GPU parameters pointer.
-	size_t									mPhysicalIndex;			// The physical index of this parameter in the GPU program.
+	// How this parameter varies (bitwise combination of GpuProgramVariability).
+	uint16 mVariability;
+	// The actual GPU parameters pointer.
+	GpuProgramParameters* mParamsPtr;
+	// The physical index of this parameter in the GPU program.
+	size_t mPhysicalIndex;
 };
 
 typedef SharedPtr<UniformParameter>				UniformParameterPtr; 
@@ -577,17 +590,17 @@ public:
 	virtual				~ConstParameter		() {}
 
 	/** Returns the native value of this parameter. (for example a Vector3) */
-	const valueType&	getValue			() const { return mValue; }
+	const valueType& getValue() const { return mValue; }
 
 	/** 
 	@see Parameter::isConstParameter.
 	*/
-	virtual bool		isConstParameter	() const { return true; }
+	virtual bool isConstParameter() const { return true; }
 
 	/** 
 	@see Parameter::toString.
 	*/
-	virtual String		toString			() const = 0;
+	virtual String toString() const = 0;
 
 protected:
 	valueType mValue;
@@ -601,44 +614,44 @@ class _OgreRTSSExport ParameterFactory
 	// Interface.
 public:
 
-	static ParameterPtr	createInPosition		(int index);	
-	static ParameterPtr	createOutPosition		(int index);
-
-	static ParameterPtr	createInNormal			(int index);
-	static ParameterPtr createInWeights			(int index);
-	static ParameterPtr createInIndices			(int index);
-	static ParameterPtr	createOutNormal			(int index);
-	static ParameterPtr	createInBiNormal		(int index);
-	static ParameterPtr	createOutBiNormal		(int index);
-	static ParameterPtr	createInTangent			(int index);
-	static ParameterPtr	createOutTangent		(int index);
-	static ParameterPtr	createInColor			(int index);
-	static ParameterPtr	createOutColor			(int index);
-
-	static ParameterPtr	createInTexcoord		(GpuConstantType type, int index, Parameter::Content content);
-	static ParameterPtr	createOutTexcoord		(GpuConstantType type, int index, Parameter::Content content);
-	static ParameterPtr	createInTexcoord1		(int index, Parameter::Content content);
-	static ParameterPtr	createOutTexcoord1		(int index, Parameter::Content content);
-	static ParameterPtr	createInTexcoord2		(int index, Parameter::Content content);
-	static ParameterPtr	createOutTexcoord2		(int index, Parameter::Content content);
-	static ParameterPtr	createInTexcoord3		(int index, Parameter::Content content);
-	static ParameterPtr	createOutTexcoord3		(int index, Parameter::Content content);
-	static ParameterPtr	createInTexcoord4		(int index, Parameter::Content content);			
-	static ParameterPtr	createOutTexcoord4		(int index, Parameter::Content content);
-
-	static ParameterPtr	createConstParamVector2	(Vector2 val);
-	static ParameterPtr	createConstParamVector3	(Vector3 val);
-	static ParameterPtr	createConstParamVector4	(Vector4 val);
-	static ParameterPtr	createConstParamFloat	(float val);	
-
-	static UniformParameterPtr	createSampler			(GpuConstantType type, int index);
-	static UniformParameterPtr	createSampler1D			(int index);
-	static UniformParameterPtr	createSampler2D			(int index);
-	static UniformParameterPtr	createSampler2DArray	(int index);
-	static UniformParameterPtr	createSampler3D			(int index);
-	static UniformParameterPtr	createSamplerCUBE		(int index);	
-
-	static UniformParameterPtr	createUniform			(GpuConstantType type, 	int index, uint16 variability, const String& suggestedName, size_t size);
+	static ParameterPtr createInPosition(int index);	
+	static ParameterPtr createOutPosition(int index);
+
+	static ParameterPtr createInNormal(int index);
+	static ParameterPtr createInWeights(int index);
+	static ParameterPtr createInIndices(int index);
+	static ParameterPtr createOutNormal(int index);
+	static ParameterPtr createInBiNormal(int index);
+	static ParameterPtr createOutBiNormal(int index);
+	static ParameterPtr createInTangent(int index);
+	static ParameterPtr createOutTangent(int index);
+	static ParameterPtr createInColor(int index);
+	static ParameterPtr createOutColor(int index);
+
+	static ParameterPtr createInTexcoord(GpuConstantType type, int index, Parameter::Content content);
+	static ParameterPtr createOutTexcoord(GpuConstantType type, int index, Parameter::Content content);
+	static ParameterPtr createInTexcoord1(int index, Parameter::Content content);
+	static ParameterPtr createOutTexcoord1(int index, Parameter::Content content);
+	static ParameterPtr createInTexcoord2(int index, Parameter::Content content);
+	static ParameterPtr createOutTexcoord2(int index, Parameter::Content content);
+	static ParameterPtr createInTexcoord3(int index, Parameter::Content content);
+	static ParameterPtr createOutTexcoord3(int index, Parameter::Content content);
+	static ParameterPtr createInTexcoord4(int index, Parameter::Content content);			
+	static ParameterPtr createOutTexcoord4(int index, Parameter::Content content);
+
+	static ParameterPtr createConstParamVector2(Vector2 val);
+	static ParameterPtr createConstParamVector3(Vector3 val);
+	static ParameterPtr createConstParamVector4(Vector4 val);
+	static ParameterPtr createConstParamFloat(float val);	
+
+	static UniformParameterPtr createSampler(GpuConstantType type, int index);
+	static UniformParameterPtr createSampler1D(int index);
+	static UniformParameterPtr createSampler2D(int index);
+	static UniformParameterPtr createSampler2DArray(int index);
+	static UniformParameterPtr createSampler3D(int index);
+	static UniformParameterPtr createSamplerCUBE(int index);	
+
+	static UniformParameterPtr createUniform(GpuConstantType type, int index, uint16 variability, const String& suggestedName, size_t size);
 };
 
 

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

@@ -53,7 +53,7 @@ class _OgreRTSSExport Program : public RTShaderSystemAlloc
 // Interface.
 public:	
 	/** Get the type of this program. */
-	GpuProgramType				getType						() const;
+	GpuProgramType getType() const;
 
 	/** Resolve uniform auto constant parameter with associated real data of this program.
 	@param autoType The auto type of the desired parameter.	
@@ -61,7 +61,7 @@ public:
 	@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);
+	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.	
@@ -70,7 +70,7 @@ public:
 	@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);
+	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.	
@@ -78,7 +78,7 @@ public:
 	@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);
+	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.
@@ -87,7 +87,7 @@ public:
 	@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);
+	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.
@@ -98,68 +98,68 @@ 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 type and index.
 	*/
-	UniformParameterPtr		resolveParameter			(GpuConstantType type, int index, uint16 variability, const String& suggestedName, size_t size = 0);
+	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);
+	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);
+	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);
+	UniformParameterPtr getParameterByType(GpuConstantType type, int index);
 
 	/** Get the list of uniform parameters of this program.
 	*/
-	const UniformParameterList&	getParameters		() const { return mParameters; };
+	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);
+	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);
+	Function* getFunctionByName(const String& name);
 
 	/** Get the function list of this program.
 	*/
-	const ShaderFunctionList&	getFunctions				() const { return mFunctions; };
+	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; }
+	void setEntryPointFunction(Function* function) { mEntryPointFunction = function; }
 
 	/** Get the entry point function of this program.*/
-	Function*					getEntryPointFunction		()					 { return mEntryPointFunction; }
+	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);
+	void addDependency(const String& libFileName);
 
 	/** Get the number of external libs this program depends on */
-	size_t						getDependencyCount			() const;
+	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;
+	const String& getDependency(unsigned int index) const;
 	
 
 	/** Sets whether a vertex program includes the required instructions
@@ -178,32 +178,38 @@ protected:
 	/** Class constructor.
 	@param type The type of this program.
 	*/
-	Program			(GpuProgramType type);
+	Program(GpuProgramType type);
 
 	/** Class destructor */
-	~Program		();
+	~Program();
 
 	/** Destroy all parameters of this program. */
-	void						destroyParameters	();
+	void destroyParameters();
 
 	/** Destroy all functions of this program. */
-	void						destroyFunctions	();
+	void destroyFunctions();
 
 	/** Add parameter to this program. */
-	void						addParameter				(UniformParameterPtr parameter);
+	void addParameter(UniformParameterPtr parameter);
 		
 	/** Remove parameter from this program. */
-	void						removeParameter				(UniformParameterPtr parameter);
+	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
+	// Program type. (Vertex, Fragment, Geometry).
+	GpuProgramType mType;
+	// Program uniform parameters.	
+	UniformParameterList mParameters;
+	// Function list.
+	ShaderFunctionList mFunctions;
+	// Entry point function for this program.	
+	Function* mEntryPointFunction;
+	// Program dependencies.
+	StringVector mDependencies;
+	// Skeletal animation calculation
+	bool mSkeletalAnimation;
 private:
 	friend class ProgramManager;
 };