path: root/src/render/render.cc

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

#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>

#include "auxiliary/functions.h"
#include "core/application.h"
#include "core/gameinterface.h"
#include "filesystem/filesystem.h"
#include "model/model.h"
#include "model/material.h"
#include "model/material.h"
#include "render/gl.h"
#include "render/state.h"
#include "render/dust.h"
#include "render/render.h"
#include "render/screenshot.h"
#include "render/textures.h"
#include "sys/sys.h"

namespace render {

model::VertexArray *vertexarray = 0;

core::Cvar *r_arraysize = 0;
core::Cvar *r_bbox = 0;
core::Cvar *r_grid = 0;
core::Cvar *r_particles = 0;
core::Cvar *r_radius = 0;
core::Cvar *r_sky = 0;
core::Cvar *r_wireframe = 0;
core::Cvar *r_mipmap = 0;

void func_list_textures(std::string const &args)
{
	Textures::list();
}

void func_list_materials(std::string const &args)
{
	model::Material::list();
}

void func_list_particles(std::string const &args)
{
	ParticleScript::list();
}

void init(int width, int height) 
{
	con_print << "^BInitializing renderer..." << std::endl;

	con_print << "  renderer   ^B" << gl::renderer() << std::endl;
	con_print << "  vendor     ^B" << gl::vendor() << std::endl;
	con_print << "  version    ^B" << gl::version() << std::endl;

	// initialize render state
	State::init(width, height);

	// size of the vertex array in megabytes
	r_arraysize = core::Cvar::get("r_arraysize", 64.0f , core::Cvar::Archive);
	r_arraysize->set_info("[int] size of the vertex array in Mb");

	size_t mb = (size_t) r_arraysize->value();
	if (mb < 4 * sizeof(float))
		mb = 4 * sizeof(float);
	if (mb > 256)
		mb = 256;
	(*r_arraysize) = (float) mb;
	vertexarray = new model::VertexArray(mb);

	// engine variables
	r_radius = core::Cvar::get("r_radius", "0", core::Cvar::Archive);
	r_radius->set_info("[bool] render entity radius");

	r_wireframe = core::Cvar::get("r_wireframe", "0", core::Cvar::Archive);
	r_wireframe->set_info("[bool] render wireframe");

	r_grid = core::Cvar::get("r_grid", "0", core::Cvar::Archive);
	r_grid->set_info("[bool] render the space grid");

	r_bbox = core::Cvar::get("r_bbox", "0", core::Cvar::Archive);
	r_bbox->set_info("[bool] render model bounding box");

	r_sky = core::Cvar::get("r_sky", "1", core::Cvar::Archive);
	r_sky->set_info("[bool] render the sky globe");

	r_particles = core::Cvar::get("r_particles", "1", core::Cvar::Archive);
	r_particles->set_info("[bool] render particles");

	Screenshot::screenshotformat = core::Cvar::get("screenshotformat", "jpg", core::Cvar::Archive);
	Screenshot::screenshotformat->set_info("[string] screenshot format: jpg png tga");

	Screenshot::screenshotquality = core::Cvar::get("screenshotquality", "85", core::Cvar::Archive);
	Screenshot::screenshotquality->set_info("[int] screenshot jpg quality");

	// hardware generate mipmaps
	r_mipmap = core::Cvar::get("r_mipmap", "0", core::Cvar::Archive);
	r_mipmap->set_info("[bool] use hardware generated mipmaps");
	if (!State::has_generate_mipmaps()) {
		con_print << "  no hardware generated mipmap support" << std::endl;
	}

	Camera::init();

	Textures::init();

	Text::init();

	Dust::init();

	// read materials
	model::Material::init();

	// engine functions
	core::Func *func = core::Func::add("list_textures", func_list_textures);
	func->set_info("list registered textures");

	func = core::Func::add("list_materials", func_list_materials);
	func->set_info("list registered materials");


	func = core::Func::add("list_particles", func_list_particles);
	func->set_info("list registered particle scripts");
}

// unload game assets (zone change)
/* TODO RenderExt class containing render state */
void unload()
{
	// clear zone sky textures
	for (core::Zone::Registry::iterator it = core::Zone::registry().begin(); it != core::Zone::registry().end(); it++) {
		core::Zone *zone = (*it).second;
		if (zone->sky_texture()) {
			render::Textures::unload(zone->sky_texture());
			zone->set_sky_texture(0);
		}
	}

	for (core::Entity::Registry::iterator it = core::Entity::registry().begin(); it != core::Entity::registry().end(); it++) {
		core:: Entity *entity = (*it).second;
	
		if (entity->type() == core::Entity::Globe) { 		
			core::EntityGlobe *globe = static_cast<core::EntityGlobe *>(entity);
			if (globe->render_texture) {
				render::Textures::unload(globe->render_texture);
				globe->render_texture = 0;
			}
		}

		if (ext_render(entity)) {
			delete ext_render(entity);
		}
	}
}

// clear all assets
void clear()
{
	//con_debug << "  clearing render data...\n";

	// clear zone sky textures
	for (core::Zone::Registry::iterator it = core::Zone::registry().begin(); it != core::Zone::registry().end(); it++) {
		core::Zone *zone = (*it).second;
		zone->set_sky_texture(0);
	}

	// clear entity models, and globe textures, this will force a reload
	for (core::Entity::Registry::iterator it = core::Entity::registry().begin(); it != core::Entity::registry().end(); it++) {
		core::Entity *entity = (*it).second;

		if (entity->model())
			entity->set_model(0);

		if (entity->type() == core::Entity::Globe) { 
			core::EntityGlobe *globe = static_cast<core::EntityGlobe *>(entity);
			globe->render_texture = 0;
		}

		if (ext_render(entity)) {
			delete ext_render(entity);
		}
	}

	// clear model registry
	model::Model::clear();

	// clear materials
	model::Material::clear();

	// clear particle system scripts
	ParticleScript::clear();

	// clear vertex array
	delete vertexarray;
	vertexarray = 0;
}

// reset render subsystem (module disconnect)
void reset()
{
	clear();

	State::clear();

	Textures::shutdown();

	Textures::init();

	size_t mb = (size_t) r_arraysize->value();
	if (mb < 4 * sizeof(float))
		mb = 4 * sizeof(float);
	if (mb > 256)
		mb = 256;
	(*r_arraysize) = (float) mb;
	vertexarray = new model::VertexArray(mb);

	Dust::reset();

	model::Material::init();
}

void resize(int width, int height)
{
	State::resize(width, height);
}

void shutdown()
{
	con_print << "^BShutting down renderer..." << std::endl;

	core::Func::remove("list_materials");
	core::Func::remove("list_particles");
	core::Func::remove("list_textures");

	clear();

	Text::shutdown();

	Textures::shutdown();

	Camera::shutdown();

	Dust::shutdown();

	State::shutdown();
}

} // namespace render