- Refactoring

- Moving the renderer to new material code

CMakeLists.txt

@@ -11,18 +11,25 @@ IF(${CMAKE_SYSTEM_NAME} STREQUAL Linux)
 	ADD_DEFINITIONS("-DPLATFORM_LINUX")
 ELSEIF(${CMAKE_SYSTEM_NAME} STREQUAL Windows)
 	ADD_DEFINITIONS("-DPLATFORM_WINDOWS")
-ENDIF(${CMAKE_SYSTEM_NAME} STREQUAL Linux)
+ENDIF()
 
 
 FIND_PACKAGE(Subversion)
 IF(Subversion_FOUND)
 	Subversion_WC_INFO(${CMAKE_CURRENT_SOURCE_DIR} ER)
 	ADD_DEFINITIONS("-DREVISION=${ER_WC_REVISION}")
-ELSE(Subversion_FOUND)
+ELSE()
 	ADD_DEFINITIONS("-DREVISION=???")
-ENDIF(Subversion_FOUND)
+ENDIF()
 
-ADD_DEFINITIONS("-DMATH_INTEL_SIMD -pedantic-errors -pedantic -ansi -Wall -Winline -W -Wwrite-strings -Wno-unused -Wno-long-long -fsingle-precision-constant -msse4")
+ADD_DEFINITIONS("-DMATH_INTEL_SIMD -pedantic-errors -pedantic -ansi -Wall -Winline -W -Wwrite-strings -Wno-unused -Wno-long-long -msse4")
+
+# Add a few compiler specific stuff 
+IF(${CMAKE_CXX_COMPILER} MATCHES ".*clang\\+\\+$")	
+	# Do nothing
+ELSE()
+	ADD_DEFINITIONS("-fsingle-precision-constant")
+ENDIF()
 
 IF(CMAKE_BUILD_TYPE STREQUAL Release OR CMAKE_BUILD_TYPE STREQUAL RelWithDebInfo)
 	ADD_DEFINITIONS("-DBOOST_DISABLE_ASSERTS -mtune=core2 -ffast-math")

src/Main.cpp

@@ -15,7 +15,7 @@
 #include "Scene/SpotLight.h"
 #include "Resources/Material.h"
 #include "Scene/Scene.h"
-#include "Util/Scanner/Scanner.h"
+#include "Util/scanner/Scanner.h"
 #include "Resources/SkelAnim.h"
 #include "Resources/LightRsrc.h"
 #include "Misc/Parser.h"

src/Misc/Parser.h

@@ -3,7 +3,7 @@
 
 #include <boost/lexical_cast.hpp>
 #include "Util/Exception.h"
-#include "Util/Scanner/Scanner.h"
+#include "Util/scanner/Scanner.h"
 
 
 /// It contains some functions and macros that are used pretty often while
@@ -37,7 +37,7 @@ namespace Parser {
 /// @param arr The array that the func returns the numbers
 /// @exception Exception
 template <typename Type>
-void parseArrOfNumbers(Scanner::Scanner& scanner, bool bracket, bool signs,
+void parseArrOfNumbers(scanner::Scanner& scanner, bool bracket, bool signs,
 	uint size, Type* arr);
 
 /// Parse a single number
@@ -45,25 +45,25 @@ void parseArrOfNumbers(Scanner::Scanner& scanner, bool bracket, bool signs,
 /// @param sign If true expect sign or not
 /// @param out The output number
 template <typename Type>
-void parseNumber(Scanner::Scanner& scanner, bool sign, Type& out);
+void parseNumber(scanner::Scanner& scanner, bool sign, Type& out);
 
 /// Parses a math structure (Vec3, Vec4, Mat3 etc) with leading and following
 /// brackets. Eg {0.1 0.2 0.3}
 template <typename Type>
-void parseMathVector(Scanner::Scanner& scanner, Type& out);
+void parseMathVector(scanner::Scanner& scanner, Type& out);
 
 /// Parse true or false identifiers
-extern bool parseBool(Scanner::Scanner& scanner);
+extern bool parseBool(scanner::Scanner& scanner);
 
 /// Parse identifier
-extern std::string parseIdentifier(Scanner::Scanner& scanner,
+extern std::string parseIdentifier(scanner::Scanner& scanner,
 	const char* expectedIdentifier = NULL);
 
 /// Is identifier
-extern bool isIdentifier(const Scanner::Token& token, const char* str);
+extern bool isIdentifier(const scanner::Token& token, const char* str);
 
 /// Parse string
-extern std::string parseString(Scanner::Scanner& scanner);
+extern std::string parseString(scanner::Scanner& scanner);
 
 
 } // end namespace Parser

src/Misc/Parser.inl.h

@@ -10,16 +10,16 @@ namespace Parser {
 // parseArrOfNumbers                                                           =
 //==============================================================================
 template <typename Type>
-void parseArrOfNumbers(Scanner::Scanner& scanner, bool bracket, bool signs,
+void parseArrOfNumbers(scanner::Scanner& scanner, bool bracket, bool signs,
 	uint size, Type* arr)
 {
-	const Scanner::Token* token;
+	const scanner::Token* token;
 
 	// first of all the left bracket
 	if(bracket)
 	{
 		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_LBRACKET)
+		if(token->getCode() != scanner::TC_L_BRACKET)
 		{
 			throw PARSER_EXCEPTION_EXPECTED("{");
 		}
@@ -35,19 +35,19 @@ void parseArrOfNumbers(Scanner::Scanner& scanner, bool bracket, bool signs,
 		bool sign = 0; // sign of the number. 0 for positive and 1 for negative
 		if(signs)
 		{
-			if(token->getCode() == Scanner::TC_MINUS)
+			if(token->getCode() == scanner::TC_MINUS)
 			{
 				sign = 1;
 				token = &scanner.getNextToken();
 			}
-			else if(token->getCode() == Scanner::TC_PLUS)
+			else if(token->getCode() == scanner::TC_PLUS)
 			{
 				sign = 0;
 				token = &scanner.getNextToken();
 			}
 
 			// check if not number
-			if(token->getCode() != Scanner::TC_NUMBER)
+			if(token->getCode() != scanner::TC_NUMBER)
 			{
 				throw PARSER_EXCEPTION_EXPECTED("number");
 			}
@@ -56,7 +56,7 @@ void parseArrOfNumbers(Scanner::Scanner& scanner, bool bracket, bool signs,
 		// put the number in the arr and do typecasting from int to float
 		Type nmbr;
 
-		if(token->getDataType() == Scanner::DT_FLOAT)
+		if(token->getDataType() == scanner::DT_FLOAT)
 		{
 			nmbr = static_cast<Type>(token->getValue().getFloat());
 		}
@@ -72,7 +72,7 @@ void parseArrOfNumbers(Scanner::Scanner& scanner, bool bracket, bool signs,
 	if(bracket)
 	{
 		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_RBRACKET)
+		if(token->getCode() != scanner::TC_R_BRACKET)
 		{
 			throw PARSER_EXCEPTION_EXPECTED("}");
 		}
@@ -84,39 +84,39 @@ void parseArrOfNumbers(Scanner::Scanner& scanner, bool bracket, bool signs,
 // parseNumber                                                                 =
 //==============================================================================
 template <typename Type>
-void parseNumber(Scanner::Scanner& scanner, bool sign, Type& out)
+void parseNumber(scanner::Scanner& scanner, bool sign, Type& out)
 {
 	try
 	{
-		const Scanner::Token* token = &scanner.getNextToken();
+		const scanner::Token* token = &scanner.getNextToken();
 		bool negative = false;
 
 		// check the sign if any
 		if(sign)
 		{
-			if(token->getCode() == Scanner::TC_PLUS)
+			if(token->getCode() == scanner::TC_PLUS)
 			{
 				negative = false;
 				token = &scanner.getNextToken();
 			}
-			else if(token->getCode() == Scanner::TC_MINUS)
+			else if(token->getCode() == scanner::TC_MINUS)
 			{
 				negative = true;
 				token = &scanner.getNextToken();
 			}
-			else if(token->getCode() != Scanner::TC_NUMBER)
+			else if(token->getCode() != scanner::TC_NUMBER)
 			{
 				throw PARSER_EXCEPTION_EXPECTED("number or sign");
 			}
 		}
 
 		// check the number
-		if(token->getCode() != Scanner::TC_NUMBER)
+		if(token->getCode() != scanner::TC_NUMBER)
 		{
 			throw PARSER_EXCEPTION_EXPECTED("number");
 		}
 
-		if(token->getDataType() == Scanner::DT_FLOAT)
+		if(token->getDataType() == scanner::DT_FLOAT)
 		{
 			double d = negative ? -token->getValue().getFloat() :
 				token->getValue().getFloat();
@@ -140,15 +140,15 @@ void parseNumber(Scanner::Scanner& scanner, bool sign, Type& out)
 // parseMathVector                                                             =
 //==============================================================================
 template <typename Type>
-void parseMathVector(Scanner::Scanner& scanner, Type& out)
+void parseMathVector(scanner::Scanner& scanner, Type& out)
 {
 	try
 	{
-		const Scanner::Token* token = &scanner.getNextToken();
+		const scanner::Token* token = &scanner.getNextToken();
 		uint elementsNum = sizeof(Type) / sizeof(float);
 
 		// {
-		if(token->getCode() != Scanner::TC_LBRACKET)
+		if(token->getCode() != scanner::TC_L_BRACKET)
 		{
 			throw PARSER_EXCEPTION_EXPECTED("{");
 		}
@@ -163,7 +163,7 @@ void parseMathVector(Scanner::Scanner& scanner, Type& out)
 
 		// }
 		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_RBRACKET)
+		if(token->getCode() != scanner::TC_R_BRACKET)
 		{
 			throw PARSER_EXCEPTION_EXPECTED("}");
 		}
@@ -178,12 +178,12 @@ void parseMathVector(Scanner::Scanner& scanner, Type& out)
 //==============================================================================
 // parseBool                                                                   =
 //==============================================================================
-inline bool parseBool(Scanner::Scanner& scanner)
+inline bool parseBool(scanner::Scanner& scanner)
 {
 	const char* errMsg = "identifier true or false";
 
-	const Scanner::Token* token = &scanner.getNextToken();
-	if(token->getCode() != Scanner::TC_IDENTIFIER)
+	const scanner::Token* token = &scanner.getNextToken();
+	if(token->getCode() != scanner::TC_IDENTIFIER)
 	{
 		throw PARSER_EXCEPTION_EXPECTED(errMsg);
 	}
@@ -206,11 +206,11 @@ inline bool parseBool(Scanner::Scanner& scanner)
 //==============================================================================
 // parseIdentifier                                                             =
 //==============================================================================
-inline std::string parseIdentifier(Scanner::Scanner& scanner,
+inline std::string parseIdentifier(scanner::Scanner& scanner,
 	const char* expectedIdentifier)
 {
-	const Scanner::Token* token = &scanner.getNextToken();
-	if(token->getCode() != Scanner::TC_IDENTIFIER)
+	const scanner::Token* token = &scanner.getNextToken();
+	if(token->getCode() != scanner::TC_IDENTIFIER)
 	{
 		if(expectedIdentifier == NULL)
 		{
@@ -235,9 +235,9 @@ inline std::string parseIdentifier(Scanner::Scanner& scanner,
 //==============================================================================
 // isIdentifier                                                                =
 //==============================================================================
-inline bool isIdentifier(const Scanner::Token& token, const char* str)
+inline bool isIdentifier(const scanner::Token& token, const char* str)
 {
-	return token.getCode() == Scanner::TC_IDENTIFIER &&
+	return token.getCode() == scanner::TC_IDENTIFIER &&
 		!strcmp(token.getValue().getString(), str);
 }
 
@@ -245,10 +245,10 @@ inline bool isIdentifier(const Scanner::Token& token, const char* str)
 //==============================================================================
 // parseString                                                                 =
 //==============================================================================
-inline std::string parseString(Scanner::Scanner& scanner)
+inline std::string parseString(scanner::Scanner& scanner)
 {
-	const Scanner::Token* token = &scanner.getNextToken();
-	if(token->getCode() != Scanner::TC_STRING)
+	const scanner::Token* token = &scanner.getNextToken();
+	if(token->getCode() != scanner::TC_STRING)
 	{
 		throw PARSER_EXCEPTION_EXPECTED("string");
 	}

src/Scene/SkinPatchNodeDeformer.cpp → src/Renderer/Deformer.cpp

@@ -1,28 +1,33 @@
-#include "SkinPatchNodeDeformer.h"
+#include "Deformer.h"
 #include "Resources/ShaderProgram.h"
 #include "Resources/Material.h"
-#include "SkinPatchNode.h"
-#include "SkinNode.h"
+#include "Scene/SkinPatchNode.h"
+#include "Scene/SkinNode.h"
+#include "MainRenderer.h"
+
+
+namespace R {
 
 
 //==============================================================================
 // Constructors & destructor                                                   =
 //==============================================================================
 
-SkinPatchNodeDeformer::SkinPatchNodeDeformer()
+Deformer::Deformer(const MainRenderer& mainR_)
+:	mainR(mainR_)
 {
 	init();
 }
 
 
-SkinPatchNodeDeformer::~SkinPatchNodeDeformer()
+Deformer::~Deformer()
 {}
 
 
 //==============================================================================
 // init                                                                        =
 //==============================================================================
-void SkinPatchNodeDeformer::init()
+void Deformer::init()
 {
 	//
 	// Load the shaders
@@ -35,11 +40,13 @@ void SkinPatchNodeDeformer::init()
 //==============================================================================
 // deform                                                                      =
 //==============================================================================
-void SkinPatchNodeDeformer::deform(SkinPatchNode& node) const
+void Deformer::deform(SkinPatchNode& node) const
 {
 	ASSERT(node.getParent() != NULL); // The SkinPatchNodes always have parent
 	ASSERT(static_cast<SceneNode*>(node.getParent())->getSceneNodeType() ==
-		SceneNode::SNT_SKIN); // And their parent must be
+		SceneNode::SNT_SKIN); // And their parent must be SkinNode
+	ASSERT(node.isFlagEnabled(SceneNode::SNF_VISIBLE)); // And it should be
+	                                                    // visible
 
 	SkinNode* skinNode = static_cast<SkinNode*>(node.getParent());
 
@@ -92,3 +99,6 @@ void SkinPatchNodeDeformer::deform(SkinPatchNode& node) const
 
 	GlStateMachineSingleton::getInstance().disable(GL_RASTERIZER_DISCARD);
 }
+
+
+} // end namespace

src/Renderer/Deformer.h

@@ -0,0 +1,39 @@
+#ifndef DEFORMER_H
+#define DEFORMER_H
+
+#include "Resources/RsrcPtr.h"
+
+
+class ShaderProgram;
+class SkinPatchNode;
+
+
+namespace R {
+
+
+class MainRenderer;
+
+
+/// SkinPatchNode deformer. It gets a SkinPatchNode and using transform
+/// feedback it deforms its vertex attributes
+class Deformer
+{
+	public:
+		Deformer(const MainRenderer& mainR);
+		~Deformer();
+
+		void deform(SkinPatchNode& node) const;
+
+	private:
+		const MainRenderer& mainR; ///< Know your father
+		RsrcPtr<ShaderProgram> tfHwSkinningAllSProg;
+		RsrcPtr<ShaderProgram> tfHwSkinningPosSProg;
+
+		void init();
+};
+
+
+} // end namespace
+
+
+#endif

src/Renderer/Drawers/SceneDrawer.cpp

@@ -29,7 +29,6 @@ SceneDrawer::UsrDefVarVisitor::UsrDefVarVisitor(
 // Visitor functors                                                            =
 //==============================================================================
 
-
 template<typename Type>
 void SceneDrawer::UsrDefVarVisitor::operator()(const Type& x) const
 {
@@ -37,6 +36,7 @@ void SceneDrawer::UsrDefVarVisitor::operator()(const Type& x) const
 }
 
 
+template<>
 void SceneDrawer::UsrDefVarVisitor::operator()(const RsrcPtr<Texture>* x) const
 {
 	const RsrcPtr<Texture>& texPtr = *x;
@@ -46,42 +46,21 @@ void SceneDrawer::UsrDefVarVisitor::operator()(const RsrcPtr<Texture>* x) const
 }
 
 
-template<>
-void SceneDrawer::UsrDefVarVisitor::operator()(
-	const MtlUserDefinedVar::Fai& x) const
-{
-	switch(x)
-	{
-		case MtlUserDefinedVar::MS_DEPTH_FAI:
-			udvr.getUniVar().set(r.getMs().getDepthFai(), texUnit);
-			break;
-		case MtlUserDefinedVar::IS_FAI:
-			udvr.getUniVar().set(r.getIs().getFai(), texUnit);
-			break;
-		case MtlUserDefinedVar::PPS_PRE_PASS_FAI:
-			udvr.getUniVar().set(r.getPps().getPrePassFai(), texUnit);
-			break;
-		case MtlUserDefinedVar::PPS_POST_PASS_FAI:
-			udvr.getUniVar().set(r.getPps().getPostPassFai(), texUnit);
-			break;
-		default:
-			ASSERT(0);
-	}
-	++texUnit;
-}
-
-
-
 //==============================================================================
 // setupShaderProg                                                             =
 //==============================================================================
 void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
+	PassType passType,
 	const Transform& nodeWorldTransform, const Camera& cam,
 	const Renderer& r, float blurring)
 {
+	typedef MaterialBuildinVariable Mvb; // Short name
 	uint textureUnit = 0;
 
-	mtlr.getMaterial().getShaderProg().bind();
+	const Material& mtl = mtlr.getMaterial();
+	const ShaderProgram& sprog = mtl.getShaderProgram(passType);
+
+	sprog.bind();
 
 	//
 	// FFP stuff
@@ -117,9 +96,9 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
 	Mat4 modelViewProjectionMat;
 
 	// should I calculate the modelViewMat ?
-	if(mtlr.getStdUniVar(Material::SUV_MODELVIEW_MAT) ||
-	   mtlr.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT) ||
-	   mtlr.getStdUniVar(Material::SUV_NORMAL_MAT))
+	if(mtl.buildinVariableExits(Mvb::MODELVIEW_MAT, passType) ||
+		mtl.buildinVariableExits(Mvb::MODELVIEWPROJECTION_MAT, passType) ||
+		mtl.buildinVariableExits(Mvb::NORMAL_MAT, passType))
 	{
 		// Optimization
 		if(modelMat == Mat4::getIdentity())
@@ -133,42 +112,45 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
 	}
 
 	// set matrices
-	if(mtlr.getStdUniVar(Material::SUV_MODEL_MAT))
+	if(mtl.buildinVariableExits(Mvb::MODEL_MAT, passType))
 	{
-		mtlr.getStdUniVar(Material::SUV_MODEL_MAT)->set(&modelMat);
+		mtl.getBuildinVariable(Mvb::MODEL_MAT).
+			getShaderProgramUniformVariable(passType).set(&modelMat);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_VIEW_MAT))
+	/// XXX
+
+	if(mtlr.getStdUniVar(Mvb::VIEW_MAT))
 	{
-		mtlr.getStdUniVar(Material::SUV_VIEW_MAT)->set(&viewMat);
+		mtlr.getStdUniVar(Mvb::VIEW_MAT)->set(&viewMat);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_PROJECTION_MAT))
+	if(mtlr.getStdUniVar(Mvb::PROJECTION_MAT))
 	{
-		mtlr.getStdUniVar(Material::SUV_PROJECTION_MAT)->set(&projectionMat);
+		mtlr.getStdUniVar(Mvb::PROJECTION_MAT)->set(&projectionMat);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_MODELVIEW_MAT))
+	if(mtlr.getStdUniVar(Mvb::MODELVIEW_MAT))
 	{
-		mtlr.getStdUniVar(Material::SUV_MODELVIEW_MAT)->set(&modelViewMat);
+		mtlr.getStdUniVar(Mvb::MODELVIEW_MAT)->set(&modelViewMat);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_VIEWPROJECTION_MAT))
+	if(mtlr.getStdUniVar(Mvb::VIEWPROJECTION_MAT))
 	{
-		mtlr.getStdUniVar(Material::SUV_VIEWPROJECTION_MAT)->set(
+		mtlr.getStdUniVar(Mvb::VIEWPROJECTION_MAT)->set(
 			&r.getViewProjectionMat());
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_NORMAL_MAT))
+	if(mtlr.getStdUniVar(Mvb::NORMAL_MAT))
 	{
 		normalMat = modelViewMat.getRotationPart();
-		mtlr.getStdUniVar(Material::SUV_NORMAL_MAT)->set(&normalMat);
+		mtlr.getStdUniVar(Mvb::NORMAL_MAT)->set(&normalMat);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT))
+	if(mtlr.getStdUniVar(Mvb::MODELVIEWPROJECTION_MAT))
 	{
 		modelViewProjectionMat = projectionMat * modelViewMat;
-		mtlr.getStdUniVar(Material::SUV_MODELVIEWPROJECTION_MAT)->set(
+		mtlr.getStdUniVar(Mvb::MODELVIEWPROJECTION_MAT)->set(
 			&modelViewProjectionMat);
 	}
 
@@ -176,45 +158,45 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
 	//
 	// FAis
 	//
-	if(mtlr.getStdUniVar(Material::SUV_MS_NORMAL_FAI))
+	if(mtlr.getStdUniVar(Mvb::MS_NORMAL_FAI))
 	{
-		mtlr.getStdUniVar(Material::SUV_MS_NORMAL_FAI)->set(
+		mtlr.getStdUniVar(Mvb::MS_NORMAL_FAI)->set(
 			r.getMs().getNormalFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI))
+	if(mtlr.getStdUniVar(Mvb::MS_DIFFUSE_FAI))
 	{
-		mtlr.getStdUniVar(Material::SUV_MS_DIFFUSE_FAI)->set(
+		mtlr.getStdUniVar(Mvb::MS_DIFFUSE_FAI)->set(
 			r.getMs().getDiffuseFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_MS_SPECULAR_FAI))
+	if(mtlr.getStdUniVar(Mvb::MS_SPECULAR_FAI))
 	{
-		mtlr.getStdUniVar(Material::SUV_MS_SPECULAR_FAI)->set(
+		mtlr.getStdUniVar(Mvb::MS_SPECULAR_FAI)->set(
 			r.getMs().getSpecularFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_MS_DEPTH_FAI))
+	if(mtlr.getStdUniVar(Mvb::MS_DEPTH_FAI))
 	{
-		mtlr.getStdUniVar(Material::SUV_MS_DEPTH_FAI)->set(
+		mtlr.getStdUniVar(Mvb::MS_DEPTH_FAI)->set(
 			r.getMs().getDepthFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_IS_FAI))
+	if(mtlr.getStdUniVar(Mvb::IS_FAI))
 	{
-		mtlr.getStdUniVar(Material::SUV_IS_FAI)->set(r.getIs().getFai(),
+		mtlr.getStdUniVar(Mvb::IS_FAI)->set(r.getIs().getFai(),
 			textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI))
+	if(mtlr.getStdUniVar(Mvb::PPS_PRE_PASS_FAI))
 	{
-		mtlr.getStdUniVar(Material::SUV_PPS_PRE_PASS_FAI)->set(
+		mtlr.getStdUniVar(Mvb::PPS_PRE_PASS_FAI)->set(
 			r.getPps().getPrePassFai(), textureUnit++);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI))
+	if(mtlr.getStdUniVar(Mvb::PPS_POST_PASS_FAI))
 	{
-		mtlr.getStdUniVar(Material::SUV_PPS_POST_PASS_FAI)->set(
+		mtlr.getStdUniVar(Mvb::PPS_POST_PASS_FAI)->set(
 			r.getPps().getPostPassFai(), textureUnit++);
 	}
 
@@ -222,24 +204,24 @@ void SceneDrawer::setupShaderProg(const MaterialRuntime& mtlr,
 	//
 	// Other
 	//
-	if(mtlr.getStdUniVar(Material::SUV_RENDERER_SIZE))
+	if(mtlr.getStdUniVar(Mvb::RENDERER_SIZE))
 	{
 		Vec2 v(r.getWidth(), r.getHeight());
-		mtlr.getStdUniVar(Material::SUV_RENDERER_SIZE)->set(&v);
+		mtlr.getStdUniVar(Mvb::RENDERER_SIZE)->set(&v);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR))
+	if(mtlr.getStdUniVar(Mvb::SCENE_AMBIENT_COLOR))
 	{
 		Vec3 col(SceneSingleton::getInstance().getAmbientCol());
-		mtlr.getStdUniVar(Material::SUV_SCENE_AMBIENT_COLOR)->set(&col);
+		mtlr.getStdUniVar(Mvb::SCENE_AMBIENT_COLOR)->set(&col);
 	}
 
-	if(mtlr.getStdUniVar(Material::SUV_BLURRING))
+	if(mtlr.getStdUniVar(Mvb::BLURRING))
 	{
 		/*blurring *= 10.0;
 		INFO(blurring);*/
 		float b = blurring;
-		mtlr.getStdUniVar(Material::SUV_BLURRING)->set(&b);
+		mtlr.getStdUniVar(Mvb::BLURRING)->set(&b);
 	}
 
 

src/Renderer/Drawers/SceneDrawer.h

@@ -1,16 +1,16 @@
 #ifndef R_SCENE_DRAWER_H
 #define R_SCENE_DRAWER_H
 
-#include <boost/variant.hpp>
 #include "Math/Math.h"
-#include "Resources/MtlUserDefinedVar.h"
+#include "Resources/MaterialCommon.h"
+#include <boost/variant.hpp>
 
 
 class RenderableNode;
 class Camera;
 class Material;
 class MaterialRuntime;
-class MaterialRuntimeUserDefinedVar;
+class MaterialRuntimeVariable;
 
 
 namespace R {
@@ -23,34 +23,27 @@ class Renderer;
 class SceneDrawer
 {
 	public:
-		enum RenderingPassType
-		{
-			RPT_COLOR,
-			RPT_DEPTH
-		};
-
 		/// The one and only constructor
 		SceneDrawer(const Renderer& r_): r(r_) {}
 
 		void renderRenderableNode(const RenderableNode& renderable,
-			const Camera& cam, RenderingPassType rtype) const;
+			const Camera& cam, PassType passType) const;
 
 	private:
 		/// Set the uniform using this visitor
 		class UsrDefVarVisitor: public boost::static_visitor<>
 		{
 			public:
-				const MaterialRuntimeUserDefinedVar& udvr;
+				const MaterialRuntimeVariable& udvr;
 				const Renderer& r;
 				uint& texUnit;
 
-				UsrDefVarVisitor(const MaterialRuntimeUserDefinedVar& udvr,
+				UsrDefVarVisitor(const MaterialRuntimeVariable& udvr,
 					const Renderer& r, uint& texUnit);
 
+				/// Functor. Its specialized for the texture case
 				template<typename Type>
 				void operator()(const Type& x) const;
-
-				void operator()(const RsrcPtr<Texture>* x) const;
 		};
 
 		const Renderer& r; ///< Keep it here cause the class wants a few stuff

src/Renderer/MainRenderer.cpp

@@ -11,14 +11,22 @@
 #include "Ssao.h"
 #include "Core/Logger.h"
 #include "GfxApi/TimeQuery.h"
+#include "Deformer.h"
 
 
 namespace R {
 
 
 //==============================================================================
-// Destructor                                                                  =
+// Constructors & destructor                                                   =
 //==============================================================================
+MainRenderer::MainRenderer():
+	dbg(*this),
+	screenshotJpegQuality(90),
+	deformer(new Deformer(*this))
+{}
+
+
 MainRenderer::~MainRenderer()
 {}
 

src/Renderer/MainRenderer.h

@@ -3,11 +3,15 @@
 
 #include "Renderer.h"
 #include "Util/Singleton.h"
+#include <boost/scoped_ptr.hpp>
 
 
 namespace R {
 
 
+class Deformer;
+
+
 /// Main onscreen renderer
 class MainRenderer: public Renderer
 {
@@ -59,18 +63,14 @@ class MainRenderer: public Renderer
 		/// of the application's window size. From 0.0(low) to 1.0(high)
 		float renderingQuality;
 
+		boost::scoped_ptr<Deformer> deformer;
+
 		void takeScreenshotTga(const char* filename);
 		void takeScreenshotJpeg(const char* filename);
 		static void initGl();
 };
 
 
-inline MainRenderer::MainRenderer():
-	dbg(*this),
-	screenshotJpegQuality(90)
-{}
-
-
 } // end namespace
 
 

src/Resources/Image.h

@@ -15,7 +15,7 @@ class Image
 		{
 			CT_R, ///< Red only
 			CT_RGB, ///< RGB
-			CT_RGBA /// RGB plus alpha
+			CT_RGBA ///< RGB plus alpha
 		};
 
 		/// The data compression

src/Resources/Material.cpp

@@ -263,7 +263,7 @@ void Material::populateVariables(const boost::property_tree::ptree& pt)
 				new MaterialBuildinVariable(svName, sProgs_);
 
 			mtlVars.push_back(v);
-			buildinsArr[v->getVariableEnum()] = v;
+			buildinsArr[v->getMatchingVariable()] = v;
 		}
 		// User defined
 		else

src/Resources/Material.h

@@ -88,11 +88,11 @@ class Material: private MaterialProperties
 
 		typedef boost::ptr_vector<MaterialVariable> VarsContainer;
 
-		typedef boost::unordered_map<MaterialBuildinVariable::BuildinEnum,
-			MaterialBuildinVariable*> BuildinEnumToBuildinHashMap;
+		typedef boost::unordered_map<MaterialBuildinVariable::MatchingVariable,
+			MaterialBuildinVariable*> MatchingVariableToBuildinHashMap;
 
 		typedef boost::array<MaterialBuildinVariable*,
-			MaterialBuildinVariable::BUILDINS_NUM> BuildinsArr;
+			MaterialBuildinVariable::MV_NUM> BuildinsArr;
 
 		//======================================================================
 		// Methods                                                             =
@@ -122,15 +122,19 @@ class Material: private MaterialProperties
 		GETTER_R(VarsContainer, mtlVars, getVariables)
 		GETTER_R(Vec<MaterialUserVariable*>, userMtlVars, getUserVariables)
 		const MaterialBuildinVariable& getBuildinVariable(
-			MaterialBuildinVariable::BuildinEnum e) const;
+			MaterialBuildinVariable::MatchingVariable e) const;
 		/// @}
 
 		/// Load a material file
 		void load(const char* filename);
 
-		/// Check if a buildin variable exists
-		bool buildinVariableExits(MaterialBuildinVariable::BuildinEnum e)
-			const {return buildinsArr[e] != NULL;}
+		/// Check if a buildin variable exists in a pass type
+		bool buildinVariableExits(MaterialBuildinVariable::MatchingVariable e,
+			PassType p) const;
+
+		/// Check if a buildin variable exists in a any pass type
+		bool buildinVariableExits(MaterialBuildinVariable::MatchingVariable e) const
+			{return buildinsArr[e] != NULL;}
 
 	private:
 		//======================================================================
@@ -173,11 +177,20 @@ class Material: private MaterialProperties
 
 
 inline const MaterialBuildinVariable& Material::getBuildinVariable(
-	MaterialBuildinVariable::BuildinEnum e) const
+	MaterialBuildinVariable::MatchingVariable e) const
 {
 	ASSERT(buildinVariableExits(e));
 	return *buildinsArr[e];
 }
 
 
+inline bool Material::buildinVariableExits(
+	MaterialBuildinVariable::MatchingVariable e,
+	PassType p) const
+
+{
+	return buildinsArr[e] != NULL && buildinsArr[e]->inPass(p);
+}
+
+
 #endif

src/Resources/MaterialBuildinVariable.cpp

@@ -10,54 +10,54 @@
 // Statics                                                                     =
 //==============================================================================
 
-ConstCharPtrHashMap<MaterialBuildinVariable::BuildinEnum>::Type
+ConstCharPtrHashMap<MaterialBuildinVariable::MatchingVariable>::Type
 	MaterialBuildinVariable::buildinNameToEnum = boost::assign::map_list_of
-	("position", POSITION)
-	("tangent", TANGENT)
-	("normal", NORMAL)
-	("texCoords", TEX_COORDS)
-	("modelMat", MODEL_MAT)
-	("viewMat", VIEW_MAT)
-	("projectionMat", PROJECTION_MAT)
-	("modelViewMat", MODELVIEW_MAT)
-	("viewProjectionMat", VIEWPROJECTION_MAT)
-	("normalMat", NORMAL_MAT)
-	("modelViewProjectionMat", MODELVIEWPROJECTION_MAT)
-	("msNormalFai", MS_NORMAL_FAI)
-	("msDiffuseFai", MS_DIFFUSE_FAI)
-	("msSpecularFai", MS_SPECULAR_FAI)
-	("msDepthFai", MS_DEPTH_FAI)
-	("isFai", IS_FAI)
-	("ppsPrePassFai", PPS_PRE_PASS_FAI)
-	("ppsPostPassFai", PPS_POST_PASS_FAI)
-	("rendererSize", RENDERER_SIZE)
-	("sceneAmbientColor", SCENE_AMBIENT_COLOR)
-	("blurring", BLURRING);
-
-
-boost::unordered_map<MaterialBuildinVariable::BuildinEnum, GLenum>
+	("position", MV_POSITION)
+	("tangent", MV_TANGENT)
+	("normal", MV_NORMAL)
+	("texCoords", MV_TEX_COORDS)
+	("modelMat", MV_MODEL_MAT)
+	("viewMat", MV_VIEW_MAT)
+	("projectionMat", MV_PROJECTION_MAT)
+	("modelViewMat", MV_MODELVIEW_MAT)
+	("viewProjectionMat", MV_VIEWPROJECTION_MAT)
+	("normalMat", MV_NORMAL_MAT)
+	("modelViewProjectionMat", MV_MODELVIEWPROJECTION_MAT)
+	("msNormalFai", MV_MS_NORMAL_FAI)
+	("msDiffuseFai", MV_MS_DIFFUSE_FAI)
+	("msSpecularFai", MV_MS_SPECULAR_FAI)
+	("msDepthFai", MV_MS_DEPTH_FAI)
+	("isFai", MV_IS_FAI)
+	("ppsPrePassFai", MV_PPS_PRE_PASS_FAI)
+	("ppsPostPassFai", MV_PPS_POST_PASS_FAI)
+	("rendererSize", MV_RENDERER_SIZE)
+	("sceneAmbientColor", MV_SCENE_AMBIENT_COLOR)
+	("blurring", MV_BLURRING);
+
+
+boost::unordered_map<MaterialBuildinVariable::MatchingVariable, GLenum>
 	MaterialBuildinVariable::buildinToGlType = boost::assign::map_list_of
-	(POSITION, GL_FLOAT_VEC3)
-	(TANGENT, GL_FLOAT_VEC4)
-	(NORMAL, GL_FLOAT_VEC3)
-	(TEX_COORDS, GL_FLOAT_VEC2)
-	(MODEL_MAT, GL_FLOAT_MAT4)
-	(VIEW_MAT, GL_FLOAT_MAT4)
-	(PROJECTION_MAT, GL_FLOAT_MAT4)
-	(PROJECTION_MAT, GL_FLOAT_MAT4)
-	(VIEWPROJECTION_MAT, GL_FLOAT_MAT4)
-	(NORMAL_MAT, GL_FLOAT_MAT3)
-	(MODELVIEWPROJECTION_MAT, GL_FLOAT_MAT4)
-	(MS_NORMAL_FAI, GL_SAMPLER_2D)
-	(MS_DIFFUSE_FAI, GL_SAMPLER_2D)
-	(MS_SPECULAR_FAI, GL_SAMPLER_2D)
-	(MS_DEPTH_FAI, GL_SAMPLER_2D)
-	(IS_FAI, GL_SAMPLER_2D)
-	(PPS_PRE_PASS_FAI, GL_SAMPLER_2D)
-	(PPS_POST_PASS_FAI, GL_SAMPLER_2D)
-	(RENDERER_SIZE, GL_FLOAT_VEC2)
-	(SCENE_AMBIENT_COLOR, GL_FLOAT_VEC3)
-	(BLURRING, GL_FLOAT);
+	(MV_POSITION, GL_FLOAT_VEC3)
+	(MV_TANGENT, GL_FLOAT_VEC4)
+	(MV_NORMAL, GL_FLOAT_VEC3)
+	(MV_TEX_COORDS, GL_FLOAT_VEC2)
+	(MV_MODEL_MAT, GL_FLOAT_MAT4)
+	(MV_VIEW_MAT, GL_FLOAT_MAT4)
+	(MV_PROJECTION_MAT, GL_FLOAT_MAT4)
+	(MV_PROJECTION_MAT, GL_FLOAT_MAT4)
+	(MV_VIEWPROJECTION_MAT, GL_FLOAT_MAT4)
+	(MV_NORMAL_MAT, GL_FLOAT_MAT3)
+	(MV_MODELVIEWPROJECTION_MAT, GL_FLOAT_MAT4)
+	(MV_MS_NORMAL_FAI, GL_SAMPLER_2D)
+	(MV_MS_DIFFUSE_FAI, GL_SAMPLER_2D)
+	(MV_MS_SPECULAR_FAI, GL_SAMPLER_2D)
+	(MV_MS_DEPTH_FAI, GL_SAMPLER_2D)
+	(MV_IS_FAI, GL_SAMPLER_2D)
+	(MV_PPS_PRE_PASS_FAI, GL_SAMPLER_2D)
+	(MV_PPS_POST_PASS_FAI, GL_SAMPLER_2D)
+	(MV_RENDERER_SIZE, GL_FLOAT_VEC2)
+	(MV_SCENE_AMBIENT_COLOR, GL_FLOAT_VEC3)
+	(MV_BLURRING, GL_FLOAT);
 
 
 //==============================================================================
@@ -66,8 +66,8 @@ boost::unordered_map<MaterialBuildinVariable::BuildinEnum, GLenum>
 MaterialBuildinVariable::MaterialBuildinVariable(
 	const char* shaderProgVarName,
 	const ShaderPrograms& shaderProgsArr)
-:	MaterialVariable(BUILDIN, shaderProgVarName, shaderProgsArr),
- 	bEnum(BUILDINS_NUM)
+:	MaterialVariable(T_BUILDIN, shaderProgVarName, shaderProgsArr),
+ 	bEnum(MV_NUM)
 {
 	GLenum dataType;
 	// Sanity checks
@@ -89,9 +89,9 @@ MaterialBuildinVariable::MaterialBuildinVariable(
 // isBuildin                                                                   =
 //==============================================================================
 bool MaterialBuildinVariable::isBuildin(const char* name,
-	BuildinEnum* var, GLenum* dataType)
+	MatchingVariable* var, GLenum* dataType)
 {
-	ConstCharPtrHashMap<BuildinEnum>::Type::const_iterator it =
+	ConstCharPtrHashMap<MatchingVariable>::Type::const_iterator it =
 		buildinNameToEnum.find(name);
 
 	if(it == buildinNameToEnum.end())
@@ -106,7 +106,7 @@ bool MaterialBuildinVariable::isBuildin(const char* name,
 
 	if(dataType)
 	{
-		boost::unordered_map<BuildinEnum, GLenum>::const_iterator it2 =
+		boost::unordered_map<MatchingVariable, GLenum>::const_iterator it2 =
 			buildinToGlType.find(it->second);
 
 		ASSERT(it2 != buildinToGlType.end());

src/Resources/MaterialBuildinVariable.h

@@ -3,6 +3,7 @@
 
 #include "MaterialVariable.h"
 #include "Util/ConstCharPtrHashMap.h"
+#include "ShaderProgramUniformVariable.h"
 #include <boost/array.hpp>
 
 
@@ -12,56 +13,71 @@ class MaterialBuildinVariable: public MaterialVariable
 	public:
 		/// Standard attribute variables that are acceptable inside the
 		/// ShaderProgram
-		enum BuildinEnum
+		enum MatchingVariable
 		{
 			// Attributes
-			POSITION,
-			TANGENT,
-			NORMAL,
-			TEX_COORDS,
+			MV_POSITION,
+			MV_TANGENT,
+			MV_NORMAL,
+			MV_TEX_COORDS,
 			// Uniforms
 			// Matrices
-			MODEL_MAT,
-			VIEW_MAT,
-			PROJECTION_MAT,
-			MODELVIEW_MAT,
-			VIEWPROJECTION_MAT,
-			NORMAL_MAT,
-			MODELVIEWPROJECTION_MAT,
+			MV_MODEL_MAT,
+			MV_VIEW_MAT,
+			MV_PROJECTION_MAT,
+			MV_MODELVIEW_MAT,
+			MV_VIEWPROJECTION_MAT,
+			MV_NORMAL_MAT,
+			MV_MODELVIEWPROJECTION_MAT,
 			// FAIs (for materials in blending stage)
-			MS_NORMAL_FAI,
-			MS_DIFFUSE_FAI,
-			MS_SPECULAR_FAI,
-			MS_DEPTH_FAI,
-			IS_FAI,
-			PPS_PRE_PASS_FAI,
-			PPS_POST_PASS_FAI,
+			MV_MS_NORMAL_FAI,
+			MV_MS_DIFFUSE_FAI,
+			MV_MS_SPECULAR_FAI,
+			MV_MS_DEPTH_FAI,
+			MV_IS_FAI,
+			MV_PPS_PRE_PASS_FAI,
+			MV_PPS_POST_PASS_FAI,
 			// Other
-			RENDERER_SIZE,
-			SCENE_AMBIENT_COLOR,
-			BLURRING,
+			MV_RENDERER_SIZE,
+			MV_SCENE_AMBIENT_COLOR,
+			MV_BLURRING,
 			// num
-			BUILDINS_NUM ///< The number of all buildin variables
+			MV_NUM ///< The number of all buildin variables
 		};
 
 		MaterialBuildinVariable(
 			const char* shaderProgVarName,
 			const ShaderPrograms& shaderProgsArr);
 
-		GETTER_R_BY_VAL(BuildinEnum, bEnum, getVariableEnum)
+		GETTER_R_BY_VAL(MatchingVariable, bEnum, getMatchingVariable)
 
-		static bool isBuildin(const char* name, BuildinEnum* var = NULL,
+		/// Uses static cast to get the uniform. It will fail if the variable
+		/// is attribute
+		const ShaderProgramUniformVariable&
+			getShaderProgramUniformVariable(PassType p) const;
+
+		static bool isBuildin(const char* name, MatchingVariable* var = NULL,
 			GLenum* dataType = NULL);
 
 	private:
 		/// Given a name of a variable find its MaterialBuildinVariable enum
-		static ConstCharPtrHashMap<BuildinEnum>::Type buildinNameToEnum;
+		static ConstCharPtrHashMap<MatchingVariable>::Type buildinNameToEnum;
 
 		/// Given a MaterialBuildinVariable enum it gives the GL type
-		static boost::unordered_map<BuildinEnum, GLenum> buildinToGlType;
+		static boost::unordered_map<MatchingVariable, GLenum> buildinToGlType;
 
-		BuildinEnum bEnum;
+		MatchingVariable bEnum;
 };
 
 
+inline const ShaderProgramUniformVariable&
+	MaterialBuildinVariable::getShaderProgramUniformVariable(PassType p) const
+{
+	ASSERT(getShaderProgramVariable(p).getType() ==
+		ShaderProgramVariable::T_UNIFORM);
+	return static_cast<const ShaderProgramUniformVariable&>(
+		getShaderProgramVariable(p));
+}
+
+
 #endif

src/Resources/MaterialShaderProgramCreator.cpp

@@ -1,5 +1,5 @@
 #include "MaterialShaderProgramCreator.h"
-#include "Util/Scanner/Scanner.h"
+#include "Util/scanner/Scanner.h"
 #include "Misc/Parser.h"
 #include "MaterialBuildinVariable.h"
 #include <boost/assign/list_of.hpp>
@@ -82,8 +82,8 @@ MaterialShaderProgramCreator::~MaterialShaderProgramCreator()
 void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 	const char* filename)
 {
-	Scanner::Scanner scanner(filename, false);
-	const Scanner::Token* token = &scanner.getCrntToken();
+	scanner::Scanner scanner(filename, false);
+	const scanner::Token* token = &scanner.getCrntToken();
 
 	// Forever
 	while(true)
@@ -92,18 +92,18 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 		FuncDefinition* funcDef = NULL;
 
 		// EOF
-		if(token->getCode() == Scanner::TC_EOF)
+		if(token->getCode() == scanner::TC_END)
 		{
 			break;
 		}
 		// #
-		else if(token->getCode() == Scanner::TC_SHARP)
+		else if(token->getCode() == scanner::TC_SHARP)
 		{
 			parseUntilNewline(scanner);
 			continue;
 		}
 		// Return type
-		else if(token->getCode() == Scanner::TC_IDENTIFIER)
+		else if(token->getCode() == scanner::TC_IDENTIFIER)
 		{
 			funcDef = new FuncDefinition;
 			funcDefs.push_back(funcDef);
@@ -128,7 +128,7 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 
 		// Function name
 		getNextTokenAndSkipNewlines(scanner);
-		if(token->getCode() != Scanner::TC_IDENTIFIER)
+		if(token->getCode() != scanner::TC_IDENTIFIER)
 		{
 			throw PARSER_EXCEPTION_EXPECTED("identifier");
 		}
@@ -139,7 +139,7 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 
 		// (
 		getNextTokenAndSkipNewlines(scanner);
-		if(token->getCode() != Scanner::TC_LPAREN)
+		if(token->getCode() != scanner::TC_L_PAREN)
 		{
 			throw PARSER_EXCEPTION_EXPECTED("(");
 		}
@@ -152,7 +152,7 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 
 			// Argument qualifier
 			getNextTokenAndSkipNewlines(scanner);
-			if(token->getCode() != Scanner::TC_IDENTIFIER)
+			if(token->getCode() != scanner::TC_IDENTIFIER)
 			{
 				throw PARSER_EXCEPTION_EXPECTED("identifier");
 			}
@@ -179,7 +179,7 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 
 			// Type
 			getNextTokenAndSkipNewlines(scanner);
-			if(token->getCode() != Scanner::TC_IDENTIFIER)
+			if(token->getCode() != scanner::TC_IDENTIFIER)
 			{
 				throw PARSER_EXCEPTION_EXPECTED("identifier");
 			}
@@ -199,7 +199,7 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 
 			// Name
 			getNextTokenAndSkipNewlines(scanner);
-			if(token->getCode() != Scanner::TC_IDENTIFIER)
+			if(token->getCode() != scanner::TC_IDENTIFIER)
 			{
 				throw PARSER_EXCEPTION_EXPECTED("identifier");
 			}
@@ -208,12 +208,12 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 
 			// ,
 			getNextTokenAndSkipNewlines(scanner);
-			if(token->getCode() == Scanner::TC_COMMA)
+			if(token->getCode() == scanner::TC_COMMA)
 			{
 				continue;
 			}
 			// )
-			else if(token->getCode() == Scanner::TC_RPAREN)
+			else if(token->getCode() == scanner::TC_R_PAREN)
 			{
 				break;
 			}
@@ -226,7 +226,7 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 
 		// {
 		getNextTokenAndSkipNewlines(scanner);
-		if(token->getCode() != Scanner::TC_LBRACKET)
+		if(token->getCode() != scanner::TC_L_BRACKET)
 		{
 			throw PARSER_EXCEPTION_EXPECTED("{");
 		}
@@ -237,7 +237,7 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 		{
 			getNextTokenAndSkipNewlines(scanner);
 
-			if(token->getCode() == Scanner::TC_RBRACKET)
+			if(token->getCode() == scanner::TC_R_BRACKET)
 			{
 				if(bracketsNum == 0)
 				{
@@ -245,11 +245,11 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 				}
 				--bracketsNum;
 			}
-			else if(token->getCode() == Scanner::TC_LBRACKET)
+			else if(token->getCode() == scanner::TC_L_BRACKET)
 			{
 				++bracketsNum;
 			}
-			else if(token->getCode() == Scanner::TC_EOF)
+			else if(token->getCode() == scanner::TC_END)
 			{
 				throw PARSER_EXCEPTION_UNEXPECTED();
 			}
@@ -274,22 +274,22 @@ void MaterialShaderProgramCreator::parseShaderFileForFunctionDefinitions(
 //==============================================================================
 // parseUntilNewline                                                           =
 //==============================================================================
-void MaterialShaderProgramCreator::parseUntilNewline(Scanner::Scanner& scanner)
+void MaterialShaderProgramCreator::parseUntilNewline(scanner::Scanner& scanner)
 {
-	const Scanner::Token* token = &scanner.getCrntToken();
-	Scanner::TokenCode prevTc;
+	const scanner::Token* token = &scanner.getCrntToken();
+	scanner::TokenCode prevTc;
 
 	while(true)
 	{
 		prevTc = token->getCode();
 		scanner.getNextToken();
 
-		if(token->getCode() == Scanner::TC_EOF)
+		if(token->getCode() == scanner::TC_END)
 		{
 			break;
 		}
-		else if(token->getCode() == Scanner::TC_NEWLINE &&
-			prevTc != Scanner::TC_BACK_SLASH)
+		else if(token->getCode() == scanner::TC_NEWLINE &&
+			prevTc != scanner::TC_BACK_SLASH)
 		{
 			break;
 		}
@@ -301,14 +301,14 @@ void MaterialShaderProgramCreator::parseUntilNewline(Scanner::Scanner& scanner)
 // getNextTokenAndSkipNewlines                                                 =
 //==============================================================================
 void MaterialShaderProgramCreator::getNextTokenAndSkipNewlines(
-	Scanner::Scanner& scanner)
+	scanner::Scanner& scanner)
 {
-	const Scanner::Token* token;
+	const scanner::Token* token;
 
 	while(true)
 	{
 		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_NEWLINE)
+		if(token->getCode() != scanner::TC_NEWLINE)
 		{
 			break;
 		}
@@ -444,7 +444,7 @@ void MaterialShaderProgramCreator::parseInputTag(
 	// Buildin or varying
 	if(!valuePt)
 	{
-		MaterialBuildinVariable::BuildinEnum tmp;
+		MaterialBuildinVariable::MatchingVariable tmp;
 
 		if(MaterialBuildinVariable::isBuildin(name.c_str(), &tmp, &glType))
 		{

src/Resources/MaterialShaderProgramCreator.h

@@ -9,7 +9,7 @@
 #include <boost/ptr_container/ptr_vector.hpp>
 
 
-namespace Scanner {
+namespace scanner {
 class Scanner;
 }
 
@@ -117,12 +117,12 @@ class MaterialShaderProgramCreator
 		/// 	10
 		/// @endcode
 		/// it skips from define to 10
-		static void parseUntilNewline(Scanner::Scanner& scanner);
+		static void parseUntilNewline(scanner::Scanner& scanner);
 
 		/// It being used by parseShaderFileForFunctionDefinitions and it
 		/// skips until newline after a '#' found. It takes into account the
 		/// back slashes that the preprocessor may have
-		static void getNextTokenAndSkipNewlines(Scanner::Scanner& scanner);
+		static void getNextTokenAndSkipNewlines(scanner::Scanner& scanner);
 
 		/// Used for shorting vectors of strings. Used in std::sort
 		static bool compareStrings(const std::string& a, const std::string& b);

src/Resources/MaterialUserVariable.cpp

@@ -10,11 +10,11 @@ MaterialUserVariable::MaterialUserVariable(
 	const char* shaderProgVarName,
 	const ShaderPrograms& shaderProgsArr,
 	float val)
-:	MaterialVariable(USER, shaderProgVarName, shaderProgsArr)
+:	MaterialVariable(T_USER, shaderProgVarName, shaderProgsArr)
 {
 	ASSERT(getGlDataType() == GL_FLOAT);
 	ASSERT(getShaderProgramVariableType() ==
-		ShaderProgramVariable::UNIFORM);
+		ShaderProgramVariable::T_UNIFORM);
 	data = val;
 }
 
@@ -23,11 +23,11 @@ MaterialUserVariable::MaterialUserVariable(
 	const char* shaderProgVarName,
 	const ShaderPrograms& shaderProgsArr,
 	const Vec2& val)
-:	MaterialVariable(USER, shaderProgVarName, shaderProgsArr)
+:	MaterialVariable(T_USER, shaderProgVarName, shaderProgsArr)
 {
 	ASSERT(getGlDataType() == GL_FLOAT_VEC2);
 	ASSERT(getShaderProgramVariableType() ==
-		ShaderProgramVariable::UNIFORM);
+		ShaderProgramVariable::T_UNIFORM);
 	data = val;
 }
 
@@ -36,11 +36,11 @@ MaterialUserVariable::MaterialUserVariable(
 	const char* shaderProgVarName,
 	const ShaderPrograms& shaderProgsArr,
 	const Vec3& val)
-:	MaterialVariable(USER, shaderProgVarName, shaderProgsArr)
+:	MaterialVariable(T_USER, shaderProgVarName, shaderProgsArr)
 {
 	ASSERT(getGlDataType() == GL_FLOAT_VEC3);
 	ASSERT(getShaderProgramVariableType() ==
-		ShaderProgramVariable::UNIFORM);
+		ShaderProgramVariable::T_UNIFORM);
 	data = val;
 }
 
@@ -49,11 +49,11 @@ MaterialUserVariable::MaterialUserVariable(
 	const char* shaderProgVarName,
 	const ShaderPrograms& shaderProgsArr,
 	const Vec4& val)
-:	MaterialVariable(USER, shaderProgVarName, shaderProgsArr)
+:	MaterialVariable(T_USER, shaderProgVarName, shaderProgsArr)
 {
 	ASSERT(getGlDataType() == GL_FLOAT_VEC4);
 	ASSERT(getShaderProgramVariableType() ==
-		ShaderProgramVariable::UNIFORM);
+		ShaderProgramVariable::T_UNIFORM);
 	data = val;
 }
 
@@ -62,11 +62,11 @@ MaterialUserVariable::MaterialUserVariable(
 	const char* shaderProgVarName,
 	const ShaderPrograms& shaderProgsArr,
 	const char* texFilename)
-:	MaterialVariable(USER, shaderProgVarName, shaderProgsArr)
+:	MaterialVariable(T_USER, shaderProgVarName, shaderProgsArr)
 {
 	ASSERT(getGlDataType() == GL_SAMPLER_2D);
 	ASSERT(getShaderProgramVariableType() ==
-		ShaderProgramVariable::UNIFORM);
+		ShaderProgramVariable::T_UNIFORM);
 	data = RsrcPtr<Texture>();
 	boost::get<RsrcPtr<Texture> >(data).loadRsrc(texFilename);
 }

src/Resources/MaterialVariable.cpp

@@ -20,7 +20,8 @@ MaterialVariable::MaterialVariable(
 	{
 		if(shaderProgsArr[i]->variableExists(shaderProgVarName))
 		{
-			sProgsVars[i] = &shaderProgsArr[i]->getVariable(shaderProgVarName);
+			sProgsVars[i] = &shaderProgsArr[i]->getVariableByName(
+				shaderProgVarName);
 
 			if(!oneSProgVar)
 			{
@@ -41,6 +42,6 @@ MaterialVariable::MaterialVariable(
 	if(!oneSProgVar)
 	{
 		throw EXCEPTION("Variable not found in any of the shader programs: " +
-					shaderProgVarName);
+			shaderProgVarName);
 	}
 }

src/Resources/MaterialVariable.h

@@ -20,8 +20,8 @@ class MaterialVariable
 		/// The type
 		enum Type
 		{
-			USER,
-			BUILDIN
+			T_USER,
+			T_BUILDIN
 		};
 
 		/// XXX Used for initialization in the constructor

src/Resources/ShaderProgram.cpp

@@ -243,9 +243,10 @@ void ShaderProgram::load(const char* filename)
 
 
 //==============================================================================
-// getVariable                                                                 =
+// getVariableByName                                                           =
 //==============================================================================
-const ShaderProgramVariable& ShaderProgram::getVariable(const char* name) const
+const ShaderProgramVariable& ShaderProgram::getVariableByName(
+	const char* name) const
 {
 	VarsHashMap::const_iterator it = nameToVar.find(name);
 	if(it == nameToVar.end())
@@ -257,9 +258,9 @@ const ShaderProgramVariable& ShaderProgram::getVariable(const char* name) const
 
 
 //==============================================================================
-// getAttributeVariable                                                        =
+// getAttributeVariableByName                                                  =
 //==============================================================================
-const ShaderProgramAttributeVariable& ShaderProgram::getAttributeVariable(
+const ShaderProgramAttributeVariable& ShaderProgram::getAttributeVariableByName(
 	const char* name) const
 {
 	AttribVarsHashMap::const_iterator it = nameToAttribVar.find(name);
@@ -272,9 +273,9 @@ const ShaderProgramAttributeVariable& ShaderProgram::getAttributeVariable(
 
 
 //==============================================================================
-// getUniformVariable                                                          =
+// getUniformVariableByName                                                    =
 //==============================================================================
-const ShaderProgramUniformVariable& ShaderProgram::getUniformVariable(
+const ShaderProgramUniformVariable& ShaderProgram::getUniformVariableByName(
 	const char* name) const
 {
 	UniVarsHashMap::const_iterator it = nameToUniVar.find(name);
@@ -369,7 +370,7 @@ std::string ShaderProgram::getShaderInfoString() const
 	BOOST_FOREACH(const ShaderProgramVariable& var, vars)
 	{
 		ss << var.getName() << " " << var.getLoc() << " ";
-		if(var.getType() == ShaderProgramVariable::ATTRIBUTE)
+		if(var.getType() == ShaderProgramVariable::T_ATTRIBUTE)
 		{
 			ss << "attribute";
 		}

src/Resources/ShaderProgram.h

@@ -43,11 +43,12 @@ class ShaderProgram
 		/// variable not found so ask if the variable with that name exists
 		/// prior using any of these
 		/// @{
-		const ShaderProgramVariable& getVariable(const char* varName) const;
-		const ShaderProgramUniformVariable&
-			getUniformVariable(const char* varName) const;
-		const ShaderProgramAttributeVariable&
-			getAttributeVariable(const char* varName) const;
+		const ShaderProgramVariable& getVariableByName(
+			const char* varName) const;
+		const ShaderProgramUniformVariable& getUniformVariableByName(
+			const char* varName) const;
+		const ShaderProgramAttributeVariable& getAttributeVariableByName(
+			const char* varName) const;
 		/// @}
 
 		/// @name Check for variable existance

src/Resources/ShaderProgramAttributeVariable.h

@@ -17,7 +17,7 @@ class ShaderProgramAttributeVariable: public ShaderProgramVariable
 inline ShaderProgramAttributeVariable::ShaderProgramAttributeVariable(
 	int loc, const char* name,
 	GLenum glDataType, const ShaderProgram& fatherSProg)
-:	ShaderProgramVariable(loc, name, glDataType, ATTRIBUTE, fatherSProg)
+:	ShaderProgramVariable(loc, name, glDataType, T_ATTRIBUTE, fatherSProg)
 {}
 
 

src/Resources/ShaderProgramPrePreprocessor.cpp

@@ -46,15 +46,15 @@ void ShaderProgramPrePreprocessor::parseFileForPragmas(
 		throw EXCEPTION("File \"" + filename + "\": Cannot open or empty");
 	}
 
-	Scanner::Scanner scanner(filename.c_str(), false);
-	const Scanner::Token* token;
+	scanner::Scanner scanner(filename.c_str(), false);
+	const scanner::Token* token;
 
 	while(true)
 	{
 		token = &scanner.getNextToken();
 
 		// #
-		if(token->getCode() == Scanner::TC_SHARP)
+		if(token->getCode() == scanner::TC_SHARP)
 		{
 			token = &scanner.getNextToken();
 			// pragma
@@ -91,13 +91,13 @@ void ShaderProgramPrePreprocessor::parseFileForPragmas(
 				} // end if anki
 
 				token = &scanner.getNextToken();
-				if(token->getCode()!=Scanner::TC_NEWLINE &&
-					token->getCode()!=Scanner::TC_EOF)
+				if(token->getCode()!=scanner::TC_NEWLINE &&
+					token->getCode()!=scanner::TC_END)
 				{
 					throw PARSER_EXCEPTION_EXPECTED("newline or end of file");
 				}
 
-				if(token->getCode() == Scanner::TC_EOF)
+				if(token->getCode() == scanner::TC_END)
 				{
 					break;
 				}
@@ -107,7 +107,7 @@ void ShaderProgramPrePreprocessor::parseFileForPragmas(
 		//
 		// newline
 		//
-		else if(token->getCode() == Scanner::TC_NEWLINE)
+		else if(token->getCode() == scanner::TC_NEWLINE)
 		{
 			sourceLines.push_back(lines[scanner.getLineNumber() - 2]);
 			//PRINT(lines[scanner.getLineNmbr() - 2])
@@ -115,7 +115,7 @@ void ShaderProgramPrePreprocessor::parseFileForPragmas(
 		//
 		// EOF
 		//
-		else if(token->getCode() == Scanner::TC_EOF)
+		else if(token->getCode() == scanner::TC_END)
 		{
 			sourceLines.push_back(lines[scanner.getLineNumber() - 1]);
 			//PRINT(lines[scanner.getLineNmbr() - 1])
@@ -124,7 +124,7 @@ void ShaderProgramPrePreprocessor::parseFileForPragmas(
 		//
 		// error
 		//
-		else if(token->getCode() == Scanner::TC_ERROR)
+		else if(token->getCode() == scanner::TC_ERROR)
 		{
 			// It will never get here
 		}
@@ -218,10 +218,10 @@ void ShaderProgramPrePreprocessor::parseFile(const char* filename)
 //==============================================================================
 // parseStartPragma                                                            =
 //==============================================================================
-void ShaderProgramPrePreprocessor::parseStartPragma(Scanner::Scanner& scanner,
+void ShaderProgramPrePreprocessor::parseStartPragma(scanner::Scanner& scanner,
 	const std::string& filename, uint depth, const Vec<std::string>& lines)
 {
-	const Scanner::Token* token = &scanner.getNextToken();
+	const scanner::Token* token = &scanner.getNextToken();
 
 	// Chose the correct pragma
 	CodeBeginningPragma* cbp;
@@ -276,12 +276,12 @@ void ShaderProgramPrePreprocessor::parseStartPragma(Scanner::Scanner& scanner,
 // parseIncludePragma                                                          =
 //==============================================================================
 void ShaderProgramPrePreprocessor::parseIncludePragma(
-	Scanner::Scanner& scanner, const std::string& /*filename*/, uint depth,
+	scanner::Scanner& scanner, const std::string& /*filename*/, uint depth,
 	const Vec<std::string>& lines)
 {
-	const Scanner::Token* token = &scanner.getNextToken();
+	const scanner::Token* token = &scanner.getNextToken();
 
-	if(token->getCode() == Scanner::TC_STRING)
+	if(token->getCode() == scanner::TC_STRING)
 	{
 		std::string filename = token->getValue().getString();
 
@@ -307,12 +307,12 @@ void ShaderProgramPrePreprocessor::parseIncludePragma(
 //==============================================================================
 // parseTrffbVarying                                                           =
 //==============================================================================
-void ShaderProgramPrePreprocessor::parseTrffbVarying(Scanner::Scanner& scanner,
+void ShaderProgramPrePreprocessor::parseTrffbVarying(scanner::Scanner& scanner,
 	const std::string& filename, uint /*depth*/, const Vec<std::string>& lines)
 {
-	const Scanner::Token* token = &scanner.getNextToken();
+	const scanner::Token* token = &scanner.getNextToken();
 
-	if(token->getCode() == Scanner::TC_IDENTIFIER)
+	if(token->getCode() == scanner::TC_IDENTIFIER)
 	{
 		std::string varName = token->getValue().getString();
 

src/Resources/ShaderProgramPrePreprocessor.h

@@ -7,7 +7,7 @@
 #include "Util/Accessors.h"
 
 
-namespace Scanner {
+namespace scanner {
 class Scanner;
 }
 
@@ -113,17 +113,17 @@ class ShaderProgramPrePreprocessor
 		void parseFileForPragmas(const std::string& filename, int depth = 0);
 
 		/// @todo
-		void parseStartPragma(Scanner::Scanner& scanner,
+		void parseStartPragma(scanner::Scanner& scanner,
 			const std::string& filename, uint depth,
 			const Vec<std::string>& lines);
 
 		/// @todo
-		void parseIncludePragma(Scanner::Scanner& scanner,
+		void parseIncludePragma(scanner::Scanner& scanner,
 			const std::string& filename, uint depth,
 			const Vec<std::string>& lines);
 
 		/// @todo
-		void parseTrffbVarying(Scanner::Scanner& scanner,
+		void parseTrffbVarying(scanner::Scanner& scanner,
 			const std::string& filename, uint depth,
 			const Vec<std::string>& lines);
 

src/Resources/ShaderProgramUniformVariable.h

@@ -41,7 +41,7 @@ class ShaderProgramUniformVariable: public ShaderProgramVariable
 inline ShaderProgramUniformVariable::ShaderProgramUniformVariable(
 	int loc_, const char* name_,
 	GLenum glDataType_, const ShaderProgram& father_)
-:	ShaderProgramVariable(loc_, name_, glDataType_, UNIFORM, father_)
+:	ShaderProgramVariable(loc_, name_, glDataType_, T_UNIFORM, father_)
 {}
 
 

src/Resources/ShaderProgramVariable.h

@@ -17,8 +17,8 @@ class ShaderProgramVariable: public boost::noncopyable
 		/// Shader var types
 		enum Type
 		{
-			ATTRIBUTE,
-			UNIFORM
+			T_ATTRIBUTE,
+			T_UNIFORM
 		};
 
 		ShaderProgramVariable(GLint loc, const char* name,

src/Resources/SkelAnim.cpp

@@ -7,13 +7,13 @@
 //==============================================================================
 void SkelAnim::load(const char* filename)
 {
-	Scanner::Scanner scanner(filename);
-	const Scanner::Token* token;
+	scanner::Scanner scanner(filename);
+	const scanner::Token* token;
 
 	// keyframes
 	token = &scanner.getNextToken();
-	if(token->getCode() != Scanner::TC_NUMBER ||
-		token->getDataType() != Scanner::DT_INT)
+	if(token->getCode() != scanner::TC_NUMBER ||
+		token->getDataType() != scanner::DT_INT)
 	{
 		throw PARSER_EXCEPTION_EXPECTED("integer");
 	}
@@ -24,8 +24,8 @@ void SkelAnim::load(const char* filename)
 
 	// bones num
 	token = &scanner.getNextToken();
-	if(token->getCode() != Scanner::TC_NUMBER ||
-		token->getDataType() != Scanner::DT_INT)
+	if(token->getCode() != scanner::TC_NUMBER ||
+		token->getDataType() != scanner::DT_INT)
 	{
 		throw PARSER_EXCEPTION_EXPECTED("integer");
 	}
@@ -36,8 +36,8 @@ void SkelAnim::load(const char* filename)
 	{
 		// has anim?
 		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_NUMBER ||
-			token->getDataType() != Scanner::DT_INT)
+		if(token->getCode() != scanner::TC_NUMBER ||
+			token->getDataType() != scanner::DT_INT)
 		{
 			throw PARSER_EXCEPTION_EXPECTED("integer");
 		}

src/Scene/GhostNode.h

@@ -13,7 +13,6 @@ class GhostNode: public SceneNode
 		virtual ~GhostNode() {}
 		void init(const char*) {}
 
-		void moveUpdate() {}
 		void frameUpdate(float /*prevUpdateTime*/, float /*crntTime*/) {}
 };
 

src/Scene/Light.h

@@ -48,7 +48,6 @@ class Light: public SceneNode, public VisibilityInfo
 
 		void init(const char* filename);
 
-		void moveUpdate() {}
 		void frameUpdate(float /*prevUpdateTime*/, float /*crntTime*/) {}
 
 	protected:

src/Scene/LightPropsScriptCtrl.h

@@ -1,20 +0,0 @@
-#ifndef LIGHT_SCRIPT_CTRL_H
-#define LIGHT_SCRIPT_CTRL_H
-
-#include "Controller.h"
-
-
-class Light;
-
-
-/*class LightPropsScriptCtrl: public Controller
-{
-	public:
-		Light* light;
-		
-		LightPropsScriptCtrl(Light* light_): 
-			controller(CT_LIGHT), light(light_) {}
-		void update(float) {  ToDo  }
-};*/
-
-#endif

src/Scene/ParticleEmitterNode.h

@@ -24,7 +24,6 @@ class ParticleEmitterNode: public SceneNode, public ParticleEmitterRsrc
 		void init(const char* filename);
 
 		void frameUpdate(float prevUpdateTime, float crntTime);
-		void moveUpdate() {}
 
 	private:
 		boost::scoped_ptr<btCollisionShape> collShape;

src/Scene/Scene.cpp

@@ -3,7 +3,6 @@
 #include "Util/Exception.h"
 #include "Scene.h"
 #include "VisibilityTester.h"
-#include "SkinPatchNodeDeformer.h"
 
 #include "Camera.h"
 #include "Light.h"
@@ -25,7 +24,6 @@ Scene::Scene()
 
 	physMasterContainer.reset(new Phys::MasterContainer);
 	visibilityTester.reset(new VisibilityTester(*this));
-	skinsDeformer.reset(new SkinPatchNodeDeformer);
 }
 
 

src/Scene/Scene.h

@@ -15,7 +15,6 @@ class Controller;
 class ParticleEmitterNode;
 class ModelNode;
 class SkinNode;
-class SkinPatchNodeDeformer;
 
 
 /// The Scene contains all the dynamic entities
@@ -56,8 +55,6 @@ class Scene
 		Phys::MasterContainer& getPhysMasterContainer();
 		const Phys::MasterContainer& getPhysMasterContainer() const;
 		const VisibilityTester& getVisibilityTester() const;
-		const SkinPatchNodeDeformer& getSkinPatchNodeDeformer() const
-			{return *skinsDeformer;}
 
 		GETTER_RW(Types<SceneNode>::Container, nodes, getAllNodes)
 		GETTER_RW(Types<Light>::Container, lights, getLights)
@@ -85,7 +82,6 @@ class Scene
 		/// Connection with Bullet wrapper
 		boost::scoped_ptr<Phys::MasterContainer> physMasterContainer;
 		boost::scoped_ptr<VisibilityTester> visibilityTester;
-		boost::scoped_ptr<SkinPatchNodeDeformer> skinsDeformer;
 
 		/// Adds a node in a container
 		template<typename ContainerType, typename Type>

src/Scene/SkelAnimModelNodeCtrl.cpp

@@ -1,206 +0,0 @@
-#include <boost/foreach.hpp>
-#include "SkelAnimModelNodeCtrl.h"
-#include "SkinNode.h"
-#include "Resources/SkelAnim.h"
-#include "Resources/Skeleton.h"
-#include "Resources/Model.h"
-#include "Resources/Skin.h"
-#include "Core/Globals.h"
-#include "SkinPatchNodeDeformer.h"
-#include "Scene.h"
-
-
-//==============================================================================
-// SkelAnimModelNodeCtrl                                                       =
-//==============================================================================
-SkelAnimModelNodeCtrl::SkelAnimModelNodeCtrl(SkinNode& skinNode_):
-	Controller(CT_SKEL_ANIM_SKIN_NODE, skinNode_),
-	frame(0.0),
-	skinNode(skinNode_)
-{}
-
-
-//==============================================================================
-// interpolate                                                                 =
-//==============================================================================
-void SkelAnimModelNodeCtrl::interpolate(const SkelAnim& animation, float frame,
-	Vec<Vec3>& boneTranslations, Vec<Mat3>& boneRotations)
-{
-	ASSERT(frame < animation.getFramesNum());
-
-	// calculate the t (used in slerp and lerp) using the keyframs and the
-	// frame and calc the lPose and rPose witch indicate the pose IDs in witch
-	// the frame lies between
-	const Vec<uint>& keyframes = animation.getKeyframes();
-	float t = 0.0;
-	uint lPose = 0, rPose = 0;
-	for(uint j = 0; j < keyframes.size(); j++)
-	{
-		if((float)keyframes[j] == frame)
-		{
-			lPose = rPose = j;
-			t = 0.0;
-			break;
-		}
-		else if((float)keyframes[j] > frame)
-		{
-			lPose = j-1;
-			rPose = j;
-			t = (frame - (float)keyframes[lPose]) / float(keyframes[rPose] -
-				keyframes[lPose]);
-			break;
-		}
-	}
-
-	// now for all bones update bone's poses
-	ASSERT(boneRotations.size() >= 1);
-	for(uint i=0; i < boneRotations.size(); i++)
-	{
-		const BoneAnim& banim = animation.getBoneAnims()[i];
-
-		Mat3& localRot = boneRotations[i];
-		Vec3& localTransl = boneTranslations[i];
-
-		// if the bone has animations then slerp and lerp to find the rotation
-		// and translation
-		if(banim.getBonePoses().size() != 0)
-		{
-			const BonePose& lBpose = banim.getBonePoses()[lPose];
-			const BonePose& rBpose = banim.getBonePoses()[rPose];
-
-			// rotation
-			const Quat& q0 = lBpose.getRotation();
-			const Quat& q1 = rBpose.getRotation();
-			localRot = Mat3(q0.slerp(q1, t));
-
-			// translation
-			const Vec3& v0 = lBpose.getTranslation();
-			const Vec3& v1 = rBpose.getTranslation();
-			localTransl = v0.lerp(v1, t);
-		}
-		// else put the idents
-		else
-		{
-			localRot = Mat3::getIdentity();
-			localTransl = Vec3(0.0, 0.0, 0.0);
-		}
-	}
-}
-
-
-//==============================================================================
-// updateBoneTransforms                                                        =
-//==============================================================================
-void SkelAnimModelNodeCtrl::updateBoneTransforms(const Skeleton& skeleton,
-	Vec<Vec3>& boneTranslations, Vec<Mat3>& boneRotations)
-{
-	uint queue[128];
-	uint head = 0, tail = 0;
-
-	// put the roots
-	BOOST_FOREACH(const Bone& bone, skeleton.getBones())
-	{
-		if(bone.getParent() == NULL)
-		{
-			queue[tail++] = bone.getPos(); // queue push
-		}
-	}
-
-	// loop
-	while(head != tail) // while queue not empty
-	{
-		uint boneId = queue[head++]; // queue pop
-		const Bone& boned = skeleton.getBones()[boneId];
-
-		// bone.final_transform = MA * ANIM * MAi
-		// where MA is bone matrix at armature space and ANIM the interpolated
-		// transformation.
-		combineTransformations(boneTranslations[boneId], boneRotations[boneId],
-			boned.getTslSkelSpaceInv(), boned.getRotSkelSpaceInv(),
-			boneTranslations[boneId], boneRotations[boneId]);
-
-		combineTransformations(boned.getTslSkelSpace(), boned.getRotSkelSpace(),
-			boneTranslations[boneId], boneRotations[boneId],
-			boneTranslations[boneId], boneRotations[boneId]);
-
-		// and finaly add the parent's transform
-		if(boned.getParent())
-		{
-			// bone.final_final_transform = parent.transf * bone.final_transform
-			combineTransformations(
-				boneTranslations[boned.getParent()->getPos()],
-				boneRotations[boned.getParent()->getPos()],
-				boneTranslations[boneId],
-				boneRotations[boneId],
-				boneTranslations[boneId],
-				boneRotations[boneId]);
-		}
-
-		// now add the bone's childes
-		for(uint i = 0; i < boned.getChildsNum(); i++)
-		{
-			queue[tail++] = boned.getChild(i).getPos();
-		}
-	}
-}
-
-
-//==============================================================================
-// deform                                                                      =
-//==============================================================================
-void SkelAnimModelNodeCtrl::deform(const Skeleton& skeleton,
-	const Vec<Vec3>& boneTranslations, const Vec<Mat3>& boneRotations,
-	Vec<Vec3>& heads, Vec<Vec3>& tails)
-{
-	for(uint i = 0; i < skeleton.getBones().size(); i++)
-	{
-		const Mat3& rot = boneRotations[i];
-		const Vec3& transl = boneTranslations[i];
-
-		heads[i] = skeleton.getBones()[i].getHead().getTransformed(transl, rot);
-		tails[i] = skeleton.getBones()[i].getTail().getTransformed(transl, rot);
-	}
-}
-
-
-//==============================================================================
-// update                                                                      =
-//==============================================================================
-void SkelAnimModelNodeCtrl::update(float)
-{
-	frame += step;
-	// if the crnt is finished then play the next or loop the crnt
-	if(frame > skelAnim->getFramesNum())
-	{
-		frame = 0.0;
-	}
-
-	if(!controlledNode.isFlagEnabled(SceneNode::SNF_VISIBLE))
-	{
-		return;
-	}
-
-	interpolate(*skelAnim, frame, skinNode.getBoneTranslations(),
-		skinNode.getBoneRotations());
-
-	updateBoneTransforms(skinNode.getSkin().getSkeleton(),
-		skinNode.getBoneTranslations(), skinNode.getBoneRotations());
-
-	/*if(R::MainRendererSingleton::getInstance().getDbg().isEnabled() &&
-		R::MainRendererSingleton::getInstance().getDbg().
-			isShowSkeletonsEnabled())
-	{
-		deform(skinNode.getSkin().getSkeleton(),
-			skinNode.getBoneTranslations(), skinNode.getBoneRotations(),
-			skinNode.getHeads(), skinNode.getTails());
-	}*/
-
-	const SkinPatchNodeDeformer& sd =
-		SceneSingleton::getInstance().getSkinPatchNodeDeformer();
-
-	BOOST_FOREACH(SkinPatchNode* skinPatchNode,
-		skinNode.getPatcheNodes())
-	{
-		sd.deform(*skinPatchNode);
-	}
-}

src/Scene/SkelAnimModelNodeCtrl.h

@@ -1,60 +0,0 @@
-#ifndef SKEL_ANIM_MODEL_NODE_CTRL_H
-#define SKEL_ANIM_MODEL_NODE_CTRL_H
-
-#include "Util/Vec.h"
-#include "Controller.h"
-#include "Math/Math.h"
-#include "Resources/RsrcPtr.h"
-#include "Util/Accessors.h"
-
-
-class Skeleton;
-class SkelAnim;
-class SkinNode;
-
-
-/// SkelAnim controls a ModelNode
-class SkelAnimModelNodeCtrl: public Controller
-{
-	public:
-		SkelAnimModelNodeCtrl(SkinNode& skelNode_);
-
-		/// @name Accessors
-		/// @{
-		float getStep() const {return step;}
-		float& getStep() {return step;}
-		void setStep(float s) {step = s;}
-		/// @}
-
-		void update(float time);
-		void set(const SkelAnim* skelAnim_) {skelAnim = skelAnim_;}
-
-	private:
-		float step;
-		float frame;
-		const SkelAnim* skelAnim; ///< The active skeleton animation
-		SkinNode& skinNode; ///< Know your father
-
-		/// @name The 3 steps of skeletal animation in 3 methods
-		/// @{
-
-		/// Interpolate
-		/// @param[in] animation Animation
-		/// @param[in] frame Frame
-		/// @param[out] translations Translations vector
-		/// @param[out] rotations Rotations vector
-		static void interpolate(const SkelAnim& animation, float frame,
-			Vec<Vec3>& translations, Vec<Mat3>& rotations);
-
-		static void updateBoneTransforms(const Skeleton& skel,
-			Vec<Vec3>& translations, Vec<Mat3>& rotations);
-
-		/// Now with HW skinning it deforms only the debug skeleton
-		static void deform(const Skeleton& skel, const Vec<Vec3>& translations,
-			const Vec<Mat3>& rotations,
-			Vec<Vec3>& heads, Vec<Vec3>& tails);
-		/// @}
-};
-
-
-#endif

src/Scene/SkinNode.cpp

@@ -2,6 +2,7 @@
 #include "Resources/Skin.h"
 #include "SkinPatchNode.h"
 #include "Resources/Skeleton.h"
+#include "Resources/SkelAnim.h"
 #include <boost/foreach.hpp>
 
 
@@ -49,3 +50,175 @@ void SkinNode::moveUpdate()
 	visibilityShapeWSpace = visibilityShapeWSpace.getTransformed(
 		getWorldTransform());
 }
+
+
+//==============================================================================
+// frameUpdate                                                                 =
+//==============================================================================
+void SkinNode::frameUpdate(float prevUpdateTime, float crntTime)
+{
+	frame += step;
+
+	if(frame > anim->getFramesNum())
+	{
+		frame = 0.0;
+	}
+
+	// A nasty optimization that may produse ugly results
+	if(!isFlagEnabled(SNF_VISIBLE))
+	{
+		return;
+	}
+
+	interpolate(*anim, frame, getBoneTranslations(),
+	    getBoneRotations());
+
+	updateBoneTransforms(getSkin().getSkeleton(),
+	    getBoneTranslations(), getBoneRotations());
+
+	deformHeadsTails(getSkin().getSkeleton(), getBoneTranslations(),
+	    getBoneRotations(), getHeads(), getTails());
+}
+
+
+//==============================================================================
+// interpolate                                                                 =
+//==============================================================================
+void SkinNode::interpolate(const SkelAnim& animation, float frame,
+	Vec<Vec3>& boneTranslations, Vec<Mat3>& boneRotations)
+{
+	ASSERT(frame < animation.getFramesNum());
+
+	// calculate the t (used in slerp and lerp) using the keyframs and the
+	// frame and calc the lPose and rPose witch indicate the pose IDs in witch
+	// the frame lies between
+	const Vec<uint>& keyframes = animation.getKeyframes();
+	float t = 0.0;
+	uint lPose = 0, rPose = 0;
+	for(uint j = 0; j < keyframes.size(); j++)
+	{
+		if((float)keyframes[j] == frame)
+		{
+			lPose = rPose = j;
+			t = 0.0;
+			break;
+		}
+		else if((float)keyframes[j] > frame)
+		{
+			lPose = j-1;
+			rPose = j;
+			t = (frame - (float)keyframes[lPose]) / float(keyframes[rPose] -
+				keyframes[lPose]);
+			break;
+		}
+	}
+
+	// now for all bones update bone's poses
+	ASSERT(boneRotations.size() >= 1);
+	for(uint i=0; i < boneRotations.size(); i++)
+	{
+		const BoneAnim& banim = animation.getBoneAnims()[i];
+
+		Mat3& localRot = boneRotations[i];
+		Vec3& localTransl = boneTranslations[i];
+
+		// if the bone has animations then slerp and lerp to find the rotation
+		// and translation
+		if(banim.getBonePoses().size() != 0)
+		{
+			const BonePose& lBpose = banim.getBonePoses()[lPose];
+			const BonePose& rBpose = banim.getBonePoses()[rPose];
+
+			// rotation
+			const Quat& q0 = lBpose.getRotation();
+			const Quat& q1 = rBpose.getRotation();
+			localRot = Mat3(q0.slerp(q1, t));
+
+			// translation
+			const Vec3& v0 = lBpose.getTranslation();
+			const Vec3& v1 = rBpose.getTranslation();
+			localTransl = v0.lerp(v1, t);
+		}
+		// else put the idents
+		else
+		{
+			localRot = Mat3::getIdentity();
+			localTransl = Vec3(0.0, 0.0, 0.0);
+		}
+	}
+}
+
+
+//==============================================================================
+// updateBoneTransforms                                                        =
+//==============================================================================
+void SkinNode::updateBoneTransforms(const Skeleton& skeleton,
+	Vec<Vec3>& boneTranslations, Vec<Mat3>& boneRotations)
+{
+	boost::array<uint, 128> queue;
+	uint head = 0, tail = 0;
+
+	// put the roots
+	BOOST_FOREACH(const Bone& bone, skeleton.getBones())
+	{
+		if(bone.getParent() == NULL)
+		{
+			queue[tail++] = bone.getPos(); // queue push
+		}
+	}
+
+	// loop
+	while(head != tail) // while queue not empty
+	{
+		uint boneId = queue[head++]; // queue pop
+		const Bone& boned = skeleton.getBones()[boneId];
+
+		// bone.final_transform = MA * ANIM * MAi
+		// where MA is bone matrix at armature space and ANIM the interpolated
+		// transformation.
+		combineTransformations(boneTranslations[boneId], boneRotations[boneId],
+			boned.getTslSkelSpaceInv(), boned.getRotSkelSpaceInv(),
+			boneTranslations[boneId], boneRotations[boneId]);
+
+		combineTransformations(boned.getTslSkelSpace(), boned.getRotSkelSpace(),
+			boneTranslations[boneId], boneRotations[boneId],
+			boneTranslations[boneId], boneRotations[boneId]);
+
+		// and finaly add the parent's transform
+		if(boned.getParent())
+		{
+			// bone.final_final_transform = parent.transf * bone.final_transform
+			combineTransformations(
+				boneTranslations[boned.getParent()->getPos()],
+				boneRotations[boned.getParent()->getPos()],
+				boneTranslations[boneId],
+				boneRotations[boneId],
+				boneTranslations[boneId],
+				boneRotations[boneId]);
+		}
+
+		// now add the bone's children
+		for(uint i = 0; i < boned.getChildsNum(); i++)
+		{
+			queue[tail++] = boned.getChild(i).getPos();
+		}
+	}
+}
+
+
+//==============================================================================
+// deformHeadsTails                                                            =
+//==============================================================================
+void SkinNode::deformHeadsTails(const Skeleton& skeleton,
+    const Vec<Vec3>& boneTranslations, const Vec<Mat3>& boneRotations,
+    Vec<Vec3>& heads, Vec<Vec3>& tails)
+{
+	for(uint i = 0; i < skeleton.getBones().size(); i++)
+	{
+		const Mat3& rot = boneRotations[i];
+		const Vec3& transl = boneTranslations[i];
+
+		heads[i] = skeleton.getBones()[i].getHead().getTransformed(transl, rot);
+		tails[i] = skeleton.getBones()[i].getTail().getTransformed(transl, rot);
+	}
+}

src/Scene/SkinNode.h

@@ -29,7 +29,12 @@ class SkinNode: public SceneNode
 		GETTER_RW(Vec<Vec3>, boneTranslations, getBoneTranslations)
 		GETTER_R(Skin, *skin, getSkin)
 		GETTER_R(Col::Obb, visibilityShapeWSpace, getVisibilityShapeWSpace)
-		GETTER_R(Vec<SkinPatchNode*>, patches, getPatcheNodes)
+		GETTER_R(Vec<SkinPatchNode*>, patches, getPatchNodes)
+
+		GETTER_SETTER_BY_VAL(float, step, getStep, setStep)
+		GETTER_SETTER_BY_VAL(float, frame, getFrame, setFrame)
+		void setAnimation(const SkelAnim& anim_) {anim = &anim_;}
+		const SkelAnim* getAnimation() const {return anim;}
 		/// @}
 
 		void init(const char* filename);
@@ -38,11 +43,21 @@ class SkinNode: public SceneNode
 		/// cause its faster that way). The tails come from the previous frame
 		void moveUpdate();
 
+		/// Update the animation stuff
+		void frameUpdate(float prevUpdateTime, float crntTime);
+
 	private:
 		RsrcPtr<Skin> skin; ///< The resource
 		Vec<SkinPatchNode*> patches;
 		Col::Obb visibilityShapeWSpace;
 
+		/// @name Animation stuff
+		/// @{
+		float step;
+		float frame;
+		const SkelAnim* anim; ///< The active skeleton animation
+		/// @}
+
 		/// @name Bone data
 		/// @{
 		Vec<Vec3> heads;
@@ -50,6 +65,23 @@ class SkinNode: public SceneNode
 		Vec<Mat3> boneRotations;
 		Vec<Vec3> boneTranslations;
 		/// @}
+
+		/// Interpolate
+		/// @param[in] animation Animation
+		/// @param[in] frame Frame
+		/// @param[out] translations Translations vector
+		/// @param[out] rotations Rotations vector
+		static void interpolate(const SkelAnim& animation, float frame,
+			Vec<Vec3>& translations, Vec<Mat3>& rotations);
+
+		/// Calculate the global pose
+		static void updateBoneTransforms(const Skeleton& skel,
+			Vec<Vec3>& translations, Vec<Mat3>& rotations);
+
+		/// Deform the heads and tails
+		static void deformHeadsTails(const Skeleton& skeleton,
+		    const Vec<Vec3>& boneTranslations, const Vec<Mat3>& boneRotations,
+		    Vec<Vec3>& heads, Vec<Vec3>& tails);
 };
 
 

src/Scene/SkinPatchNode.h

@@ -41,8 +41,6 @@ class SkinPatchNode: public PatchNode
 		const Vbo& getTfVbo(uint i) const {return tfVbos[i];}
 		/// @}
 
-		virtual void moveUpdate() {}
-
 	private:
 		/// VBOs that contain the deformed vertex attributes
 		boost::array<Vbo, TFV_NUM> tfVbos;

src/Scene/SkinPatchNodeDeformer.h

@@ -1,28 +0,0 @@
-#ifndef SKIN_PATCH_NODE_DEFORMER_H
-#define SKIN_PATCH_NODE_DEFORMER_H
-
-#include "Resources/RsrcPtr.h"
-
-
-class ShaderProgram;
-class SkinPatchNode;
-
-
-/// XXX
-class SkinPatchNodeDeformer
-{
-	public:
-		SkinPatchNodeDeformer();
-		~SkinPatchNodeDeformer();
-
-		void deform(SkinPatchNode& node) const;
-
-	private:
-		RsrcPtr<ShaderProgram> tfHwSkinningAllSProg;
-		RsrcPtr<ShaderProgram> tfHwSkinningPosSProg;
-
-		void init();
-};
-
-
-#endif

src/Scene/TrfScriptCtrl.h

@@ -1,17 +0,0 @@
-#ifndef TRF_SCRIPT_CTRL_H
-#define TRF_SCRIPT_CTRL_H
-
-#include "Controller.h"
-
-
-/// Transformation controlled by a script
-/*class TrfScriptCtrl: public Controller
-{
-	public:
-		SceneNode* node;
-	
-		TrfScriptCtrl(SceneNode* node_): Controller(CT_TRF), node(node_) {}
-		void Update(float) {  ToDo  }
-};*/
-
-#endif

src/Scene/VisibilityTester.cpp

@@ -282,7 +282,7 @@ void VisibilityTester::getRenderableNodesJobCallback(
 
 		// Put all the patches into the visible container
 		BOOST_FOREACH(SkinPatchNode* patchNode,
-			node->getPatcheNodes())
+			node->getPatchNodes())
 		{
 			if(!patchNode->isFlagEnabled(SceneNode::SNF_ACTIVE))
 			{

src/Util/StdTypes.h

@@ -3,19 +3,19 @@
 
 
 #ifndef uchar
-	typedef unsigned char uchar;
+typedef unsigned char uchar;
 #endif
 
 #ifndef uint
-	typedef unsigned int uint;
+typedef unsigned int uint;
 #endif
 
 #ifndef ushort
-	typedef unsigned short int ushort;
+typedef unsigned short int ushort;
 #endif
 
 #ifndef ulong
-	typedef unsigned long int ulong;
+typedef unsigned long int ulong;
 #endif
 
 

src/Util/Scanner/Common.h → src/Util/scanner/Common.h

@@ -2,7 +2,7 @@
 #define SCANNER_COMMON_H
 
 
-namespace Scanner {
+namespace scanner {
 
 /// The max allowed length of a script line
 const int MAX_SCRIPT_LINE_LEN = 1024;

src/Util/Scanner/Exception.cpp → src/Util/scanner/Exception.cpp

@@ -2,7 +2,7 @@
 #include <boost/lexical_cast.hpp>
 
 
-namespace Scanner {
+namespace scanner {
 
 
 //==============================================================================

src/Util/Scanner/Exception.h → src/Util/scanner/Exception.h

@@ -5,7 +5,7 @@
 #include <string>
 
 
-namespace Scanner {
+namespace scanner {
 
 
 class Exception: public std::exception

src/Util/Scanner/Scanner.cpp → src/Util/scanner/Scanner.cpp

@@ -10,7 +10,7 @@
 #include <boost/lexical_cast.hpp>
 
 
-namespace Scanner {
+namespace scanner {
 
 #define SCANNER_EXCEPTION(x) \
 	Exception(std::string() + x, __LINE__, scriptName, lineNmbr)
@@ -96,42 +96,42 @@ Scanner::Scanner(std::istream& istream_, const char* scriptName_,
 void Scanner::initAsciiMap()
 {
 	memset(&asciiLookupTable[0], AC_ERROR, sizeof(asciiLookupTable));
-	for(uint x='a'; x<='z'; x++)
+	for(uint x = 'a'; x <= 'z'; x++)
 	{
-		asciiLookupTable[x] = AC_LETTER;
+		lookupAscii(x) = AC_LETTER;
 	}
 
-	for(uint x='A'; x<='Z'; x++)
+	for(uint x = 'A'; x <= 'Z'; x++)
 	{
-		asciiLookupTable[x] = AC_LETTER;
+		lookupAscii(x) = AC_LETTER;
 	}
 
-	for(uint x='0'; x<='9'; x++)
+	for(uint x = '0'; x <= '9'; x++)
 	{
-		asciiLookupTable[x] = AC_DIGIT;
+		lookupAscii(x) = AC_DIGIT;
 	}
 
-	asciiLookupTable[':'] = asciiLookupTable['['] = asciiLookupTable[']'] =
-		asciiLookupTable['('] = asciiLookupTable[')'] = asciiLookupTable['.'] =
-		asciiLookupTable['{'] = asciiLookupTable['}'] = asciiLookupTable[','] =
-		asciiLookupTable[';'] = asciiLookupTable['?'] = asciiLookupTable['='] =
-		asciiLookupTable['!'] = asciiLookupTable['<'] = asciiLookupTable['>'] =
-		asciiLookupTable['|'] = asciiLookupTable['&'] = asciiLookupTable['+'] =
-		asciiLookupTable['-'] = asciiLookupTable['*'] = asciiLookupTable['/'] =
-		asciiLookupTable['~'] = asciiLookupTable['%'] = asciiLookupTable['#'] =
-		asciiLookupTable['^'] = asciiLookupTable['\\'] = AC_SPECIAL;
-
-	asciiLookupTable['\t'] = asciiLookupTable[' '] = asciiLookupTable['\0'] =
+	lookupAscii(':') = lookupAscii('[') = lookupAscii(']') =
+		lookupAscii('(') = lookupAscii(')') = lookupAscii('.') =
+		lookupAscii('{') = lookupAscii('}') = lookupAscii(',') =
+		lookupAscii(';') = lookupAscii('?') = lookupAscii('=') =
+		lookupAscii('!') = lookupAscii('<') = lookupAscii('>') =
+		lookupAscii('|') = lookupAscii('&') = lookupAscii('+') =
+		lookupAscii('-') = lookupAscii('*') = lookupAscii('/') =
+		lookupAscii('~') = lookupAscii('%') = lookupAscii('#') =
+		lookupAscii('^') = lookupAscii('\\') = AC_SPECIAL;
+
+	lookupAscii('\t') = lookupAscii(' ') = lookupAscii('\0') =
 		AC_WHITESPACE;
-	asciiLookupTable['\n'] = AC_ERROR; // newline is unacceptable char
+	lookupAscii('\n') = AC_ERROR; // newline is unacceptable char
 
-	asciiLookupTable['@'] = asciiLookupTable['`'] = asciiLookupTable['$'] =
+	lookupAscii('@') = lookupAscii('`') = lookupAscii('$') =
 		AC_ACCEPTABLE_IN_COMMENTS;
 
-	asciiLookupTable['\"'] = AC_DOUBLEQUOTE;
-	asciiLookupTable['\''] = AC_QUOTE;
-	asciiLookupTable[(int)eofChar] = AC_EOF;
-	asciiLookupTable['_'] = AC_LETTER;
+	lookupAscii('\"') = AC_DOUBLEQUOTE;
+	lookupAscii('\'') = AC_QUOTE;
+	lookupAscii((int)eofChar) = AC_EOF;
+	lookupAscii('_') = AC_LETTER;
 }
 
 
@@ -144,7 +144,7 @@ void Scanner::init(bool newlinesAsWhitespace_)
 	commentedLines = 0;
 	inStream = NULL;
 
-	if(asciiLookupTable['a'] != AC_LETTER)
+	if(lookupAscii('a') != AC_LETTER)
 	{
 		initAsciiMap();
 	}
@@ -225,7 +225,7 @@ void Scanner::getAllPrintAll()
 		getNextToken();
 		std::cout << std::setw(3) << std::setfill('0') << getLineNumber() <<
 			": " << crntToken.getInfoStr() << std::endl;
-	} while(crntToken.code != TC_EOF);
+	} while(crntToken.code != TC_END);
 }
 
 
@@ -329,7 +329,7 @@ const Token& Scanner::getNextToken()
 	{
 		if(lookupAscii(getNextChar()) == AC_EOF)
 		{
-			crntToken.code = TC_EOF;
+			crntToken.code = TC_END;
 		}
 		else
 		{
@@ -360,7 +360,7 @@ const Token& Scanner::getNextToken()
 				checkString();
 				break;
 			case AC_EOF:
-				crntToken.code = TC_EOF;
+				crntToken.code = TC_END;
 				break;
 			case AC_ERROR:
 			default:
@@ -984,7 +984,7 @@ void Scanner::checkChar()
 	if(ch=='\'')    //end
 	{
 		*tmpStr = '\0';
-		crntToken.code = TC_CHAR;
+		crntToken.code = TC_CHARACTER;
 		getNextChar();
 		return;
 	}
@@ -1013,35 +1013,35 @@ void Scanner::checkSpecial()
 			code = TC_PERIOD;
 			break;
 		case '(':
-			code = TC_LPAREN;
+			code = TC_L_PAREN;
 			break;
 		case ')':
-			code = TC_RPAREN;
+			code = TC_R_PAREN;
 			break;
 		case '[':
-			code = TC_LSQBRACKET;
+			code = TC_L_SQ_BRACKET;
 			break;
 		case ']':
-			code = TC_RSQBRACKET;
+			code = TC_R_SQ_BRACKET;
 			break;
 		case '{':
-			code = TC_LBRACKET;
+			code = TC_L_BRACKET;
 			break;
 		case '}':
-			code = TC_RBRACKET;
+			code = TC_R_BRACKET;
 			break;
 		case '?':
 			code = TC_QUESTIONMARK;
 			break;
 		case '~':
-			code = TC_ONESCOMPLEMENT;
+			code = TC_UNARAY_COMPLEMENT;
 			break;
 		case '.':
 			ch = getNextChar();
 			switch(ch)
 			{
 				case '*':
-					code = TC_POINTERTOMEMBER;
+					code = TC_POINTER_TO_MEMBER;
 					break;
 				default:
 					putBackChar();
@@ -1054,7 +1054,7 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case ':':
-					code = TC_SCOPERESOLUTION;
+					code = TC_SCOPE_RESOLUTION;
 					break;
 				default:
 					putBackChar();
@@ -1067,13 +1067,13 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '>':
-					code = TC_POINTERTOMEMBER;
+					code = TC_POINTER_TO_MEMBER;
 					break;
 				case '-':
 					code = TC_DEC;
 					break;
 				case '=':
-					code = TC_ASSIGNSUB;
+					code = TC_ASSIGN_SUB;
 					break;
 				default:
 					putBackChar();
@@ -1099,7 +1099,7 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '=':
-					code = TC_NOTEQUAL;
+					code = TC_NOT_EQUAL;
 					break;
 				default:
 					putBackChar();
@@ -1112,14 +1112,14 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '=':
-					code = TC_LESSEQUAL;
+					code = TC_LESS_EQUAL;
 					break;
 				case '<':
 					ch = getNextChar();
 					switch(ch)
 					{
 						case '=':
-							code = TC_ASSIGNSHL;
+							code = TC_ASSIGN_SHL;
 							break;
 						default:
 							putBackChar();
@@ -1137,14 +1137,14 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '=':
-					code = TC_GREATEREQUAL;
+					code = TC_GREATER_EQUAL;
 					break;
 				case '>':
 					ch = getNextChar();
 					switch(ch)
 					{
 						case '=':
-							code = TC_ASSIGNSHR;
+							code = TC_ASSIGN_SHR;
 							break;
 						default:
 							putBackChar();
@@ -1162,14 +1162,14 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '|':
-					code = TC_LOGICALOR;
+					code = TC_LOGICAL_OR;
 					break;
 				case '=':
-					code = TC_ASSIGNOR;
+					code = TC_ASSIGN_OR;
 					break;
 				default:
 					putBackChar();
-					code = TC_BITWISEOR;
+					code = TC_BITWISE_OR;
 			}
 			break;
 
@@ -1178,14 +1178,14 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '&':
-					code = TC_LOGICALAND;
+					code = TC_LOGICAL_AND;
 					break;
 				case '=':
-					code = TC_ASSIGNAND;
+					code = TC_ASSIGN_AND;
 					break;
 				default:
 					putBackChar();
-					code = TC_BITWISEAND;
+					code = TC_BITWISE_AND;
 			}
 			break;
 
@@ -1197,7 +1197,7 @@ void Scanner::checkSpecial()
 					code = TC_INC;
 					break;
 				case '=':
-					code = TC_ASSIGNADD;
+					code = TC_ASSIGN_ADD;
 					break;
 				default:
 					putBackChar();
@@ -1210,7 +1210,7 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '=':
-					code = TC_ASSIGNMUL;
+					code = TC_ASSIGN_MUL;
 					break;
 				default:
 					putBackChar();
@@ -1223,7 +1223,7 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '=':
-					code = TC_ASSIGNDIV;
+					code = TC_ASSIGN_DIV;
 					break;
 				default:
 					putBackChar();
@@ -1236,7 +1236,7 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '=':
-					code = TC_ASSIGNMOD;
+					code = TC_ASSIGN_MOD;
 					break;
 				default:
 					putBackChar();
@@ -1249,7 +1249,7 @@ void Scanner::checkSpecial()
 			switch(ch)
 			{
 				case '=':
-					code = TC_ASSIGNXOR;
+					code = TC_ASSIGN_XOR;
 					break;
 				default:
 					putBackChar();

src/Util/Scanner/Scanner.h → src/Util/scanner/Scanner.h

@@ -5,7 +5,7 @@
 #include <fstream>
 
 
-namespace Scanner {
+namespace scanner {
 
 
 /// C++ Tokenizer
@@ -160,8 +160,9 @@ class Scanner
 		/// construction of the first Scanner @see Scanner()
 		static void initAsciiMap();
 
-		/// To save us from typing
-		AsciiFlag lookupAscii(char ch_) {return asciiLookupTable[(int)ch_];}
+		/// A function to save us from typing
+		static AsciiFlag& lookupAscii(char c)
+			{return asciiLookupTable[static_cast<int>(c)];}
 
 		/// Common initialization code
 		void init(bool newlinesAsWhitespace_);

src/Util/Scanner/Token.cpp → src/Util/scanner/Token.cpp

@@ -5,7 +5,7 @@
 #include <boost/lexical_cast.hpp>
 
 
-namespace Scanner {
+namespace scanner {
 
 
 //==============================================================================
@@ -46,12 +46,12 @@ std::string Token::getInfoStr() const
 			return "comment";
 		case TC_NEWLINE:
 			return "newline";
-		case TC_EOF:
+		case TC_END:
 			return "end of file";
 		case TC_STRING:
 			sprintf(tokenInfoStr, "string \"%s\"", value.string);
 			break;
-		case TC_CHAR:
+		case TC_CHARACTER:
 			sprintf(tokenInfoStr, "char '%c' (\"%s\")", value.char_,
 				&asString[0]);
 			break;
@@ -76,10 +76,10 @@ std::string Token::getInfoStr() const
 			{
 				sprintf(tokenInfoStr, "reserved word \"%s\"", value.string);
 			}
-			else if(code>=TC_SCOPERESOLUTION && code<=TC_ASSIGNOR)
+			else if(code>=TC_SCOPE_RESOLUTION && code<=TC_ASSIGN_OR)
 			{
 				sprintf(tokenInfoStr, "operator no %d",
-					code - TC_SCOPERESOLUTION);
+					code - TC_SCOPE_RESOLUTION);
 			}
 	}
 

src/Util/Scanner/Token.h → src/Util/scanner/Token.h

@@ -6,15 +6,15 @@
 #include "Common.h"
 
 
-namespace Scanner {
+namespace scanner {
 
 
 /// The TokenCode is an enum that defines the Token type
 enum TokenCode
 {
 	// general codes
-	TC_ERROR, TC_EOF, TC_COMMENT, TC_NUMBER, TC_CHAR, TC_STRING, TC_IDENTIFIER,
-	TC_NEWLINE,
+	TC_ERROR, TC_END, TC_COMMENT, TC_NUMBER, TC_CHARACTER, TC_STRING,
+	TC_IDENTIFIER, TC_NEWLINE,
 
 	// keywords listed by strlen (dummy keywords at the moment)
 	TC_KE,
@@ -24,22 +24,22 @@ enum TokenCode
 	TC_KEYWOR,
 	TC_KEYWORD,
 
-	// operators (in 5s)
-	TC_SCOPERESOLUTION, TC_LSQBRACKET, TC_RSQBRACKET, TC_LPAREN, TC_RPAREN,
-	TC_DOT, TC_POINTERTOMEMBER, TC_LBRACKET, TC_RBRACKET, TC_COMMA,
+	// operators
+	TC_SCOPE_RESOLUTION, TC_L_SQ_BRACKET, TC_R_SQ_BRACKET, TC_L_PAREN, TC_R_PAREN,
+	TC_DOT, TC_POINTER_TO_MEMBER, TC_L_BRACKET, TC_R_BRACKET, TC_COMMA,
 	TC_PERIOD, TC_UPDOWNDOT, TC_QUESTIONMARK, TC_SHARP, TC_EQUAL,
-	TC_NOTEQUAL, TC_LESS, TC_GREATER, TC_LESSEQUAL, TC_GREATEREQUAL,
-	TC_LOGICALOR, TC_LOGICALAND, TC_PLUS, TC_MINUS, TC_STAR,
-	TC_BSLASH, TC_NOT, TC_BITWISEAND, TC_BITWISEOR, TC_ONESCOMPLEMENT,
+	TC_NOT_EQUAL, TC_LESS, TC_GREATER, TC_LESS_EQUAL, TC_GREATER_EQUAL,
+	TC_LOGICAL_OR, TC_LOGICAL_AND, TC_PLUS, TC_MINUS, TC_STAR,
+	TC_BSLASH, TC_NOT, TC_BITWISE_AND, TC_BITWISE_OR, TC_UNARAY_COMPLEMENT,
 	TC_MOD, TC_XOR, TC_INC, TC_DEC, TC_SHL,
-	TC_SHR, TC_ASSIGN, TC_ASSIGNADD, TC_ASSIGNSUB, TC_ASSIGNMUL,
-	TC_ASSIGNDIV, TC_ASSIGNMOD, TC_ASSIGNSHL, TC_ASSIGNSHR, TC_ASSIGNAND,
-	TC_ASSIGNXOR, TC_ASSIGNOR, TC_BACK_SLASH
+	TC_SHR, TC_ASSIGN, TC_ASSIGN_ADD, TC_ASSIGN_SUB, TC_ASSIGN_MUL,
+	TC_ASSIGN_DIV, TC_ASSIGN_MOD, TC_ASSIGN_SHL, TC_ASSIGN_SHR, TC_ASSIGN_AND,
+	TC_ASSIGN_XOR, TC_ASSIGN_OR, TC_BACK_SLASH
 }; // end enum TokenCode
 
 
 /// The value of Token::dataType
-enum TokenDataType
+enum DataType
 {
 	DT_FLOAT,
 	DT_INT,
@@ -95,7 +95,7 @@ class Token
 		/// @{
 		const char* getString() const {return &asString[0];}
 		TokenCode getCode() const {return code;}
-		TokenDataType getDataType() const {return dataType;}
+		DataType getDataType() const {return dataType;}
 		const TokenDataVal& getValue() const {return value;}
 		/// @}
 
@@ -103,7 +103,7 @@ class Token
 		boost::array<char, MAX_SCRIPT_LINE_LEN> asString;
 		TokenCode code; ///< The first thing you should know about a token
 		/// Additional info in case @ref code is @ref TC_NUMBER
-		TokenDataType dataType;
+		DataType dataType;
 		TokenDataVal value; ///< A value variant
 };
 

unit-tests/Util/Scanner.ut.cpp

@@ -10,34 +10,34 @@ TEST(ScannerTests, Numbers)
 	std::stringstream ss;	
 	ss << "12345678901234 1.12 0.00000000000001 0.01e1 1e- 10.123e-7 1ab";
 
-	std::auto_ptr<Scanner::Scanner> scanner_;
-	const Scanner::Token* token;
+	std::auto_ptr<scanner::Scanner> scanner_;
+	const scanner::Token* token;
 	
-	EXPECT_NO_THROW(scanner_.reset(new Scanner::Scanner(ss, "numbers")));
-	Scanner::Scanner& scanner = *scanner_;
+	EXPECT_NO_THROW(scanner_.reset(new scanner::Scanner(ss, "numbers")));
+	scanner::Scanner& scanner = *scanner_;
 
 	// 12345678901234
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_NUMBER);	
-	EXPECT_EQ(token->getDataType(), Scanner::DT_INT);	
+	EXPECT_EQ(token->getCode(), scanner::TC_NUMBER);	
+	EXPECT_EQ(token->getDataType(), scanner::DT_INT);	
 	EXPECT_EQ(token->getValue().getInt(), 12345678901234);
 	
 	// 1.12
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_NUMBER);	
-	EXPECT_EQ(token->getDataType(), Scanner::DT_FLOAT);	
+	EXPECT_EQ(token->getCode(), scanner::TC_NUMBER);	
+	EXPECT_EQ(token->getDataType(), scanner::DT_FLOAT);	
 	EXPECT_FLOAT_EQ(token->getValue().getFloat(), 1.12);
 	
 	// 0.00000000000001
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_NUMBER);	
-	EXPECT_EQ(token->getDataType(), Scanner::DT_FLOAT);	
+	EXPECT_EQ(token->getCode(), scanner::TC_NUMBER);	
+	EXPECT_EQ(token->getDataType(), scanner::DT_FLOAT);	
 	EXPECT_FLOAT_EQ(token->getValue().getFloat(), 0.00000000000001);
 	
 	// 0.01e1
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_NUMBER);	
-	EXPECT_EQ(token->getDataType(), Scanner::DT_FLOAT);	
+	EXPECT_EQ(token->getCode(), scanner::TC_NUMBER);	
+	EXPECT_EQ(token->getDataType(), scanner::DT_FLOAT);	
 	EXPECT_FLOAT_EQ(token->getValue().getFloat(), 0.01e1);
 	
 	// 1e-
@@ -45,8 +45,8 @@ TEST(ScannerTests, Numbers)
 	
 	// 10.123e-7
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_NUMBER);	
-	EXPECT_EQ(token->getDataType(), Scanner::DT_FLOAT);	
+	EXPECT_EQ(token->getCode(), scanner::TC_NUMBER);	
+	EXPECT_EQ(token->getDataType(), scanner::DT_FLOAT);	
 	EXPECT_FLOAT_EQ(token->getValue().getFloat(), 10.123e-7);
 	
 	// 1ab
@@ -54,7 +54,7 @@ TEST(ScannerTests, Numbers)
 	
 	// EOF
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_EOF);
+	EXPECT_EQ(token->getCode(), scanner::TC_END);
 }
 
 
@@ -63,34 +63,34 @@ TEST(ScannerTests, Identifiers)
 	std::stringstream ss;	
 	ss << "1 la0_la ha\n_ha";
 
-	std::auto_ptr<Scanner::Scanner> scanner_;
-	const Scanner::Token* token;
+	std::auto_ptr<scanner::Scanner> scanner_;
+	const scanner::Token* token;
 	
-	EXPECT_NO_THROW(scanner_.reset(new Scanner::Scanner(ss, "identifiers")));
-	Scanner::Scanner& scanner = *scanner_;
+	EXPECT_NO_THROW(scanner_.reset(new scanner::Scanner(ss, "identifiers")));
+	scanner::Scanner& scanner = *scanner_;
 	
 	// 1
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_NE(token->getCode(), Scanner::TC_IDENTIFIER);
+	EXPECT_NE(token->getCode(), scanner::TC_IDENTIFIER);
 	
 	// la_la
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_IDENTIFIER);	
+	EXPECT_EQ(token->getCode(), scanner::TC_IDENTIFIER);	
 	EXPECT_EQ(token->getValue().getString(), std::string("la0_la"));
 	
 	// ha
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_IDENTIFIER);	
+	EXPECT_EQ(token->getCode(), scanner::TC_IDENTIFIER);	
 	EXPECT_EQ(token->getValue().getString(), std::string("ha"));
 	
 	// _ha
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_IDENTIFIER);	
+	EXPECT_EQ(token->getCode(), scanner::TC_IDENTIFIER);	
 	EXPECT_EQ(token->getValue().getString(), std::string("_ha"));
 	
 	// EOF
 	EXPECT_NO_THROW(token = &scanner.getNextToken());
-	EXPECT_EQ(token->getCode(), Scanner::TC_EOF);
+	EXPECT_EQ(token->getCode(), scanner::TC_END);
 }