# HG changeset patch
# User John Tsiombikas <nuclear@member.fsf.org>
# Date 1434857439 -10800
# Node ID 52e0dd47753ba714479f65198d786fb719cdf916

initial commit

diff -r 000000000000 -r 52e0dd47753b .hgignore
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/.hgignore	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,4 @@
+\.o$
+\.swp$
+\.d$
+^tavli$
diff -r 000000000000 -r 52e0dd47753b Makefile
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Makefile	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,31 @@
+PREFIX ?= /usr/local
+
+src = $(wildcard src/*.cc)
+obj = $(src:.cc=.o)
+
+bin = tavli
+
+CXXFLAGS = -pedantic -Wall -g
+LDFLAGS = $(libgl)
+
+ifeq ($(shell uname -s), Darwin)
+	libgl = -framework OpenGL -framework GLUT -lGLEW
+else
+	libgl = -lGL -lGLU -lglut -lGLEW
+endif
+
+$(bin): $(obj)
+	$(CXX) -o $@ $(obj) $(LDFLAGS)
+
+.PHONY: clean
+clean:
+	rm -f $(obj) $(bin)
+
+.PHONY: install
+install: $(bin)
+	mkdir -p $(PREFIX)/bin
+	cp $(bin) $(PREFIX)/bin/$(bin)
+
+.PHONY: uninstall
+uninstall:
+	rm -f $(PREFIX)/bin/$(bin)
diff -r 000000000000 -r 52e0dd47753b src/board.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/board.cc	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,54 @@
+#include "opengl.h"
+#include "board.h"
+
+static Mesh *gen_board_mesh();
+static Mesh *gen_puck_mesh();
+
+Board::Board()
+{
+	clear();
+}
+
+Board::~Board()
+{
+	destroy();
+}
+
+bool Board::init()
+{
+	if(!(board_mesh = gen_board_mesh())) {
+		return false;
+	}
+	if(!(puck_mesh = gen_puck_mesh())) {
+		return false;
+	}
+	return true;
+}
+
+void Board::destroy()
+{
+	delete board_mesh;
+	delete puck_mesh;
+	board_mesh = puck_mesh = 0;
+}
+
+void Board::clear()
+{
+	memset(slots, 0, sizeof slots);
+}
+
+void Board::draw() const
+{
+	if(board_mesh)
+		board_mesh->draw();
+}
+
+static Mesh *gen_board_mesh()
+{
+	return 0;
+}
+
+static Mesh *gen_puck_mesh()
+{
+	return 0;
+}
diff -r 000000000000 -r 52e0dd47753b src/board.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/board.h	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,28 @@
+#ifndef BOARD_H_
+#define BOARD_H_
+
+#include "mesh.h"
+
+#define NUM_SLOTS	24
+#define MAX_PUCKS	30
+
+enum { EMPTY = 0, MINE, OTHER };
+
+class Board {
+private:
+	int slots[NUM_SLOTS][MAX_PUCKS];
+	Mesh *board_mesh, *puck_mesh;
+
+public:
+	Board();
+	~Board();
+
+	bool init();
+	void destroy();
+
+	void clear();
+
+	void draw() const;
+};
+
+#endif	// BOARD_H_
diff -r 000000000000 -r 52e0dd47753b src/game.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/game.cc	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include <GL/glew.h>
+#include "game.h"
+
+static void draw_backdrop();
+
+int win_width, win_height;
+
+static float cam_theta, cam_phi = 25, cam_dist = 6;
+static bool bnstate[8];
+static int prev_x, prev_y;
+
+
+bool game_init()
+{
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_CULL_FACE);
+
+	glEnable(GL_LIGHTING);
+	glEnable(GL_LIGHT0);
+
+	return true;
+}
+
+void game_cleanup()
+{
+}
+
+void game_update(unsigned long time_msec)
+{
+}
+
+void game_display()
+{
+	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+	glMatrixMode(GL_MODELVIEW);
+	glLoadIdentity();
+	glTranslatef(0, 0, -cam_dist);
+	glRotatef(cam_phi, 1, 0, 0);
+	glRotatef(cam_theta, 0, 1, 0);
+
+	draw_backdrop();
+
+	glBegin(GL_QUADS);
+	glNormal3f(0, 1, 0);
+	glVertex3f(-1, 0, 1);
+	glVertex3f(1, 0, 1);
+	glVertex3f(1, 0, -1);
+	glVertex3f(-1, 0, -1);
+	glEnd();
+}
+
+static void draw_backdrop()
+{
+	glPushAttrib(GL_ENABLE_BIT);
+	glDisable(GL_LIGHTING);
+	glDisable(GL_DEPTH_TEST);
+
+	glMatrixMode(GL_PROJECTION);
+	glPushMatrix();
+	glLoadIdentity();
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+	glLoadIdentity();
+
+	glBegin(GL_QUADS);
+	glColor3f(0.9, 0.8, 0.6);
+	glVertex2f(-1, -1);
+	glVertex2f(1, -1);
+	glColor3f(0.4, 0.5, 0.8);
+	glVertex2f(1, 1);
+	glVertex2f(-1, 1);
+	glEnd();
+
+	glMatrixMode(GL_PROJECTION);
+	glPopMatrix();
+	glMatrixMode(GL_MODELVIEW);
+	glPopMatrix();
+
+	glPopAttrib();
+}
+
+void game_reshape(int x, int y)
+{
+	glMatrixMode(GL_PROJECTION);
+	glLoadIdentity();
+	gluPerspective(50, (float)x / (float)y, 0.5, 500.0);
+
+	glViewport(0, 0, x, y);
+}
+
+void game_keyboard(int bn, bool press)
+{
+	if(press) {
+		switch(bn) {
+		case 27:
+			quit();
+		}
+	}
+}
+
+void game_mbutton(int bn, bool press, int x, int y)
+{
+	bnstate[bn] = press;
+	prev_x = x;
+	prev_y = y;
+}
+
+void game_mmotion(int x, int y)
+{
+	int dx = x - prev_x;
+	int dy = y - prev_y;
+	prev_x = x;
+	prev_y = y;
+
+	if(bnstate[0]) {
+		cam_theta += dx * 0.5;
+		cam_phi += dy * 0.5;
+
+		if(cam_phi < -90) cam_phi = -90;
+		if(cam_phi > 90) cam_phi = 90;
+
+		redisplay();
+	}
+	if(bnstate[2]) {
+		cam_dist += dy * 0.1;
+		if(cam_dist < 0.0) cam_dist = 0.0;
+
+		redisplay();
+	}
+}
diff -r 000000000000 -r 52e0dd47753b src/game.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/game.h	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,18 @@
+#ifndef GAME_H_
+#define GAME_H_
+
+extern int win_width, win_height;
+
+bool game_init();
+void game_cleanup();
+void game_update(unsigned long time_msec);
+void game_display();
+void game_reshape(int x, int y);
+void game_keyboard(int bn, bool press);
+void game_mbutton(int bn, bool press, int x, int y);
+void game_mmotion(int x, int y);
+
+void redisplay();
+void quit();
+
+#endif	/* GAME_H_ */
diff -r 000000000000 -r 52e0dd47753b src/geom.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/geom.cc	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,251 @@
+#include <algorithm>
+#include <float.h>
+#include "geom.h"
+
+GeomObject::~GeomObject()
+{
+}
+
+
+Sphere::Sphere()
+{
+	radius = 1.0;
+}
+
+Sphere::Sphere(const Vector3 &cent, float radius)
+	: center(cent)
+{
+	this->radius = radius;
+}
+
+void Sphere::set_union(const GeomObject *obj1, const GeomObject *obj2)
+{
+	const Sphere *sph1 = dynamic_cast<const Sphere*>(obj1);
+	const Sphere *sph2 = dynamic_cast<const Sphere*>(obj2);
+
+	if(!sph1 || !sph2) {
+		fprintf(stderr, "Sphere::set_union: arguments must be spheres");
+		return;
+	}
+
+	float dist = (sph1->center - sph2->center).length();
+	float surf_dist = dist - (sph1->radius + sph2->radius);
+	float d1 = sph1->radius + surf_dist / 2.0;
+	float d2 = sph2->radius + surf_dist / 2.0;
+	float t = d1 / (d1 + d2);
+
+	if(t < 0.0) t = 0.0;
+	if(t > 1.0) t = 1.0;
+
+	center = sph1->center * t + sph2->center * (1.0 - t);
+	radius = std::max(dist * t + sph2->radius, dist * (1.0f - t) + sph1->radius);
+}
+
+void Sphere::set_intersection(const GeomObject *obj1, const GeomObject *obj2)
+{
+	fprintf(stderr, "Sphere::intersection undefined\n");
+}
+
+bool Sphere::intersect(const Ray &ray, HitPoint *hit) const
+{
+	float a = dot_product(ray.dir, ray.dir);
+	float b = 2.0 * ray.dir.x * (ray.origin.x - center.x) +
+		2.0 * ray.dir.y * (ray.origin.y - center.y) +
+		2.0 * ray.dir.z * (ray.origin.z - center.z);
+	float c = dot_product(ray.origin, ray.origin) + dot_product(center, center) -
+		2.0 * dot_product(ray.origin, center) - radius * radius;
+
+	float discr = b * b - 4.0 * a * c;
+	if(discr < 1e-4) {
+		return false;
+	}
+
+	float sqrt_discr = sqrt(discr);
+	float t0 = (-b + sqrt_discr) / (2.0 * a);
+	float t1 = (-b - sqrt_discr) / (2.0 * a);
+
+	if(t0 < 1e-4)
+		t0 = t1;
+	if(t1 < 1e-4)
+		t1 = t0;
+
+	float t = t0 < t1 ? t0 : t1;
+	if(t < 1e-4) {
+		return false;
+	}
+
+	// fill the HitPoint structure
+	if(hit) {
+		hit->obj = this;
+		hit->dist = t;
+		hit->pos = ray.origin + ray.dir * t;
+		hit->normal = (hit->pos - center) / radius;
+	}
+	return true;
+}
+
+
+AABox::AABox()
+{
+}
+
+AABox::AABox(const Vector3 &vmin, const Vector3 &vmax)
+	: min(vmin), max(vmax)
+{
+}
+
+void AABox::set_union(const GeomObject *obj1, const GeomObject *obj2)
+{
+	const AABox *box1 = dynamic_cast<const AABox*>(obj1);
+	const AABox *box2 = dynamic_cast<const AABox*>(obj2);
+
+	if(!box1 || !box2) {
+		fprintf(stderr, "AABox::set_union: arguments must be AABoxes too\n");
+		return;
+	}
+
+	min.x = std::min(box1->min.x, box2->min.x);
+	min.y = std::min(box1->min.y, box2->min.y);
+	min.z = std::min(box1->min.z, box2->min.z);
+
+	max.x = std::max(box1->max.x, box2->max.x);
+	max.y = std::max(box1->max.y, box2->max.y);
+	max.z = std::max(box1->max.z, box2->max.z);
+}
+
+void AABox::set_intersection(const GeomObject *obj1, const GeomObject *obj2)
+{
+	const AABox *box1 = dynamic_cast<const AABox*>(obj1);
+	const AABox *box2 = dynamic_cast<const AABox*>(obj2);
+
+	if(!box1 || !box2) {
+		fprintf(stderr, "AABox::set_intersection: arguments must be AABoxes too\n");
+		return;
+	}
+
+	for(int i=0; i<3; i++) {
+		min[i] = std::max(box1->min[i], box2->min[i]);
+		max[i] = std::min(box1->max[i], box2->max[i]);
+
+		if(max[i] < min[i]) {
+			max[i] = min[i];
+		}
+	}
+}
+
+bool AABox::intersect(const Ray &ray, HitPoint *hit) const
+{
+	Vector3 param[2] = {min, max};
+	Vector3 inv_dir(1.0 / ray.dir.x, 1.0 / ray.dir.y, 1.0 / ray.dir.z);
+	int sign[3] = {inv_dir.x < 0, inv_dir.y < 0, inv_dir.z < 0};
+
+	float tmin = (param[sign[0]].x - ray.origin.x) * inv_dir.x;
+	float tmax = (param[1 - sign[0]].x - ray.origin.x) * inv_dir.x;
+	float tymin = (param[sign[1]].y - ray.origin.y) * inv_dir.y;
+	float tymax = (param[1 - sign[1]].y - ray.origin.y) * inv_dir.y;
+
+	if(tmin > tymax || tymin > tmax) {
+		return false;
+	}
+	if(tymin > tmin) {
+		tmin = tymin;
+	}
+	if(tymax < tmax) {
+		tmax = tymax;
+	}
+
+	float tzmin = (param[sign[2]].z - ray.origin.z) * inv_dir.z;
+	float tzmax = (param[1 - sign[2]].z - ray.origin.z) * inv_dir.z;
+
+	if(tmin > tzmax || tzmin > tmax) {
+		return false;
+	}
+	if(tzmin > tmin) {
+		tmin = tzmin;
+	}
+	if(tzmax < tmax) {
+		tmax = tzmax;
+	}
+
+	float t = tmin < 1e-4 ? tmax : tmin;
+	if(t >= 1e-4) {
+
+		if(hit) {
+			hit->obj = this;
+			hit->dist = t;
+			hit->pos = ray.origin + ray.dir * t;
+
+			float min_dist = FLT_MAX;
+			Vector3 offs = min + (max - min) / 2.0;
+			Vector3 local_hit = hit->pos - offs;
+
+			static const Vector3 axis[] = {
+				Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(0, 0, 1)
+			};
+			//int tcidx[][2] = {{2, 1}, {0, 2}, {0, 1}};
+
+			for(int i=0; i<3; i++) {
+				float dist = fabs((max[i] - offs[i]) - fabs(local_hit[i]));
+				if(dist < min_dist) {
+					min_dist = dist;
+					hit->normal = axis[i] * (local_hit[i] < 0.0 ? 1.0 : -1.0);
+					//hit->texcoord = Vector2(hit->pos[tcidx[i][0]], hit->pos[tcidx[i][1]]);
+				}
+			}
+		}
+		return true;
+	}
+	return false;
+
+}
+
+Plane::Plane()
+	: normal(0.0, 1.0, 0.0)
+{
+}
+
+Plane::Plane(const Vector3 &p, const Vector3 &norm)
+	: pt(p)
+{
+	normal = norm.normalized();
+}
+
+Plane::Plane(const Vector3 &p1, const Vector3 &p2, const Vector3 &p3)
+	: pt(p1)
+{
+	normal = cross_product(p2 - p1, p3 - p1).normalized();
+}
+
+Plane::Plane(const Vector3 &normal, float dist)
+{
+	this->normal = normal.normalized();
+	pt = this->normal * dist;
+}
+
+void Plane::set_union(const GeomObject *obj1, const GeomObject *obj2)
+{
+	fprintf(stderr, "Plane::set_union undefined\n");
+}
+
+void Plane::set_intersection(const GeomObject *obj1, const GeomObject *obj2)
+{
+	fprintf(stderr, "Plane::set_intersection undefined\n");
+}
+
+bool Plane::intersect(const Ray &ray, HitPoint *hit) const
+{
+	float ndotdir = dot_product(normal, ray.dir);
+	if(fabs(ndotdir) < 1e-4) {
+		return false;
+	}
+
+	if(hit) {
+		Vector3 ptdir = pt - ray.origin;
+		float t = dot_product(normal, ptdir) / ndotdir;
+
+		hit->pos = ray.origin + ray.dir * t;
+		hit->normal = normal;
+		hit->obj = this;
+	}
+	return true;
+}
diff -r 000000000000 -r 52e0dd47753b src/geom.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/geom.h	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,67 @@
+#ifndef GEOMOBJ_H_
+#define GEOMOBJ_H_
+
+#include "vmath/vmath.h"
+
+class GeomObject;
+
+struct HitPoint {
+	float dist;				//< parametric distance along the ray
+	Vector3 pos;			//< position of intersection (orig + dir * dist)
+	Vector3 normal;			//< normal at the point of intersection
+	const void *obj;		//< pointer to the intersected object
+};
+
+class GeomObject {
+public:
+	virtual ~GeomObject();
+
+	virtual void set_union(const GeomObject *obj1, const GeomObject *obj2) = 0;
+	virtual void set_intersection(const GeomObject *obj1, const GeomObject *obj2) = 0;
+
+	virtual bool intersect(const Ray &ray, HitPoint *hit = 0) const = 0;
+};
+
+class Sphere : public GeomObject {
+public:
+	Vector3 center;
+	float radius;
+
+	Sphere();
+	Sphere(const Vector3 &center, float radius);
+
+	void set_union(const GeomObject *obj1, const GeomObject *obj2);
+	void set_intersection(const GeomObject *obj1, const GeomObject *obj2);
+
+	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
+};
+
+class AABox : public GeomObject {
+public:
+	Vector3 min, max;
+
+	AABox();
+	AABox(const Vector3 &min, const Vector3 &max);
+
+	void set_union(const GeomObject *obj1, const GeomObject *obj2);
+	void set_intersection(const GeomObject *obj1, const GeomObject *obj2);
+
+	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
+};
+
+class Plane : public GeomObject {
+public:
+	Vector3 pt, normal;
+
+	Plane();
+	Plane(const Vector3 &pt, const Vector3 &normal);
+	Plane(const Vector3 &p1, const Vector3 &p2, const Vector3 &p3);
+	Plane(const Vector3 &normal, float dist);
+
+	void set_union(const GeomObject *obj1, const GeomObject *obj2);
+	void set_intersection(const GeomObject *obj1, const GeomObject *obj2);
+
+	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
+};
+
+#endif	// GEOMOBJ_H_
diff -r 000000000000 -r 52e0dd47753b src/main.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main.cc	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <GL/glew.h>
+#ifdef __APPLE__
+#include <GLUT/glut.h>
+#else
+#include <GL/glut.h>
+#endif
+#include "game.h"
+
+static void display();
+static void reshape(int x, int y);
+static void keypress(unsigned char key, int x, int y);
+static void keyrelease(unsigned char key, int x, int y);
+static void mouse(int bn, int st, int x, int y);
+static void motion(int x, int y);
+
+int main(int argc, char **argv)
+{
+	glutInit(&argc, argv);
+	glutInitWindowSize(1280, 800);
+	glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH | GLUT_DOUBLE);
+	glutCreateWindow("Tavli");
+
+	glutDisplayFunc(display);
+	glutReshapeFunc(reshape);
+	glutKeyboardFunc(keypress);
+	glutKeyboardUpFunc(keyrelease);
+	glutMouseFunc(mouse);
+	glutMotionFunc(motion);
+	glutPassiveMotionFunc(motion);
+
+	glewInit();
+
+	if(!game_init()) {
+		return 1;
+	}
+	atexit(game_cleanup);
+
+	glutMainLoop();
+	return 0;
+}
+
+void redisplay()
+{
+	glutPostRedisplay();
+}
+
+void quit()
+{
+	exit(0);
+}
+
+static void display()
+{
+	unsigned int msec = glutGet(GLUT_ELAPSED_TIME);
+	game_update(msec);
+	game_display();
+
+	assert(glGetError() == GL_NO_ERROR);
+	glutSwapBuffers();
+}
+
+static void reshape(int x, int y)
+{
+	win_width = x;
+	win_height = y;
+
+	game_reshape(x, y);
+}
+
+static void keypress(unsigned char key, int x, int y)
+{
+	game_keyboard(key, true);
+}
+
+static void keyrelease(unsigned char key, int x, int y)
+{
+	game_keyboard(key, false);
+}
+
+static void mouse(int bn, int st, int x, int y)
+{
+	game_mbutton(bn - GLUT_LEFT_BUTTON, st == GLUT_DOWN, x, y);
+}
+
+static void motion(int x, int y)
+{
+	game_mmotion(x, y);
+}
diff -r 000000000000 -r 52e0dd47753b src/mesh.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/mesh.cc	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,1190 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <float.h>
+#include <assert.h>
+#include "opengl.h"
+#include "mesh.h"
+//#include "xform_node.h"
+#include "shader.h"
+
+int Mesh::global_sdr_loc[NUM_MESH_ATTR] = {
+	(int)SDR_ATTR_VERTEX,
+	(int)SDR_ATTR_NORMAL,
+	(int)SDR_ATTR_TANGENT,
+	(int)SDR_ATTR_TEXCOORD,
+	(int)SDR_ATTR_COLOR,
+	-1, -1};
+unsigned int Mesh::intersect_mode = ISECT_DEFAULT;
+float Mesh::vertex_sel_dist = 0.01;
+float Mesh::vis_vecsize = 1.0;
+
+Mesh::Mesh()
+{
+	clear();
+
+	glGenBuffers(NUM_MESH_ATTR + 1, buffer_objects);
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		vattr[i].vbo = buffer_objects[i];
+	}
+	ibo = buffer_objects[NUM_MESH_ATTR];
+	wire_ibo = 0;
+}
+
+Mesh::~Mesh()
+{
+	glDeleteBuffers(NUM_MESH_ATTR + 1, buffer_objects);
+
+	if(wire_ibo) {
+		glDeleteBuffers(1, &wire_ibo);
+	}
+}
+
+Mesh::Mesh(const Mesh &rhs)
+{
+	clear();
+
+	glGenBuffers(NUM_MESH_ATTR + 1, buffer_objects);
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		vattr[i].vbo = buffer_objects[i];
+	}
+	ibo = buffer_objects[NUM_MESH_ATTR];
+	wire_ibo = 0;
+
+	clone(rhs);
+}
+
+Mesh &Mesh::operator =(const Mesh &rhs)
+{
+	if(&rhs != this) {
+		clone(rhs);
+	}
+	return *this;
+}
+
+bool Mesh::clone(const Mesh &m)
+{
+	clear();
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		if(m.has_attrib(i)) {
+			m.get_attrib_data(i);	// force validation of the actual data on the source mesh
+
+			vattr[i].nelem = m.vattr[i].nelem;
+			vattr[i].data = m.vattr[i].data;	// copy the actual data
+			vattr[i].data_valid = true;
+		}
+	}
+
+	if(m.is_indexed()) {
+		m.get_index_data();		// again, force validation
+
+		// copy the index data
+		idata = m.idata;
+		idata_valid = true;
+	}
+
+	name = m.name;
+	nverts = m.nverts;
+	nfaces = m.nfaces;
+
+	//bones = m.bones;
+
+	memcpy(cur_val, m.cur_val, sizeof cur_val);
+
+	aabb = m.aabb;
+	aabb_valid = m.aabb_valid;
+	bsph = m.bsph;
+	bsph_valid = m.bsph_valid;
+
+	hitface = m.hitface;
+	hitvert = m.hitvert;
+
+	intersect_mode = m.intersect_mode;
+	vertex_sel_dist = m.vertex_sel_dist;
+	vis_vecsize = m.vis_vecsize;
+
+	return true;
+}
+
+void Mesh::set_name(const char *name)
+{
+	this->name = name;
+}
+
+const char *Mesh::get_name() const
+{
+	return name.c_str();
+}
+
+bool Mesh::has_attrib(int attr) const
+{
+	if(attr < 0 || attr >= NUM_MESH_ATTR) {
+		return false;
+	}
+
+	// if neither of these is valid, then nobody has set this attribute
+	return vattr[attr].vbo_valid || vattr[attr].data_valid;
+}
+
+bool Mesh::is_indexed() const
+{
+	return ibo_valid || idata_valid;
+}
+
+void Mesh::clear()
+{
+	//bones.clear();
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		vattr[i].nelem = 0;
+		vattr[i].vbo_valid = false;
+		vattr[i].data_valid = false;
+		//vattr[i].sdr_loc = -1;
+		vattr[i].data.clear();
+	}
+	ibo_valid = idata_valid = false;
+	idata.clear();
+
+	wire_ibo_valid = false;
+
+	nverts = nfaces = 0;
+
+	bsph_valid = false;
+	aabb_valid = false;
+}
+
+float *Mesh::set_attrib_data(int attrib, int nelem, unsigned int num, const float *data)
+{
+	if(attrib < 0 || attrib >= NUM_MESH_ATTR) {
+		fprintf(stderr, "%s: invalid attrib: %d\n", __FUNCTION__, attrib);
+		return 0;
+	}
+
+	if(nverts && num != nverts) {
+		fprintf(stderr, "%s: attribute count missmatch (%d instead of %d)\n", __FUNCTION__, num, nverts);
+		return 0;
+	}
+	nverts = num;
+
+	vattr[attrib].data.clear();
+	vattr[attrib].nelem = nelem;
+	vattr[attrib].data.resize(num * nelem);
+
+	if(data) {
+		memcpy(&vattr[attrib].data[0], data, num * nelem * sizeof *data);
+	}
+
+	vattr[attrib].data_valid = true;
+	vattr[attrib].vbo_valid = false;
+	return &vattr[attrib].data[0];
+}
+
+float *Mesh::get_attrib_data(int attrib)
+{
+	if(attrib < 0 || attrib >= NUM_MESH_ATTR) {
+		fprintf(stderr, "%s: invalid attrib: %d\n", __FUNCTION__, attrib);
+		return 0;
+	}
+
+	vattr[attrib].vbo_valid = false;
+	return (float*)((const Mesh*)this)->get_attrib_data(attrib);
+}
+
+const float *Mesh::get_attrib_data(int attrib) const
+{
+	if(attrib < 0 || attrib >= NUM_MESH_ATTR) {
+		fprintf(stderr, "%s: invalid attrib: %d\n", __FUNCTION__, attrib);
+		return 0;
+	}
+
+	if(!vattr[attrib].data_valid) {
+#if GL_ES_VERSION_2_0
+		fprintf(stderr, "%s: can't read back attrib data on CrippledGL ES\n", __FUNCTION__);
+		return 0;
+#else
+		if(!vattr[attrib].vbo_valid) {
+			fprintf(stderr, "%s: unavailable attrib: %d\n", __FUNCTION__, attrib);
+			return 0;
+		}
+
+		// local data copy is unavailable, grab the data from the vbo
+		Mesh *m = (Mesh*)this;
+		m->vattr[attrib].data.resize(nverts * vattr[attrib].nelem);
+
+		glBindBuffer(GL_ARRAY_BUFFER, vattr[attrib].vbo);
+		void *data = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
+		memcpy(&m->vattr[attrib].data[0], data, nverts * vattr[attrib].nelem * sizeof(float));
+		glUnmapBuffer(GL_ARRAY_BUFFER);
+
+		vattr[attrib].data_valid = true;
+#endif
+	}
+
+	return &vattr[attrib].data[0];
+}
+
+void Mesh::set_attrib(int attrib, int idx, const Vector4 &v)
+{
+	float *data = get_attrib_data(attrib);
+	if(data) {
+		data += idx * vattr[attrib].nelem;
+		for(int i=0; i<vattr[attrib].nelem; i++) {
+			data[i] = v[i];
+		}
+	}
+}
+
+Vector4 Mesh::get_attrib(int attrib, int idx) const
+{
+	Vector4 v(0.0, 0.0, 0.0, 1.0);
+	const float *data = get_attrib_data(attrib);
+	if(data) {
+		data += idx * vattr[attrib].nelem;
+		for(int i=0; i<vattr[attrib].nelem; i++) {
+			v[i] = data[i];
+		}
+	}
+	return v;
+}
+
+int Mesh::get_attrib_count(int attrib) const
+{
+	return has_attrib(attrib) ? nverts : 0;
+}
+
+
+unsigned int *Mesh::set_index_data(int num, const unsigned int *indices)
+{
+	int nidx = nfaces * 3;
+	if(nidx && num != nidx) {
+		fprintf(stderr, "%s: index count missmatch (%d instead of %d)\n", __FUNCTION__, num, nidx);
+		return 0;
+	}
+	nfaces = num / 3;
+
+	idata.clear();
+	idata.resize(num);
+
+	if(indices) {
+		memcpy(&idata[0], indices, num * sizeof *indices);
+	}
+
+	idata_valid = true;
+	ibo_valid = false;
+
+	return &idata[0];
+}
+
+unsigned int *Mesh::get_index_data()
+{
+	ibo_valid = false;
+	return (unsigned int*)((const Mesh*)this)->get_index_data();
+}
+
+const unsigned int *Mesh::get_index_data() const
+{
+	if(!idata_valid) {
+#if GL_ES_VERSION_2_0
+		fprintf(stderr, "%s: can't read back index data in CrippledGL ES\n", __FUNCTION__);
+		return 0;
+#else
+		if(!ibo_valid) {
+			fprintf(stderr, "%s: indices unavailable\n", __FUNCTION__);
+			return 0;
+		}
+
+		// local data copy is unavailable, gram the data from the ibo
+		Mesh *m = (Mesh*)this;
+		int nidx = nfaces * 3;
+		m->idata.resize(nidx);
+
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
+		void *data = glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
+		memcpy(&m->idata[0], data, nidx * sizeof(unsigned int));
+		glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
+
+		idata_valid = true;
+#endif
+	}
+
+	return &idata[0];
+}
+
+int Mesh::get_index_count() const
+{
+	return nfaces * 3;
+}
+
+void Mesh::append(const Mesh &mesh)
+{
+	unsigned int idxoffs = nverts;
+
+	nverts += mesh.nverts;
+	nfaces += mesh.nfaces;
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		if(has_attrib(i) && mesh.has_attrib(i)) {
+			// force validating the data arrays
+			get_attrib_data(i);
+			mesh.get_attrib_data(i);
+
+			// append the mesh data
+			vattr[i].data.insert(vattr[i].data.end(), mesh.vattr[i].data.begin(), mesh.vattr[i].data.end());
+		}
+	}
+
+	if(ibo_valid || idata_valid) {
+		// make index arrays valid
+		get_index_data();
+		mesh.get_index_data();
+
+		size_t orig_sz = idata.size();
+
+		idata.insert(idata.end(), mesh.idata.begin(), mesh.idata.end());
+
+		// fixup all the new indices
+		for(size_t i=orig_sz; i<idata.size(); i++) {
+			idata[i] += idxoffs;
+		}
+	}
+
+	// fuck everything
+	wire_ibo_valid = false;
+	aabb_valid = false;
+	bsph_valid = false;
+}
+
+// assemble a complete vertex by adding all the useful attributes
+void Mesh::vertex(float x, float y, float z)
+{
+	cur_val[MESH_ATTR_VERTEX] = Vector4(x, y, z, 1.0f);
+	vattr[MESH_ATTR_VERTEX].data_valid = true;
+	vattr[MESH_ATTR_VERTEX].nelem = 3;
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		if(vattr[i].data_valid) {
+			for(int j=0; j<vattr[MESH_ATTR_VERTEX].nelem; j++) {
+				vattr[i].data.push_back(cur_val[i][j]);
+			}
+		}
+		vattr[i].vbo_valid = false;
+	}
+
+	if(idata_valid) {
+		idata.clear();
+	}
+	ibo_valid = idata_valid = false;
+}
+
+void Mesh::normal(float nx, float ny, float nz)
+{
+	cur_val[MESH_ATTR_NORMAL] = Vector4(nx, ny, nz, 1.0f);
+	vattr[MESH_ATTR_NORMAL].data_valid = true;
+	vattr[MESH_ATTR_NORMAL].nelem = 3;
+}
+
+void Mesh::tangent(float tx, float ty, float tz)
+{
+	cur_val[MESH_ATTR_TANGENT] = Vector4(tx, ty, tz, 1.0f);
+	vattr[MESH_ATTR_TANGENT].data_valid = true;
+	vattr[MESH_ATTR_TANGENT].nelem = 3;
+}
+
+void Mesh::texcoord(float u, float v, float w)
+{
+	cur_val[MESH_ATTR_TEXCOORD] = Vector4(u, v, w, 1.0f);
+	vattr[MESH_ATTR_TEXCOORD].data_valid = true;
+	vattr[MESH_ATTR_TEXCOORD].nelem = 3;
+}
+
+void Mesh::boneweights(float w1, float w2, float w3, float w4)
+{
+	cur_val[MESH_ATTR_BONEWEIGHTS] = Vector4(w1, w2, w3, w4);
+	vattr[MESH_ATTR_BONEWEIGHTS].data_valid = true;
+	vattr[MESH_ATTR_BONEWEIGHTS].nelem = 4;
+}
+
+void Mesh::boneidx(int idx1, int idx2, int idx3, int idx4)
+{
+	cur_val[MESH_ATTR_BONEIDX] = Vector4(idx1, idx2, idx3, idx4);
+	vattr[MESH_ATTR_BONEIDX].data_valid = true;
+	vattr[MESH_ATTR_BONEIDX].nelem = 4;
+}
+
+int Mesh::get_poly_count() const
+{
+	if(nfaces) {
+		return nfaces;
+	}
+	if(nverts) {
+		return nverts / 3;
+	}
+	return 0;
+}
+
+/// static function
+void Mesh::set_attrib_location(int attr, int loc)
+{
+	if(attr < 0 || attr >= NUM_MESH_ATTR) {
+		return;
+	}
+	Mesh::global_sdr_loc[attr] = loc;
+}
+
+/// static function
+int Mesh::get_attrib_location(int attr)
+{
+	if(attr < 0 || attr >= NUM_MESH_ATTR) {
+		return -1;
+	}
+	return Mesh::global_sdr_loc[attr];
+}
+
+/// static function
+void Mesh::clear_attrib_locations()
+{
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		Mesh::global_sdr_loc[i] = -1;
+	}
+}
+
+/// static function
+void Mesh::set_vis_vecsize(float sz)
+{
+	Mesh::vis_vecsize = sz;
+}
+
+float Mesh::get_vis_vecsize()
+{
+	return Mesh::vis_vecsize;
+}
+
+void Mesh::apply_xform(const Matrix4x4 &xform)
+{
+	Matrix4x4 dir_xform = xform;
+	dir_xform[0][3] = dir_xform[1][3] = dir_xform[2][3] = 0.0f;
+	dir_xform[3][0] = dir_xform[3][1] = dir_xform[3][2] = 0.0f;
+	dir_xform[3][3] = 1.0f;
+
+	apply_xform(xform, dir_xform);
+}
+
+void Mesh::apply_xform(const Matrix4x4 &xform, const Matrix4x4 &dir_xform)
+{
+	for(unsigned int i=0; i<nverts; i++) {
+		Vector4 v = get_attrib(MESH_ATTR_VERTEX, i);
+		set_attrib(MESH_ATTR_VERTEX, i, v.transformed(xform));
+
+		if(has_attrib(MESH_ATTR_NORMAL)) {
+			Vector3 n = get_attrib(MESH_ATTR_NORMAL, i);
+			set_attrib(MESH_ATTR_NORMAL, i, n.transformed(dir_xform));
+		}
+		if(has_attrib(MESH_ATTR_TANGENT)) {
+			Vector3 t = get_attrib(MESH_ATTR_TANGENT, i);
+			set_attrib(MESH_ATTR_TANGENT, i, t.transformed(dir_xform));
+		}
+	}
+}
+
+void Mesh::flip()
+{
+	flip_faces();
+	flip_normals();
+}
+
+void Mesh::flip_faces()
+{
+	if(is_indexed()) {
+		unsigned int *indices = get_index_data();
+		if(!indices) return;
+
+		int idxnum = get_index_count();
+		for(int i=0; i<idxnum; i+=3) {
+			unsigned int tmp = indices[i + 2];
+			indices[i + 2] = indices[i + 1];
+			indices[i + 1] = tmp;
+		}
+
+	} else {
+		Vector3 *verts = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
+		if(!verts) return;
+
+		int vnum = get_attrib_count(MESH_ATTR_VERTEX);
+		for(int i=0; i<vnum; i+=3) {
+			Vector3 tmp = verts[i + 2];
+			verts[i + 2] = verts[i + 1];
+			verts[i + 1] = tmp;
+		}
+	}
+}
+
+void Mesh::flip_normals()
+{
+	Vector3 *normals = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);
+	if(!normals) return;
+
+	int num = get_attrib_count(MESH_ATTR_NORMAL);
+	for(int i=0; i<num; i++) {
+		normals[i] = -normals[i];
+	}
+}
+
+/*
+int Mesh::add_bone(XFormNode *bone)
+{
+	int idx = bones.size();
+	bones.push_back(bone);
+	return idx;
+}
+
+const XFormNode *Mesh::get_bone(int idx) const
+{
+	if(idx < 0 || idx >= (int)bones.size()) {
+		return 0;
+	}
+	return bones[idx];
+}
+
+int Mesh::get_bones_count() const
+{
+	return (int)bones.size();
+}
+*/
+
+void Mesh::draw() const
+{
+#ifdef GL_ES_VERSION_2_0
+	if(!SdrProg::active) {
+		fprintf(stderr, "%s: CrippledGL ES can't draw without a shader\n", __FUNCTION__);
+		return;
+	}
+#endif
+
+	((Mesh*)this)->update_buffers();
+
+	if(!vattr[MESH_ATTR_VERTEX].vbo_valid) {
+		fprintf(stderr, "%s: invalid vertex buffer\n", __FUNCTION__);
+		return;
+	}
+
+	if(SdrProg::active) {
+		// rendering with shaders
+		if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
+			fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);
+			return;
+		}
+
+		for(int i=0; i<NUM_MESH_ATTR; i++) {
+			int loc = global_sdr_loc[i];
+			if(loc >= 0 && vattr[i].vbo_valid) {
+				glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
+				glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
+				glEnableVertexAttribArray(loc);
+			}
+		}
+	} else {
+#ifndef GL_ES_VERSION_2_0
+		// rendering with fixed-function (not available in GLES2)
+		glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_VERTEX].vbo);
+		glVertexPointer(vattr[MESH_ATTR_VERTEX].nelem, GL_FLOAT, 0, 0);
+		glEnableClientState(GL_VERTEX_ARRAY);
+
+		if(vattr[MESH_ATTR_NORMAL].vbo_valid) {
+			glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_NORMAL].vbo);
+			glNormalPointer(GL_FLOAT, 0, 0);
+			glEnableClientState(GL_NORMAL_ARRAY);
+		}
+		if(vattr[MESH_ATTR_TEXCOORD].vbo_valid) {
+			glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_TEXCOORD].vbo);
+			glTexCoordPointer(vattr[MESH_ATTR_TEXCOORD].nelem, GL_FLOAT, 0, 0);
+			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
+		}
+		if(vattr[MESH_ATTR_COLOR].vbo_valid) {
+			glBindBuffer(GL_ARRAY_BUFFER, vattr[MESH_ATTR_COLOR].vbo);
+			glColorPointer(vattr[MESH_ATTR_COLOR].nelem, GL_FLOAT, 0, 0);
+			glEnableClientState(GL_COLOR_ARRAY);
+		}
+#endif
+	}
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	if(ibo_valid) {
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
+		glDrawElements(GL_TRIANGLES, nfaces * 3, GL_UNSIGNED_INT, 0);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+	} else {
+		glDrawArrays(GL_TRIANGLES, 0, nverts);
+	}
+
+	if(SdrProg::active) {
+		// rendered with shaders
+		for(int i=0; i<NUM_MESH_ATTR; i++) {
+			int loc = global_sdr_loc[i];
+			if(loc >= 0 && vattr[i].vbo_valid) {
+				glDisableVertexAttribArray(loc);
+			}
+		}
+	} else {
+#ifndef GL_ES_VERSION_2_0
+		// rendered with fixed-function
+		glDisableClientState(GL_VERTEX_ARRAY);
+		if(vattr[MESH_ATTR_NORMAL].vbo_valid) {
+			glDisableClientState(GL_NORMAL_ARRAY);
+		}
+		if(vattr[MESH_ATTR_TEXCOORD].vbo_valid) {
+			glDisableClientState(GL_TEXTURE_COORD_ARRAY);
+		}
+		if(vattr[MESH_ATTR_COLOR].vbo_valid) {
+			glDisableClientState(GL_COLOR_ARRAY);
+		}
+#endif
+	}
+}
+
+void Mesh::draw_wire() const
+{
+	((Mesh*)this)->update_wire_ibo();
+
+	if(!vattr[MESH_ATTR_VERTEX].vbo_valid || !wire_ibo_valid) {
+		fprintf(stderr, "%s: invalid vertex buffer\n", __FUNCTION__);
+		return;
+	}
+	if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
+		fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);
+		return;
+	}
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		int loc = global_sdr_loc[i];
+		if(loc >= 0 && vattr[i].vbo_valid) {
+			glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
+			glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
+			glEnableVertexAttribArray(loc);
+		}
+	}
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);
+	glDrawElements(GL_LINES, nfaces * 6, GL_UNSIGNED_INT, 0);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		int loc = global_sdr_loc[i];
+		if(loc >= 0 && vattr[i].vbo_valid) {
+			glDisableVertexAttribArray(loc);
+		}
+	}
+}
+
+void Mesh::draw_vertices() const
+{
+	((Mesh*)this)->update_buffers();
+
+	if(!vattr[MESH_ATTR_VERTEX].vbo_valid) {
+		fprintf(stderr, "%s: invalid vertex buffer\n", __FUNCTION__);
+		return;
+	}
+	if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
+		fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);
+		return;
+	}
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		int loc = global_sdr_loc[i];
+		if(loc >= 0 && vattr[i].vbo_valid) {
+			glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
+			glVertexAttribPointer(loc, vattr[i].nelem, GL_FLOAT, GL_FALSE, 0, 0);
+			glEnableVertexAttribArray(loc);
+		}
+	}
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	glDrawArrays(GL_POINTS, 0, nverts);
+
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		int loc = global_sdr_loc[i];
+		if(loc >= 0 && vattr[i].vbo_valid) {
+			glDisableVertexAttribArray(loc);
+		}
+	}
+}
+
+void Mesh::draw_normals() const
+{
+#ifdef USE_OLDGL
+	Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
+	Vector3 *norm = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);
+	if(!varr || !norm) {
+		return;
+	}
+
+	glBegin(GL_LINES);
+	if(get_current_shader()) {
+		int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];
+		if(vert_loc < 0) {
+			glEnd();
+			return;
+		}
+
+		for(size_t i=0; i<nverts; i++) {
+			glVertexAttrib3f(vert_loc, varr[i].x, varr[i].y, varr[i].z);
+			Vector3 end = varr[i] + norm[i] * vis_vecsize;
+			glVertexAttrib3f(vert_loc, end.x, end.y, end.z);
+		}
+	} else {
+		for(size_t i=0; i<nverts; i++) {
+			glVertex3f(varr[i].x, varr[i].y, varr[i].z);
+			Vector3 end = varr[i] + norm[i] * vis_vecsize;
+			glVertex3f(end.x, end.y, end.z);
+		}
+	}
+	glEnd();
+#endif	// USE_OLDGL
+}
+
+void Mesh::draw_tangents() const
+{
+#ifdef USE_OLDGL
+	Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
+	Vector3 *tang = (Vector3*)get_attrib_data(MESH_ATTR_TANGENT);
+	if(!varr || !tang) {
+		return;
+	}
+
+	glBegin(GL_LINES);
+	if(get_current_shader()) {
+		int vert_loc = global_sdr_loc[MESH_ATTR_VERTEX];
+		if(vert_loc < 0) {
+			glEnd();
+			return;
+		}
+
+		for(size_t i=0; i<nverts; i++) {
+			glVertexAttrib3f(vert_loc, varr[i].x, varr[i].y, varr[i].z);
+			Vector3 end = varr[i] + tang[i] * vis_vecsize;
+			glVertexAttrib3f(vert_loc, end.x, end.y, end.z);
+		}
+	} else {
+		for(size_t i=0; i<nverts; i++) {
+			glVertex3f(varr[i].x, varr[i].y, varr[i].z);
+			Vector3 end = varr[i] + tang[i] * vis_vecsize;
+			glVertex3f(end.x, end.y, end.z);
+		}
+	}
+	glEnd();
+#endif	// USE_OLDGL
+}
+
+void Mesh::get_aabbox(Vector3 *vmin, Vector3 *vmax) const
+{
+	if(!aabb_valid) {
+		((Mesh*)this)->calc_aabb();
+	}
+	*vmin = aabb.min;
+	*vmax = aabb.max;
+}
+
+const AABox &Mesh::get_aabbox() const
+{
+	if(!aabb_valid) {
+		((Mesh*)this)->calc_aabb();
+	}
+	return aabb;
+}
+
+float Mesh::get_bsphere(Vector3 *center, float *rad) const
+{
+	if(!bsph_valid) {
+		((Mesh*)this)->calc_bsph();
+	}
+	*center = bsph.center;
+	*rad = bsph.radius;
+	return bsph.radius;
+}
+
+const Sphere &Mesh::get_bsphere() const
+{
+	if(!bsph_valid) {
+		((Mesh*)this)->calc_bsph();
+	}
+	return bsph;
+}
+
+/// static function
+void Mesh::set_intersect_mode(unsigned int mode)
+{
+	Mesh::intersect_mode = mode;
+}
+
+/// static function
+unsigned int Mesh::get_intersect_mode()
+{
+	return Mesh::intersect_mode;
+}
+
+/// static function
+void Mesh::set_vertex_select_distance(float dist)
+{
+	Mesh::vertex_sel_dist = dist;
+}
+
+/// static function
+float Mesh::get_vertex_select_distance()
+{
+	return Mesh::vertex_sel_dist;
+}
+
+bool Mesh::intersect(const Ray &ray, HitPoint *hit) const
+{
+	assert((Mesh::intersect_mode & (ISECT_VERTICES | ISECT_FACE)) != (ISECT_VERTICES | ISECT_FACE));
+
+	const Vector3 *varr = (Vector3*)get_attrib_data(MESH_ATTR_VERTEX);
+	const Vector3 *narr = (Vector3*)get_attrib_data(MESH_ATTR_NORMAL);
+	if(!varr) {
+		return false;
+	}
+	const unsigned int *idxarr = get_index_data();
+
+	// first test with the bounding box
+	AABox box;
+	get_aabbox(&box.min, &box.max);
+	if(!box.intersect(ray)) {
+		return false;
+	}
+
+	HitPoint nearest_hit;
+	nearest_hit.dist = FLT_MAX;
+	nearest_hit.obj = 0;
+
+	if(Mesh::intersect_mode & ISECT_VERTICES) {
+		// we asked for "intersections" with the vertices of the mesh
+		long nearest_vidx = -1;
+		float thres_sq = Mesh::vertex_sel_dist * Mesh::vertex_sel_dist;
+
+		for(unsigned int i=0; i<nverts; i++) {
+
+			if((Mesh::intersect_mode & ISECT_FRONT) && dot_product(narr[i], ray.dir) > 0) {
+				continue;
+			}
+
+			// project the vertex onto the ray line
+			float t = dot_product(varr[i] - ray.origin, ray.dir);
+			Vector3 vproj = ray.origin + ray.dir * t;
+
+			float dist_sq = (vproj - varr[i]).length_sq();
+			if(dist_sq < thres_sq) {
+				if(!hit) {
+					return true;
+				}
+				if(t < nearest_hit.dist) {
+					nearest_hit.dist = t;
+					nearest_vidx = i;
+				}
+			}
+		}
+
+		if(nearest_vidx != -1) {
+			hitvert = varr[nearest_vidx];
+			nearest_hit.obj = &hitvert;
+		}
+
+	} else {
+		// regular intersection test with polygons
+
+		for(unsigned int i=0; i<nfaces; i++) {
+			Triangle face(i, varr, idxarr);
+
+			// ignore back-facing polygons if the mode flags include ISECT_FRONT
+			if((Mesh::intersect_mode & ISECT_FRONT) && dot_product(face.get_normal(), ray.dir) > 0) {
+				continue;
+			}
+
+			HitPoint fhit;
+			if(face.intersect(ray, hit ? &fhit : 0)) {
+				if(!hit) {
+					return true;
+				}
+				if(fhit.dist < nearest_hit.dist) {
+					nearest_hit = fhit;
+					hitface = face;
+				}
+			}
+		}
+	}
+
+	if(nearest_hit.obj) {
+		if(hit) {
+			*hit = nearest_hit;
+
+			// if we are interested in the mesh and not the faces set obj to this
+			if(Mesh::intersect_mode & ISECT_FACE) {
+				hit->obj = &hitface;
+			} else if(Mesh::intersect_mode & ISECT_VERTICES) {
+				hit->obj = &hitvert;
+			} else {
+				hit->obj = this;
+			}
+		}
+		return true;
+	}
+	return false;
+}
+
+
+// ------ private member functions ------
+
+void Mesh::calc_aabb()
+{
+	// the cast is to force calling the const version which doesn't invalidate
+	if(!((const Mesh*)this)->get_attrib_data(MESH_ATTR_VERTEX)) {
+		return;
+	}
+
+	aabb.min = Vector3(FLT_MAX, FLT_MAX, FLT_MAX);
+	aabb.max = -aabb.min;
+
+	for(unsigned int i=0; i<nverts; i++) {
+		Vector4 v = get_attrib(MESH_ATTR_VERTEX, i);
+		for(int j=0; j<3; j++) {
+			if(v[j] < aabb.min[j]) {
+				aabb.min[j] = v[j];
+			}
+			if(v[j] > aabb.max[j]) {
+				aabb.max[j] = v[j];
+			}
+		}
+	}
+	aabb_valid = true;
+}
+
+void Mesh::calc_bsph()
+{
+	// the cast is to force calling the const version which doesn't invalidate
+	if(!((const Mesh*)this)->get_attrib_data(MESH_ATTR_VERTEX)) {
+		return;
+	}
+
+	Vector3 v;
+	bsph.center = Vector3(0, 0, 0);
+
+	// first find the center
+	for(unsigned int i=0; i<nverts; i++) {
+		v = get_attrib(MESH_ATTR_VERTEX, i);
+		bsph.center += v;
+	}
+	bsph.center /= (float)nverts;
+
+	bsph.radius = 0.0f;
+	for(unsigned int i=0; i<nverts; i++) {
+		v = get_attrib(MESH_ATTR_VERTEX, i);
+		float dist_sq = (v - bsph.center).length_sq();
+		if(dist_sq > bsph.radius) {
+			bsph.radius = dist_sq;
+		}
+	}
+	bsph.radius = sqrt(bsph.radius);
+
+	bsph_valid = true;
+}
+
+void Mesh::update_buffers()
+{
+	for(int i=0; i<NUM_MESH_ATTR; i++) {
+		if(has_attrib(i) && !vattr[i].vbo_valid) {
+			glBindBuffer(GL_ARRAY_BUFFER, vattr[i].vbo);
+			glBufferData(GL_ARRAY_BUFFER, nverts * vattr[i].nelem * sizeof(float), &vattr[i].data[0], GL_STATIC_DRAW);
+			vattr[i].vbo_valid = true;
+		}
+	}
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	if(idata_valid && !ibo_valid) {
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
+		glBufferData(GL_ELEMENT_ARRAY_BUFFER, nfaces * 3 * sizeof(unsigned int), &idata[0], GL_STATIC_DRAW);
+		ibo_valid = true;
+	}
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+
+void Mesh::update_wire_ibo()
+{
+	update_buffers();
+
+	if(wire_ibo_valid) {
+		return;
+	}
+
+	if(!wire_ibo) {
+		glGenBuffers(1, &wire_ibo);
+	}
+
+	unsigned int *wire_idxarr = new unsigned int[nfaces * 6];
+	unsigned int *dest = wire_idxarr;
+
+	if(ibo_valid) {
+		// we're dealing with an indexed mesh
+		const unsigned int *idxarr = ((const Mesh*)this)->get_index_data();
+
+		for(unsigned int i=0; i<nfaces; i++) {
+			*dest++ = idxarr[0];
+			*dest++ = idxarr[1];
+			*dest++ = idxarr[1];
+			*dest++ = idxarr[2];
+			*dest++ = idxarr[2];
+			*dest++ = idxarr[0];
+			idxarr += 3;
+		}
+	} else {
+		// not an indexed mesh ...
+		for(unsigned int i=0; i<nfaces; i++) {
+			int vidx = i * 3;
+			*dest++ = vidx;
+			*dest++ = vidx + 1;
+			*dest++ = vidx + 1;
+			*dest++ = vidx + 2;
+			*dest++ = vidx + 2;
+			*dest++ = vidx;
+		}
+	}
+
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, wire_ibo);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER, nfaces * 6 * sizeof(unsigned int), wire_idxarr, GL_STATIC_DRAW);
+	delete [] wire_idxarr;
+	wire_ibo_valid = true;
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+}
+
+
+// ------ class Triangle ------
+Triangle::Triangle()
+{
+	normal_valid = false;
+	id = -1;
+}
+
+Triangle::Triangle(const Vector3 &v0, const Vector3 &v1, const Vector3 &v2)
+{
+	v[0] = v0;
+	v[1] = v1;
+	v[2] = v2;
+	normal_valid = false;
+	id = -1;
+}
+
+Triangle::Triangle(int n, const Vector3 *varr, const unsigned int *idxarr)
+{
+	if(idxarr) {
+		v[0] = varr[idxarr[n * 3]];
+		v[1] = varr[idxarr[n * 3 + 1]];
+		v[2] = varr[idxarr[n * 3 + 2]];
+	} else {
+		v[0] = varr[n * 3];
+		v[1] = varr[n * 3 + 1];
+		v[2] = varr[n * 3 + 2];
+	}
+	normal_valid = false;
+	id = n;
+}
+
+void Triangle::calc_normal()
+{
+	normal = cross_product(v[1] - v[0], v[2] - v[0]).normalized();
+	normal_valid = true;
+}
+
+const Vector3 &Triangle::get_normal() const
+{
+	if(!normal_valid) {
+		((Triangle*)this)->calc_normal();
+	}
+	return normal;
+}
+
+void Triangle::transform(const Matrix4x4 &xform)
+{
+	v[0].transform(xform);
+	v[1].transform(xform);
+	v[2].transform(xform);
+	normal_valid = false;
+}
+
+void Triangle::draw() const
+{
+	Vector3 n[3];
+	n[0] = get_normal();
+	n[1] = get_normal();
+	n[2] = get_normal();
+
+	int vloc = Mesh::get_attrib_location(MESH_ATTR_VERTEX);
+	int nloc = Mesh::get_attrib_location(MESH_ATTR_NORMAL);
+
+	glEnableVertexAttribArray(vloc);
+	glVertexAttribPointer(vloc, 3, GL_FLOAT, GL_FALSE, 0, &v[0].x);
+	glVertexAttribPointer(nloc, 3, GL_FLOAT, GL_FALSE, 0, &n[0].x);
+
+	glDrawArrays(GL_TRIANGLES, 0, 3);
+
+	glDisableVertexAttribArray(vloc);
+	glDisableVertexAttribArray(nloc);
+	CHECK_GLERROR;
+}
+
+void Triangle::draw_wire() const
+{
+	static const int idxarr[] = {0, 1, 1, 2, 2, 0};
+	int vloc = Mesh::get_attrib_location(MESH_ATTR_VERTEX);
+
+	glEnableVertexAttribArray(vloc);
+	glVertexAttribPointer(vloc, 3, GL_FLOAT, GL_FALSE, 0, &v[0].x);
+
+	glDrawElements(GL_LINES, 6, GL_UNSIGNED_INT, idxarr);
+
+	glDisableVertexAttribArray(vloc);
+	CHECK_GLERROR;
+}
+
+Vector3 Triangle::calc_barycentric(const Vector3 &pos) const
+{
+	Vector3 norm = get_normal();
+
+	float area_sq = fabs(dot_product(cross_product(v[1] - v[0], v[2] - v[0]), norm));
+	if(area_sq < 1e-5) {
+		return Vector3(0, 0, 0);
+	}
+
+	float asq0 = fabs(dot_product(cross_product(v[1] - pos, v[2] - pos), norm));
+	float asq1 = fabs(dot_product(cross_product(v[2] - pos, v[0] - pos), norm));
+	float asq2 = fabs(dot_product(cross_product(v[0] - pos, v[1] - pos), norm));
+
+	return Vector3(asq0 / area_sq, asq1 / area_sq, asq2 / area_sq);
+}
+
+bool Triangle::intersect(const Ray &ray, HitPoint *hit) const
+{
+	Vector3 normal = get_normal();
+
+	float ndotdir = dot_product(ray.dir, normal);
+	if(fabs(ndotdir) < 1e-4) {
+		return false;
+	}
+
+	Vector3 vertdir = v[0] - ray.origin;
+	float t = dot_product(normal, vertdir) / ndotdir;
+
+	Vector3 pos = ray.origin + ray.dir * t;
+	Vector3 bary = calc_barycentric(pos);
+
+	if(bary.x + bary.y + bary.z > 1.00001) {
+		return false;
+	}
+
+	if(hit) {
+		hit->dist = t;
+		hit->pos = ray.origin + ray.dir * t;
+		hit->normal = normal;
+		hit->obj = this;
+	}
+	return true;
+}
diff -r 000000000000 -r 52e0dd47753b src/mesh.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/mesh.h	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,225 @@
+#ifndef MESH_H_
+#define MESH_H_
+
+#include <string>
+#include <vector>
+#include "vmath/vmath.h"
+#include "geom.h"
+
+enum {
+	MESH_ATTR_VERTEX,
+	MESH_ATTR_NORMAL,
+	MESH_ATTR_TANGENT,
+	MESH_ATTR_TEXCOORD,
+	MESH_ATTR_COLOR,
+	MESH_ATTR_BONEWEIGHTS,
+	MESH_ATTR_BONEIDX,
+
+	NUM_MESH_ATTR
+};
+
+// intersection mode flags
+enum {
+	ISECT_DEFAULT	= 0,	// default (whole mesh, all intersections)
+	ISECT_FRONT		= 1,	// front-faces only
+	ISECT_FACE		= 2,	// return intersected face pointer instead of mesh
+	ISECT_VERTICES	= 4		// return (?) TODO
+};
+
+//class XFormNode;
+
+
+class Triangle {
+public:
+	Vector3 v[3];
+	Vector3 normal;
+	bool normal_valid;
+	int id;
+
+	Triangle();
+	Triangle(const Vector3 &v0, const Vector3 &v1, const Vector3 &v2);
+	Triangle(int n, const Vector3 *varr, const unsigned int *idxarr = 0);
+
+	/// calculate normal (quite expensive)
+	void calc_normal();
+	const Vector3 &get_normal() const;
+
+	void transform(const Matrix4x4 &xform);
+
+	void draw() const;
+	void draw_wire() const;
+
+	/// calculate barycentric coordinates of a point
+	Vector3 calc_barycentric(const Vector3 &pos) const;
+
+	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
+};
+
+
+class Mesh {
+private:
+	std::string name;
+	unsigned int nverts, nfaces;
+
+	// current value for each attribute for the immedate mode
+	// interface.
+	Vector4 cur_val[NUM_MESH_ATTR];
+
+	unsigned int buffer_objects[NUM_MESH_ATTR + 1];
+
+	// vertex attribute data and buffer objects
+	struct {
+		int nelem;					// number of elements per attribute range: [1, 4]
+		std::vector<float> data;
+		unsigned int vbo;
+		mutable bool vbo_valid;		// if this is false, the vbo needs updating from the data
+		mutable bool data_valid;	// if this is false, the data needs to be pulled from the vbo
+		//int sdr_loc;
+	} vattr[NUM_MESH_ATTR];
+
+	static int global_sdr_loc[NUM_MESH_ATTR];
+
+	//std::vector<XFormNode*> bones;	// bones affecting this mesh
+
+	// index data and buffer object
+	std::vector<unsigned int> idata;
+	unsigned int ibo;
+	mutable bool ibo_valid;
+	mutable bool idata_valid;
+
+	// index buffer object for wireframe rendering (constructed on demand)
+	unsigned int wire_ibo;
+	mutable bool wire_ibo_valid;
+
+	// axis-aligned bounding box
+	mutable AABox aabb;
+	mutable bool aabb_valid;
+
+	// bounding sphere
+	mutable Sphere bsph;
+	mutable bool bsph_valid;
+
+	// keeps the last intersected face
+	mutable Triangle hitface;
+	// keeps the last intersected vertex position
+	mutable Vector3 hitvert;
+
+	void calc_aabb();
+	void calc_bsph();
+
+	static unsigned int intersect_mode;
+	static float vertex_sel_dist;
+
+	static float vis_vecsize;
+
+	/// update the VBOs after data has changed (invalid vbo/ibo)
+	void update_buffers();
+	/// construct/update the wireframe index buffer (called from draw_wire).
+	void update_wire_ibo();
+
+
+public:
+	Mesh();
+	~Mesh();
+
+	Mesh(const Mesh &rhs);
+	Mesh &operator =(const Mesh &rhs);
+	bool clone(const Mesh &m);
+
+	void set_name(const char *name);
+	const char *get_name() const;
+
+	bool has_attrib(int attr) const;
+	bool is_indexed() const;
+
+	// clears everything about this mesh, and returns to the newly constructed state
+	void clear();
+
+	// access the vertex attribute data
+	// if vdata == 0, space is just allocated
+	float *set_attrib_data(int attrib, int nelem, unsigned int num, const float *vdata = 0); // invalidates vbo
+	float *get_attrib_data(int attrib);	// invalidates vbo
+	const float *get_attrib_data(int attrib) const;
+
+	// simple access to any particular attribute
+	void set_attrib(int attrib, int idx, const Vector4 &v); // invalidates vbo
+	Vector4 get_attrib(int attrib, int idx) const;
+
+	int get_attrib_count(int attrib) const;
+
+	// ... same for index data
+	unsigned int *set_index_data(int num, const unsigned int *indices = 0); // invalidates ibo
+	unsigned int *get_index_data();	// invalidates ibo
+	const unsigned int *get_index_data() const;
+
+	int get_index_count() const;
+
+	void append(const Mesh &mesh);
+
+	// immediate-mode style mesh construction interface
+	void vertex(float x, float y, float z);
+	void normal(float nx, float ny, float nz);
+	void tangent(float tx, float ty, float tz);
+	void texcoord(float u, float v, float w);
+	void boneweights(float w1, float w2, float w3, float w4);
+	void boneidx(int idx1, int idx2, int idx3, int idx4);
+
+	int get_poly_count() const;
+
+	/* apply a transformation to the vertices and its inverse-transpose
+	 * to the normals and tangents.
+	 */
+	void apply_xform(const Matrix4x4 &xform);
+	void apply_xform(const Matrix4x4 &xform, const Matrix4x4 &dir_xform);
+
+	void flip();	// both faces and normals
+	void flip_faces();
+	void flip_normals();
+
+	// adds a bone and returns its index
+	/*int add_bone(XFormNode *bone);
+	const XFormNode *get_bone(int idx) const;
+	int get_bones_count() const;*/
+
+	// access the shader attribute locations
+	static void set_attrib_location(int attr, int loc);
+	static int get_attrib_location(int attr);
+	static void clear_attrib_locations();
+
+	static void set_vis_vecsize(float sz);
+	static float get_vis_vecsize();
+
+	void draw() const;
+	void draw_wire() const;
+	void draw_vertices() const;
+	void draw_normals() const;
+	void draw_tangents() const;
+
+	/** get the bounding box in local space. The result will be cached, and subsequent
+	 * calls will return the same box. The cache gets invalidated by any functions that can affect
+	 * the vertex data (non-const variant of get_attrib_data(MESH_ATTR_VERTEX, ...) included).
+	 * @{ */
+	void get_aabbox(Vector3 *vmin, Vector3 *vmax) const;
+	const AABox &get_aabbox() const;
+	/// @}
+
+	/** get the bounding sphere in local space. The result will be cached, and subsequent
+	 * calls will return the same box. The cache gets invalidated by any functions that can affect
+	 * the vertex data (non-const variant of get_attrib_data(MESH_ATTR_VERTEX, ...) included).
+	 * @{ */
+	float get_bsphere(Vector3 *center, float *rad) const;
+	const Sphere &get_bsphere() const;
+
+	static void set_intersect_mode(unsigned int mode);
+	static unsigned int get_intersect_mode();
+	static void set_vertex_select_distance(float dist);
+	static float get_vertex_select_distance();
+
+	/** Find the intersection between the mesh and a ray.
+	 * XXX Brute force at the moment, not intended to be used for anything other than picking in tools.
+	 *     If you intend to use it in a speed-critical part of the code, you'll *have* to optimize it!
+	 */
+	bool intersect(const Ray &ray, HitPoint *hit = 0) const;
+};
+
+#endif	// MESH_H_
diff -r 000000000000 -r 52e0dd47753b src/opengl.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/opengl.h	Sun Jun 21 06:30:39 2015 +0300
@@ -0,0 +1,6 @@
+#ifndef OPENGL_H_
+#define OPENGL_H_
+
+#include <GL/glew.h>
+
+#endif	/* OPENGL_H_ */