path: root/src/ui/modelview.cc

/*
   ui/modelview.cc
   This file is part of the Osirion project and is distributed under
   the terms of the GNU General Public License version 2
*/

#include "auxiliary/functions.h"
#include "core/application.h"
#include "ui/modelview.h"
#include "ui/paint.h"
#include "ui/ui.h"
#include "sys/sys.h"
#include "render/camera.h"
#include "render/draw.h"
#include "render/render.h"
#include <sstream>
#include <iomanip>

namespace ui
{

ModelView::ModelView(Widget *parent, const char *modelname) : Widget(parent)
{
	set_border(false);
	set_background(false);
	set_label("modelview");

	set_modelname(modelname);

	modelview_radius = 0.75f;
	modelview_zoom = 1.0f;
	modelview_dragging = false;
	
	modelview_axis.clear();
	modelview_axis.change_direction(180);
	modelview_axis.change_pitch(-15);
}

ModelView::~ModelView()
{}

void ModelView::print(const size_t indent) const
{
	std::string marker("");
	con_print << aux::pad_left(marker, indent*2) << label() << " \"" << modelname() << "\"" << std::endl;
}

void ModelView::set_modelname(const char *modelname)
{
	if (modelname)
		modelview_modelname.assign(modelname);
	else
		modelview_modelname.clear();
	
	set_background(false);
	
	modelview_axis.clear();
	modelview_axis.change_direction(180);
	modelview_axis.change_pitch(-15);
	modelview_zoom = 1.0f;
}

void ModelView::set_colors(const math::Color & color_primary, const math::Color & color_secondary)
{
	modelview_color_primary.assign(color_primary);
	modelview_color_secondary.assign(color_secondary);
}

void ModelView::set_zoom(const float zoom)
{
	modelview_zoom = zoom;
	math::clamp(modelview_zoom, 1.0f, 5.0f);
}

bool ModelView::on_keypress(const int key, const unsigned int modifier)
{
	if (key == 512 + SDL_BUTTON_WHEELUP) {
		modelview_zoom -= 0.25f;
		if (modelview_zoom < 1.0f)
			modelview_zoom = 1.0f;
		return true;
	} else 	if (key == 512 + SDL_BUTTON_WHEELDOWN) {
		modelview_zoom += 0.25f;
		if (modelview_zoom > 5.0f)
			modelview_zoom = 5.0f;
		return true;
	} else if (key == 512 + SDL_BUTTON_LEFT) {
		modelview_dragging = true;
		return true;
	}

	return false;
}

bool ModelView::on_keyrelease(const int key, const unsigned int modifier)
{
	if (key == 512 + SDL_BUTTON_LEFT) {
		modelview_dragging = false;
		return true;
	}

	return false;
}

void ModelView::on_mousemove(const math::Vector2f &cursor) 
{
	if ((width() <= 0) || (height() <= 0)) {
		return;
	}
	
	if (modelview_dragging) {	
		const math::Vector2f pos(cursor - modelview_cursor);
		
		const math::Vector3f up(0.0f, 0.0f, 1.0f);
		const float zrot =  2.0f * M_PI * pos.x() / width();
		modelview_axis.rotate(up, -zrot);
		
		const math::Vector3f left(0.0f, 1.0f, 0.0f);
		const float yrot =  2.0f * M_PI * pos.y() / height();
		modelview_axis.rotate(left, yrot);
	
		modelview_cursor.assign(cursor);
	}
	modelview_cursor.assign(cursor);
}

void ModelView::on_mouseover(const math::Vector2f &cursor)
{
	modelview_cursor.assign(cursor);
	modelview_dragging = false;
}

void ModelView::draw_background()
{
	Paint::set_color(1.0f, 1.0f, 1.0f);
	Paint::draw_bitmap(global_location(), size(), "textures/common/notex");	
}

void ModelView::draw()
{
	if (!modelview_modelname.size()) {
		return;
	}

	if (!core::application()->connected() || !core::game()->time()) {
		return;
	}
	
	Paint::set_color(1.0f, 1.0f, 1.0f);
	model::Model *model = model::Model::load(modelview_modelname);
	if (!model) {
		modelview_modelname.clear();
		set_background(true);
		return;
	}

	math ::Vector2f center(global_location() + size() * 0.5f);

	const float minscreen(math::min(root()->width(),root()->height()));
	const float minwidget(math::min(width(), height()));
	const float reference_radius = radius() * minwidget / minscreen;
	const float modelscale = reference_radius / model->radius();

	// gl 3d mode
	render::Camera::frustum_default(modelview_zoom, center.x(), center.y());

	// reset lighting
	render::pass_reset_lights();

	// enable lighting
	gl::enable(GL_LIGHTING);
	
	gl::disable(GL_BLEND);
	gl::depthmask(GL_TRUE);		// enable writing to the depth buffer
	gl::enable(GL_DEPTH_TEST);	// enable depth test

	gl::enable(GL_CULL_FACE);	// enable culling
	gl::enable(GL_COLOR_MATERIAL);	// enable color tracking
	
	// clear depth buffer
	gl::clear(GL_DEPTH_BUFFER_BIT);
	
	// enable vertex arrays
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
	glEnableClientState(GL_NORMAL_ARRAY);
	
	// apply manipulation
	gl::push();
	gl::multmatrix(modelview_axis);
	gl::scale(modelscale, modelscale, modelscale);
	
	render::State::set_normalize(true);
	
	// FIXME the inventory window needs to be able to use actual thrust values
	float thrust = ::sinf(core::application()->time() * 0.5f);
	if (thrust < 0.0f ) {
		thrust = 1.0f + thrust;
	} else {
		thrust = 1.0f;
	}

	render::draw_model_fragments(model, modelview_color_primary, modelview_color_primary, core::application()->time(), true, true, thrust);
	
	render::State::set_normalize(false);
	
	gl::pop();

	glDisableClientState(GL_VERTEX_ARRAY);
	glDisableClientState(GL_NORMAL_ARRAY);
	glDisableClientState(GL_TEXTURE_COORD_ARRAY);

	gl::disable(GL_LIGHTING);
	gl::enable(GL_TEXTURE_2D);
	gl::enable(GL_BLEND);
	gl::depthmask(GL_FALSE);		// disable depth buffer writing

	// load model light textures
	for (model::Model::Lights::iterator lit = model->lights().begin(); lit != model->lights().end(); lit++) {
		model::Light *light = (*lit);

		// load light texture
		std::stringstream texturename;
		texturename << "textures/fx/flare" << std::setfill('0') << std::setw(2) << light->flare();
		light->set_texture(render::Textures::load(texturename.str()));
	}

	for (model::Model::Flares::iterator flit = model->flares().begin(); flit != model->flares().end(); flit++) {
		model::Flare *flare = (*flit);

		// load flare texture
		std::stringstream texturename;
		texturename << "textures/fx/flare" << std::setfill('0') << std::setw(2) << flare->flare();
		flare->set_texture(render::Textures::load(texturename.str()));
	}
	
	render::draw_model_lights(model, modelscale, math::Vector3f(), modelview_axis, core::localplayer()->color(), thrust, 0.0f);
	
	gl::disable(GL_TEXTURE_2D);
	gl::disable(GL_COLOR_MATERIAL);	// disable color tracking
	gl::disable(GL_CULL_FACE);	// disable culling
	gl::depthmask(GL_FALSE);	// enable depth buffer writing
	gl::disable(GL_DEPTH_TEST);	// disable depth buffer testing

	// gl 2d mode
	render::Camera::ortho();
}

void ModelView::draw_border()
{
	Paint::set_color(palette()->foreground());
	Paint::draw_border(global_location(), size());
}

}