# HG changeset patch
# User John Tsiombikas <nuclear@member.fsf.org>
# Date 1434938737 -10800
# Node ID 3fcd7b4d631f14d17a439b0e46d8b3efc1ac7733
# Parent  52e0dd47753ba714479f65198d786fb719cdf916
board mesh generation

diff -r 52e0dd47753b -r 3fcd7b4d631f Makefile
--- a/Makefile	Sun Jun 21 06:30:39 2015 +0300
+++ b/Makefile	Mon Jun 22 05:05:37 2015 +0300
@@ -6,7 +6,7 @@
 bin = tavli
 
 CXXFLAGS = -pedantic -Wall -g
-LDFLAGS = $(libgl)
+LDFLAGS = $(libgl) -lvmath -limago -lm -lpthread
 
 ifeq ($(shell uname -s), Darwin)
 	libgl = -framework OpenGL -framework GLUT -lGLEW
diff -r 52e0dd47753b -r 3fcd7b4d631f src/board.cc
--- a/src/board.cc	Sun Jun 21 06:30:39 2015 +0300
+++ b/src/board.cc	Mon Jun 22 05:05:37 2015 +0300
@@ -1,11 +1,11 @@
 #include "opengl.h"
 #include "board.h"
+#include "meshgen.h"
 
-static Mesh *gen_board_mesh();
-static Mesh *gen_puck_mesh();
 
 Board::Board()
 {
+	puck_mesh = 0;
 	clear();
 }
 
@@ -16,20 +16,22 @@
 
 bool Board::init()
 {
-	if(!(board_mesh = gen_board_mesh())) {
+	if(!generate()) {
 		return false;
 	}
-	if(!(puck_mesh = gen_puck_mesh())) {
-		return false;
-	}
+
 	return true;
 }
 
 void Board::destroy()
 {
-	delete board_mesh;
+	for(size_t i=0; i<board_meshes.size(); i++) {
+		delete board_meshes[i];
+	}
+	board_meshes.clear();
+
 	delete puck_mesh;
-	board_mesh = puck_mesh = 0;
+	puck_mesh = 0;
 }
 
 void Board::clear()
@@ -39,16 +41,77 @@
 
 void Board::draw() const
 {
-	if(board_mesh)
-		board_mesh->draw();
+	for(size_t i=0; i<board_meshes.size(); i++) {
+		board_meshes[i]->draw();
+	}
 }
 
-static Mesh *gen_board_mesh()
+#define HSIZE	1.0
+#define VSIZE	(2.0 * HSIZE)
+#define BOT_THICKNESS	(HSIZE * 0.01)
+#define WALL_THICKNESS	(HSIZE * 0.05)
+#define WALL_HEIGHT		(HSIZE * 0.1)
+#define GAP				(HSIZE * 0.025)
+#define HINGE_RAD		(GAP * 0.5)
+#define HINGE_HEIGHT	(VSIZE * 0.075)
+
+bool Board::generate()
 {
-	return 0;
+	Matrix4x4 xform;
+
+	// generate bottom
+	Mesh *bottom = new Mesh;
+	gen_box(bottom, HSIZE, BOT_THICKNESS, HSIZE * 2.0);
+	xform.set_translation(Vector3(0, -BOT_THICKNESS / 2.0, 0));
+	bottom->apply_xform(xform);
+
+	// generate the 4 sides
+	Mesh *sides = new Mesh;
+	gen_box(sides, WALL_THICKNESS, WALL_HEIGHT, VSIZE + WALL_THICKNESS * 2);
+	xform.set_translation(Vector3(-(HSIZE + WALL_THICKNESS) / 2.0,
+				WALL_HEIGHT / 2.0 - BOT_THICKNESS, 0));
+	sides->apply_xform(xform);
+
+	Mesh tmp;
+	gen_box(&tmp, WALL_THICKNESS, WALL_HEIGHT, VSIZE + WALL_THICKNESS * 2);
+	xform.set_translation(Vector3((HSIZE + WALL_THICKNESS) / 2.0,
+				WALL_HEIGHT / 2.0 - BOT_THICKNESS, 0));
+	tmp.apply_xform(xform);
+	sides->append(tmp);
+	tmp.clear();
+
+	gen_box(&tmp, HSIZE, WALL_HEIGHT, WALL_THICKNESS);
+	xform.set_translation(Vector3(0, WALL_HEIGHT / 2.0 - BOT_THICKNESS,
+				(VSIZE + WALL_THICKNESS) / 2.0));
+	tmp.apply_xform(xform);
+	sides->append(tmp);
+	tmp.clear();
+
+	gen_box(&tmp, HSIZE, WALL_HEIGHT, WALL_THICKNESS);
+	xform.set_translation(Vector3(0, WALL_HEIGHT / 2.0 - BOT_THICKNESS,
+				-(VSIZE + WALL_THICKNESS) / 2.0));
+	tmp.apply_xform(xform);
+	sides->append(tmp);
+	tmp.clear();
+
+	// generate the hinges
+	Mesh *hinges = new Mesh;
+	gen_cylinder(hinges, HINGE_RAD, HINGE_HEIGHT, 10, 1, 1);
+	xform.set_rotation(Vector3(M_PI / 2.0, 0, 0));
+	xform.translate(Vector3(0, VSIZE / 4.0, 0));
+	hinges->apply_xform(xform);
+
+	gen_cylinder(&tmp, HINGE_RAD, HINGE_HEIGHT, 10, 1, 1);
+	xform.set_rotation(Vector3(M_PI / 2.0, 0, 0));
+	xform.translate(Vector3(0, -VSIZE / 4.0, 0));
+	tmp.apply_xform(xform);
+
+	hinges->append(tmp);
+
+
+	board_meshes.clear();
+	board_meshes.push_back(bottom);
+	board_meshes.push_back(sides);
+	board_meshes.push_back(hinges);
+	return true;
 }
-
-static Mesh *gen_puck_mesh()
-{
-	return 0;
-}
diff -r 52e0dd47753b -r 3fcd7b4d631f src/board.h
--- a/src/board.h	Sun Jun 21 06:30:39 2015 +0300
+++ b/src/board.h	Mon Jun 22 05:05:37 2015 +0300
@@ -1,6 +1,7 @@
 #ifndef BOARD_H_
 #define BOARD_H_
 
+#include <vector>
 #include "mesh.h"
 
 #define NUM_SLOTS	24
@@ -11,7 +12,10 @@
 class Board {
 private:
 	int slots[NUM_SLOTS][MAX_PUCKS];
-	Mesh *board_mesh, *puck_mesh;
+	std::vector<Mesh*> board_meshes;
+	Mesh *puck_mesh;
+
+	bool generate();
 
 public:
 	Board();
diff -r 52e0dd47753b -r 3fcd7b4d631f src/game.cc
--- a/src/game.cc	Sun Jun 21 06:30:39 2015 +0300
+++ b/src/game.cc	Mon Jun 22 05:05:37 2015 +0300
@@ -1,11 +1,14 @@
 #include <stdio.h>
 #include <GL/glew.h>
 #include "game.h"
+#include "board.h"
 
 static void draw_backdrop();
 
 int win_width, win_height;
 
+static Board board;
+
 static float cam_theta, cam_phi = 25, cam_dist = 6;
 static bool bnstate[8];
 static int prev_x, prev_y;
@@ -19,11 +22,16 @@
 	glEnable(GL_LIGHTING);
 	glEnable(GL_LIGHT0);
 
+	if(!board.init()) {
+		return false;
+	}
+
 	return true;
 }
 
 void game_cleanup()
 {
+	board.destroy();
 }
 
 void game_update(unsigned long time_msec)
@@ -42,13 +50,16 @@
 
 	draw_backdrop();
 
+	board.draw();
+
+	/*
 	glBegin(GL_QUADS);
 	glNormal3f(0, 1, 0);
 	glVertex3f(-1, 0, 1);
 	glVertex3f(1, 0, 1);
 	glVertex3f(1, 0, -1);
 	glVertex3f(-1, 0, -1);
-	glEnd();
+	glEnd();*/
 }
 
 static void draw_backdrop()
@@ -85,7 +96,7 @@
 {
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
-	gluPerspective(50, (float)x / (float)y, 0.5, 500.0);
+	gluPerspective(50, (float)x / (float)y, 0.2, 200.0);
 
 	glViewport(0, 0, x, y);
 }
diff -r 52e0dd47753b -r 3fcd7b4d631f src/mesh.cc
--- a/src/mesh.cc	Sun Jun 21 06:30:39 2015 +0300
+++ b/src/mesh.cc	Mon Jun 22 05:05:37 2015 +0300
@@ -5,15 +5,16 @@
 #include "opengl.h"
 #include "mesh.h"
 //#include "xform_node.h"
-#include "shader.h"
 
-int Mesh::global_sdr_loc[NUM_MESH_ATTR] = {
+int Mesh::global_sdr_loc[NUM_MESH_ATTR] = { 0, 1, 2, 3, 4, 5, 6 };
+/*
 	(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;
@@ -555,12 +556,9 @@
 
 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
+	int cur_sdr;
+	glGetIntegerv(GL_CURRENT_PROGRAM, &cur_sdr);
+
 
 	((Mesh*)this)->update_buffers();
 
@@ -569,7 +567,7 @@
 		return;
 	}
 
-	if(SdrProg::active) {
+	if(cur_sdr) {
 		// rendering with shaders
 		if(global_sdr_loc[MESH_ATTR_VERTEX] == -1) {
 			fprintf(stderr, "%s: shader attribute location for vertices unset\n", __FUNCTION__);
@@ -618,7 +616,7 @@
 		glDrawArrays(GL_TRIANGLES, 0, nverts);
 	}
 
-	if(SdrProg::active) {
+	if(cur_sdr) {
 		// rendered with shaders
 		for(int i=0; i<NUM_MESH_ATTR; i++) {
 			int loc = global_sdr_loc[i];
@@ -1128,7 +1126,6 @@
 
 	glDisableVertexAttribArray(vloc);
 	glDisableVertexAttribArray(nloc);
-	CHECK_GLERROR;
 }
 
 void Triangle::draw_wire() const
@@ -1142,7 +1139,6 @@
 	glDrawElements(GL_LINES, 6, GL_UNSIGNED_INT, idxarr);
 
 	glDisableVertexAttribArray(vloc);
-	CHECK_GLERROR;
 }
 
 Vector3 Triangle::calc_barycentric(const Vector3 &pos) const
diff -r 52e0dd47753b -r 3fcd7b4d631f src/meshgen.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/meshgen.cc	Mon Jun 22 05:05:37 2015 +0300
@@ -0,0 +1,487 @@
+#include <stdio.h>
+#include "meshgen.h"
+#include "mesh.h"
+
+// -------- sphere --------
+
+#define SURAD(u)	((u) * 2.0 * M_PI)
+#define SVRAD(v)	((v) * M_PI)
+
+static Vector3 sphvec(float theta, float phi)
+{
+	return Vector3(sin(theta) * sin(phi),
+			cos(phi),
+			cos(theta) * sin(phi));
+}
+
+void gen_sphere(Mesh *mesh, float rad, int usub, int vsub, float urange, float vrange)
+{
+	if(usub < 4) usub = 4;
+	if(vsub < 2) vsub = 2;
+
+	int uverts = usub + 1;
+	int vverts = vsub + 1;
+
+	int num_verts = uverts * vverts;
+	int num_quads = usub * vsub;
+	int num_tri = num_quads * 2;
+
+	mesh->clear();
+	Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);
+	Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);
+	Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);
+	Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);
+	unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);
+
+	float du = urange / (float)(uverts - 1);
+	float dv = vrange / (float)(vverts - 1);
+
+	float u = 0.0;
+	for(int i=0; i<uverts; i++) {
+		float theta = SURAD(u * urange);
+
+		float v = 0.0;
+		for(int j=0; j<vverts; j++) {
+			float phi = SVRAD(v * vrange);
+
+			Vector3 pos = sphvec(theta, phi);
+
+			*varr++ = pos * rad;
+			*narr++ = pos;
+			*tarr++ = (sphvec(theta + 0.1f, (float)M_PI / 2.0f) - sphvec(theta - 0.1f, (float)M_PI / 2.0f)).normalized();
+			*uvarr++ = Vector2(u * urange, v * vrange);
+
+			if(i < usub && j < vsub) {
+				int idx = i * vverts + j;
+				*idxarr++ = idx;
+				*idxarr++ = idx + 1;
+				*idxarr++ = idx + vverts + 1;
+
+				*idxarr++ = idx;
+				*idxarr++ = idx + vverts + 1;
+				*idxarr++ = idx + vverts;
+			}
+
+			v += dv;
+		}
+		u += du;
+	}
+}
+
+
+// -------- cylinder --------
+
+static Vector3 cylvec(float theta, float height)
+{
+	return Vector3(sin(theta), height, cos(theta));
+}
+
+void gen_cylinder(Mesh *mesh, float rad, float height, int usub, int vsub, int capsub, float urange, float vrange)
+{
+	if(usub < 4) usub = 4;
+	if(vsub < 1) vsub = 1;
+
+	int uverts = usub + 1;
+	int vverts = vsub + 1;
+
+	int num_body_verts = uverts * vverts;
+	int num_body_quads = usub * vsub;
+	int num_body_tri = num_body_quads * 2;
+
+	int capvverts = capsub ? capsub + 1 : 0;
+	int num_cap_verts = uverts * capvverts;
+	int num_cap_quads = usub * capsub;
+	int num_cap_tri = num_cap_quads * 2;
+
+	int num_verts = num_body_verts + num_cap_verts * 2;
+	int num_tri = num_body_tri + num_cap_tri * 2;
+
+	mesh->clear();
+	Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);
+	Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);
+	Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);
+	Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);
+	unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);
+
+	float du = urange / (float)(uverts - 1);
+	float dv = vrange / (float)(vverts - 1);
+
+	float u = 0.0;
+	for(int i=0; i<uverts; i++) {
+		float theta = SURAD(u);
+
+		float v = 0.0;
+		for(int j=0; j<vverts; j++) {
+			float y = (v - 0.5) * height;
+			Vector3 pos = cylvec(theta, y);
+
+			*varr++ = Vector3(pos.x * rad, pos.y, pos.z * rad);
+			*narr++ = Vector3(pos.x, 0.0, pos.z);
+			*tarr++ = (cylvec(theta + 0.1, 0.0) - cylvec(theta - 0.1, 0.0)).normalized();
+			*uvarr++ = Vector2(u * urange, v * vrange);
+
+			if(i < usub && j < vsub) {
+				int idx = i * vverts + j;
+
+				*idxarr++ = idx;
+				*idxarr++ = idx + vverts + 1;
+				*idxarr++ = idx + 1;
+
+				*idxarr++ = idx;
+				*idxarr++ = idx + vverts;
+				*idxarr++ = idx + vverts + 1;
+			}
+
+			v += dv;
+		}
+		u += du;
+	}
+
+
+	// now the cap!
+	if(!capsub) {
+		return;
+	}
+
+	dv = 1.0 / (float)(capvverts - 1);
+
+	u = 0.0;
+	for(int i=0; i<uverts; i++) {
+		float theta = SURAD(u);
+
+		float v = 0.0;
+		for(int j=0; j<capvverts; j++) {
+			float r = v * rad;
+
+			Vector3 pos = cylvec(theta, height / 2.0) * r;
+			pos.y = height / 2.0;
+			Vector3 tang = (cylvec(theta + 0.1, 0.0) - cylvec(theta - 0.1, 0.0)).normalized();
+
+			*varr++ = pos;
+			*narr++ = Vector3(0, 1, 0);
+			*tarr++ = tang;
+			*uvarr++ = Vector2(u * urange, v);
+
+			pos.y = -height / 2.0;
+			*varr++ = pos;
+			*narr++ = Vector3(0, -1, 0);
+			*tarr++ = -tang;
+			*uvarr++ = Vector2(u * urange, v);
+
+			if(i < usub && j < capsub) {
+				unsigned int idx = num_body_verts + (i * capvverts + j) * 2;
+
+				unsigned int vidx[4] = {
+					idx,
+					idx + capvverts * 2,
+					idx + (capvverts + 1) * 2,
+					idx + 2
+				};
+
+				*idxarr++ = vidx[0];
+				*idxarr++ = vidx[2];
+				*idxarr++ = vidx[1];
+				*idxarr++ = vidx[0];
+				*idxarr++ = vidx[3];
+				*idxarr++ = vidx[2];
+
+				*idxarr++ = vidx[0] + 1;
+				*idxarr++ = vidx[1] + 1;
+				*idxarr++ = vidx[2] + 1;
+				*idxarr++ = vidx[0] + 1;
+				*idxarr++ = vidx[2] + 1;
+				*idxarr++ = vidx[3] + 1;
+			}
+
+			v += dv;
+		}
+		u += du;
+	}
+}
+
+// -------- cone --------
+
+static Vector3 conevec(float theta, float y, float height)
+{
+	float scale = 1.0 - y / height;
+	return Vector3(sin(theta) * scale, y, cos(theta) * scale);
+}
+
+void gen_cone(Mesh *mesh, float rad, float height, int usub, int vsub, int capsub, float urange, float vrange)
+{
+	if(usub < 4) usub = 4;
+	if(vsub < 1) vsub = 1;
+
+	int uverts = usub + 1;
+	int vverts = vsub + 1;
+
+	int num_body_verts = uverts * vverts;
+	int num_body_quads = usub * vsub;
+	int num_body_tri = num_body_quads * 2;
+
+	int capvverts = capsub ? capsub + 1 : 0;
+	int num_cap_verts = uverts * capvverts;
+	int num_cap_quads = usub * capsub;
+	int num_cap_tri = num_cap_quads * 2;
+
+	int num_verts = num_body_verts + num_cap_verts;
+	int num_tri = num_body_tri + num_cap_tri;
+
+	mesh->clear();
+	Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);
+	Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);
+	Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);
+	Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);
+	unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);
+
+	float du = urange / (float)(uverts - 1);
+	float dv = vrange / (float)(vverts - 1);
+
+	float u = 0.0;
+	for(int i=0; i<uverts; i++) {
+		float theta = SURAD(u);
+
+		float v = 0.0;
+		for(int j=0; j<vverts; j++) {
+			float y = v * height;
+			Vector3 pos = conevec(theta, y, height);
+
+			Vector3 tang = (conevec(theta + 0.1, 0.0, height) - conevec(theta - 0.1, 0.0, height)).normalized();
+			Vector3 bitang = (conevec(theta, y + 0.1, height) - pos).normalized();
+
+			*varr++ = Vector3(pos.x * rad, pos.y, pos.z * rad);
+			*narr++ = cross_product(tang, bitang);
+			*tarr++ = tang;
+			*uvarr++ = Vector2(u * urange, v * vrange);
+
+			if(i < usub && j < vsub) {
+				int idx = i * vverts + j;
+
+				*idxarr++ = idx;
+				*idxarr++ = idx + vverts + 1;
+				*idxarr++ = idx + 1;
+
+				*idxarr++ = idx;
+				*idxarr++ = idx + vverts;
+				*idxarr++ = idx + vverts + 1;
+			}
+
+			v += dv;
+		}
+		u += du;
+	}
+
+
+	// now the bottom cap!
+	if(!capsub) {
+		return;
+	}
+
+	dv = 1.0 / (float)(capvverts - 1);
+
+	u = 0.0;
+	for(int i=0; i<uverts; i++) {
+		float theta = SURAD(u);
+
+		float v = 0.0;
+		for(int j=0; j<capvverts; j++) {
+			float r = v * rad;
+
+			Vector3 pos = conevec(theta, 0.0, height) * r;
+			Vector3 tang = (cylvec(theta + 0.1, 0.0) - cylvec(theta - 0.1, 0.0)).normalized();
+
+			*varr++ = pos;
+			*narr++ = Vector3(0, -1, 0);
+			*tarr++ = tang;
+			*uvarr++ = Vector2(u * urange, v);
+
+			if(i < usub && j < capsub) {
+				unsigned int idx = num_body_verts + i * capvverts + j;
+
+				unsigned int vidx[4] = {
+					idx,
+					idx + capvverts,
+					idx + (capvverts + 1),
+					idx + 1
+				};
+
+				*idxarr++ = vidx[0];
+				*idxarr++ = vidx[1];
+				*idxarr++ = vidx[2];
+				*idxarr++ = vidx[0];
+				*idxarr++ = vidx[2];
+				*idxarr++ = vidx[3];
+			}
+
+			v += dv;
+		}
+		u += du;
+	}
+}
+
+
+// -------- plane --------
+
+void gen_plane(Mesh *mesh, float width, float height, int usub, int vsub)
+{
+	gen_heightmap(mesh, width, height, usub, vsub, 0);
+}
+
+
+// ----- heightmap ------
+
+void gen_heightmap(Mesh *mesh, float width, float height, int usub, int vsub, float (*hf)(float, float, void*), void *hfdata)
+{
+	if(usub < 1) usub = 1;
+	if(vsub < 1) vsub = 1;
+
+	mesh->clear();
+
+	int uverts = usub + 1;
+	int vverts = vsub + 1;
+	int num_verts = uverts * vverts;
+
+	int num_quads = usub * vsub;
+	int num_tri = num_quads * 2;
+
+	Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);
+	Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);
+	Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);
+	Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);
+	unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);
+
+	float du = 1.0 / (float)usub;
+	float dv = 1.0 / (float)vsub;
+
+	float u = 0.0;
+	for(int i=0; i<uverts; i++) {
+		float v = 0.0;
+		for(int j=0; j<vverts; j++) {
+			float x = (u - 0.5) * width;
+			float y = (v - 0.5) * height;
+			float z = hf ? hf(u, v, hfdata) : 0.0;
+
+			Vector3 normal = Vector3(0, 0, 1);
+			if(hf) {
+				float u1z = hf(u + du, v, hfdata);
+				float v1z = hf(u, v + dv, hfdata);
+
+				Vector3 tang = Vector3(du * width, 0, u1z - z);
+				Vector3 bitan = Vector3(0, dv * height, v1z - z);
+				normal = cross_product(tang, bitan).normalized();
+			}
+
+			*varr++ = Vector3(x, y, z);
+			*narr++ = normal;
+			*tarr++ = Vector3(1, 0, 0);
+			*uvarr++ = Vector2(u, v);
+
+			if(i < usub && j < vsub) {
+				int idx = i * vverts + j;
+
+				*idxarr++ = idx;
+				*idxarr++ = idx + vverts + 1;
+				*idxarr++ = idx + 1;
+
+				*idxarr++ = idx;
+				*idxarr++ = idx + vverts;
+				*idxarr++ = idx + vverts + 1;
+			}
+
+			v += dv;
+		}
+		u += du;
+	}
+}
+
+// ----- heightmap ------
+
+void gen_box(Mesh *mesh, float xsz, float ysz, float zsz)
+{
+	mesh->clear();
+
+	const int num_faces = 6;
+	int num_verts = num_faces * 4;
+	int num_tri = num_faces * 2;
+
+	float x = xsz / 2.0;
+	float y = ysz / 2.0;
+	float z = zsz / 2.0;
+
+	Vector3 *varr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, 0);
+	Vector3 *narr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, 0);
+	Vector3 *tarr = (Vector3*)mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, 0);
+	Vector2 *uvarr = (Vector2*)mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 2, num_verts, 0);
+	unsigned int *idxarr = mesh->set_index_data(num_tri * 3, 0);
+
+	static const Vector2 uv[] = { Vector2(0, 0), Vector2(1, 0), Vector2(1, 1), Vector2(0, 1) };
+
+	// front
+	for(int i=0; i<4; i++) {
+		*narr++ = Vector3(0, 0, 1);
+		*tarr++ = Vector3(1, 0, 0);
+		*uvarr++ = uv[i];
+	}
+	*varr++ = Vector3(-x, -y, z);
+	*varr++ = Vector3(x, -y, z);
+	*varr++ = Vector3(x, y, z);
+	*varr++ = Vector3(-x, y, z);
+	// right
+	for(int i=0; i<4; i++) {
+		*narr++ = Vector3(1, 0, 0);
+		*tarr++ = Vector3(0, 0, -1);
+		*uvarr++ = uv[i];
+	}
+	*varr++ = Vector3(x, -y, z);
+	*varr++ = Vector3(x, -y, -z);
+	*varr++ = Vector3(x, y, -z);
+	*varr++ = Vector3(x, y, z);
+	// back
+	for(int i=0; i<4; i++) {
+		*narr++ = Vector3(0, 0, -1);
+		*tarr++ = Vector3(-1, 0, 0);
+		*uvarr++ = uv[i];
+	}
+	*varr++ = Vector3(x, -y, -z);
+	*varr++ = Vector3(-x, -y, -z);
+	*varr++ = Vector3(-x, y, -z);
+	*varr++ = Vector3(x, y, -z);
+	// left
+	for(int i=0; i<4; i++) {
+		*narr++ = Vector3(-1, 0, 0);
+		*tarr++ = Vector3(0, 0, 1);
+		*uvarr++ = uv[i];
+	}
+	*varr++ = Vector3(-x, -y, -z);
+	*varr++ = Vector3(-x, -y, z);
+	*varr++ = Vector3(-x, y, z);
+	*varr++ = Vector3(-x, y, -z);
+	// top
+	for(int i=0; i<4; i++) {
+		*narr++ = Vector3(0, 1, 0);
+		*tarr++ = Vector3(1, 0, 0);
+		*uvarr++ = uv[i];
+	}
+	*varr++ = Vector3(-x, y, z);
+	*varr++ = Vector3(x, y, z);
+	*varr++ = Vector3(x, y, -z);
+	*varr++ = Vector3(-x, y, -z);
+	// bottom
+	for(int i=0; i<4; i++) {
+		*narr++ = Vector3(0, -1, 0);
+		*tarr++ = Vector3(1, 0, 0);
+		*uvarr++ = uv[i];
+	}
+	*varr++ = Vector3(-x, -y, -z);
+	*varr++ = Vector3(x, -y, -z);
+	*varr++ = Vector3(x, -y, z);
+	*varr++ = Vector3(-x, -y, z);
+
+	// index array
+	static const int faceidx[] = {0, 1, 2, 0, 2, 3};
+	for(int i=0; i<num_faces; i++) {
+		for(int j=0; j<6; j++) {
+			*idxarr++ = faceidx[j] + i * 4;
+		}
+	}
+}
diff -r 52e0dd47753b -r 3fcd7b4d631f src/meshgen.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/meshgen.h	Mon Jun 22 05:05:37 2015 +0300
@@ -0,0 +1,13 @@
+#ifndef MESHGEN_H_
+#define MESHGEN_H_
+
+class Mesh;
+
+void gen_sphere(Mesh *mesh, float rad, int usub, int vsub, float urange = 1.0, float vrange = 1.0);
+void gen_cylinder(Mesh *mesh, float rad, float height, int usub, int vsub, int capsub = 0, float urange = 1.0, float vrange = 1.0);
+void gen_cone(Mesh *mesh, float rad, float height, int usub, int vsub, int capsub = 0, float urange = 1.0, float vrange = 1.0);
+void gen_plane(Mesh *mesh, float width, float height, int usub = 1, int vsub = 1);
+void gen_heightmap(Mesh *mesh, float width, float height, int usub, int vsub, float (*hf)(float, float, void*), void *hfdata = 0);
+void gen_box(Mesh *mesh, float xsz, float ysz, float zsz);
+
+#endif	// MESHGEN_H_
diff -r 52e0dd47753b -r 3fcd7b4d631f src/object.cc
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/object.cc	Mon Jun 22 05:05:37 2015 +0300
@@ -0,0 +1,45 @@
+#include "object.h"
+#include "opengl.h"
+
+Object::Object()
+{
+	mesh = 0;
+}
+
+Object::~Object()
+{
+	delete mesh;
+}
+
+Matrix4x4 &Object::xform()
+{
+	return matrix;
+}
+
+const Matrix4x4 &Object::xform() const
+{
+	return matrix;
+}
+
+void Object::set_mesh(Mesh *m)
+{
+	this->mesh = m;
+}
+
+Mesh *Object::get_mesh() const
+{
+	return mesh;
+}
+
+void Object::draw() const
+{
+	if(!mesh) return;
+
+	glMatrixMode(GL_MODELVIEW);
+	glPushMatrix();
+	glLoadTransposeMatrixf(matrix[0]);
+
+	mesh->draw();
+
+	glPopMatrix();
+}
diff -r 52e0dd47753b -r 3fcd7b4d631f src/object.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/object.h	Mon Jun 22 05:05:37 2015 +0300
@@ -0,0 +1,24 @@
+#ifndef OBJECT_H_
+#define OBJECT_H_
+
+#include "mesh.h"
+
+class Object {
+private:
+	Mesh *mesh;
+	Matrix4x4 matrix;
+
+public:
+	Object();
+	~Object();
+
+	Matrix4x4 &xform();
+	const Matrix4x4 &xform() const;
+
+	void set_mesh(Mesh *m);
+	Mesh *get_mesh() const;
+
+	void draw() const;
+};
+
+#endif	// OBJECT_H_