// Goes through the vertices with that no. of verts, and draws them.
void cObjModel::createListFace(vector<cObject>::iterator j, vector<cMaterial>::iterator &m, 
		vector<int>::size_type &k, string &mName, unsigned int vertno, bool transp) {
	// While still in range, and we have that no. of verts.
	while (k != j->face.size() && j->face[k].vertex.size() == vertno) {
		// If we have the right material carry on and draw it.
		if (mName == j->face[k].material) {
			// Make sure this is the right list for it.
			if (transp && m->dissolve == 1.f || !transp && m->dissolve != 1.f) {
				++k;
				continue;
			}
			// Draw the face, with texture coords if it has a texture.
			for (vector<int>::size_type l = 0; l != vertno; ++l) {
				if (m->texture) {
					glTexCoord2f(texCoord[j->face[k].texCoord[l]].u(),
						texCoord[j->face[k].texCoord[l]].v());
				}
				glNormal3f(normal[j->face[k].normal[l]].x(),
					normal[j->face[k].normal[l]].y(),
					normal[j->face[k].normal[l]].z());
				glVertex3f(vertex[j->face[k].vertex[l]].x(),
					vertex[j->face[k].vertex[l]].y(),
					vertex[j->face[k].vertex[l]].z());
			}
			++k;
		// We need to find the right material.
		} else {
			mName = j->face[k].material;
			// Set m to point to the right material.
			for (m = material.begin(); m != material.end(); ++m) {
				if (m->name == mName) {
					break;
				}
			}
			// N.B. At the moment no colour blending with texture...
			// If we have a texture, set it.
			if (m->texture) {
				glBindTexture(GL_TEXTURE_2D, m->texture);
			// Set the new material parameters.
			} else {
				//float Ka[] = {m->refAmbient.r(), m->refAmbient.g(), m->refAmbient.b(), m->dissolve};
				float Kd[] = {m->refDiffuse.r(), m->refDiffuse.g(), m->refDiffuse.b(), m->dissolve};
				float Ks[] = {m->refSpecular.r(), m->refSpecular.g(), m->refSpecular.b(), m->dissolve};
				glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, Kd);
				glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, Kd);
				glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, Ks);
				glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, &(m->specExp));
			}
		}
	}
}

// It would be easier here to just use multiple calls to glBegin(GL_POLYGON), but
// apparently that's pretty costly, and shouldn't be done, so we do the whole
// sorting thing instead. :-/
void cObjModel::createList() {
	// Sorts faces by number of vertices, then by material.
	for (vector<cObject>::iterator j = object.begin(); j != object.end(); ++j) {
		sort(j->face.begin(), j->face.end());
	}
	
	// Set up the list for opaque surfaces.
	opaqueListID = glGenLists(2);
	glNewList(opaqueListID, GL_COMPILE);
		for (vector<cObject>::iterator j = object.begin(); j != object.end(); ++j) {
			vector<int>::size_type k = 0;
			string mName = "";
			vector<cMaterial>::iterator m = material.begin();
			glBegin(GL_TRIANGLES);
				createListFace(j, m, k, mName, 3, 0);
			glEnd();
			glBegin(GL_QUADS);
				createListFace(j, m, k, mName, 4, 0);
			glEnd();
		}
	glEndList();
	
	// Set up the list for transparent surfaces
	transpListID = opaqueListID + 1;
	glNewList(transpListID, GL_COMPILE);
		glEnable(GL_BLEND);
		glDepthMask(GL_FALSE);
		for (vector<cObject>::iterator j = object.begin(); j != object.end(); ++j) {
			vector<int>::size_type k = 0;
			string mName = "";
			vector<cMaterial>::iterator m = material.begin();
			glBegin(GL_TRIANGLES);
				createListFace(j, m, k, mName, 3, 1);
			glEnd();
			glBegin(GL_QUADS);
				createListFace(j, m, k, mName, 4, 1);
			glEnd();
		}
		glDepthMask(GL_TRUE);
		glDisable(GL_BLEND);
	glEndList();
}

void cApp::reshape(int sx, int sy) {
	// Set the new width / height.
	glViewport(0, 0, sx, sy);
	
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	
	// Calculate the new aspect ratio (fov and clipping planes constant).
	gluPerspective(45.f, GLfloat(sx) / GLfloat(sy), 0.f, 100.f);
	
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

bool cApp::initOGL() {
	// Set up OGL viewport and perspective.
	reshape(S_WIDTH, S_HEIGHT);
	
	GLfloat L0Amb[] = { 0.2, 0.2, 0.2, 1 }; GLfloat L0Diff[] = { 1, 1, 1, 1 };
	GLfloat L0Spec[] = { 0.5, 0.5, 0.5, 1 }; GLfloat L0Pos[] = { 0, 5, 0, 1 };
	glLightfv(GL_LIGHT0, GL_AMBIENT, L0Amb); glLightfv(GL_LIGHT0, GL_DIFFUSE, L0Diff);
	glLightfv(GL_LIGHT0, GL_SPECULAR, L0Spec); glLightfv(GL_LIGHT0, GL_POSITION, L0Pos);
	
	glEnable(GL_LIGHT0);
	glEnable(GL_LIGHTING);
	glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
	
	glShadeModel(GL_SMOOTH);
	glColor4f(0.9,0.6,0.2,1);
	glClearColor(0,0,0,0.5);
	glClearDepth(1);
	
	glDepthFunc(GL_GEQUAL);
	glEnable(GL_DEPTH_TEST);
	
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
	
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glEnable(GL_TEXTURE_2D);
	
	return true;
}