legacy/rts_glOBJ.cpp

#include "rts_glOBJ.h"
#include "gl\glut.h"

OBJint rts_glOBJ::f_RenderTexCoord(vertex_texture &texcoord)
{
	if(texcoord.mask & OBJ_VT_W)
		glTexCoord3f(texcoord.u, texcoord.v, texcoord.w);
	else if(texcoord.mask & OBJ_VT_V)
		glTexCoord2f(texcoord.u, texcoord.v);
	else
		glTexCoord1f(texcoord.u);
	return OBJ_OK;
}

OBJint rts_glOBJ::f_RenderNormal(vertex_normal &normal)
{
	if(normal.mask & OBJ_VN_K)
		glNormal3f(normal.i, normal.j, normal.k);
	else
		return OBJ_ERROR;

	return OBJ_OK;

}

OBJint rts_glOBJ::f_RenderVertex(vertex_position &v)
{
	if(v.mask & OBJ_V_W)
		glVertex4f(v.x, v.y, v.z, v.w);
	else if(v.mask & OBJ_V_Z)
		glVertex3f(v.x, v.y, v.z);
	else if(v.mask & OBJ_V_Y)
		glVertex2f(v.x, v.y);
	else
		//glVertex1f(v.x);
		return OBJ_ERROR;

	return OBJ_OK;
}

inline void rts_glOBJ::f_RenderPointList(unsigned int id)
{
	glBegin(GL_POINTS);
	unsigned int num_vertices = primitives[id].p.size();
	for(unsigned int v = 0; v<num_vertices; v++)
	{
		f_RenderVertex(v_list[primitives[id].p[v].v]);
	}
	glEnd();
}

inline void rts_glOBJ::f_RenderLineStrip(unsigned int id)
{
	//render each line as a line strip
	glBegin(GL_LINE_STRIP);
	unsigned int num_vertices = primitives[id].p.size();
	for(unsigned int v=0; v<num_vertices; v++)
	{
		f_RenderVertex(v_list[primitives[id].p[v].v]);
	}

	//end rendering
	glEnd();

}

inline void rts_glOBJ::f_RenderFace(unsigned int id)
{
	//start the proper render mode
	if(primitives[id].p.size() > 4)
		glBegin(GL_POLYGON);
	else if(primitives[id].p.size() == 4)
		glBegin(GL_QUADS);
	else if(primitives[id].p.size() == 3)
		glBegin(GL_TRIANGLES);
	else
		return;

	//now run through each vertex
	unsigned int num_vertices = primitives[id].p.size();
	for(unsigned int v=0; v<num_vertices; v++)
	{
		f_RenderVertex(v_list[primitives[id].p[v].v]);
	}

	//end rendering
	glEnd();

}

OBJint rts_glOBJ::f_RenderPrimitive(unsigned int i)
{
	switch(primitives[i].type)
	{
	case OBJ_POINTS:
		f_RenderPointList(i);
		break;
	case OBJ_LINES:
		f_RenderLineStrip(i);
		break;
	case OBJ_FACE:
		f_RenderFace(i);
		break;
	}

	return OBJ_OK;

}

OBJint rts_glOBJ::f_CreateDisplayList()
{
	/*This function creates a display list representing the OBJ.
	*/
	
	//create the display list
	if(glIsList(dl))	//if the list already exists
		glDeleteLists(dl, 1);
	//create a new display list
	dl = glGenLists(1);

	//start the list
	glNewList(dl, GL_COMPILE);

	//draw the OBJ
	unsigned int prim = primitives.size();
	for(unsigned int i=0; i<prim; i++)
		f_RenderPrimitive(i);

	//finish the list
	glEndList();

	dl_valid = true;	//the display list is now valid

	return OBJ_OK;
}

OBJint rts_glOBJ::glRender()
{
	//create the display list if necessary
	if(!dl_valid)
		f_CreateDisplayList();

	//call the display list
	glCallList(dl);

	return OBJ_OK;
}

OBJint rts_glOBJ::glRenderSelected()
{
	if(is_selected)
	{
		list<unsigned int>::iterator p;
		for(p = selected_primitives.begin(); p!=selected_primitives.end(); p++)
			f_RenderPrimitive(*p);
	}
	return OBJ_OK;
}


void rts_glOBJ::SelectPrimitive(unsigned int primitive)
{
	//adds a primitive to the selection list
	selected_primitives.push_back(primitive);
	selected_primitives.unique();
}

void rts_glOBJ::UnselectPrimitive(unsigned int primitive)
{
	selected_primitives.remove(primitive);
}

void rts_glOBJ::SelectMultipleHits(GLuint* buffer, unsigned int num_hits)
{
	GLuint* hit_entry = buffer;
	GLuint num_names;
	GLuint nearest_name;
	GLuint minZ = 0xffffffff;
	
	//push the hits into the selection buffer
	for(int h=0; h<num_hits; h++)
	{
		num_names = hit_entry[0];
		SelectPrimitive(hit_entry[3]);
	
		hit_entry = hit_entry + 3 + num_names;
	}

}

void rts_glOBJ::UnselectMultipleHits(GLuint* buffer, unsigned int num_hits)
{
	GLuint* hit_entry = buffer;
	GLuint num_names;
	GLuint nearest_name;
	GLuint minZ = 0xffffffff;
	
	//push the hits into the selection buffer
	for(int h=0; h<num_hits; h++)
	{
		num_names = hit_entry[0];
		UnselectPrimitive(hit_entry[3]);
	
		hit_entry = hit_entry + 3 + num_names;
	}

}

void rts_glOBJ::SelectClosestHit(GLuint* buffer, unsigned int num_hits)
{
	GLuint* hit_entry = buffer;
	GLuint num_names;
	GLuint nearest_name;
	GLuint minZ = 0xffffffff;
	
	//push the hits into the selection buffer
	for(int h=0; h<num_hits; h++)
	{
		num_names = hit_entry[0];
		if(hit_entry[1] < minZ)
		{
			nearest_name = hit_entry[3];
			minZ = hit_entry[1];
		}		
		hit_entry = hit_entry + 3 + num_names;

	}
	SelectPrimitive(nearest_name);

}

void rts_glOBJ::UnselectClosestHit(GLuint* buffer, unsigned int num_hits)
{
	GLuint* hit_entry = buffer;
	GLuint num_names;
	GLuint nearest_name;
	GLuint minZ = 0xffffffff;
	
	//push the hits into the selection buffer
	for(int h=0; h<num_hits; h++)
	{
		num_names = hit_entry[0];
		if(hit_entry[1] < minZ)
		{
			nearest_name = hit_entry[3];
			minZ = hit_entry[1];
		}		
		hit_entry = hit_entry + 3 + num_names;

	}
	UnselectPrimitive(nearest_name);

}


void rts_glOBJ::Pick(unsigned int x, unsigned int y, unsigned int size_x, unsigned int size_y,
					 unsigned int picktype)
{
	//initialize selection buffer properties
	GLuint selectBuf[BUFSIZE];
	GLint hits;
	GLint viewport[4];		//storage space for viewport data

	//get the viewport information
	glGetIntegerv(GL_VIEWPORT, viewport);
	
	//set the selection buffer
	glSelectBuffer(BUFSIZE, selectBuf);

	//set the render mode to selection
	glRenderMode(GL_SELECT);

	//we pick the object with the assumption that the active projection
	//matrix is the one used to display the object in the viewport

	//get the current projection matrix
	float projection[16];
	glGetFloatv(GL_PROJECTION_MATRIX, projection);

	//save and reset the current projection matrix
	glMatrixMode(GL_PROJECTION);
	glPushMatrix();
	glLoadIdentity();

	//set the picking matrix using GLU
	gluPickMatrix(x, viewport[3] - y, size_x, size_y, viewport);
	//multiply in the saved projection matrix
	glMultMatrixf(projection);

	//Draw the object with names for each primitive.

	int num_prim = primitives.size();	//get the number of primitives
	glInitNames();						//set the name stack to zero
	for(int p = 0; p < num_prim; p++)
	{
		glPushName(p);				//push the name on to the stack
		f_RenderPrimitive(p);			//render the primitive
		glPopName();
	}

	glFinish();				//force the rendering to complete	

	hits = glRenderMode(GL_RENDER);		//find the number of hits

	if(hits)					//if there is a hit, select the OBJ and the primitive
	{
		is_selected = true;		//select the object

		//if this is a new selection, clear the list
		if(picktype == RTS_GLOBJ_SINGLE_NEW_SELECTION || 
		   picktype == RTS_GLOBJ_MULTI_NEW_SELECTION)
			selected_primitives.clear();

		//if this is adding multiple hits to the selection list
		if(picktype == RTS_GLOBJ_MULTI_NEW_SELECTION ||
		   picktype == RTS_GLOBJ_MULTI_ADD_SELECTION)
			SelectMultipleHits(selectBuf, hits);

		if(picktype == RTS_GLOBJ_SINGLE_NEW_SELECTION ||
		   picktype == RTS_GLOBJ_SINGLE_ADD_SELECTION)
			SelectClosestHit(selectBuf, hits);

		if(picktype == RTS_GLOBJ_SINGLE_SUB_SELECTION)
			UnselectClosestHit(selectBuf, hits);

		if(picktype == RTS_GLOBJ_MULTI_SUB_SELECTION)
			UnselectMultipleHits(selectBuf, hits);
		//SelectPrimitive(processHits(selectBuf, hits), picktype);
		//selected_primitives.clear();
		
		//select the primitive
		//selected_primitives.push_back(processHits(selectBuf, hits));
	}
	else
		is_selected = false;

	//restore the previous projection matrix
	glMatrixMode(GL_PROJECTION);
	glPopMatrix();

}
rts_glOBJ rts_glOBJ::GetSelected()
{
	//right now this creates duplicate vertices
	
	rts_glOBJ result;

	//for each primitive
	list<unsigned int>::iterator p;
	for(p = selected_primitives.begin(); p != selected_primitives.end(); p++)
	{
		primitive selected_prim = primitives[(*p)];
		//create a new primitive
		primitive new_prim;
		new_prim.mask = selected_prim.mask;
		new_prim.type = selected_prim.type;

		//for each vertex in the primitive
		int num_vertices = selected_prim.p.size();
		for(int v = 0; v<num_vertices; v++)
		{
			vertex new_vert;
			if(new_prim.mask & OBJ_V)	//if the primitive has a vertex coord
			{
				new_vert.v = result.v_list.size();
				new_prim.p.push_back(new_vert);
				result.v_list.push_back(v_list[selected_prim.p[v].v]);				
			}
		}
		result.primitives.push_back(new_prim);
	}

	return result;


}

void rts_glOBJ::ExpandSelection()
{
	/*
	//create a list of all selected vertices
	list<unsigned int> selected_v;

	list<unsigned int>::iterator p;	//selected primitive
	vector<vertex>::iterator v;		//vertex

	//insert all selected vertex indices into selected_v
	for(p = selected_primitives.begin(); p!=selected_primitives.end(); p++)
	{
		for(v=primitives[(*p)].p.begin(); v!=primitives[(*p)].p.end(); v++)
		{
			selected_v.push_back((*v).v);
		}
	}
	selected_v.unique();	//remove redundant entries

	//now find all primitives connected to these vertices
	int num_primitives = primitives.size();
	int prim;
	list<unsigned int>::iterator s_v;
	for(prim =0; prim<num_primitives; prim++)
	{
		for(v=primitives[prim].p.begin(); v!=primitives[prim].p.end(); v++)
		{
			for(s_v = selected_v.begin(); s_v!=selected_v.end(); s_v++)
			{
				if((*s_v) == (*v).v)
				{
					selected_primitives.push_back(prim);
				}
			}
		}
	}
		selected_primitives.unique();

	*/
	

	//create the vertex-primitive list
	vector<unsigned int>* vertex_to_prim = new vector<unsigned int>[v_list.size()];
	int num_primitives = primitives.size();
	int p;
	int num_vertices, v;
	int vertex;
	for(p=0; p<num_primitives; p++)
	{
		num_vertices = primitives[p].p.size();
		for(v = 0; v<num_vertices; v++)
		{
			vertex = primitives[p].p[v].v;
			vertex_to_prim[vertex].push_back(p);
		}
	}

	//create the list of selected vertices
	list<unsigned int> selected_verts;
	list<unsigned int>::iterator sel;
	for(sel = selected_primitives.begin(); sel != selected_primitives.end(); sel++)
	{
		num_vertices = primitives[(*sel)].p.size();
		for(v=0; v<num_vertices; v++)
		{
			selected_verts.push_back(primitives[(*sel)].p[v].v);
		}
	}
	selected_verts.unique();

	//erase the selected array
	selected_primitives.clear();
	list<unsigned int>::iterator s_v;
	for(s_v = selected_verts.begin(); s_v != selected_verts.end(); s_v++)
	{
		num_primitives = vertex_to_prim[(*s_v)].size();
		for(p=0; p<num_primitives; p++)
			selected_primitives.push_back(vertex_to_prim[(*s_v)][p]);
	}
	cout<<"Before: "<<selected_primitives.size()<<endl;

	selected_primitives.sort();
	selected_primitives.unique();
	cout<<"After: "<<selected_primitives.size()<<endl;
	

}