Make "blobs" work properly

git-svn-id: svn://cook.msm.cam.ac.uk:745/diff-tomo/dtr@105 bf6ca9ba-c028-0410-8290-897cf20841d1

2 files changed, 166 insertions, 132 deletions

diff --git a/src/control.h b/src/control.h
index 6fab72d..dbeda36 100644
--- a/src/control.h
+++ b/src/control.h
@@ -116,24 +116,22 @@ typedef struct cctx_struct {
 	GtkWidget		*combo_peaksearch;
 	GtkWidget		*checkbox_prealign;
 	GtkWidget		*checkbox_savecache;
-	GLuint			gl_list_id;
 
-	GLuint			gl_ref_vertex_buffer;
-	GLuint			gl_ref_element_buffer;
-//	GLfloat			*gl_ref_vertex_array;
-//	GLuint			*gl_ref_element_array;
+	/* OpenGL bits */
+	GLuint			gl_list_id;			/* Display list for "everything else" */
+	int			gl_use_buffers;			/* 0=use vertex arrays only, otherwise use VBOs */
+	GLuint			gl_ref_vertex_buffer;		/* "Measured reflection" stuff */
+	GLfloat			*gl_ref_vertex_array;
 	GLsizei			gl_ref_num_vertices;
-	
-	GLuint			gl_marker_vertex_buffer;
-	GLuint			gl_marker_element_buffer;
-//	GLfloat			*gl_marker_vertex_array;
-//	GLuint			*gl_marker_element_array;
+	GLuint			gl_marker_vertex_buffer;	/* Marker "reflection" stuff */
+	GLuint			gl_marker_normal_buffer;
+	GLfloat			*gl_marker_vertex_array;
+	GLfloat			*gl_marker_normal_array;
 	GLsizei			gl_marker_num_vertices;
-
-	GLuint			gl_gen_vertex_buffer;
-	GLuint			gl_gen_element_buffer;
-//	GLfloat			*gl_gen_vertex_array;
-//	GLuint			*gl_gen_element_array;
+	GLuint			gl_gen_vertex_buffer;		/* Generated reflection stuff */
+	GLuint			gl_gen_normal_buffer;
+	GLfloat			*gl_gen_vertex_array;
+	GLfloat			*gl_gen_normal_array;
 	GLsizei			gl_gen_num_vertices;
 
 } ControlContext;
diff --git a/src/displaywindow.c b/src/displaywindow.c
index 8264a5b..dae3ba6 100644
--- a/src/displaywindow.c
+++ b/src/displaywindow.c
@@ -20,6 +20,7 @@
 #include <math.h>
 #include <gdk/gdkgl.h>
 #include <gtk/gtkgl.h>
+#define GL_GLEXT_PROTOTYPES 1
 #include <GL/gl.h>
 #include <GL/glext.h>
 #include <GL/glu.h>
@@ -114,10 +115,10 @@ static void displaywindow_gl_set_perspective(GLfloat w, GLfloat h) {
 	glLoadIdentity();
 	if ( w > h ) {
 		GLfloat aspect = w/h;
-		glFrustum(-aspect, aspect, -1.0, 1.0, 2.0, 1000.0);
+		glFrustum(-aspect, aspect, -1.0, 1.0, 10.0, 1000.0);
 	} else {
 		GLfloat aspect = h/w;
-		glFrustum(-1.0, 1.0, -aspect, aspect, 2.0, 1000.0);
+		glFrustum(-1.0, 1.0, -aspect, aspect, 10.0, 1000.0);
 	}
 	glMatrixMode(GL_MODELVIEW);
 
@@ -240,35 +241,44 @@ static gint displaywindow_gl_motion_notify(GtkWidget *widget, GdkEventMotion *ev
 	return TRUE;
 }
 
-#define VERTICES_IN_A_BLOB 4*10*10
-#define ADD_VERTEX 					\
-	vertices[3*i + 0] = reflection->x/1e9 + xv;	\
-	vertices[3*i + 1] = reflection->y/1e9 + yv;	\
-	vertices[3*i + 2] = reflection->z/1e9 + zv;	\
-	elements[i] = i;  i++;
-
+#define BLOB_BITS 5
+#define VERTICES_IN_A_BLOB 4*BLOB_BITS*BLOB_BITS*2
+#define ADD_VERTEX 						\
+	norm = sqrt(xv*xv + yv*yv + zv*zv);			\
+	vertices[3*i + 0] = reflection->x/1e9 + size*xv;	\
+	vertices[3*i + 1] = reflection->y/1e9 + size*yv;	\
+	vertices[3*i + 2] = reflection->z/1e9 + size*zv;	\
+	normals[3*i + 0] = xv/norm;				\
+	normals[3*i + 1] = yv/norm;				\
+	normals[3*i + 2] = zv/norm;				\
+	i++;
+	
 #define DRAW_BLOB							\
-	double theta, phi;						\
-	double steps = 10;						\
+	double step = M_PI/(double)BLOB_BITS;				\
 	double size = 0.2;						\
-	for ( theta = 0.0; theta<2*M_PI; theta+=2*M_PI/steps ) {	\
-		for ( phi = 0.0; phi<M_PI; phi+=M_PI/steps ) {		\
+	int is, js;							\
+	for ( is=0; is<BLOB_BITS; is++ ) {				\
+		for ( js=0; js<BLOB_BITS*2; js++ ) {			\
+			double norm;					\
+			double theta, phi;				\
 			GLfloat xv, yv, zv;				\
-			xv = size*sin(phi) + size*cos(theta);		\
-			yv = size*cos(phi);				\
-			zv = size*sin(theta);				\
+			theta = (M_PI/(double)BLOB_BITS) * (double)js;	\
+			phi = (M_PI/(double)BLOB_BITS) * (double)is;	\
+			xv = sin(theta)*sin(phi);			\
+			yv = cos(phi);					\
+			zv = cos(theta)*sin(phi);			\
 			ADD_VERTEX					\
-			xv = size*sin(phi+M_PI/steps) + size*cos(theta);\
-			yv = size*cos(phi+M_PI/steps);			\
-			zv = size*sin(theta);				\
+			xv = sin(theta)*sin(phi+step);			\
+			yv = cos(phi+step);				\
+			zv = cos(theta)*sin(phi+step);			\
 			ADD_VERTEX					\
-			xv = size*sin(phi+M_PI/steps) + size*cos(theta+2*M_PI/steps);\
-			yv = size*cos(phi+M_PI/steps);			\
-			zv = size*sin(theta+2*M_PI/steps);		\
+			xv = sin(theta+step)*sin(phi+step);		\
+			yv = cos(phi+step);				\
+			zv = cos(theta+step)*sin(phi+step);		\
 			ADD_VERTEX					\
-			xv = size*sin(phi) + size*cos(theta+2*M_PI/steps);\
-			yv = size*cos(phi);				\
-			zv = size*sin(theta+2*M_PI/steps);		\
+			xv = sin(theta+step)*sin(phi);			\
+			yv = cos(phi);					\
+			zv = cos(theta+step)*sin(phi);			\
 			ADD_VERTEX					\
 		}							\
 	}
@@ -280,15 +290,17 @@ static void displaywindow_gl_create_list(ControlContext *ctx) {
 	GLfloat red[] = { 1.0, 0.0, 0.0, 1.0 };
 	GLfloat yellow[] = { 1.0, 1.0, 0.0, 1.0 };
 	GLfloat yellow_glass[] = { 1.0, 1.0, 0.0, 000.1 };
+	GLfloat yellow_glass_spec[] = { 1.0, 1.0, 0.0, 1.0 };
 	Reflection *reflection;
 	GLUquadricObj *quadric;
 	int i;
 	GLfloat *vertices;
-	GLuint *elements;
-	
+	GLfloat *normals;
+		
 	/* "Measured" reflections */
-	glGenBuffersARB(1, &ctx->gl_ref_vertex_buffer);
-	glGenBuffersARB(1, &ctx->gl_ref_element_buffer);
+	if ( ctx->gl_use_buffers ) {
+		glGenBuffersARB(1, &ctx->gl_ref_vertex_buffer);
+	}
 	reflection = ctx->reflectionctx->reflections;
 	i = 0;
 	do {
@@ -299,31 +311,29 @@ static void displaywindow_gl_create_list(ControlContext *ctx) {
 	i = 0;
 	reflection = ctx->reflectionctx->reflections;
 	vertices = malloc(3*ctx->gl_ref_num_vertices*sizeof(GLfloat));
-	elements = malloc(ctx->gl_ref_num_vertices*sizeof(GLuint));
 	do {
 		if ( reflection->type == REFLECTION_NORMAL ) {
 			vertices[3*i + 0] = reflection->x/1e9;
 			vertices[3*i + 1] = reflection->y/1e9;
 			vertices[3*i + 2] = reflection->z/1e9;
-			elements[i] = i;
 			i++;
 		}
 		reflection = reflection->next;
 	} while ( reflection != NULL );	
-//	ctx->gl_ref_vertex_array = vertices;
-	glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_ref_vertex_buffer);
-	glBufferDataARB(GL_ARRAY_BUFFER, 3*ctx->gl_ref_num_vertices*sizeof(GLfloat), vertices, GL_STATIC_DRAW);
-	free(vertices);
-//	ctx->gl_ref_element_array = elements;
-	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, ctx->gl_ref_element_buffer);
-	glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER, ctx->gl_ref_num_vertices*sizeof(GLuint), elements, GL_STATIC_DRAW);
-	free(elements);
-	glBindBufferARB(GL_ARRAY_BUFFER, NULL);
-	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, NULL);
+	if ( ctx->gl_use_buffers ) {
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_ref_vertex_buffer);
+		glBufferDataARB(GL_ARRAY_BUFFER, 3*ctx->gl_ref_num_vertices*sizeof(GLfloat), vertices, GL_STATIC_DRAW);
+		free(vertices);
+	} else {
+		ctx->gl_ref_vertex_array = vertices;
+	}
+	
 	
 	/* Marker "reflections" */
-	glGenBuffersARB(1, &ctx->gl_marker_vertex_buffer);
-	glGenBuffersARB(1, &ctx->gl_marker_element_buffer);
+	if ( ctx->gl_use_buffers ) {
+		glGenBuffersARB(1, &ctx->gl_marker_vertex_buffer);
+		glGenBuffersARB(1, &ctx->gl_marker_normal_buffer);
+	}
 	reflection = ctx->reflectionctx->reflections;
 	i = 0;
 	do {
@@ -334,25 +344,30 @@ static void displaywindow_gl_create_list(ControlContext *ctx) {
 	i = 0;
 	reflection = ctx->reflectionctx->reflections;
 	vertices = malloc(3*ctx->gl_marker_num_vertices*sizeof(GLfloat));
-	elements = malloc(ctx->gl_marker_num_vertices*sizeof(GLuint));
+	normals = malloc(3*ctx->gl_marker_num_vertices*sizeof(GLfloat));
 	do {
 		if ( reflection->type == REFLECTION_MARKER ) {
 			DRAW_BLOB
 		}
 		reflection = reflection->next;
 	} while ( reflection != NULL );	
-//	ctx->gl_marker_vertex_array = vertices;
-	glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_marker_vertex_buffer);
-	glBufferDataARB(GL_ARRAY_BUFFER, 3*ctx->gl_marker_num_vertices*sizeof(GLfloat), vertices, GL_STATIC_DRAW);
-	free(vertices);
-//	ctx->gl_marker_element_array = elements;
-	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, ctx->gl_marker_element_buffer);
-	glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER, ctx->gl_marker_num_vertices*sizeof(GLuint), elements, GL_STATIC_DRAW);
-	free(elements);
+	if ( ctx->gl_use_buffers ) {
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_marker_vertex_buffer);
+		glBufferDataARB(GL_ARRAY_BUFFER, 3*ctx->gl_marker_num_vertices*sizeof(GLfloat), vertices, GL_STATIC_DRAW);
+		free(vertices);
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_marker_normal_buffer);
+		glBufferDataARB(GL_ARRAY_BUFFER, 3*ctx->gl_marker_num_vertices*sizeof(GLfloat), normals, GL_STATIC_DRAW);
+		free(normals);
+	} else {
+		ctx->gl_marker_vertex_array = vertices;
+		ctx->gl_marker_normal_array = normals;
+	}
 	
 	/* Generated reflections */
-	glGenBuffersARB(1, &ctx->gl_gen_vertex_buffer);
-	glGenBuffersARB(1, &ctx->gl_gen_element_buffer);
+	if ( ctx->gl_use_buffers ) {
+		glGenBuffersARB(1, &ctx->gl_gen_vertex_buffer);
+		glGenBuffersARB(1, &ctx->gl_gen_normal_buffer);
+	}
 	reflection = ctx->reflectionctx->reflections;
 	i = 0;
 	do {
@@ -363,21 +378,24 @@ static void displaywindow_gl_create_list(ControlContext *ctx) {
 	i = 0;
 	reflection = ctx->reflectionctx->reflections;
 	vertices = malloc(3*ctx->gl_gen_num_vertices*sizeof(GLfloat));
-	elements = malloc(ctx->gl_gen_num_vertices*sizeof(GLuint));
+	normals = malloc(3*ctx->gl_gen_num_vertices*sizeof(GLfloat));
 	do {
 		if ( reflection->type == REFLECTION_GENERATED ) {
 			DRAW_BLOB
 		}
 		reflection = reflection->next;
 	} while ( reflection != NULL );	
-//	ctx->gl_gen_vertex_array = vertices;
-	glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_gen_vertex_buffer);
-	glBufferDataARB(GL_ARRAY_BUFFER, 3*ctx->gl_gen_num_vertices*sizeof(GLfloat), vertices, GL_STATIC_DRAW);
-	free(vertices);
-//	ctx->gl_gen_element_array = elements;
-	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, ctx->gl_gen_element_buffer);
-	glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER, ctx->gl_gen_num_vertices*sizeof(GLuint), elements, GL_STATIC_DRAW);
-	free(elements);
+	if ( ctx->gl_use_buffers ) {
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_gen_vertex_buffer);
+		glBufferDataARB(GL_ARRAY_BUFFER, 3*ctx->gl_gen_num_vertices*sizeof(GLfloat), vertices, GL_STATIC_DRAW);
+		free(vertices);
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_gen_normal_buffer);
+		glBufferDataARB(GL_ARRAY_BUFFER, 3*ctx->gl_gen_num_vertices*sizeof(GLfloat), normals, GL_STATIC_DRAW);
+		free(normals);
+		glBindBufferARB(GL_ARRAY_BUFFER, 0);	/* ************* */
+	} else {
+		ctx->gl_gen_vertex_array = vertices;
+	}
 	
 	ctx->gl_list_id = glGenLists(1);
 	glNewList(ctx->gl_list_id, GL_COMPILE);
@@ -410,6 +428,8 @@ static void displaywindow_gl_create_list(ControlContext *ctx) {
 	glEnd();
 
 	/* Tilt axis */
+	glPolygonOffset(1.0, 1.0);
+	glEnable(GL_POLYGON_OFFSET_LINE);
 	glBegin(GL_LINES);
 		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, yellow);
 		glVertex3f(50, 0.0, 0.0);
@@ -424,6 +444,7 @@ static void displaywindow_gl_create_list(ControlContext *ctx) {
 		glVertex3f(50-5, 1.0, -1.0);
 		glVertex3f(50-5, 1.0, 1.0);
 	glEnd();
+	glDisable(GL_POLYGON_OFFSET_LINE);
 	
 	/* Plot the other reflections */
 	reflection = ctx->reflectionctx->reflections;
@@ -432,9 +453,9 @@ static void displaywindow_gl_create_list(ControlContext *ctx) {
 		
 		if ( reflection->type == REFLECTION_CENTRAL ) {
 		
-			glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, blue);
-			glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, blue_spec);
-			glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0);
+			glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
+			glMaterialfv(GL_FRONT, GL_SPECULAR, blue_spec);
+			glMaterialf(GL_FRONT, GL_SHININESS, 50.0);
 			glPushMatrix();
 			glTranslatef(reflection->x/1e9, reflection->y/1e9, reflection->z/1e9);
 			gluSphere(quadric, 0.2, 32, 32);
@@ -497,6 +518,8 @@ static void displaywindow_gl_create_list(ControlContext *ctx) {
 	/* Zero plane */
 	glBegin(GL_QUADS);
 		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, yellow_glass);
+		glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, yellow_glass_spec);
+		glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0);
 		glVertex3f(50, 50, 0.0);
 		glVertex3f(50, -50, 0.0);
 		glVertex3f(-50, -50, 0.0);
@@ -504,6 +527,8 @@ static void displaywindow_gl_create_list(ControlContext *ctx) {
 	glEnd();
 	
 	glEndList();
+	
+	printf("DW: Vertex counts: meas:%i, mark:%i, gen:%i\n", ctx->gl_ref_num_vertices, ctx->gl_marker_num_vertices, ctx->gl_gen_num_vertices);
 
 }
 
@@ -512,17 +537,17 @@ static gint displaywindow_gl_expose(GtkWidget *widget, GdkEventExpose *event, Co
 	GdkGLContext *glcontext = gtk_widget_get_gl_context(widget);
 	GdkGLDrawable *gldrawable = gtk_widget_get_gl_drawable(widget);
 	float m[4][4];
+	GLfloat green[] = { 0.0, 1.0, 0.0, 1.0 };
+	GLfloat blue[] = { 0.0, 0.0, 0.2, 1.0 };
+	GLfloat blue_spec[] = { 0.0, 0.0, 1.0, 1.0 };
+	GLfloat gold[] = { 0.5, 0.5, 0.0, 1.0 };
+	GLfloat gold_spec[] = { 0.9, 0.9, 0.0, 1.0 };
 	GLfloat light0_position[] = { 0.0, 0.0, 100.0, 0.0 };
 	GLfloat light0_diffuse[]  = { 1.0, 1.0, 1.0, 1.0 };
 	GLfloat light0_specular[] = { 0.5, 0.5, 0.5, 1.0 };
 	GLfloat light1_position[] = { 0.0, 0.0, -100.0, 0.0 };
 	GLfloat light1_diffuse[]  = { 0.8, 0.8, 0.8, 1.0 };
 	GLfloat light1_specular[] = { 0.5, 0.5, 0.5, 1.0 };
-	GLfloat green[] = { 0.0, 1.0, 0.0, 1.0 };
-	GLfloat blue[] = { 0.0, 0.0, 0.2, 1.0 };
-	GLfloat blue_spec[] = { 0.0, 0.0, 1.0, 1.0 };
-	GLfloat gold[] = { 0.5, 0.5, 0.0, 1.0 };
-	GLfloat gold_spec[] = { 0.7, 0.7, 0.0, 1.0 };
 	
 	if ( !gdk_gl_drawable_gl_begin(gldrawable, glcontext) ) {
 		return 0;
@@ -530,12 +555,6 @@ static gint displaywindow_gl_expose(GtkWidget *widget, GdkEventExpose *event, Co
 	
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ACCUM_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 	
-	glEnable(GL_DEPTH_TEST);
-	glEnable(GL_FOG);
-	glFogf(GL_FOG_DENSITY, 0.005);
-	glEnable(GL_BLEND);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-	
 	glLoadIdentity();
 	glTranslatef(displaywindow_x_pos, -displaywindow_y_pos, -displaywindow_distance);
 	build_rotmatrix(m, view_quat);
@@ -556,47 +575,59 @@ static gint displaywindow_gl_expose(GtkWidget *widget, GdkEventExpose *event, Co
 	glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
 	glEnableClientState(GL_VERTEX_ARRAY);
 	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, green);
-	glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_ref_vertex_buffer);
-	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, ctx->gl_ref_element_buffer);
-//	glVertexPointer(3, GL_FLOAT, 0, ctx->gl_ref_vertex_array);
-	glVertexPointer(3, GL_FLOAT, 0, NULL);
-//	glDrawRangeElements(GL_POINTS, 0, ctx->gl_ref_num_vertices, ctx->gl_ref_num_vertices, GL_UNSIGNED_INT, ctx->gl_ref_element_array);
-	glDrawRangeElements(GL_POINTS, 0, ctx->gl_ref_num_vertices, ctx->gl_ref_num_vertices, GL_UNSIGNED_INT, NULL);
+	if ( ctx->gl_use_buffers ) {
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_ref_vertex_buffer);
+		glVertexPointer(3, GL_FLOAT, 0, NULL);
+		glDrawArrays(GL_POINTS, 0, ctx->gl_ref_num_vertices);
+	} else {
+		glVertexPointer(3, GL_FLOAT, 0, ctx->gl_ref_vertex_array);
+		glDrawArrays(GL_POINTS, 0, ctx->gl_ref_num_vertices);
+	}
 	glPopClientAttrib();
-///	glBindBufferARB(GL_ARRAY_BUFFER, NULL);
-///	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, NULL);
 	
 	/* Draw marker points */
 	glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
 	glEnableClientState(GL_VERTEX_ARRAY);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, blue);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, blue_spec);
-	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0);
-	glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_marker_vertex_buffer);
-	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, ctx->gl_marker_element_buffer);
-//	glVertexPointer(3, GL_FLOAT, 0, ctx->gl_marker_vertex_array);
-	glVertexPointer(3, GL_FLOAT, 0, NULL);
-//	glDrawRangeElements(GL_QUADS, 0, ctx->gl_marker_num_vertices, ctx->gl_marker_num_vertices, GL_UNSIGNED_INT, ctx->gl_marker_element_array);
-	glDrawRangeElements(GL_QUADS, 0, ctx->gl_marker_num_vertices, ctx->gl_marker_num_vertices, GL_UNSIGNED_INT, NULL);
+	glEnableClientState(GL_NORMAL_ARRAY);
+	glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, blue);
+	glMaterialfv(GL_FRONT, GL_SPECULAR, blue_spec);
+	glMaterialf(GL_FRONT, GL_SHININESS, 50.0);
+	glPolygonOffset(1.0, 1.0);
+	glEnable(GL_POLYGON_OFFSET_FILL);
+	if ( ctx->gl_use_buffers ) {
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_marker_vertex_buffer);
+		glVertexPointer(3, GL_FLOAT, 0, NULL);
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_marker_normal_buffer);
+		glNormalPointer(GL_FLOAT, 0, NULL);
+		glDrawArrays(GL_QUADS, 0, ctx->gl_marker_num_vertices);
+	} else {
+		glVertexPointer(3, GL_FLOAT, 0, ctx->gl_marker_vertex_array);
+		glNormalPointer(GL_FLOAT, 0, ctx->gl_marker_normal_array);
+		glDrawArrays(GL_QUADS, 0, ctx->gl_marker_num_vertices);
+	}
+	glDisable(GL_POLYGON_OFFSET_FILL);
 	glPopClientAttrib();
-///	glBindBufferARB(GL_ARRAY_BUFFER, NULL);
-///	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, NULL);
 	
 	/* Draw generated reflections */
 	glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
 	glEnableClientState(GL_VERTEX_ARRAY);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, gold);
-	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, gold_spec);
-	glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 50.0);
-	glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_gen_vertex_buffer);
-	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, ctx->gl_gen_element_buffer);
-//	glVertexPointer(3, GL_FLOAT, 0, ctx->gl_gen_vertex_array);
-	glVertexPointer(3, GL_FLOAT, 0, NULL);
-//	glDrawRangeElements(GL_QUADS, 0, ctx->gl_gen_num_vertices, ctx->gl_gen_num_vertices, GL_UNSIGNED_INT, ctx->gl_gen_element_array);
-	glDrawRangeElements(GL_QUADS, 0, ctx->gl_gen_num_vertices, ctx->gl_gen_num_vertices, GL_UNSIGNED_INT, NULL);
+	glEnableClientState(GL_NORMAL_ARRAY);
+	glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, gold);
+	glMaterialfv(GL_FRONT, GL_SPECULAR, gold_spec);
+	glMaterialf(GL_FRONT, GL_SHININESS, 70.0);
+	if ( ctx->gl_use_buffers ) {
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_gen_vertex_buffer);
+		glVertexPointer(3, GL_FLOAT, 0, NULL);
+		glBindBufferARB(GL_ARRAY_BUFFER, ctx->gl_gen_normal_buffer);
+		glNormalPointer(GL_FLOAT, 0, NULL);
+		glDrawArrays(GL_QUADS, 0, ctx->gl_gen_num_vertices);
+		glBindBufferARB(GL_ARRAY_BUFFER, 0);			/* NOTE THIS PLZKTHX */
+	} else {
+		glVertexPointer(3, GL_FLOAT, 0, ctx->gl_gen_vertex_array);
+		glNormalPointer(GL_FLOAT, 0, ctx->gl_gen_normal_array);
+		glDrawArrays(GL_QUADS, 0, ctx->gl_gen_num_vertices);
+	}
 	glPopClientAttrib();
-	glBindBufferARB(GL_ARRAY_BUFFER, NULL);
-	glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER, NULL);
 	
 	/* Draw everything else */
 	glCallList(ctx->gl_list_id);
@@ -645,7 +676,13 @@ static gboolean displaywindow_gl_configure(GtkWidget *widget, GdkEventConfigure
 		return FALSE;
 	}
 	glViewport(0, 0, w, h);
-	gdk_gl_drawable_gl_end(gldrawable);
+	
+	glEnable(GL_DEPTH_TEST);
+	glEnable(GL_FOG);
+	glFogf(GL_FOG_DENSITY, 0.005);
+	glEnable(GL_BLEND);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glShadeModel(GL_SMOOTH);
 	
 	/* Nudge the projection matrix routines to preserve the aspect ratio */
 	if ( displaywindow_view == DW_ORTHO ) {
@@ -653,7 +690,9 @@ static gboolean displaywindow_gl_configure(GtkWidget *widget, GdkEventConfigure
 	} else {
 		displaywindow_gl_set_perspective(w, h);
 	}
-
+	
+	gdk_gl_drawable_gl_end(gldrawable);
+	
 	return FALSE;
 
 }
@@ -669,16 +708,13 @@ void displaywindow_open(ControlContext *ctx) {
 	const char *filename;
 	char *title;
 	GdkGLConfig *glconfig;
-	
-	/*o = gen_octtree(ctx->reflectionctx,15);
-	print_octtree(o);
-	int count=0;
-	ol = find_sparse_trees(o,3,1,&count);
-	*/	
+		
 	filename =  basename(ctx->filename);
 	title = malloc(10+strlen(filename));
-	strcpy(title, "dtr: ");
-	strcat(title, filename);
+	strcpy(title, filename);
+	strcat(title, " - dtr");
+	
+	ctx->gl_use_buffers = 1;
 	
 	displaywindow_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 	gtk_window_set_title(GTK_WINDOW(displaywindow_window), title);