Shaders no longer require unifroms to be declared in the material file and loaded directly from GLSL, fixed a crash in resource manager destructor, added additive blending operation for Color

Core/Contents/Include/PolyColor.h

@@ -262,7 +262,8 @@ namespace Polycode {
 
 			const static int BLEND_NORMAL = 0;
 			const static int BLEND_REPLACE_COLOR = 1;
-						
+			const static int BLEND_ADDITIVE = 2;
+									
 		protected:
 	
 	};

Core/Contents/Include/PolyFixedShader.h

@@ -47,7 +47,6 @@ namespace Polycode {
 			
 			void addTexture(const String& name, Texture *texture);
 			void addCubemap(const String& name, Cubemap *cubemap);
-			void addParam(const String& type, const String& name, const String& value);
 			
 			Texture *getDiffuseTexture();
 			

Core/Contents/Include/PolyGLSLShader.h

@@ -52,6 +52,8 @@ namespace Polycode {
 			
 			void handleEvent(Event *event);
 			
+			static int getPolycodeParamType(int glType);
+			
 			void setVertexProgram(ShaderProgram *vp);
 			void setFragmentProgram(ShaderProgram *fp);			
 				
@@ -70,7 +72,6 @@ namespace Polycode {
 			void addCubemap(const String& name, Cubemap *cubemap);
 			void clearTexture(const String& name);
 			Texture *getTexture(const String& name);
-			void addParam(const String& type, const String& name, const String& value);
 			
 			std::vector<GLSLTextureBinding> textures;
 			std::vector<GLSLCubemapBinding> cubemaps;

Core/Contents/Include/PolyGLSLShaderModule.h

@@ -46,8 +46,7 @@ namespace Polycode {
 			void clearShader();
 		
 	protected:
-
-		ProgramParam addParamToProgram(GLSLProgram *program,TiXmlNode *node);		
+		
 		GLSLProgram *createGLSLProgram(const String& fileName, int type);
 		void updateGLSLParam(Renderer *renderer, GLSLShader *glslShader, ProgramParam &param, ShaderBinding *materialOptions, ShaderBinding *localOptions);			
 		

Core/Contents/Include/PolyShader.h

@@ -39,24 +39,16 @@ namespace Polycode {
 		public:
 	
 	String name;
-	String typeString;
-	String valueString;
-	bool isAuto;
-	int autoID;
-	void *defaultData;
-	void *minValue;
-	void *maxValue;	
-	int paramType;
-			
-	static const int PARAM_UNKNOWN = 0;	
-	static const int PARAM_Number = 1;
-	static const int PARAM_Vector2 = 2;		
-	static const int PARAM_Vector3 = 3;
-	static const int PARAM_Color = 4;
-	
-	static void createParamData(int *retType, const String& type, const String& value, const String& min, const String& max, void **valueRes, void **minRes, void **maxRes);	
-	
+	int type;
+
+	static void *createParamData(int type);
 	
+	static const int PARAM_UNKNOWN = 0;	
+	static const int PARAM_NUMBER = 1;
+	static const int PARAM_VECTOR2 = 2;		
+	static const int PARAM_VECTOR3 = 3;
+	static const int PARAM_COLOR = 4;
+	static const int PARAM_MATRIX = 5;
 	};	
 
 	class _PolyExport ShaderProgram : public Resource {
@@ -73,10 +65,6 @@ namespace Polycode {
 			
 			void reloadResource();
 			
-			std::vector<ProgramParam> params;
-			
-			ProgramParam addParam(const String& name, const String& typeString, const String& valueString, bool isAuto, int autoID, int paramType, void *defaultData, void *minData, void *maxData);
-					
 	};
 
 	class _PolyExport Shader : public Resource {
@@ -89,7 +77,9 @@ namespace Polycode {
 			const String& getName() const;
 			
 			virtual ShaderBinding *createBinding() = 0;
-			virtual void reload() {}
+			virtual void reload() {}								
+			
+			int getExpectedParamType(String name);
 			
 			virtual void setVertexProgram(ShaderProgram *vp) {}
 			virtual void setFragmentProgram(ShaderProgram *fp) {}
@@ -101,8 +91,8 @@ namespace Polycode {
 			int numAreaLights;
 			
 			std::vector<String> expectedTextures;
-			std::vector<ProgramParam> expectedFragmentParams;
-			std::vector<ProgramParam> expectedVertexParams;
+			std::vector<String> expectedCubemaps;			
+			std::vector<ProgramParam> expectedParams;
 								
 			bool screenShader;
 			
@@ -165,7 +155,7 @@ namespace Polycode {
 			virtual Texture *getTexture(const String& name){ return NULL;};
 			virtual void clearTexture(const String& name){};
 			virtual void addTexture(const String& name, Texture *texture)  {};
-			virtual void addParam(const String& type, const String& name, const String& value) {};
+			LocalShaderParam *addParam(int type, const String& name);
 			virtual void addCubemap(const String& name, Cubemap *cubemap) {};
 		
 			unsigned int getNumLocalParams();

Core/Contents/Source/PolyColor.cpp

@@ -92,6 +92,19 @@ Color Color::blendColor(Color c2, int mode, Number amount, Color c3) {
 			ret.b = (b * (1.0-premul)) + (c3.b * premul);
 			ret.a = a + premul;
 		break;
+		case Color::BLEND_ADDITIVE:
+			ret.r = r + (c2.r);
+			ret.g = g + (c2.g);
+			ret.b = b + (c2.b);
+			ret.a = a + premul;
+			if(ret.r > 1.0)
+				ret.r = 1.0;
+			if(ret.g > 1.0)
+				ret.g = 1.0;
+			if(ret.b > 1.0)
+				ret.b = 1.0;
+
+		break;		
 	}
 	
 	if(ret.a > 1.0)

Core/Contents/Source/PolyFixedShader.cpp

@@ -45,11 +45,6 @@ Texture *FixedShaderBinding::getDiffuseTexture() {
 	return textures[0];
 }
 
-void FixedShaderBinding::addParam(const String& type, const String& name, const String& value) {
-
-}
-
-
 FixedShader::FixedShader() : Shader(Shader::FIXED_SHADER) {
 }
 

Core/Contents/Source/PolyGLSLShader.cpp

@@ -79,7 +79,6 @@ void GLSLShaderBinding::addTexture(const String& name, Texture *texture) {
 	GLSLTextureBinding binding;
 	binding.name = name;
 	binding.texture = texture;
-//	binding.vpParam = GLSLGetNamedParameter(glslShader->fp->program, name.c_str());
 	textures.push_back(binding);
 }
 
@@ -87,7 +86,6 @@ void GLSLShaderBinding::addCubemap(const String& name, Cubemap *cubemap) {
 	GLSLCubemapBinding binding;
 	binding.cubemap = cubemap;
 	binding.name = name;
-//	binding.vpParam = GLSLGetNamedParameter(GLSLShader->fp->program, name.c_str());
 	cubemaps.push_back(binding);
 }
 
@@ -100,20 +98,65 @@ void GLSLShaderBinding::clearTexture(const String& name) {
 	}
 }
 
-
-void GLSLShaderBinding::addParam(const String& type, const String& name, const String& value) {
-	int paramType;
-	void *defaultData;
-	void *minData;
-	void *maxData;		
-	ProgramParam::createParamData(&paramType, type, value, "", "", &defaultData,&minData, &maxData);
-	LocalShaderParam *newParam = new LocalShaderParam;
-	newParam->data = defaultData;
-	newParam->name = name;
-	localParams.push_back(newParam);
+int GLSLShader::getPolycodeParamType(int glType) {
+	switch(glType) {
+		case GL_FLOAT:
+			return ProgramParam::PARAM_NUMBER;
+		break;
+		case GL_FLOAT_VEC2:
+			return ProgramParam::PARAM_VECTOR2;
+		break;
+		case GL_FLOAT_VEC3:
+			return ProgramParam::PARAM_VECTOR3;		
+		break;
+		case GL_FLOAT_VEC4:
+			return ProgramParam::PARAM_COLOR;
+		break;
+		case GL_INT:
+			return ProgramParam::PARAM_NUMBER;
+		break;
+		case GL_INT_VEC2:
+			return ProgramParam::PARAM_VECTOR2;
+		break;
+		case GL_INT_VEC3:
+			return ProgramParam::PARAM_VECTOR3;		
+		break;
+		case GL_INT_VEC4:
+			return ProgramParam::PARAM_COLOR;		
+		break;
+		case GL_BOOL:
+			return ProgramParam::PARAM_NUMBER;
+		break;
+		case GL_BOOL_VEC2:
+			return ProgramParam::PARAM_VECTOR2;		
+		break;
+		case GL_BOOL_VEC3:
+			return ProgramParam::PARAM_VECTOR3;		
+		break;
+		case GL_BOOL_VEC4:
+			return ProgramParam::PARAM_COLOR;
+		break;
+		case GL_FLOAT_MAT2:
+			return ProgramParam::PARAM_MATRIX;
+		break;
+		case GL_FLOAT_MAT3:
+			return ProgramParam::PARAM_MATRIX;		
+		break;
+		case GL_FLOAT_MAT4:
+			return ProgramParam::PARAM_MATRIX;		
+		break;
+		default:
+			return ProgramParam::PARAM_UNKNOWN;
+		break;
+	}
 }
 
 void GLSLShader::linkProgram() {
+
+	expectedParams.clear();
+	expectedTextures.clear();
+	expectedCubemaps.clear();
+
 	shader_id = glCreateProgram();
     glAttachShader(shader_id, ((GLSLProgram*)fp)->program);
     glAttachShader(shader_id, ((GLSLProgram*)vp)->program);	
@@ -124,6 +167,34 @@ void GLSLShader::linkProgram() {
 	}
 	if(fp) {
 		fp->addEventListener(this, Event::RESOURCE_RELOAD_EVENT);
+	}
+	
+	int total = -1;
+	glGetProgramiv( shader_id, GL_ACTIVE_UNIFORMS, &total ); 
+	for(int i=0; i < total; i++)  {
+		int name_len=-1, num=-1;
+		GLenum type = GL_ZERO;
+		char name[128];
+		glGetActiveUniform(shader_id, GLuint(i), sizeof(name)-1, &name_len, &num, &type, name );
+		name[name_len] = 0;
+		GLuint location = glGetUniformLocation( shader_id, name );
+		
+		if(String(name).find("gl_") == -1) {
+		switch(type) {
+			case GL_SAMPLER_2D:
+				expectedTextures.push_back(String(name));
+			break;
+			case GL_SAMPLER_CUBE:
+				expectedCubemaps.push_back(String(name));
+			break;			
+			default:
+				ProgramParam param;
+				param.name = String(name);
+				param.type = getPolycodeParamType(type);
+				expectedParams.push_back(param);
+			break;
+		}
+		}
 	}	
 }
 

Core/Contents/Source/PolyGLSLShaderModule.cpp

@@ -118,10 +118,6 @@ Shader *GLSLShaderModule::createShader(String name, String vpName, String fpName
 
 	GLSLProgram *vp = NULL;
 	GLSLProgram *fp = NULL;
-		
-	std::vector<String> expectedTextures;
-	std::vector<ProgramParam> expectedFragmentParams;	
-	std::vector<ProgramParam> expectedVertexParams;
 
 	vp = (GLSLProgram*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_PROGRAM, vpName);
 	fp = (GLSLProgram*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_PROGRAM, fpName);
@@ -129,9 +125,6 @@ Shader *GLSLShaderModule::createShader(String name, String vpName, String fpName
 	if(vp != NULL && fp != NULL) {
 		GLSLShader *shader = new GLSLShader(vp,fp);
 		shader->setName(name);
-		shader->expectedTextures = expectedTextures;
-		shader->expectedVertexParams = expectedVertexParams;
-		shader->expectedFragmentParams = expectedFragmentParams;				
 		retShader = shader;
 		shaders.push_back((Shader*)shader);
 	}
@@ -143,11 +136,7 @@ Shader *GLSLShaderModule::createShader(TiXmlNode *node) {
 	GLSLProgram *vp = NULL;
 	GLSLProgram *fp = NULL;
 	GLSLShader *retShader = NULL;
-	
-	std::vector<String> expectedTextures;
-	std::vector<ProgramParam> expectedFragmentParams;	
-	std::vector<ProgramParam> expectedVertexParams;
-		
+			
 	TiXmlElement *nodeElement = node->ToElement();
 	if (!nodeElement) return NULL; // Skip comment nodes
 	
@@ -157,50 +146,15 @@ Shader *GLSLShaderModule::createShader(TiXmlNode *node) {
 		
 		if(strcmp(pChild->Value(), "vp") == 0) {
 			vp = (GLSLProgram*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_PROGRAM, String(pChildElement->Attribute("source")));
-			if(vp) {
-				for (pChild2 = pChild->FirstChild(); pChild2 != 0; pChild2 = pChild2->NextSibling()) {
-					if(strcmp(pChild2->Value(), "params") == 0) {
-						for (pChild3 = pChild2->FirstChild(); pChild3 != 0; pChild3 = pChild3->NextSibling()) {
-							if(strcmp(pChild3->Value(), "param") == 0) {
-								expectedVertexParams.push_back(addParamToProgram(vp,pChild3));
-							}
-						}
-					}
-				}
-			}
 		}
 		if(strcmp(pChild->Value(), "fp") == 0) {
 			fp = (GLSLProgram*)CoreServices::getInstance()->getResourceManager()->getResource(Resource::RESOURCE_PROGRAM, String(pChildElement->Attribute("source")));
-			if(fp) {
-				for (pChild2 = pChild->FirstChild(); pChild2 != 0; pChild2 = pChild2->NextSibling()) {
-					if(strcmp(pChild2->Value(), "params") == 0) {
-						for (pChild3 = pChild2->FirstChild(); pChild3 != 0; pChild3 = pChild3->NextSibling()) {
-							if(strcmp(pChild3->Value(), "param") == 0) {
-								expectedFragmentParams.push_back(addParamToProgram(fp,pChild3));	
-							}
-						}
-					}
-					if(strcmp(pChild2->Value(), "textures") == 0) {
-						for (pChild3 = pChild2->FirstChild(); pChild3 != 0; pChild3 = pChild3->NextSibling()) {
-							if(strcmp(pChild3->Value(), "texture") == 0) {
-								TiXmlElement *texNodeElement = pChild3->ToElement();
-								if (texNodeElement) {
-									expectedTextures.push_back(String(texNodeElement->Attribute("name")));
-								}
-							}
-						}
-					}					
-				}
-			}
 		}
 		
 	}
 	if(vp != NULL && fp != NULL) {
 		GLSLShader *cgShader = new GLSLShader(vp,fp);
 		cgShader->setName(String(nodeElement->Attribute("name")));
-		cgShader->expectedTextures = expectedTextures;
-		cgShader->expectedVertexParams = expectedVertexParams;
-		cgShader->expectedFragmentParams = expectedFragmentParams;				
 		retShader = cgShader;
 		shaders.push_back((Shader*)cgShader);
 	}
@@ -214,46 +168,49 @@ void GLSLShaderModule::clearShader() {
 
 void GLSLShaderModule::updateGLSLParam(Renderer *renderer, GLSLShader *glslShader, ProgramParam &param, ShaderBinding *materialOptions, ShaderBinding *localOptions) {
 	
-		void *paramData = param.defaultData;
-		LocalShaderParam *localParam = materialOptions->getLocalParamByName(param.name);
-		if(localParam) {
-			paramData = localParam->data;
-		}
+		LocalShaderParam *localParam = NULL;		
+		localParam = materialOptions->getLocalParamByName(param.name);
 		
-		localParam = localOptions->getLocalParamByName(param.name);
-		if(localParam) {
-			paramData = localParam->data;
+		// local options override material options.
+		LocalShaderParam *localOptionsParam = localOptions->getLocalParamByName(param.name);
+		if(localOptionsParam) {
+			localParam = localOptionsParam;
 		}
-		
-		switch(param.paramType) {
-			case ProgramParam::PARAM_Number:
-			{
-				Number *fval;			
-				fval = (Number*)paramData;
-				int paramLocation = glGetUniformLocation(glslShader->shader_id, param.name.c_str());
-				glUniform1f(paramLocation, *fval);
-				break;
-			}
-			case ProgramParam::PARAM_Vector2:
-			{
-				Vector2 *fval2 = (Vector2*)paramData;
-				int paramLocation = glGetUniformLocation(glslShader->shader_id, param.name.c_str());
-				glUniform2f(paramLocation, fval2->x, fval2->y);				break;				
-			}			
-			case ProgramParam::PARAM_Vector3:
-			{
-				Vector3 *fval3 = (Vector3*)paramData;
-				int paramLocation = glGetUniformLocation(glslShader->shader_id, param.name.c_str());
-				glUniform3f(paramLocation, fval3->x,fval3->y,fval3->z);
-				break;				
-			}
-			case ProgramParam::PARAM_Color:
-			{
-				Color *col = (Color*)paramData;
-				int paramLocation = glGetUniformLocation(glslShader->shader_id, param.name.c_str());
-				glUniform4f(paramLocation, col->r, col->g, col->b, col->a);
-				break;				
-			}
+
+		int paramLocation = glGetUniformLocation(glslShader->shader_id, param.name.c_str());
+					
+		switch(param.type) {
+			case ProgramParam::PARAM_NUMBER:
+				if(localParam) {
+					glUniform1f(paramLocation, localParam->getNumber());				
+				} else {
+					glUniform1f(paramLocation, 0.0f);
+				}
+			break;
+			case ProgramParam::PARAM_VECTOR2:
+				if(localParam) {
+					Vector2 vec2 = localParam->getVector2();
+					glUniform2f(paramLocation, vec2.x, vec2.y);
+				} else {
+					glUniform2f(paramLocation, 0.0f, 0.0f);
+				}				
+			break;
+			case ProgramParam::PARAM_VECTOR3:
+				if(localParam) {
+					Vector3 vec3 = localParam->getVector3();
+					glUniform3f(paramLocation, vec3.x, vec3.y, vec3.z);
+				} else {
+					glUniform3f(paramLocation, 0.0f, 0.0f, 0.0f);
+				}
+			break;
+			case ProgramParam::PARAM_COLOR:
+				if(localParam) {
+					Color color = localParam->getColor();
+					glUniform4f(paramLocation, color.r, color.g, color.b, color.a);
+				} else {
+					glUniform4f(paramLocation, 0.0f, 0.0f, 0.0f, 0.0f);
+				}
+			break;				
 		}
 }
 
@@ -445,16 +402,11 @@ bool GLSLShaderModule::applyShaderMaterial(Renderer *renderer, Material *materia
 		
 	GLSLShaderBinding *cgBinding = (GLSLShaderBinding*)material->getShaderBinding(shaderIndex);
 	
-	for(int i=0; i < glslShader->vp->params.size(); i++) {
-		ProgramParam param = glslShader->vp->params[i];
+	for(int i=0; i < glslShader->expectedParams.size(); i++) {
+		ProgramParam param = glslShader->expectedParams[i];
 		updateGLSLParam(renderer, glslShader, param, material->getShaderBinding(shaderIndex), localOptions);
 	}
-	
-	for(int i=0; i < glslShader->fp->params.size(); i++) {
-		ProgramParam param = glslShader->fp->params[i];
-		updateGLSLParam(renderer, glslShader, param, material->getShaderBinding(shaderIndex), localOptions);
-	}	
-	
+		
 	for(int i=0; i < cgBinding->textures.size(); i++) {
 		int texture_location = glGetUniformLocation(glslShader->shader_id, cgBinding->textures[i].name.c_str());
 		glUniform1i(texture_location, textureIndex);
@@ -487,33 +439,6 @@ bool GLSLShaderModule::applyShaderMaterial(Renderer *renderer, Material *materia
 	return true;
 }
 
-ProgramParam GLSLShaderModule::addParamToProgram(GLSLProgram *program,TiXmlNode *node) {
-		bool isAuto = false;
-		int autoID = 0;
-		int paramType = ProgramParam::PARAM_UNKNOWN;
-		void *defaultData = NULL;
-		void *minData = NULL;
-		void *maxData = NULL;
-		
-		TiXmlElement *nodeElement = node->ToElement();
-		if (!nodeElement) {
-			ProgramParam::createParamData(&paramType, "Number", "0.0", "0.0", "0.0", &defaultData, &minData, &maxData);		
-			return program->addParam("Unknown", "Number", nodeElement->Attribute("default"), isAuto, autoID, paramType, defaultData, minData, maxData); // Skip comment nodes
-		}
-
-		isAuto = false;
-		
-		if(nodeElement->Attribute("auto")) {
-			if(strcmp(nodeElement->Attribute("auto"), "true") == 0) {
-				isAuto = true;
-			}
-		}
-		
-		ProgramParam::createParamData(&paramType, nodeElement->Attribute("type"), nodeElement->Attribute("default"), nodeElement->Attribute("min"), nodeElement->Attribute("max"), &defaultData, &minData, &maxData);
-		
-		return program->addParam(nodeElement->Attribute("name"), nodeElement->Attribute("type"), nodeElement->Attribute("default"), isAuto, autoID, paramType, defaultData, minData, maxData);
-}
-
 void GLSLShaderModule::reloadPrograms() {
 	for(int i=0; i < programs.size(); i++) {
 		GLSLProgram *program = programs[i];

Core/Contents/Source/PolyMaterial.cpp

@@ -70,21 +70,11 @@ void Material::addShader(Shader *shader,ShaderBinding *shaderBinding) {
 	materialShaders.push_back(shader);
 	shaderBindings.push_back(shaderBinding);
 	
-	for(int i=0; i < shader->expectedFragmentParams.size(); i++) {
-		if(!shaderBinding->getLocalParamByName(shader->expectedFragmentParams[i].name)) {
-		if(!shader->expectedFragmentParams[i].isAuto) {
-			shaderBinding->addParam(shader->expectedFragmentParams[i].typeString, shader->expectedFragmentParams[i].name, shader->expectedFragmentParams[i].valueString);
+	for(int i=0; i < shader->expectedParams.size(); i++) {
+		if(!shaderBinding->getLocalParamByName(shader->expectedParams[i].name)) {
+			shaderBinding->addParam(shader->expectedParams[i].type, shader->expectedParams[i].name);
 		}
-		}
-	}		
-	
-	for(int i=0; i < shader->expectedVertexParams.size(); i++) {
-		if(!shaderBinding->getLocalParamByName(shader->expectedVertexParams[i].name)) {
-		if(!shader->expectedVertexParams[i].isAuto) {	
-			shaderBinding->addParam(shader->expectedVertexParams[i].typeString, shader->expectedVertexParams[i].name, shader->expectedVertexParams[i].valueString);
-		}
-		}
-	}	
+	}
 	
 	CoreServices::getInstance()->getRenderer()->setRendererShaderParams(shader, shaderBinding);	
 }

Core/Contents/Source/PolyMaterialManager.cpp

@@ -451,9 +451,48 @@ Material *MaterialManager::materialFromXMLNode(TiXmlNode *node) {
 
 							if(strcmp(pChild2->Value(), "param") == 0){
 								String pname =  pChild2Element->Attribute("name");
-								String ptype =  pChild2Element->Attribute("type");
-								String pvalue =  pChild2Element->Attribute("value");
-								newShaderBinding->addParam(ptype, pname, pvalue);
+								String pvalue =  pChild2Element->Attribute("value");																
+								int type = materialShader->getExpectedParamType(pname);								
+								LocalShaderParam *param = newShaderBinding->addParam(type, pname);
+								if(param) {
+									switch(type) {
+										case ProgramParam::PARAM_NUMBER:
+										{
+											param->setNumber(atof(pvalue.c_str()));
+										}
+										break;
+										case ProgramParam::PARAM_VECTOR2:
+										{
+											std::vector<String> values = pvalue.split(" ");
+											if(values.size() == 2) {
+												param->setVector2(Vector2(atof(values[0].c_str()), atof(values[1].c_str())));
+											} else {
+												printf("Material parameter error: A Vector2 must have 2 values (%d provided)!\n", (int)values.size());
+											}
+										}											
+										break;
+										case ProgramParam::PARAM_VECTOR3:
+										{
+											std::vector<String> values = pvalue.split(" ");
+											if(values.size() == 3) {
+												param->setVector3(Vector3(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str())));
+											} else {
+												printf("Material parameter error: A Vector3 must have 3 values (%d provided)!\n", (int)values.size());
+											}
+										}										
+										break;
+										case ProgramParam::PARAM_COLOR:
+										{
+											std::vector<String> values = pvalue.split(" ");
+											if(values.size() == 4) {
+												param->setColor(Color(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str()), atof(values[3].c_str())));
+											} else {
+												printf("Material parameter error: A Vector3 must have 3 values (%d provided)!\n", (int)values.size());
+											}
+										}										
+										break;										
+									}
+								}
 							}						
 						}
 					}

Core/Contents/Source/PolyRenderer.cpp

@@ -347,19 +347,9 @@ void *Renderer::getDataPointerForName(const String &name) {
 }
 
 void Renderer::setRendererShaderParams(Shader *shader, ShaderBinding *binding) {
-	for(int i=0; i < shader->expectedFragmentParams.size(); i++) {
-		if(shader->expectedFragmentParams[i].isAuto) {
-			binding->addLocalParam(shader->expectedFragmentParams[i].name, getDataPointerForName(shader->expectedFragmentParams[i].name));
-		}
-	}
-
-	for(int i=0; i < shader->expectedVertexParams.size(); i++) {
-		if(shader->expectedVertexParams[i].isAuto) {			
-			binding->addLocalParam(shader->expectedVertexParams[i].name, getDataPointerForName(shader->expectedVertexParams[i].name));
-		}
+	for(int i=0; i < shader->expectedParams.size(); i++) {
+		binding->addLocalParam(shader->expectedParams[i].name, getDataPointerForName(shader->expectedParams[i].name));
 	}
-
-
 }
 
 void Renderer::pushDataArrayForMesh(Mesh *mesh, int arrayType) {

Core/Contents/Source/PolyResourceManager.cpp

@@ -47,9 +47,25 @@ ResourceManager::ResourceManager() {
 ResourceManager::~ResourceManager() {
 		printf("Shutting down resource manager...\n");
 		PHYSFS_deinit();
+		
+		for(int i=0; i < resources.size(); i++)	{
+			if(resources[i]->getResourceType() == Resource::RESOURCE_MATERIAL) {
+				delete resources[i];
+			}
+		}
+		
 		for(int i=0; i < resources.size(); i++)	{
-			delete resources[i];
+			if(resources[i]->getResourceType() == Resource::RESOURCE_SHADER) {
+				delete resources[i];
+			}
 		}
+
+		for(int i=0; i < resources.size(); i++)	{
+			if(resources[i]->getResourceType() == Resource::RESOURCE_PROGRAM) {
+				delete resources[i];
+			}
+		}
+		
 		resources.clear();
 }
 

Core/Contents/Source/PolyShader.cpp

@@ -21,9 +21,48 @@
 */
 
 #include "PolyShader.h"
+#include "PolyMatrix4.h"
 
 using namespace Polycode;
 
+void *ProgramParam::createParamData(int type) {
+	switch (type) {
+		case PARAM_NUMBER:
+		{
+			Number *val = new Number();
+			return (void*)val;
+		}
+		break;
+		case PARAM_VECTOR2:
+		{
+			Vector2 *val = new Vector2();
+			return (void*)val;
+		}
+		break;
+		case PARAM_VECTOR3:
+		{
+			Vector3 *val = new Vector3();
+			return (void*)val;
+		}
+		break;		
+		case PARAM_COLOR:
+		{
+			Color *val = new Color();
+			return (void*)val;
+		}
+		break;		
+		case PARAM_MATRIX:
+		{
+			Matrix4 *val = new Matrix4();
+			return (void*)val;
+		}
+		break;		
+		default:		
+			return NULL;
+		break;
+	}
+}
+
 ShaderProgram::ShaderProgram(int type) : Resource(Resource::RESOURCE_PROGRAM) {
 	this->type = type;
 }
@@ -37,82 +76,6 @@ void ShaderProgram::reloadResource() {
 	Resource::reloadResource();	
 }
 
-ProgramParam ShaderProgram::addParam(const String& name, const String& typeString, const String& valueString, bool isAuto, int autoID, int paramType, void *defaultData, void *minData, void *maxData) {
-	ProgramParam newParam;
-	newParam.name = name;
-	newParam.typeString = typeString;
-	newParam.valueString = valueString;	
-	newParam.paramType = paramType;
-	newParam.defaultData = defaultData;
-	newParam.minValue = minData;
-	newParam.maxValue = maxData;
-	newParam.isAuto = isAuto;
-	newParam.autoID = autoID;
-
-	params.push_back(newParam);
-	return newParam;
-}
-
-void ProgramParam::createParamData(int *retType, const String& type, const String& value, const String& min, const String& max, void **valueRes, void **minRes, void **maxRes) {
-		
-		(*valueRes) = NULL;
-		(*minRes) = NULL;
-		(*maxRes) = NULL;
-						
-		if(type == "Number") {
-			*retType = ProgramParam::PARAM_Number;
-			Number *val = new Number();
-			*val = atof(value.c_str());
-			(*valueRes) = (void*)val;
-			
-			val = new Number();
-			*val = atof(min.c_str());
-			(*minRes) = (void*)val;
-
-			val = new Number();
-			*val = atof(max.c_str());
-			(*maxRes) = (void*)val;			
-			
-			return;		
-		} else if(type == "Vector2") {
-			*retType = ProgramParam::PARAM_Vector2;
-			Vector2 *val = new Vector2();
-			(*valueRes) = (void*)val;
-			std::vector<String> values = value.split(" ");
-			if(values.size() == 2) {
-				val->set(atof(values[0].c_str()), atof(values[1].c_str()));
-			} else {
-				printf("Error: A Vector2 must have 2 values (%d provided)!\n", (int)values.size());
-			}
-			return;				
-		} else if(type == "Vector3") {
-			*retType = ProgramParam::PARAM_Vector3;
-			Vector3 *val = new Vector3();
-			(*valueRes) = (void*)val;
-			std::vector<String> values = value.split(" ");
-			if(values.size() == 3) {
-				val->set(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str()));
-			} else {
-				printf("Error: A Vector3 must have 3 values (%d provided)!\n", (int)values.size());
-			}
-			return;
-		} else if(type == "Color") {
-			*retType = ProgramParam::PARAM_Color;
-			Color *val = new Color();
-			(*valueRes) = (void*)val;
-			std::vector<String> values = value.split(" ");
-			if(values.size() == 4) {
-				val->setColor(atof(values[0].c_str()), atof(values[1].c_str()), atof(values[2].c_str()), atof(values[3].c_str()));
-			} else {
-				printf("Error: A Color must have 4 values (%d provided)!\n", (int)values.size());
-			}
-			return;			
-		} else {
-			*retType = ProgramParam::PARAM_UNKNOWN;
-			(*valueRes) =  NULL;
-		}
-}
-
 
 ShaderBinding::ShaderBinding(Shader *shader) {
 	this->shader = shader;
@@ -158,6 +121,14 @@ LocalShaderParam *ShaderBinding::addLocalParam(const String& name, void *ptr) {
 	return newParam;
 }
 
+LocalShaderParam * ShaderBinding::addParam(int type, const String& name) {
+	void *defaultData = ProgramParam::createParamData(type);
+	LocalShaderParam *newParam = new LocalShaderParam();
+	newParam->data = defaultData;
+	newParam->name = name;
+	localParams.push_back(newParam);
+}
+
 void ShaderBinding::addRenderTargetBinding(RenderTargetBinding *binding) {
 	renderTargetBindings.push_back(binding);
 	if(binding->mode == RenderTargetBinding::MODE_IN) {
@@ -202,6 +173,15 @@ Shader::Shader(int type) : Resource(Resource::RESOURCE_SHADER) {
 	fp = NULL;
 }
 
+int Shader::getExpectedParamType(String name) {
+	for(int i=0; i < expectedParams.size(); i++) {
+		if(expectedParams[i].name == name) {
+			return expectedParams[i].type;
+		}
+	}
+	return ProgramParam::PARAM_UNKNOWN;
+}
+
 Shader::~Shader() {
 
 }

IDE/Contents/Include/PolycodeMaterialEditor.h

@@ -144,8 +144,7 @@ class MaterialEditorPane : public UIElement {
 		ComboProp *shaderProp;
 		
 		ShaderTexturesSheet *shaderTextureSheet;
-		ShaderOptionsSheet *vertexOptionsSheet;	
-		ShaderOptionsSheet *fragmentOptionsSheet;
+		ShaderOptionsSheet *shaderOptionsSheet;	
 };
 
 class MaterialMainWindow : public UIElement {

IDE/Contents/Source/PolycodeFrame.cpp

@@ -801,7 +801,7 @@ void PolycodeFrame::handleEvent(Event *event) {
 	}
 	
 	if(event->getDispatcher() == editorManager) {
-		updateFileSelector();
+	//	updateFileSelector();
 	}
 	
 	if(event->getDispatcher() == projectManager) {

IDE/Contents/Source/PolycodeMaterialEditor.cpp

@@ -270,14 +270,10 @@ MaterialEditorPane::MaterialEditorPane() : UIElement() {
 	shaderTextureSheet = new ShaderTexturesSheet();
 	propList->addPropSheet(shaderTextureSheet);			
 	shaderTextureSheet->addEventListener(this, Event::CHANGE_EVENT);
-	
-	vertexOptionsSheet = new ShaderOptionsSheet("VERTEX SHADER OPTIONS", "vertex_options", false);
-	propList->addPropSheet(vertexOptionsSheet);
-	vertexOptionsSheet->addEventListener(this, Event::CHANGE_EVENT);
-	
-	fragmentOptionsSheet = new ShaderOptionsSheet("FRAGMENT SHADER OPTIONS", "fragment_options", true);
-	propList->addPropSheet(fragmentOptionsSheet);
-	fragmentOptionsSheet->addEventListener(this, Event::CHANGE_EVENT);
+		
+	shaderOptionsSheet = new ShaderOptionsSheet("SHADER OPTIONS", "shader_options", true);
+	propList->addPropSheet(shaderOptionsSheet);
+	shaderOptionsSheet->addEventListener(this, Event::CHANGE_EVENT);
 		
 	propList->updateProps();
 						
@@ -406,7 +402,7 @@ void MaterialEditorPane::showPrimitive(unsigned int index) {
 
 void MaterialEditorPane::handleEvent(Event *event) {
 
-	if(event->getDispatcher() == shaderTextureSheet || event->getDispatcher() == vertexOptionsSheet || event->getDispatcher() == fragmentOptionsSheet) {
+	if(event->getDispatcher() == shaderTextureSheet || event->getDispatcher() == shaderOptionsSheet) {
 		if(!changingMaterial) {
 			dispatchEvent(new Event(), Event::CHANGE_EVENT);
 		}		
@@ -434,8 +430,7 @@ void MaterialEditorPane::handleEvent(Event *event) {
 			}
 			
 			shaderTextureSheet->setShader(selectedShader, currentMaterial);
-			vertexOptionsSheet->setShader(selectedShader, currentMaterial);
-			fragmentOptionsSheet->setShader(selectedShader, currentMaterial);						
+			shaderOptionsSheet->setShader(selectedShader, currentMaterial);
 		}
 		
 		if(!changingMaterial) {
@@ -630,22 +625,22 @@ String PolycodeMaterialEditor::createStringValue(unsigned int type, void *value)
 	String retString;
 	
 	switch(type) {
-		case ProgramParam::PARAM_Number:
+		case ProgramParam::PARAM_NUMBER:
 			retString = String::NumberToString(*((Number*)value));
 		break;
-		case ProgramParam::PARAM_Color:
+		case ProgramParam::PARAM_COLOR:
 		{
 			Color color = *((Color*)value);
 			retString = String::NumberToString(color.r) + " " + String::NumberToString(color.g) + " " + String::NumberToString(color.b) + " " + String::NumberToString(color.a);
 		}
 		break;
-		case ProgramParam::PARAM_Vector2:
+		case ProgramParam::PARAM_VECTOR2:
 		{
 			Vector2 vec = *((Vector2*)value);
 			retString = String::NumberToString(vec.x) + " " + String::NumberToString(vec.y);
 		}
 		break;
-		case ProgramParam::PARAM_Vector3:
+		case ProgramParam::PARAM_VECTOR3:
 		{
 			Vector3 vec = *((Vector3*)value);
 			retString = String::NumberToString(vec.x) + " " + String::NumberToString(vec.y) + " " + String::NumberToString(vec.z);
@@ -690,28 +685,17 @@ void PolycodeMaterialEditor::saveFile() {
 			}
 		}
 
-		if(shader->expectedFragmentParams.size() > 0 || shader->expectedVertexParams.size() > 0) {
+		if(shader->expectedParams.size() > 0 || shader->expectedParams.size() > 0) {
 			ObjectEntry *paramsEntry = shaderEntry->addChild("params");
 			
-			for(int j=0; j < shader->expectedFragmentParams.size(); j++) {
-				if(shaderBinding->getLocalParamByName(shader->expectedFragmentParams[j].name) && !shader->expectedFragmentParams[j].isAuto) {
-				ObjectEntry *paramEntry = paramsEntry->addChild("param");
-				paramEntry->addChild("name", shader->expectedFragmentParams[j].name);
-				paramEntry->addChild("type", shader->expectedFragmentParams[j].typeString);
-				paramEntry->addChild("value", createStringValue(shader->expectedFragmentParams[j].paramType, shaderBinding->getLocalParamByName(shader->expectedFragmentParams[j].name)->data));
+			for(int j=0; j < shader->expectedParams.size(); j++) {
+				if(shaderBinding->getLocalParamByName(shader->expectedParams[j].name)) {
+					ObjectEntry *paramEntry = paramsEntry->addChild("param");
+					paramEntry->addChild("name", shader->expectedParams[j].name);
+					paramEntry->addChild("value", createStringValue(shader->expectedParams[j].type, shaderBinding->getLocalParamByName(shader->expectedParams[j].name)->data));
 				}
 			}
-
-			for(int j=0; j < shader->expectedVertexParams.size(); j++) {
-				if(shaderBinding->getLocalParamByName(shader->expectedVertexParams[j].name) && !shader->expectedVertexParams[j].isAuto) {
-				ObjectEntry *paramEntry = paramsEntry->addChild("param");
-				paramEntry->addChild("name", shader->expectedVertexParams[j].name);
-				paramEntry->addChild("type", shader->expectedVertexParams[j].typeString);
-				paramEntry->addChild("value", createStringValue(shader->expectedVertexParams[j].paramType, shaderBinding->getLocalParamByName(shader->expectedVertexParams[j].name)->data));
-				}
-			}
-			}
-			
+		}
 		}
 	}
 	

IDE/Contents/Source/PolycodeProps.cpp

@@ -1351,8 +1351,8 @@ void ShaderOptionsSheet::handleEvent(Event *event) {
 	if(event->getEventCode() == Event::CHANGE_EVENT) {
 		for(int i=0 ; i < props.size(); i++) {
 			if(event->getDispatcher() == props[i]) {
-				if(props[i]->propType == "Slider") {
-					(*(Number*)binding->getLocalParamByName(props[i]->label->getText())->data) = ((SliderProp*)props[i])->get();
+				if(props[i]->propType == "Number") {
+					(*(Number*)binding->getLocalParamByName(props[i]->label->getText())->data) = ((NumberProp*)props[i])->get();
 				} else if(props[i]->propType == "Color") {
 					(*(Color*)binding->getLocalParamByName(props[i]->label->getText())->data) = ((ColorProp*)props[i])->get();
 				
@@ -1383,23 +1383,20 @@ void ShaderOptionsSheet::clearShader() {
 void ShaderOptionsSheet::setOptionsFromParams(std::vector<ProgramParam> &params) {
 
 	for(int i=0; i < params.size(); i++) {
-			if(!params[i].isAuto) {
-				switch (params[i].paramType) {
+				switch (params[i].type) {
 				
-					case ProgramParam::PARAM_Number:
+					case ProgramParam::PARAM_NUMBER:
 					{
 						String paramName = params[i].name;
-						Number paramMin = (*(Number*) params[i].minValue);
-						Number paramMax = (*(Number*) params[i].maxValue);						
-						SliderProp *sliderProp = new SliderProp(paramName, paramMin, paramMax);
-						addProp(sliderProp);
-						
+						NumberProp *numberProp = new NumberProp(paramName);
+						addProp(numberProp);
+												
 						Number numberValue = (*(Number*)binding->getLocalParamByName(params[i].name)->data);
-						sliderProp->set(numberValue);
+						numberProp->set(numberValue);
 						propHeight += 30;
 					}
 					break;					
-					case ProgramParam::PARAM_Color:
+					case ProgramParam::PARAM_COLOR:
 					{
 						String paramName = params[i].name;
 						
@@ -1414,8 +1411,6 @@ void ShaderOptionsSheet::setOptionsFromParams(std::vector<ProgramParam> &params)
 					break;
 					
 				}				
-														
-			}
 		}	
 }
 
@@ -1429,11 +1424,7 @@ void ShaderOptionsSheet::setShader(Shader *shader, Material *material) {
 		
 	binding = material->getShaderBinding(0);
 	
-	if(fragmentParams) {	
-		setOptionsFromParams(shader->expectedFragmentParams);
-	} else {
-		setOptionsFromParams(shader->expectedVertexParams);
-	}
+	setOptionsFromParams(shader->expectedParams);
 	
 	dispatchEvent(new Event(), Event::COMPLETE_EVENT);	
 	Resize(width, height);