worldspawn/plugins/md3model/model.h

/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#if !defined( INCLUDED_MODEL_H )
#define INCLUDED_MODEL_H

#include "globaldefs.h"
#include "cullable.h"
#include "renderable.h"
#include "selectable.h"
#include "modelskin.h"

#include "math/frustum.h"
#include "string/string.h"
#include "generic/static.h"
#include "stream/stringstream.h"
#include "os/path.h"
#include "scenelib.h"
#include "instancelib.h"
#include "transformlib.h"
#include "traverselib.h"
#include "render.h"

class VectorLightList : public LightList {
typedef std::vector<const RendererLight *> Lights;
Lights m_lights;
public:
void addLight(const RendererLight &light)
{
	m_lights.push_back(&light);
}

void clear()
{
	m_lights.clear();
}

void evaluateLights() const
{
}

void lightsChanged() const
{
}

void forEachLight(const RendererLightCallback &callback) const
{
	for (Lights::const_iterator i = m_lights.begin(); i != m_lights.end(); ++i) {
		callback(*(*i));
	}
}
};

inline VertexPointer vertexpointer_arbitrarymeshvertex(const ArbitraryMeshVertex *array)
{
	return VertexPointer(VertexPointer::pointer(&array->vertex), sizeof(ArbitraryMeshVertex));
}

inline void parseTextureName(CopiedString &name, const char *token)
{
	StringOutputStream cleaned(256);
	cleaned << PathCleaned(token);
	name = StringRange(cleaned.c_str(), path_get_filename_base_end(cleaned.c_str())); // remove extension
}

// generic renderable triangle surface
class Surface :
	public OpenGLRenderable {
public:
typedef VertexBuffer<ArbitraryMeshVertex> vertices_t;
typedef IndexBuffer indices_t;
private:

AABB m_aabb_local;
CopiedString m_shader;
Shader *m_state;

vertices_t m_vertices;
indices_t m_indices;

void CaptureShader()
{
	m_state = GlobalShaderCache().capture(m_shader.c_str());
}

void ReleaseShader()
{
	GlobalShaderCache().release(m_shader.c_str());
}

public:

Surface()
	: m_shader(""), m_state(0)
{
	CaptureShader();
}

~Surface()
{
	ReleaseShader();
}

vertices_t &vertices()
{
	return m_vertices;
}

indices_t &indices()
{
	return m_indices;
}

void setShader(const char *name)
{
	ReleaseShader();
	parseTextureName(m_shader, name);
	CaptureShader();
}

const char *getShader() const
{
	return m_shader.c_str();
}

Shader *getState() const
{
	return m_state;
}

void updateAABB()
{
	m_aabb_local = AABB();
	for (vertices_t::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
		aabb_extend_by_point_safe(m_aabb_local, reinterpret_cast<const Vector3 &>((*i).vertex ));
	}


	for (Surface::indices_t::iterator i = m_indices.begin(); i != m_indices.end(); i += 3) {
		ArbitraryMeshVertex &a = m_vertices[*(i + 0)];
		ArbitraryMeshVertex &b = m_vertices[*(i + 1)];
		ArbitraryMeshVertex &c = m_vertices[*(i + 2)];

		ArbitraryMeshTriangle_sumTangents(a, b, c);
	}

	for (Surface::vertices_t::iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
		vector3_normalise(reinterpret_cast<Vector3 &>((*i).tangent ));
		vector3_normalise(reinterpret_cast<Vector3 &>((*i).bitangent ));
	}
}

void render(RenderStateFlags state) const
{
	if ((state & RENDER_BUMP) != 0) {
		if (GlobalShaderCache().useShaderLanguage()) {
			glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
			glVertexAttribPointerARB(c_attr_TexCoord0, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
			                         &m_vertices.data()->texcoord);
			glVertexAttribPointerARB(c_attr_Tangent, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
			                         &m_vertices.data()->tangent);
			glVertexAttribPointerARB(c_attr_Binormal, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
			                         &m_vertices.data()->bitangent);
		} else {
			glVertexAttribPointerARB(11, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
			glVertexAttribPointerARB(8, 2, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
			glVertexAttribPointerARB(9, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex), &m_vertices.data()->tangent);
			glVertexAttribPointerARB(10, 3, GL_FLOAT, 0, sizeof(ArbitraryMeshVertex),
			                         &m_vertices.data()->bitangent);
		}
	} else {
		glNormalPointer(GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->normal);
		glTexCoordPointer(2, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->texcoord);
	}
	glVertexPointer(3, GL_FLOAT, sizeof(ArbitraryMeshVertex), &m_vertices.data()->vertex);
	glDrawElements(GL_TRIANGLES, GLsizei(m_indices.size()), RenderIndexTypeID, m_indices.data());

#if 0
	glBegin(GL_LINES);

	for (VertexBuffer<ArbitraryMeshVertex>::const_iterator i = m_vertices.begin(); i != m_vertices.end(); ++i) {
		Vector3 normal = vector3_added(vertex3f_to_vector3((*i).vertex),
		                               vector3_scaled(normal3f_to_vector3((*i).normal), 8));
		glVertex3fv(vertex3f_to_array((*i).vertex));
		glVertex3fv(vector3_to_array(normal));
	}
	glEnd();
#endif
}

VolumeIntersectionValue intersectVolume(const VolumeTest &test, const Matrix4 &localToWorld) const
{
	return test.TestAABB(m_aabb_local, localToWorld);
}

const AABB &localAABB() const
{
	return m_aabb_local;
}

void render(Renderer &renderer, const Matrix4 &localToWorld, Shader *state) const
{
	renderer.SetState(state, Renderer::eFullMaterials);
	renderer.addRenderable(*this, localToWorld);
}

void render(Renderer &renderer, const Matrix4 &localToWorld) const
{
	render(renderer, localToWorld, m_state);
}

void testSelect(Selector &selector, SelectionTest &test, const Matrix4 &localToWorld)
{
	test.BeginMesh(localToWorld);

	SelectionIntersection best;
	test.TestTriangles(
		vertexpointer_arbitrarymeshvertex(m_vertices.data()),
		IndexPointer(m_indices.data(), IndexPointer::index_type(m_indices.size())),
		best
		);
	if (best.valid()) {
		selector.addIntersection(best);
	}
}
};

// generic model node
class Model :
	public Cullable,
	public Bounded {
typedef std::vector<Surface *> surfaces_t;
surfaces_t m_surfaces;

AABB m_aabb_local;
public:
Callback<void()> m_lightsChanged;

~Model()
{
	for (surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i) {
		delete *i;
	}
}

typedef surfaces_t::const_iterator const_iterator;

const_iterator begin() const
{
	return m_surfaces.begin();
}

const_iterator end() const
{
	return m_surfaces.end();
}

std::size_t size() const
{
	return m_surfaces.size();
}

Surface &newSurface()
{
	m_surfaces.push_back(new Surface);
	return *m_surfaces.back();
}

void updateAABB()
{
	m_aabb_local = AABB();
	for (surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i) {
		aabb_extend_by_aabb_safe(m_aabb_local, (*i)->localAABB());
	}
}

VolumeIntersectionValue intersectVolume(const VolumeTest &test, const Matrix4 &localToWorld) const
{
	return test.TestAABB(m_aabb_local, localToWorld);
}

virtual const AABB &localAABB() const
{
	return m_aabb_local;
}

void testSelect(Selector &selector, SelectionTest &test, const Matrix4 &localToWorld)
{
	for (surfaces_t::iterator i = m_surfaces.begin(); i != m_surfaces.end(); ++i) {
		if ((*i)->intersectVolume(test.getVolume(), localToWorld) != c_volumeOutside) {
			(*i)->testSelect(selector, test, localToWorld);
		}
	}
}
};

inline void Surface_addLight(const Surface &surface, VectorLightList &lights, const Matrix4 &localToWorld,
                             const RendererLight &light)
{
	if (light.testAABB(aabb_for_oriented_aabb(surface.localAABB(), localToWorld))) {
		lights.addLight(light);
	}
}

class ModelInstance :
	public scene::Instance,
	public Renderable,
	public SelectionTestable,
	public LightCullable,
	public SkinnedModel {
class TypeCasts {
InstanceTypeCastTable m_casts;
public:
TypeCasts()
{
	InstanceContainedCast<ModelInstance, Bounded>::install(m_casts);
	InstanceContainedCast<ModelInstance, Cullable>::install(m_casts);
	InstanceStaticCast<ModelInstance, Renderable>::install(m_casts);
	InstanceStaticCast<ModelInstance, SelectionTestable>::install(m_casts);
	InstanceStaticCast<ModelInstance, SkinnedModel>::install(m_casts);
}

InstanceTypeCastTable &get()
{
	return m_casts;
}
};

Model &m_model;

const LightList *m_lightList;
typedef Array<VectorLightList> SurfaceLightLists;
SurfaceLightLists m_surfaceLightLists;

class Remap {
public:
CopiedString first;
Shader *second;

Remap() : second(0)
{
}
};

typedef Array<Remap> SurfaceRemaps;
SurfaceRemaps m_skins;
public:

typedef LazyStatic<TypeCasts> StaticTypeCasts;

Bounded &get(NullType<Bounded>)
{
	return m_model;
}

Cullable &get(NullType<Cullable>)
{
	return m_model;
}

void lightsChanged()
{
	m_lightList->lightsChanged();
}

typedef MemberCaller<ModelInstance, void (), &ModelInstance::lightsChanged> LightsChangedCaller;

void constructRemaps()
{
	ModelSkin *skin = NodeTypeCast<ModelSkin>::cast(path().parent());
	if (skin != 0 && skin->realised()) {
		SurfaceRemaps::iterator j = m_skins.begin();
		for (Model::const_iterator i = m_model.begin(); i != m_model.end(); ++i, ++j) {
			const char *remap = skin->getRemap((*i)->getShader());
			if (!string_empty(remap)) {
				(*j).first = remap;
				(*j).second = GlobalShaderCache().capture(remap);
			} else {
				(*j).second = 0;
			}
		}
		SceneChangeNotify();
	}
}

void destroyRemaps()
{
	for (SurfaceRemaps::iterator i = m_skins.begin(); i != m_skins.end(); ++i) {
		if ((*i).second != 0) {
			GlobalShaderCache().release((*i).first.c_str());
			(*i).second = 0;
		}
	}
}

void skinChanged()
{
	ASSERT_MESSAGE(m_skins.size() == m_model.size(), "ERROR");
	destroyRemaps();
	constructRemaps();
}

ModelInstance(const scene::Path &path, scene::Instance *parent, Model &model) :
	Instance(path, parent, this, StaticTypeCasts::instance().get()),
	m_model(model),
	m_surfaceLightLists(m_model.size()),
	m_skins(m_model.size())
{
	m_lightList = &GlobalShaderCache().attach(*this);
	m_model.m_lightsChanged = LightsChangedCaller(*this);

	Instance::setTransformChangedCallback(LightsChangedCaller(*this));

	constructRemaps();
}

~ModelInstance()
{
	destroyRemaps();

	Instance::setTransformChangedCallback(Callback<void()>());

	m_model.m_lightsChanged = Callback<void()>();
	GlobalShaderCache().detach(*this);
}

void render(Renderer &renderer, const VolumeTest &volume, const Matrix4 &localToWorld) const
{
	SurfaceLightLists::const_iterator j = m_surfaceLightLists.begin();
	SurfaceRemaps::const_iterator k = m_skins.begin();
	for (Model::const_iterator i = m_model.begin(); i != m_model.end(); ++i, ++j, ++k) {
		if ((*i)->intersectVolume(volume, localToWorld) != c_volumeOutside) {
			renderer.setLights(*j);
			(*i)->render(renderer, localToWorld, (*k).second != 0 ? (*k).second : (*i)->getState());
		}
	}
}

void renderSolid(Renderer &renderer, const VolumeTest &volume) const
{
	m_lightList->evaluateLights();

	render(renderer, volume, Instance::localToWorld());
}

void renderWireframe(Renderer &renderer, const VolumeTest &volume) const
{
	renderSolid(renderer, volume);
}

void testSelect(Selector &selector, SelectionTest &test)
{
	m_model.testSelect(selector, test, Instance::localToWorld());
}

bool testLight(const RendererLight &light) const
{
	return light.testAABB(worldAABB());
}

void insertLight(const RendererLight &light)
{
	const Matrix4 &localToWorld = Instance::localToWorld();
	SurfaceLightLists::iterator j = m_surfaceLightLists.begin();
	for (Model::const_iterator i = m_model.begin(); i != m_model.end(); ++i) {
		Surface_addLight(*(*i), *j++, localToWorld, light);
	}
}

void clearLights()
{
	for (SurfaceLightLists::iterator i = m_surfaceLightLists.begin(); i != m_surfaceLightLists.end(); ++i) {
		(*i).clear();
	}
}
};

class ModelNode : public scene::Node::Symbiot, public scene::Instantiable {
class TypeCasts {
NodeTypeCastTable m_casts;
public:
TypeCasts()
{
	NodeStaticCast<ModelNode, scene::Instantiable>::install(m_casts);
}

NodeTypeCastTable &get()
{
	return m_casts;
}
};


scene::Node m_node;
InstanceSet m_instances;
Model m_model;
public:

typedef LazyStatic<TypeCasts> StaticTypeCasts;

ModelNode() : m_node(this, this, StaticTypeCasts::instance().get())
{
}

Model &model()
{
	return m_model;
}

void release()
{
	delete this;
}

scene::Node &node()
{
	return m_node;
}

scene::Instance *create(const scene::Path &path, scene::Instance *parent)
{
	return new ModelInstance(path, parent, m_model);
}

void forEachInstance(const scene::Instantiable::Visitor &visitor)
{
	m_instances.forEachInstance(visitor);
}

void insert(scene::Instantiable::Observer *observer, const scene::Path &path, scene::Instance *instance)
{
	m_instances.insert(observer, path, instance);
}

scene::Instance *erase(scene::Instantiable::Observer *observer, const scene::Path &path)
{
	return m_instances.erase(observer, path);
}
};


inline void
Surface_constructQuad(Surface &surface, const Vector3 &a, const Vector3 &b, const Vector3 &c, const Vector3 &d,
                      const Vector3 &normal)
{
	surface.vertices().push_back(
		ArbitraryMeshVertex(
			vertex3f_for_vector3(a),
			normal3f_for_vector3(normal),
			texcoord2f_from_array(aabb_texcoord_topleft)
			)
		);
	surface.vertices().push_back(
		ArbitraryMeshVertex(
			vertex3f_for_vector3(b),
			normal3f_for_vector3(normal),
			texcoord2f_from_array(aabb_texcoord_topright)
			)
		);
	surface.vertices().push_back(
		ArbitraryMeshVertex(
			vertex3f_for_vector3(c),
			normal3f_for_vector3(normal),
			texcoord2f_from_array(aabb_texcoord_botright)
			)
		);
	surface.vertices().push_back(
		ArbitraryMeshVertex(
			vertex3f_for_vector3(d),
			normal3f_for_vector3(normal),
			texcoord2f_from_array(aabb_texcoord_botleft)
			)
		);
}

inline void Model_constructNull(Model &model)
{
	Surface &surface = model.newSurface();

	AABB aabb(Vector3(0, 0, 0), Vector3(8, 8, 8));

	Vector3 points[8];
	aabb_corners(aabb, points);

	surface.vertices().reserve(24);

	Surface_constructQuad(surface, points[2], points[1], points[5], points[6], aabb_normals[0]);
	Surface_constructQuad(surface, points[1], points[0], points[4], points[5], aabb_normals[1]);
	Surface_constructQuad(surface, points[0], points[1], points[2], points[3], aabb_normals[2]);
	Surface_constructQuad(surface, points[0], points[3], points[7], points[4], aabb_normals[3]);
	Surface_constructQuad(surface, points[3], points[2], points[6], points[7], aabb_normals[4]);
	Surface_constructQuad(surface, points[7], points[6], points[5], points[4], aabb_normals[5]);

	surface.indices().reserve(36);

	RenderIndex indices[36] = {
		0, 1, 2, 0, 2, 3,
		4, 5, 6, 4, 6, 7,
		8, 9, 10, 8, 10, 11,
		12, 13, 14, 12, 14, 15,
		16, 17, 18, 16, 18, 19,
		20, 21, 22, 10, 22, 23,
	};

	for (RenderIndex *i = indices; i != indices + (sizeof(indices) / sizeof(RenderIndex)); ++i) {
		surface.indices().insert(*i);
	}

	surface.setShader("");

	surface.updateAABB();

	model.updateAABB();
}

#endif