Adding exceptions. WIP

src/Misc/Parser.h

@@ -6,7 +6,7 @@
 #include "Scanner.h"
 
 
-/// @brief It contains some functions and macros that include code commonly used in parsing
+/// It contains some functions and macros that include code commonly used while parsing
 namespace Parser {
 
 
@@ -27,88 +27,19 @@ namespace Parser {
 //======================================================================================================================
 // parseArrOfNumbers                                                                                                   =
 //======================================================================================================================
-/**
- * This template func is used for a common operation of parsing arrays of numbers
- *
- * It parses expressions like this one: { 10 -0.2 123.e-10 -0x0FF } and stores the result in the arr array. The
- * acceptable types (typename Type) are integer or floating point types
- *
- * @param scanner The scanner that we will use
- * @param bracket If true the array starts and ends with brackets eg { 10 0 -1 }
- * @param signs If true the array has numbers that may contain sign
- * @param size The count of numbers of the array wa want to parse
- * @param arr The array that the func returns the numbers
- * @return True if the parsing was successful
-*/
-/*template <typename Type>
-bool parseArrOfNumbers(Scanner& scanner, bool bracket, bool signs, uint size, Type* arr)
-{
-	const Scanner::Token* token;
-
-	// first of all the left bracket
-	if(bracket)
-	{
-		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_LBRACKET)
-		{
-			PARSE_ERR_EXPECTED("{");
-			return false;
-		}
-	}
-
-	// loop to parse numbers
-	for(uint i=0; i<size; i++)
-	{
-		token = &scanner.getNextToken();
-
-
-		// check if there is a sign in front of a number
-		bool sign = 0; // sign of the number. 0 for positive and 1 for negative
-		if(signs)
-		{
-			if(token->getCode() == Scanner::TC_MINUS)
-			{
-				sign = 1;
-				token = &scanner.getNextToken();
-			}
-			else if(token->getCode() == Scanner::TC_PLUS)
-			{
-				sign = 0;
-				token = &scanner.getNextToken();
-			}
-
-			// check if not number
-			if(token->getCode() != Scanner::TC_NUMBER)
-			{
-				PARSE_ERR_EXPECTED("number");
-				return false;
-			}
-		} // end if signs
-
-		// put the number in the arr and do typecasting from int to float
-		Type nmbr;
-
-		if(token->getDataType() == Scanner::DT_FLOAT)
-			nmbr = static_cast<Type>(token->getValue().getFloat());
-		else
-			nmbr = static_cast<Type>(token->getValue().getInt());
-
-		arr[i] = (sign==0) ? nmbr : -nmbr;
-	}
-
-	// the last thing is the right bracket
-	if(bracket)
-	{
-		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_RBRACKET)
-		{
-			PARSE_ERR_EXPECTED("}");
-			return false;
-		}
-	}
-
-	return true;
-}*/
+/// This template func is used for a common operation of parsing arrays of numbers
+///
+/// It parses expressions like this one: { 10 -0.2 123.e-10 -0x0FF } and stores the result in the arr array. The
+/// acceptable types (typename Type) are integer or floating point types
+///
+/// @param scanner The scanner that we will use
+/// @param bracket If true the array starts and ends with brackets eg { 10 0 -1 }
+/// @param signs If true the array has numbers that may contain sign
+/// @param size The count of numbers of the array wa want to parse
+/// @param arr The array that the func returns the numbers
+/// @exception Exception
+template <typename Type>
+void parseArrOfNumbers(Scanner& scanner, bool bracket, bool signs, uint size, Type* arr);
 
 
 /// Parse a single number

src/Misc/Parser.inl.h

@@ -5,6 +5,79 @@
 namespace Parser {
 
 
+//======================================================================================================================
+// parseArrOfNumbers                                                                                                   =
+//======================================================================================================================
+template <typename Type>
+void parseArrOfNumbers(Scanner& scanner, bool bracket, bool signs, uint size, Type* arr)
+{
+	const Scanner::Token* token;
+
+	// first of all the left bracket
+	if(bracket)
+	{
+		token = &scanner.getNextToken();
+		if(token->getCode() != Scanner::TC_LBRACKET)
+		{
+			throw PARSER_EXCEPTION_EXPECTED("{");
+		}
+	}
+
+	// loop to parse numbers
+	for(uint i=0; i<size; i++)
+	{
+		token = &scanner.getNextToken();
+
+
+		// check if there is a sign in front of a number
+		bool sign = 0; // sign of the number. 0 for positive and 1 for negative
+		if(signs)
+		{
+			if(token->getCode() == Scanner::TC_MINUS)
+			{
+				sign = 1;
+				token = &scanner.getNextToken();
+			}
+			else if(token->getCode() == Scanner::TC_PLUS)
+			{
+				sign = 0;
+				token = &scanner.getNextToken();
+			}
+
+			// check if not number
+			if(token->getCode() != Scanner::TC_NUMBER)
+			{
+				throw PARSER_EXCEPTION_EXPECTED("number");
+			}
+		} // end if signs
+
+		// put the number in the arr and do typecasting from int to float
+		Type nmbr;
+
+		if(token->getDataType() == Scanner::DT_FLOAT)
+		{
+			nmbr = static_cast<Type>(token->getValue().getFloat());
+		}
+		else
+		{
+			nmbr = static_cast<Type>(token->getValue().getInt());
+		}
+
+		arr[i] = (sign==0) ? nmbr : -nmbr;
+	}
+
+	// the last thing is the right bracket
+	if(bracket)
+	{
+		token = &scanner.getNextToken();
+		if(token->getCode() != Scanner::TC_RBRACKET)
+		{
+			throw PARSER_EXCEPTION_EXPECTED("}");
+		}
+	}
+}
+
+
 //======================================================================================================================
 // parseNumber                                                                                                         =
 //======================================================================================================================

src/Resources/Core/Resource.h

@@ -54,8 +54,4 @@ inline Resource::Resource(const ResourceType& type_):
 {}
 
 
-/// Special throwing exception macro for the resources
-#define RSRC_THROW_EXCEPTION(x) THROW_EXCEPTION("File \"" + getRsrcPath() + "/" + getRsrcName() + "\: " + x)
-
-
 #endif

src/Resources/Material.cpp

@@ -51,7 +51,7 @@ Material::StdVarNameAndGlDataTypePair Material::stdUniVarInfos[SUV_NUM] =
 
 
 //======================================================================================================================
-// Stuff for custom material stage shader prgs                                                                         =
+// Stuff for custom material stage shader progs                                                                        =
 //======================================================================================================================
 
 /// A simple pair-like structure
@@ -122,308 +122,301 @@ static bool searchBlendEnum(const char* str, int& gl_enum)
 //======================================================================================================================
 void Material::load(const char* filename)
 {
-	try
+	Scanner scanner(filename);
+	const Scanner::Token* token;
+
+	while(true)
 	{
-		Scanner scanner(filename);
-		const Scanner::Token* token;
+		token = &scanner.getNextToken();
 
-		while(true)
+		//
+		// SHADER_PROG
+		//
+		if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "SHADER_PROG"))
 		{
-			token = &scanner.getNextToken();
+			if(shaderProg.get())
+			{
+				throw PARSER_EXCEPTION("Shader program already loaded");
+			}
 
-			//
-			// SHADER_PROG
-			//
-			if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "SHADER_PROG"))
+			token = &scanner.getNextToken();
+			string shaderFilename;
+			// Just a string
+			if(token->getCode() == Scanner::TC_STRING)
 			{
-				if(shaderProg.get())
+				shaderFilename = token->getValue().getString();
+			}
+			// build custom shader
+			else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getString(), "buildMsSProg"))
+			{
+				// (
+				token = &scanner.getNextToken();
+				if(token->getCode() != Scanner::TC_LPAREN)
 				{
-					PARSER_THROW_EXCEPTION("Shader program already loaded");
+					throw PARSER_EXCEPTION_EXPECTED("(");
 				}
 
+				// shader prog
 				token = &scanner.getNextToken();
-				string shaderFilename;
-				// Just a string
-				if(token->getCode() == Scanner::TC_STRING)
+				if(token->getCode() != Scanner::TC_STRING)
 				{
-					shaderFilename = token->getValue().getString();
+					throw PARSER_EXCEPTION_EXPECTED("string");
 				}
-				// build custom shader
-				else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getString(), "buildMsSProg"))
+				string sProgFilename = token->getValue().getString();
+
+				// get the switches
+				string source;
+				string prefix;
+				while(true)
 				{
-					// (
 					token = &scanner.getNextToken();
-					if(token->getCode() != Scanner::TC_LPAREN)
+
+					if(token->getCode() == Scanner::TC_RPAREN)
 					{
-						throw PARSER_EXCEPTION_EXPECTED("(");
+						break;
 					}
 
-					// shader prog
-					token = &scanner.getNextToken();
-					if(token->getCode() != Scanner::TC_STRING)
+					if(token->getCode() != Scanner::TC_IDENTIFIER)
 					{
-						throw PARSER_EXCEPTION_EXPECTED("string");
+						throw PARSER_EXCEPTION_EXPECTED("identifier");
 					}
-					string sProgFilename = token->getValue().getString();
 
-					// get the switches
-					string source;
-					string prefix;
-					while(true)
+					// Check if acceptable value. Loop the switches array
+					MsSwitch* mss = msSwitches;
+					while(mss->switchName != NULL)
 					{
-						token = &scanner.getNextToken();
-
-						if(token->getCode() == Scanner::TC_RPAREN)
+						if(!strcmp(mss->switchName, token->getString()))
 						{
 							break;
 						}
 
-						if(token->getCode() != Scanner::TC_IDENTIFIER)
-						{
-							throw PARSER_EXCEPTION_EXPECTED("identifier");
-						}
-
-						// Check if acceptable value. Loop the switches array
-						MsSwitch* mss = msSwitches;
-						while(mss->switchName != NULL)
-						{
-							if(!strcmp(mss->switchName, token->getString()))
-							{
-								break;
-							}
+						++mss;
+					}
 
-							++mss;
-						}
+					if(mss->switchName == NULL)
+					{
+						throw PARSER_EXCEPTION("Incorrect switch " + token->getString());
+					}
 
-						if(mss->switchName == NULL)
-						{
-							PARSER_THROW_EXCEPTION("Incorrect switch " + token->getString());
-						}
+					source += string("#define ") + token->getString() + "\n";
+					prefix.push_back(mss->prefix);
+				} // end get the switches
 
-						source += string("#define ") + token->getString() + "\n";
-						prefix.push_back(mss->prefix);
-					} // end get the switches
+				std::sort(prefix.begin(), prefix.end());
 
-					std::sort(prefix.begin(), prefix.end());
+				shaderFilename = ShaderProg::createSrcCodeToCache(sProgFilename.c_str(), source.c_str(), prefix.c_str());
+			}
+			else
+			{
+				throw PARSER_EXCEPTION_EXPECTED("string or buildMsSProg");
+			}
 
-					shaderFilename = ShaderProg::createSrcCodeToCache(sProgFilename.c_str(), source.c_str(), prefix.c_str());
-				}
-				else
-				{
-					throw PARSER_EXCEPTION_EXPECTED("string or buildMsSProg");
-				}
+			shaderProg.loadRsrc(shaderFilename.c_str());
+		}
+		//
+		// DEPTH_PASS_MATERIAL
+		//
+		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "DEPTH_PASS_MATERIAL"))
+		{
+			if(dpMtl.get())
+			{
+				throw PARSER_EXCEPTION("Depth material already loaded");
+			}
 
-				shaderProg.loadRsrc(shaderFilename.c_str());
+			token = &scanner.getNextToken();
+			if(token->getCode() != Scanner::TC_STRING)
+			{
+				throw PARSER_EXCEPTION_EXPECTED("string");
 			}
-			//
-			// DEPTH_PASS_MATERIAL
-			//
-			else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "DEPTH_PASS_MATERIAL"))
+			dpMtl.loadRsrc(token->getValue().getString());
+		}
+		//
+		// BLENDS
+		//
+		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "BLENDS"))
+		{
+			token = &scanner.getNextToken();
+			if(token->getCode() != Scanner::TC_NUMBER)
 			{
-				if(dpMtl.get())
-				{
-					PARSER_THROW_EXCEPTION("Depth material already loaded");
-				}
-
-				token = &scanner.getNextToken();
-				if(token->getCode() != Scanner::TC_STRING)
-				{
-					throw PARSER_EXCEPTION_EXPECTED("string");
-				}
-				dpMtl.loadRsrc(token->getValue().getString());
+				throw PARSER_EXCEPTION_EXPECTED("number");
 			}
-			//
-			// BLENDS
-			//
-			else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "BLENDS"))
+			blends = token->getValue().getInt();
+		}
+		//
+		// BLENDING_SFACTOR
+		//
+		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "BLENDING_SFACTOR"))
+		{
+			token = &scanner.getNextToken();
+			if(token->getCode() != Scanner::TC_IDENTIFIER)
 			{
-				token = &scanner.getNextToken();
-				if(token->getCode() != Scanner::TC_NUMBER)
-				{
-					throw PARSER_EXCEPTION_EXPECTED("number");
-				}
-				blends = token->getValue().getInt();
+				throw PARSER_EXCEPTION_EXPECTED("identifier");
 			}
-			//
-			// BLENDING_SFACTOR
-			//
-			else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "BLENDING_SFACTOR"))
+			int gl_enum;
+			if(!searchBlendEnum(token->getValue().getString(), gl_enum))
 			{
-				token = &scanner.getNextToken();
-				if(token->getCode() != Scanner::TC_IDENTIFIER)
-				{
-					throw PARSER_EXCEPTION_EXPECTED("identifier");
-				}
-				int gl_enum;
-				if(!searchBlendEnum(token->getValue().getString(), gl_enum))
-				{
-					PARSER_THROW_EXCEPTION("Incorrect blending factor \"" + token->getValue().getString() + "\"");
-				}
-				blendingSfactor = gl_enum;
+				throw PARSER_EXCEPTION("Incorrect blending factor \"" + token->getValue().getString() + "\"");
 			}
-			//
-			// BLENDING_DFACTOR
-			//
-			else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "BLENDING_DFACTOR"))
+			blendingSfactor = gl_enum;
+		}
+		//
+		// BLENDING_DFACTOR
+		//
+		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "BLENDING_DFACTOR"))
+		{
+			token = &scanner.getNextToken();
+			if(token->getCode() != Scanner::TC_IDENTIFIER)
 			{
-				token = &scanner.getNextToken();
-				if(token->getCode() != Scanner::TC_IDENTIFIER)
-				{
-					throw PARSER_EXCEPTION_EXPECTED("identifier");
-				}
-				int gl_enum;
-				if(!searchBlendEnum(token->getValue().getString(), gl_enum))
-				{
-					PARSE_ERR("Incorrect blending factor \"" << token->getValue().getString() << "\"");
-				}
-				blendingDfactor = gl_enum;
+				throw PARSER_EXCEPTION_EXPECTED("identifier");
 			}
-			//
-			// DEPTH_TESTING
-			//
-			else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "DEPTH_TESTING"))
+			int gl_enum;
+			if(!searchBlendEnum(token->getValue().getString(), gl_enum))
 			{
-				token = &scanner.getNextToken();
-				if(token->getCode() != Scanner::TC_NUMBER)
-				{
-					throw PARSER_EXCEPTION_EXPECTED("number");
-				}
-				depthTesting = token->getValue().getInt();
+				throw PARSER_EXCEPTION("Incorrect blending factor \"" + token->getValue().getString() + "\"");
 			}
-			//
-			// WIREFRAME
-			//
-			else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "WIREFRAME"))
+			blendingDfactor = gl_enum;
+		}
+		//
+		// DEPTH_TESTING
+		//
+		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "DEPTH_TESTING"))
+		{
+			token = &scanner.getNextToken();
+			if(token->getCode() != Scanner::TC_NUMBER)
 			{
-				token = &scanner.getNextToken();
-				if(token->getCode() != Scanner::TC_NUMBER)
-				{
-					throw PARSER_EXCEPTION_EXPECTED("number");
-				}
-				wireframe = token->getValue().getInt();
+				throw PARSER_EXCEPTION_EXPECTED("number");
 			}
-			//
-			// CASTS_SHADOW
-			//
-			else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "CASTS_SHADOW"))
+			depthTesting = token->getValue().getInt();
+		}
+		//
+		// WIREFRAME
+		//
+		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "WIREFRAME"))
+		{
+			token = &scanner.getNextToken();
+			if(token->getCode() != Scanner::TC_NUMBER)
 			{
-				token = &scanner.getNextToken();
-				if(token->getCode() != Scanner::TC_NUMBER)
-				{
-					throw PARSER_EXCEPTION_EXPECTED("number");
-				}
-				castsShadow = token->getValue().getInt();
+				throw PARSER_EXCEPTION_EXPECTED("number");
 			}
-			//
-			// USER_DEFINED_VARS
-			//
-			else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "USER_DEFINED_VARS"))
+			wireframe = token->getValue().getInt();
+		}
+		//
+		// CASTS_SHADOW
+		//
+		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "CASTS_SHADOW"))
+		{
+			token = &scanner.getNextToken();
+			if(token->getCode() != Scanner::TC_NUMBER)
 			{
-				// first check if the shader is defined
-				if(shaderProg.get() == NULL)
-				{
-					PARSER_THROW_EXCEPTION("You have to define the shader program before the user defined vars");
-				}
+				throw PARSER_EXCEPTION_EXPECTED("number");
+			}
+			castsShadow = token->getValue().getInt();
+		}
+		//
+		// USER_DEFINED_VARS
+		//
+		else if(token->getCode() == Scanner::TC_IDENTIFIER && !strcmp(token->getValue().getString(), "USER_DEFINED_VARS"))
+		{
+			// first check if the shader is defined
+			if(shaderProg.get() == NULL)
+			{
+				throw PARSER_EXCEPTION("You have to define the shader program before the user defined vars");
+			}
 
-				// {
+			// {
+			token = &scanner.getNextToken();
+			if(token->getCode() != Scanner::TC_LBRACKET)
+			{
+				throw PARSER_EXCEPTION_EXPECTED("{");
+			}
+			// loop all the vars
+			do
+			{
+				// read the name
 				token = &scanner.getNextToken();
-				if(token->getCode() != Scanner::TC_LBRACKET)
+				if(token->getCode() == Scanner::TC_RBRACKET)
 				{
-					throw PARSER_EXCEPTION_EXPECTED("{");
+					break;
 				}
-				// loop all the vars
-				do
-				{
-					// read the name
-					token = &scanner.getNextToken();
-					if(token->getCode() == Scanner::TC_RBRACKET)
-					{
-						break;
-					}
 
-					if(token->getCode() != Scanner::TC_IDENTIFIER)
-					{
-						throw PARSER_EXCEPTION_EXPECTED("identifier");
-					}
+				if(token->getCode() != Scanner::TC_IDENTIFIER)
+				{
+					throw PARSER_EXCEPTION_EXPECTED("identifier");
+				}
 
-					string varName;
-					varName = token->getValue().getString();
+				string varName;
+				varName = token->getValue().getString();
 
-					userDefinedVars.push_back(new UserDefinedUniVar); // create new var
-					UserDefinedUniVar& var = userDefinedVars.back();
+				userDefinedVars.push_back(new UserDefinedUniVar); // create new var
+				UserDefinedUniVar& var = userDefinedVars.back();
 
-					// check if the uniform exists
-					if(!shaderProg->uniVarExists(varName.c_str()))
-					{
-						PARSER_THROW_EXCEPTION("The variable \"" + varName + "\" is not an active uniform");
-					}
+				// check if the uniform exists
+				if(!shaderProg->uniVarExists(varName.c_str()))
+				{
+					throw PARSER_EXCEPTION("The variable \"" + varName + "\" is not an active uniform");
+				}
 
-					var.sProgVar = shaderProg->findUniVar(varName.c_str());
+				var.sProgVar = shaderProg->findUniVar(varName.c_str());
 
-					// read the values
-					switch(var.sProgVar->getGlDataType())
-					{
-						// texture
-						case GL_SAMPLER_2D:
-							token = &scanner.getNextToken();
-							if(token->getCode() == Scanner::TC_STRING)
-							{
-								var.value.texture.loadRsrc(token->getValue().getString());
-							}
-							else
-							{
-								throw PARSER_EXCEPTION_EXPECTED("string");
-							}
-							break;
-						// float
-						case GL_FLOAT:
-							token = &scanner.getNextToken();
-							if(token->getCode() == Scanner::TC_NUMBER && token->getDataType() == Scanner::DT_FLOAT)
-							{
-								var.value.float_ = token->getValue().getFloat();
-							}
-							else
-							{
-								throw PARSER_EXCEPTION_EXPECTED("float");
-							}
-							break;
-						// vec2
-						case GL_FLOAT_VEC2:
-							Parser::parseMathVector(scanner, var.value.vec2);
-							break;
-						// vec3
-						case GL_FLOAT_VEC3:
-							Parser::parseMathVector(scanner, var.value.vec3);
-							break;
-						// vec4
-						case GL_FLOAT_VEC4:
-							Parser::parseMathVector(scanner, var.value.vec4);
-							break;
-					};
+				// read the values
+				switch(var.sProgVar->getGlDataType())
+				{
+					// texture
+					case GL_SAMPLER_2D:
+						token = &scanner.getNextToken();
+						if(token->getCode() == Scanner::TC_STRING)
+						{
+							var.value.texture.loadRsrc(token->getValue().getString());
+						}
+						else
+						{
+							throw PARSER_EXCEPTION_EXPECTED("string");
+						}
+						break;
+					// float
+					case GL_FLOAT:
+						token = &scanner.getNextToken();
+						if(token->getCode() == Scanner::TC_NUMBER && token->getDataType() == Scanner::DT_FLOAT)
+						{
+							var.value.float_ = token->getValue().getFloat();
+						}
+						else
+						{
+							throw PARSER_EXCEPTION_EXPECTED("float");
+						}
+						break;
+					// vec2
+					case GL_FLOAT_VEC2:
+						Parser::parseMathVector(scanner, var.value.vec2);
+						break;
+					// vec3
+					case GL_FLOAT_VEC3:
+						Parser::parseMathVector(scanner, var.value.vec3);
+						break;
+					// vec4
+					case GL_FLOAT_VEC4:
+						Parser::parseMathVector(scanner, var.value.vec4);
+						break;
+				};
 
-				}while(true); // end loop for all the vars
+			}while(true); // end loop for all the vars
 
-			}
-			//
-			// EOF
-			//
-			else if(token->getCode() == Scanner::TC_EOF)
-			{
-				break;
-			}
-			//
-			// other crap
-			//
-			else
-			{
-				PARSER_THROW_EXCEPTION_UNEXPECTED();
-			}
-		} // end while
-	}
-	catch(std::exception& e)
-	{
-		ERROR(e.what());
-	}
+		}
+		//
+		// EOF
+		//
+		else if(token->getCode() == Scanner::TC_EOF)
+		{
+			break;
+		}
+		//
+		// other crap
+		//
+		else
+		{
+			throw PARSER_EXCEPTION_UNEXPECTED();
+		}
+	} // end while
 
 	initStdShaderVars();
 }
@@ -437,7 +430,7 @@ void Material::initStdShaderVars()
 	// sanity checks
 	if(!shaderProg.get())
 	{
-		MTL_THROW_EXCEPTION("Without shader is like cake without sugar (missing SHADER_PROG)");
+		throw MTL_EXCEPTION("Without shader is like cake without sugar (missing SHADER_PROG)");
 	}
 
 	// the attributes
@@ -456,9 +449,8 @@ void Material::initStdShaderVars()
 		// check if the shader has different GL data type from that it suppose to have
 		if(stdAttribVars[i]->getGlDataType() != stdAttribVarInfos[i].dataType)
 		{
-			MTL_THROW_EXCEPTION("The \"" + stdAttribVarInfos[i].varName +
-			                    "\" attribute var has incorrect GL data type from the expected (0x" + hex +
-			                    stdAttribVars[i]->getGlDataType() + ")");
+			throw MTL_EXCEPTION("The \"" + stdAttribVarInfos[i].varName +
+			                    "\" attribute var has incorrect GL data type from the expected");
 		}
 	}
 
@@ -478,9 +470,8 @@ void Material::initStdShaderVars()
 		// check if the shader has different GL data type from that it suppose to have
 		if(stdUniVars[i]->getGlDataType() != stdUniVarInfos[i].dataType)
 		{
-			MTL_THROW_EXCEPTION("The \"" + stdUniVarInfos[i].varName +
-			                    "\" uniform var has incorrect GL data type from the expected (0x" + hex +
-			                    stdUniVars[i]->getGlDataType() + ")");
+			throw MTL_EXCEPTION("The \"" + stdUniVarInfos[i].varName +
+			                    "\" uniform var has incorrect GL data type from the expected");
 		}
 	}
 }

src/Resources/Material.h

@@ -20,10 +20,43 @@
 ///
 /// File format:
 /// @code
+/// shaderProg <string> |
+/// 	standardMsSProg {
+/// 		shaderProg <string>
+/// 		defines {
+/// 			<identifier>
+/// 			<identifier>
+/// 			...
+/// 			<identifier>
+/// 		}
+/// 	}
+///
+/// dpMtl <string>
+///
+/// [blendingStage <true | false>]
+///
+/// [blendFuncs* {
+/// 	sFactor <identifier>
+/// 	dFactor <identifier>
+/// }]
+///
+/// [depthTesting <true | false>]
+///
+/// [wireFrame <true | false>]
+///
+/// [castsShadow <true | false>]
+///
+/// [userDefinedVars {
+/// 	<identifier> <value**>
+/// }]
+///
+///
+/// *: Has nothing to do with the blendFuncs. blendFuncs can be in material stage as well
+/// **: Depends on the type of the var
 /// @endcode
 class Material: public Resource
 {
-	friend class Renderer; ///< For the setupMaterial
+	friend class Renderer; ///< For setupMaterial
 	friend class Ez;
 	friend class Sm;
 	friend class Ms;
@@ -32,13 +65,14 @@ class Material: public Resource
 	friend class MeshNode;
 
 	public:
+		/// Initialize with default values
 		Material();
 
 		/// @see Resource::load
 		void load(const char* filename);
 
 	private:
-		/// Standard attribute variables that are acceptable inside the @ref ShaderProg
+		/// Standard attribute variables that are acceptable inside the material stage @ref ShaderProg
 		enum StdAttribVars
 		{
 			SAV_POSITION,
@@ -55,7 +89,7 @@ class Material: public Resource
 		/// After changing the enum update also:
 		/// - Some statics in Material.cpp
 		/// - Renderer::setupMaterial
-		/// - The generic material shader (maybe)
+		/// - The generic material GLSL shader (maybe)
 		enum StdUniVars
 		{
 			// Skinning
@@ -121,7 +155,7 @@ class Material: public Resource
 		int blendingDfactor;
 		bool depthTesting;
 		bool wireframe;
-		bool castsShadow; ///< Used in shadowmapping passes but not in Ez
+		bool castsShadow; ///< Used in depth passes of shadowmapping and not in other depth passes like EarlyZ
 
 		/// The func sweeps all the variables of the shader program to find standard shader program variables. It updates
 		/// the stdAttribVars and stdUniVars arrays.
@@ -129,7 +163,6 @@ class Material: public Resource
 		void initStdShaderVars();
 
 		bool hasHWSkinning() const {return stdAttribVars[SAV_VERT_WEIGHT_BONES_NUM] != NULL;}
-		bool hasAlphaTesting() const {return stdAttribVars[SAV_VERT_WEIGHT_BONES_NUM] != NULL;}
 };
 
 

src/Resources/Mesh.h

@@ -15,6 +15,7 @@ class Material;
 /// Mesh Resource. If the material name is empty then the mesh wont be rendered and no VBOs will be created
 ///
 /// Binary file format:
+///
 /// @code
 /// <magic:ANKIMESH>
 /// <string:meshName>

src/Resources/ParticleEmitterProps.cpp

@@ -5,6 +5,9 @@
 static const char* errMsg = "Incorrect or missing value ";
 
 
+#define PE_EXCEPTION(x) EXCEPTION("File \"" + getRsrcPath() + getRsrcName() + "\": " + x)
+
+
 //======================================================================================================================
 // Constructor                                                                                                         =
 //======================================================================================================================
@@ -93,31 +96,31 @@ void ParticleEmitterProps::load(const char* /*filename*/)
 	// sanity checks
 	if(particleLife <= 0.0)
 	{
-		RSRC_THROW_EXCEPTION(errMsg + "particleLife");
+		throw PE_EXCEPTION(errMsg + "particleLife");
 	}
 
 	if(particleLife - particleLifeMargin <= 0.0)
 	{
-		RSRC_THROW_EXCEPTION(errMsg + "particleLifeMargin");
+		throw PE_EXCEPTION(errMsg + "particleLifeMargin");
 	}
 
 	if(size <= 0.0)
 	{
-		RSRC_THROW_EXCEPTION(errMsg + "size");
+		throw PE_EXCEPTION(errMsg + "size");
 	}
 
 	if(maxNumOfParticles < 1)
 	{
-		RSRC_THROW_EXCEPTION(errMsg + "maxNumOfParticles");
+		throw PE_EXCEPTION(errMsg + "maxNumOfParticles");
 	}
 
 	if(emittionPeriod <= 0.0)
 	{
-		RSRC_THROW_EXCEPTION(errMsg + "emittionPeriod");
+		throw PE_EXCEPTION(errMsg + "emittionPeriod");
 	}
 
 	if(particlesPerEmittion < 1)
 	{
-		RSRC_THROW_EXCEPTION(errMsg + "particlesPerEmittion");
+		throw PE_EXCEPTION(errMsg + "particlesPerEmittion");
 	}
 }

src/Resources/ParticleEmitterProps.h

@@ -1,7 +1,6 @@
 #ifndef PARTICLE_EMITTER_PROPS_H
 #define PARTICLE_EMITTER_PROPS_H
 
-#include "Common.h"
 #include "Math.h"
 #include "Resource.h"
 
@@ -11,7 +10,7 @@
 class ParticleEmitterPropsStruct
 {
 	public:
-		/// @name Particle properties
+		/// @name Particle specific properties
 		/// @{
 		float particleLife; ///< Required and > 0.0
 		float particleLifeMargin;
@@ -33,7 +32,7 @@ class ParticleEmitterPropsStruct
 		float size; ///< The size of the collision shape. Required and > 0.0
 		/// @}
 
-		/// @name Emitter properties
+		/// @name Emitter specific properties
 		/// @{
 		uint maxNumOfParticles; ///< The size of the particles vector. Required
 		float emittionPeriod; ///< How often the emitter emits new particles. In secs. Required

src/Resources/SkelAnim.cpp

@@ -1,77 +1,61 @@
 #include "SkelAnim.h"
-#include "Scanner.h"
 #include "Parser.h"
 
 
 //======================================================================================================================
 // load                                                                                                                =
 //======================================================================================================================
-bool SkelAnim::load(const char* filename)
+void SkelAnim::load(const char* filename)
 {
-	try
+	Scanner scanner(filename);
+	const Scanner::Token* token;
+
+	// keyframes
+	token = &scanner.getNextToken();
+	if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
 	{
-		Scanner scanner(filename);
-		const Scanner::Token* token;
+		throw PARSER_EXCEPTION_EXPECTED("integer");
+	}
+	keyframes.resize(token->getValue().getInt());
 
-		// keyframes
-		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
-		{
-			PARSE_ERR_EXPECTED("integer");
-			return false;
-		}
-		keyframes.resize(token->getValue().getInt());
+	Parser::parseArrOfNumbers(scanner, false, false, keyframes.size(), &keyframes[0]);
 
-		if(!Parser::parseArrOfNumbers(scanner, false, false, keyframes.size(), &keyframes[0]))
-			return false;
+	// bones num
+	token = &scanner.getNextToken();
+	if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
+	{
+		throw PARSER_EXCEPTION_EXPECTED("integer");
+	}
+	bones.resize(token->getValue().getInt());
 
-		// bones num
+	// poses
+	for(uint i=0; i<bones.size(); i++)
+	{
+		// has anim?
 		token = &scanner.getNextToken();
 		if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
 		{
-			PARSE_ERR_EXPECTED("integer");
-			return false;
+			throw PARSER_EXCEPTION_EXPECTED("integer");
 		}
-		bones.resize(token->getValue().getInt());
 
-		// poses
-		for(uint i=0; i<bones.size(); i++)
+		// it has
+		if(token->getValue().getInt() == 1)
 		{
-			// has anim?
-			token = &scanner.getNextToken();
-			if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
-			{
-				PARSE_ERR_EXPECTED("integer");
-				return false;
-			}
+			bones[i].keyframes.resize(keyframes.size());
 
-			// it has
-			if(token->getValue().getInt() == 1)
+			for(uint j=0; j<keyframes.size(); ++j)
 			{
-				bones[i].keyframes.resize(keyframes.size());
-
-				for(uint j=0; j<keyframes.size(); ++j)
-				{
-					// parse the quat
-					float tmp[4];
-					if(!Parser::parseArrOfNumbers(scanner, false, true, 4, &tmp[0]))
-						return false;
-					bones[i].keyframes[j].rotation = Quat(tmp[1], tmp[2], tmp[3], tmp[0]);
+				// parse the quat
+				float tmp[4];
+				Parser::parseArrOfNumbers(scanner, false, true, 4, &tmp[0]);
+				bones[i].keyframes[j].rotation = Quat(tmp[1], tmp[2], tmp[3], tmp[0]);
 
-					// parse the vec3
-					if(!Parser::parseArrOfNumbers(scanner, false, true, 3, &bones[i].keyframes[j].translation[0]))
-						return false;
-				}
+				// parse the vec3
+				Parser::parseArrOfNumbers(scanner, false, true, 3, &bones[i].keyframes[j].translation[0]);
 			}
-		} // end for all bones
-	}
-	catch(Exception& e)
-	{
-		ERROR(e.what());
-		return false;
-	}
+		}
+	} // end for all bones
 
-	framesNum = keyframes[keyframes.size()-1] + 1;
 
-	return true;
+	framesNum = keyframes[keyframes.size()-1] + 1;
 }

src/Resources/SkelAnim.h

@@ -1,7 +1,6 @@
-#ifndef SKELANIM_H
-#define SKELANIM_H
+#ifndef SKEL_ANIM_H
+#define SKEL_ANIM_H
 
-#include "Common.h"
 #include "Resource.h"
 #include "Math.h"
 
@@ -9,14 +8,15 @@
 /// Skeleton animation resource
 ///
 /// The format will be changed to:
+///
 /// @code
 /// skeletonAnimation
 /// {
 /// 	name same-as-file
-/// 	keyframes {<val> <val> ... <val>}
+/// 	keyframes {<integer> <integer> ... <integer>}
 /// 	bones
 /// 	{
-/// 		num <val>
+/// 		num <integer>
 /// 		boneAnims
 /// 		{
 /// 			boneAnim
@@ -26,8 +26,8 @@
 /// 				{
 /// 					bonePose
 /// 					{
-/// 						quat {<val> <val> <val> <val>}
-/// 						trf {<val> <val> <val>}
+/// 						quat {<float> <float> <float> <float>}
+/// 						trf {<float> <float> <float>}
 /// 					}
 /// 					...
 /// 					bonePose
@@ -48,9 +48,7 @@
 class SkelAnim: public Resource
 {
 	public:
-		/**
-		 * Bone pose
-		 */
+		/// Bone pose
 		class BonePose
 		{
 			public:
@@ -58,9 +56,7 @@ class SkelAnim: public Resource
 				Vec3 translation;
 		};
 
-		/**
-		 * Bone animation
-		 */
+		/// Bone animation
 		class BoneAnim
 		{
 			public:
@@ -76,7 +72,9 @@ class SkelAnim: public Resource
 
 		SkelAnim();
 		~SkelAnim() {}
-		bool load(const char* filename);
+
+		/// Implements Resource::loat
+		void load(const char* filename);
 };
 
 

src/Resources/Skeleton.cpp

@@ -7,110 +7,99 @@
 //======================================================================================================================
 // load                                                                                                                =
 //======================================================================================================================
-bool Skeleton::load(const char* filename)
+void Skeleton::load(const char* filename)
 {
-	try
+	Scanner scanner(filename);
+	const Scanner::Token* token;
+
+	//
+	// BONES NUM
+	//
+	token = &scanner.getNextToken();
+	if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
 	{
-		Scanner scanner(filename);
-		const Scanner::Token* token;
+		throw PARSER_EXCEPTION_EXPECTED("integer");
+	}
+	bones.resize(token->getValue().getInt(), Bone());
+
+	for(uint i=0; i<bones.size(); i++)
+	{
+		Bone& bone = bones[i];
+		bone.id = i;
 
-		//** BONES NUM **
+		///@todo clean
+		/*Mat3 m3_(Axisang(-PI/2, Vec3(1,0,0)));
+		Mat4 m4_(Vec3(0), m3_, 1.0);*/
+
+		// NAME
 		token = &scanner.getNextToken();
-		if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
+		if(token->getCode() != Scanner::TC_STRING)
 		{
-			PARSE_ERR_EXPECTED("integer");
-			return false;
+			throw PARSER_EXCEPTION_EXPECTED("string");
 		}
-		bones.resize(token->getValue().getInt(), Bone());
+		bone.name = token->getValue().getString();
 
-		for(uint i=0; i<bones.size(); i++)
-		{
-			Bone& bone = bones[i];
-			bone.id = i;
-
-			///@todo clean
-			/*Mat3 m3_(Axisang(-PI/2, Vec3(1,0,0)));
-			Mat4 m4_(Vec3(0), m3_, 1.0);*/
+		// head
+		Parser::parseMathVector(scanner, bone.head);
 
-			// NAME
-			token = &scanner.getNextToken();
-			if(token->getCode() != Scanner::TC_STRING)
-			{
-				PARSE_ERR_EXPECTED("string");
-				return false;
-			}
-			bone.name = token->getValue().getString();
+		//bone.head = m3_ * bone.head;
 
-			// head
-			if(!Parser::parseArrOfNumbers<float>(scanner, false, true, 3, &bone.head[0]))
-				return false;
+		// tail
+		Parser::parseMathVector(scanner, bone.tail);
 
-			//bone.head = m3_ * bone.head;
+		//bone.tail = m3_ * bone.tail;
 
-			// tail
-			if(!Parser::parseArrOfNumbers<float>(scanner, false, true, 3, &bone.tail[0]))
-				return false;
+		// matrix
+		Mat4 m4;
+		Parser::parseMathVector(scanner, m4);
 
-			//bone.tail = m3_ * bone.tail;
+		//m4 = m4_ * m4;
 
-			// matrix
-			Mat4 m4;
-			if(!Parser::parseArrOfNumbers<float>(scanner, false, true, 16, &m4[0]))
-				return false;
+		// matrix for real
+		bone.rotSkelSpace = m4.getRotationPart();
+		bone.tslSkelSpace = m4.getTranslationPart();
+		Mat4 MAi(m4.getInverse());
+		bone.rotSkelSpaceInv = MAi.getRotationPart();
+		bone.tslSkelSpaceInv = MAi.getTranslationPart();
 
-			//m4 = m4_ * m4;
+		// parent
+		token = &scanner.getNextToken();
+		if((token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT) &&
+			 (token->getCode() != Scanner::TC_IDENTIFIER || strcmp(token->getValue().getString(), "NULL") != 0))
+		{
+			throw PARSER_EXCEPTION_EXPECTED("integer or NULL");
+		}
 
-			// matrix for real
-			bone.rotSkelSpace = m4.getRotationPart();
-			bone.tslSkelSpace = m4.getTranslationPart();
-			Mat4 MAi(m4.getInverse());
-			bone.rotSkelSpaceInv = MAi.getRotationPart();
-			bone.tslSkelSpaceInv = MAi.getTranslationPart();
+		if(token->getCode() == Scanner::TC_IDENTIFIER)
+		{
+			bone.parent = NULL;
+		}
+		else
+		{
+			bone.parent = &bones[token->getValue().getInt()];
+		}
 
-			// parent
-			token = &scanner.getNextToken();
-			if((token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT) &&
-				 (token->getCode() != Scanner::TC_IDENTIFIER || strcmp(token->getValue().getString(), "NULL") != 0))
-			{
-				PARSE_ERR_EXPECTED("integer or NULL");
-				return false;
-			}
+		// childs
+		token = &scanner.getNextToken();
+		if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
+		{
+			throw PARSER_EXCEPTION_EXPECTED("integer");
+		}
 
-			if(token->getCode() == Scanner::TC_IDENTIFIER)
-				bone.parent = NULL;
-			else
-				bone.parent = &bones[token->getValue().getInt()];
+		if(token->getValue().getInt() > Bone::MAX_CHILDS_PER_BONE)
+		{
+			throw PARSER_EXCEPTION("Childs for bone \"" + bone.getName() + "\" exceed the max");
+		}
 
-			// childs
+		bone.childsNum = token->getValue().getInt();
+		for(int j=0; j<bone.childsNum; j++)
+		{
 			token = &scanner.getNextToken();
 			if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
 			{
-				PARSE_ERR_EXPECTED("integer");
-				return false;
+				throw PARSER_EXCEPTION_EXPECTED("integer");
 			}
-			if(token->getValue().getInt() > Bone::MAX_CHILDS_PER_BONE)
-			{
-				ERROR("Childs for bone \"" << bone.getName() << "\" exceed the max");
-				return false;
-			}
-			bone.childsNum = token->getValue().getInt();
-			for(int j=0; j<bone.childsNum; j++)
-			{
-				token = &scanner.getNextToken();
-				if(token->getCode() != Scanner::TC_NUMBER || token->getDataType() != Scanner::DT_INT)
-				{
-					PARSE_ERR_EXPECTED("integer");
-					return false;
-				}
-				bone.childs[j] = &bones[token->getValue().getInt()];
-			}
-		} // for all bones
-	}
-	catch(Exception& e)
-	{
-		ERROR(e.what());
-		return false;
-	}
-
-	return true;
+			bone.childs[j] = &bones[token->getValue().getInt()];
+		}
+	} // for all bones
 }

src/Resources/Skeleton.h

@@ -1,26 +1,41 @@
-#ifndef _SKELETON_H_
-#define _SKELETON_H_
+#ifndef SKELETON_H
+#define SKELETON_H
 
-#include "Common.h"
 #include "Math.h"
 #include "Resource.h"
 
 
-/**
- * It contains the bones with their position and hierarchy
- */
+/// It contains the bones with their position and hierarchy
+///
+/// Binary file format:
+///
+/// @code
+/// magic: ANKISKEL
+/// uint: bones num
+/// n * bone: bones
+/// 
+/// bone:
+/// string: name
+/// 3 * floats: head
+/// 3 * floats: tail
+/// 16 * floats: armature space matrix
+/// uint: parent id
+/// uint: children number
+/// n * child: children
+/// 
+/// child:
+/// uint: bone id
+/// @endcode
 class Skeleton: public Resource
 {
 	public:
-		/**
-		 * Skeleton bone
-		 *
-		 * @note The rotation and translation that transform the bone from bone space to armature space. Meaning that if
-		 * MA = TRS(rotSkelSpace, tslSkelSpace) then head = MA * Vec3(0.0, length, 0.0) and tail = MA * Vec3(0.0, 0.0, 0.0).
-		 * We need the MA because the animation rotations and translations are in bone space. We also keep the inverted ones
-		 * for fast calculations. rotSkelSpaceInv = MA.Inverted().getRotationPart() and NOT
-		 * rotSkelSpaceInv = rotSkelSpace.getInverted()
-		 */
+		/// Skeleton bone
+		///
+		/// @note The rotation and translation that transform the bone from bone space to armature space. Meaning that if
+		/// MA = TRS(rotSkelSpace, tslSkelSpace) then head = MA * Vec3(0.0, length, 0.0) and tail = MA * Vec3(0.0, 0.0, 0.0).
+		/// We need the MA because the animation rotations and translations are in bone space. We also keep the inverted
+		/// ones for fast calculations. rotSkelSpaceInv = MA.Inverted().getRotationPart() and NOT
+		/// rotSkelSpaceInv = rotSkelSpace.getInverted()
 		class Bone
 		{
 			PROPERTY_R(string, name, getName) ///< @ref PROPERTY_R : The name of the bone
@@ -48,15 +63,12 @@ class Skeleton: public Resource
 	
 		Vec<Bone> bones;
 
-		 Skeleton();
+		 Skeleton(): Resource(RT_SKELETON) {}
 		~Skeleton() {}
-		bool load(const char* filename);
-};
-
 
-inline Skeleton::Skeleton():
-	Resource(RT_SKELETON)
-{}
+		/// Implements Resource::load
+		void load(const char* filename);
+};
 
 
 #endif

src/Util/Exception.h

@@ -5,13 +5,20 @@
 #include <string>
 
 
-/// Custom exception that takes. Throw it used the THROW_EXCEPTION macro
+/// Custom exception that takes file, line and function that throwed it. Throw it using the EXCEPTION macro
 class Exception: public std::exception
 {
 	public:
+		/// Constructor #1
 		Exception(const char* err_, const char* file, int line, const char* func) {init(err_, file, line, func);}
+
+		/// Constructor #2
 		Exception(const std::string& err_, const char* file, int line, const char* func);
+
+		/// Destructor. Do nothing
 		~Exception() throw() {}
+
+		/// Return the error code
 		const char* what() const throw() {return err.c_str();}
 
 	private: