Moved material context functions into the State class.

1 files changed, 151 insertions, 24 deletions

diff --git a/src/render/state.cc b/src/render/state.cc
index fb64319..21a142f 100644
--- a/src/render/state.cc
+++ b/src/render/state.cc
@@ -16,18 +16,23 @@
 namespace render
 {
 
-int	State::render_width = 0;
-int 	State::render_height = 0;
-float	State::render_aspect = 0;
-bool	State::render_has_generate_mipmaps = false;
-bool	State::render_has_vbo = false;
-GLuint	State::render_vbo = 0;
+int	State::state_width = 0;
+int 	State::state_height = 0;
+float	State::state_aspect = 0;
+bool	State::state_has_generate_mipmaps = false;
+bool	State::state_has_vbo = false;
+GLuint	State::state_vbo = 0;
+
+	
+math::Color	State::state_color_primary;
+math::Color	State::state_color_secondary;
+math::Color	State::state_color_engine;
 
 void State::init(int width, int height)
 {
 	resize(width, height);
 
-	render_has_generate_mipmaps = false;
+	state_has_generate_mipmaps = false;
 
 	std::string version(gl::version());
 	for (size_t i = 0; i < version.size(); i++) {
@@ -40,10 +45,10 @@ void State::init(int width, int height)
 	if (versionstream >> major >> minor) {
 
 		if (major > 1) {
-			render_has_generate_mipmaps = true;
+			state_has_generate_mipmaps = true;
 		} else if (major == 1) {
 			if (minor > 3)
-				render_has_generate_mipmaps = true;
+				state_has_generate_mipmaps = true;
 		}
 
 	} else {
@@ -51,61 +56,61 @@ void State::init(int width, int height)
 	}
 	
 	con_print << "  hardware generated mipmaps ";
-	if (render_has_generate_mipmaps)
+	if (state_has_generate_mipmaps)
 		con_print << "available" << std::endl;
 	else
 		con_print << "not available" << std::endl;
 	
 	// initialize gl functions
-	render_has_vbo = true;
+	state_has_vbo = true;
 	gl::genbuffers = (gl::genbuffers_func) SDL_GL_GetProcAddress("glGenBuffers");
 	if (!gl::genbuffers) {
 		con_debug << "  glGenBuffers not available" << std::endl;
-		render_has_vbo = false;
+		state_has_vbo = false;
 	}
 	
 	gl::deletebuffers = (gl::deletebuffers_func) SDL_GL_GetProcAddress("glDeleteBuffers");
 	if (!gl::deletebuffers) {
 		con_debug << "  glDeleteBuffers not available" << std::endl;
-		render_has_vbo = false;
+		state_has_vbo = false;
 	}
 
 	gl::bindbuffer = (gl::bindbuffer_func) SDL_GL_GetProcAddress("glBindBuffer");
 	if (!gl::bindbuffer) {
 		con_debug << "  glBindBuffer not available" << std::endl;
-		render_has_vbo = false;
+		state_has_vbo = false;
 	}
 	
 	gl::bufferdata = (gl::bufferdata_func) SDL_GL_GetProcAddress("glBufferData");
 	if (!gl::bufferdata) {
 		con_debug << "  glBufferData not available" << std::endl;
-		render_has_vbo = false;
+		state_has_vbo = false;
 	}
 
 	con_print << "  vertex bufer objects ";
-	if (render_has_vbo)
+	if (state_has_vbo)
 		con_print << "enabled" << std::endl;
 	else
 		con_print << "disabled" << std::endl;
 
 	// Generate VBO
-	if (render_has_vbo)
-		gl::genbuffers(1, &render_vbo);
+	if (state_has_vbo)
+		gl::genbuffers(1, &state_vbo);
 }
 
 void State::shutdown()
 {
 	// Delete VBO
-	if (render_has_vbo)
-		gl::deletebuffers(1, &render_vbo);
+	if (state_has_vbo)
+		gl::deletebuffers(1, &state_vbo);
 }
 
 void State::resize(int width, int height)
 {
-	render_width = width;
-	render_height = height;
+	state_width = width;
+	state_height = height;
 
-	render_aspect = (float) width / (float) height;
+	state_aspect = (float) width / (float) height;
 
 	clear();
 }
@@ -113,7 +118,7 @@ void State::resize(int width, int height)
 void State::clear()
 {
 	// set viewport
-	gl::viewport(0, 0, render_width, render_height);
+	gl::viewport(0, 0, state_width, state_height);
 
 	// set clear color
 	gl::clearcolor(0.0f, 0.0f, 0.0f, 1.0f);
@@ -171,4 +176,126 @@ void State::set_normalize(const bool enable)
 	}
 }
 
+
+
+void State::set_color(const math::Color & color)
+{
+	state_color_primary.assign(color);
+}
+
+void State::set_color_second(const math::Color & color)
+{
+	state_color_secondary.assign(color);
+}
+	
+void State::set_color_engine(const math::Color & color) {
+	state_color_engine.assign(color);
+}
+
+void State::set_color(const core::Entity *entity)
+{
+	state_color_primary.assign(entity->color());
+	state_color_secondary.assign(entity->color_second());
+}
+	
+void State::use_material(const model::Material * material) {
+	
+	math::Color color;
+	
+	reset();
+		
+	if (!material) {	
+		color.assign(1.0f, 0.0f, 1.0f);
+		gl::color(color);
+		return;
+	}
+	
+	// assign the opengl drawing color according to material flags
+	if (material->flags() & model::Material::Engine) {
+		
+		// use current engine color
+		color.assign(state_color_engine);
+
+	} else if (material->flags() & model::Material::Tertiary) {
+
+		// use entity colors
+		if ((material->flags() & model::Material::Tertiary) == model::Material::Tertiary) {
+			for (size_t i = 0; i < 3; i++)
+				color[i] = (state_color_primary[i] + state_color_secondary[i]) / 2;
+
+		} else if ((material->flags() & model::Material::Secondary) == model::Material::Secondary) {
+			color.assign(state_color_secondary);
+
+		} else if ((material->flags() & model::Material::Primary) == model::Material::Primary) {
+			color.assign(state_color_primary);
+		}
+
+		color.r *= material->color().r;
+		color.g *= material->color().g;
+		color.b *= material->color().b;
+		
+	} else {
+		// use material color
+		color.assign(material->color());
+	}
+
+	// lighted or fullbright
+	// FIXME entity power
+	if (material->flags() & model::Material::Bright) {
+		gl::disable(GL_LIGHTING);
+		
+	} else if (material->flags() & model::Material::Engine) {
+		gl::disable(GL_LIGHTING);
+		
+	} else {
+		gl::enable(GL_LIGHTING);
+	}
+	
+	// texture
+	if (material->flags() & model::Material::Texture) {
+
+		Textures::bind(material->texture_id());
+		gl::enable(GL_TEXTURE_2D);
+		
+		if (material->flags() & model::Material::Environment) {
+
+			gl::texgeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+			gl::texgeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
+				
+			gl::enable(GL_TEXTURE_GEN_S);
+			gl::enable(GL_TEXTURE_GEN_T);
+		}
+
+	} else {	
+			// envmapped without texture: use the skybox as envmap
+			if (material->flags() & model::Material::Environment) {
+				
+				if (core::localplayer()->zone()->sky().size()) {
+					gl::enable(GL_TEXTURE_CUBE_MAP);
+					
+					glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
+					glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
+					glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP);
+					
+					gl::enable(GL_TEXTURE_GEN_S);
+					gl::enable(GL_TEXTURE_GEN_T);
+					gl::enable(GL_TEXTURE_GEN_R);
+				}			
+			}
+	}
+	
+
+	gl::color(color);
+}
+
+void State::reset() {
+	gl::disable(GL_TEXTURE_GEN_S);
+	gl::disable(GL_TEXTURE_GEN_T);
+	gl::disable(GL_TEXTURE_GEN_R);
+	gl::disable(GL_LIGHTING);
+	gl::disable(GL_TEXTURE_CUBE_MAP);
+	gl::disable(GL_TEXTURE_2D);
+	gl::color(1.0f, 1.0f, 1.0f, 1.0f);
+}
+	
 } // namespace render