void CylinderNode::recomputeDisplayList() {
unsigned int nCurrentDisplayList = getDisplayList();
if (0 < nCurrentDisplayList)
glDeleteLists(nCurrentDisplayList, 1);
unsigned int nNewDisplayList = glGenLists(1);
glNewList(nNewDisplayList, GL_COMPILE);
GLUquadricObj *quadObj;
glFrontFace(GL_CCW);
glPushMatrix ();
glMatrixMode(GL_TEXTURE);
glLoadIdentity();
glRotatef (180.0, 0.0, 1.0, 0.0);
glMatrixMode(GL_MODELVIEW);
glRotatef (180.0, 0.0, 1.0, 0.0);
glRotatef (90.0, 1.0, 0.0, 0.0);
glTranslatef (0.0, 0.0, -getHeight()/2.0f);
if (getSide()) {
quadObj = gluNewQuadric ();
gluQuadricDrawStyle(quadObj, GLU_FILL);
gluQuadricNormals(quadObj, GLU_SMOOTH);
gluQuadricTexture(quadObj, GL_TRUE);
gluCylinder(quadObj, getRadius(), getRadius(), getHeight(), 12, 2);
gluDeleteQuadric(quadObj);
}
if (getTop()) {
glPushMatrix ();
glRotatef (180.0, 1.0, 0.0, 0.0);
quadObj = gluNewQuadric ();
gluQuadricTexture(quadObj, GL_TRUE);
gluDisk(quadObj, 0.0, getRadius(), 12, 2);
gluDeleteQuadric(quadObj);
glPopMatrix ();
}
if (getBottom()) {
glTranslatef (0.0, 0.0, getHeight());
quadObj = gluNewQuadric ();
gluQuadricTexture(quadObj, GL_TRUE);
gluDisk(quadObj, 0.0, getRadius(), 12, 2);
gluDeleteQuadric(quadObj);
}
glPopMatrix ();
glEndList();
setDisplayList(nNewDisplayList);
};
/**
* Initialize the project, doing any necessary opengl initialization.
* @param camera An already-initialized camera.
* @param mesh The mesh to be rendered and subdivided.
* @param texture_filename The filename of the texture to use with the mesh.
* Is null if there is no texture data with the mesh or no texture filename
* was passed in the arguments, in which case textures should not be used.
* @return true on success, false on error.
*/
bool GeometryProject::initialize( const Camera* camera, const MeshData* mesh, const char* texture_filename )
{
this->mesh = *mesh;
/***********************************************/
textureHeight = -1;
textureWidth = -1;
if(texture_filename != NULL) {
textureArr = imageio_load_image(texture_filename, &textureWidth, &textureHeight);
} else {
hasTexture = false;
}
/************some initialization*****************/
glClearColor(0.0,0.0,0.0,0.0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_NORMALIZE);
/************texture********************/
if(textureHeight != -1 && textureWidth != -1)
{
hasTexture = true;
} else {
hasTexture = false;
}
std::cout<<"has Texture:"<<hasTexture<<"\n";
if(hasTexture) {
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, *textureArr);
glTexImage2D(GL_TEXTURE_2D, 0, 4, textureWidth, textureHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE,textureArr);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
}
/**************camera****************/
glMatrixMode(GL_PROJECTION);
gluPerspective(camera->get_fov_degrees(), camera->get_aspect_ratio(), camera->get_near_clip(), camera->get_far_clip());
glMatrixMode(GL_MODELVIEW);
/*************lights******************/
initLights();
/******read the data from the mesh, do some initialization**********/
std::cout<<"read the data from the mesh and do some initialization"<<"\n";
num_vertice = mesh->num_vertices;
oldVerticeArr = new Vertex[num_vertice];
oldAdjVerticeArr = new AdjVertice[num_vertice];
for(int i = 0; i < num_vertice; i++) {
oldVerticeArr[i] = mesh->vertices[i];
oldAdjVerticeArr[i].boundary = false;
oldAdjVerticeArr[i].num_AdjVertice = 0;
}
num_triangles = mesh->num_triangles;
oldTriangleArr = new Triangle[num_triangles];
for(int i = 0; i < num_triangles; i++) {
oldTriangleArr[i] = mesh->triangles[i];
}
/*********find the adj between vertices*****************/
std::cout<<"find the adj between vertices"<<"\n";
unsigned int index1, index2, index3;
for(int i = 0; i <num_triangles; i++) {
index1 = oldTriangleArr[i].vertices[0];
index2 = oldTriangleArr[i].vertices[1];
index3 = oldTriangleArr[i].vertices[2];
findAdjVertice(index1, index2, index3, oldAdjVerticeArr);
findAdjVertice(index2, index1, index3, oldAdjVerticeArr);
findAdjVertice(index3, index1, index2, oldAdjVerticeArr);
}
setDisplayList();
firstSubdivision = true;
// TODO opengl initialization code
return true;
}
/**
* Subdivide the mesh that we are rendering using Loop subdivison.
*/
void GeometryProject::subdivide()
{
// TODO perform a single subdivision.
/************switch the data of the changed array(new array) and the old one *****************/
//std::cout<<"some initialization and switch the new/odd array"<<"\n";
num_oddVertice = num_vertice;
vertice_index = num_oddVertice;
triangle_index = 0;
if(firstSubdivision) {
firstSubdivision = false;
} else {
delete []newVerticeArr;
delete []newTriangleArr;
delete []newAdjVerticeArr;
}
newVerticeArr = new Vertex[num_triangles * 3];
newTriangleArr = new Triangle[num_triangles * 4];
newAdjVerticeArr = new AdjVertice[num_triangles * 3];
for(int i = 0; i < num_vertice; i++) {
newAdjVerticeArr[i] = oldAdjVerticeArr[i];
}
for(int i = num_vertice; i < num_triangles * 3; i++) {
newAdjVerticeArr[i].num_AdjVertice = 0;
newAdjVerticeArr[i].boundary = false;
}
/***********first pass*****************/
//std::cout<<"first pass"<<"\n";
unsigned int newIndex1, newIndex2, newIndex3;
unsigned int index1, index2, index3;
for(int i = 0; i < num_triangles; i++) {
index1 = oldTriangleArr[i].vertices[0];
index2 = oldTriangleArr[i].vertices[1];
index3 = oldTriangleArr[i].vertices[2];
newIndex1 = createNewPoint(index1, index2);
newIndex2 = createNewPoint(index2, index3);
newIndex3 = createNewPoint(index1, index3);
formNewTriangle(index1, index2, index3, newIndex1, newIndex2, newIndex3);
}
num_vertice = vertice_index;
num_triangles = triangle_index;
/*******find new adj between vertices**********/
//std::cout<<"find new adj between vertices"<<"\n";
for(int i = 0; i < num_triangles; i++) {
index1 = newTriangleArr[i].vertices[0];
index2 = newTriangleArr[i].vertices[1];
index3 = newTriangleArr[i].vertices[2];
if(index1 >= num_oddVertice) {
findAdjVertice(index1, index2, index3, newAdjVerticeArr);
}
if(index2 >= num_oddVertice) {
findAdjVertice(index2, index1, index3, newAdjVerticeArr);
}
if(index3 >= num_oddVertice) {
findAdjVertice(index3, index1, index2, newAdjVerticeArr);
}
}
/***********second pass****************/
//std::cout<<"second pass"<<"\n";
double beta;
Vector3 newPos;
Vector2 newTexCord;
int boundaryIndex = 0;
unsigned int tempBoundary[2];
for(int i = 0; i < num_oddVertice; i++) {
if(!oldAdjVerticeArr[i].boundary) { //interior
beta = (0.625 - pow((0.375 + (cos(2 * PI / oldAdjVerticeArr[i].num_AdjVertice) / 4)),2)) / oldAdjVerticeArr[i].num_AdjVertice;
newPos = (1 - beta * oldAdjVerticeArr[i].num_AdjVertice) * oldVerticeArr[i].position;
if(hasTexture) {
newTexCord = (1 - beta * oldAdjVerticeArr[i].num_AdjVertice) * oldVerticeArr[i].texture_coord;
}
for(int j = 0; j <oldAdjVerticeArr[i].num_AdjVertice; j++) {
newPos += beta * oldVerticeArr[oldAdjVerticeArr[i].adjArray[j]].position;
if(hasTexture) {
newTexCord += beta * oldVerticeArr[oldAdjVerticeArr[i].adjArray[j]].texture_coord;
}
}
if(hasTexture) {
newVerticeArr[i].texture_coord = newTexCord;
}
newVerticeArr[i].position = newPos;
} else { //boundary
boundaryIndex = 0;
for(int j = 0; j < oldAdjVerticeArr[i].num_AdjVertice; j++) {
if(oldAdjVerticeArr[oldAdjVerticeArr[i].adjArray[j]].boundary) {
tempBoundary[boundaryIndex] = oldAdjVerticeArr[i].adjArray[j];
boundaryIndex++;
if(boundaryIndex == 2) goto endloop; // after finding two adjacent boundary vertices, jump out of the loop
}
}
endloop:
newPos = 3 * oldVerticeArr[i].position / 4
+ oldVerticeArr[tempBoundary[0]].position / 8
+ oldVerticeArr[tempBoundary[1]].position / 8;
newVerticeArr[i].position = newPos;
if(hasTexture) {
newTexCord = 3 * oldVerticeArr[i].texture_coord / 4
+ oldVerticeArr[tempBoundary[0]].texture_coord / 8
+ oldVerticeArr[tempBoundary[1]].texture_coord / 8;
newVerticeArr[i].texture_coord = newTexCord;
}
}
}
/***************************************************************/
/**********switch the new array to the old one for drawing**********/
//std::cout<<"swtich the new to the old"<<"\n";
delete []oldTriangleArr;
oldTriangleArr = new Triangle[triangle_index];
for(int i = 0; i < triangle_index; i++) {
oldTriangleArr[i] = newTriangleArr[i];
}
delete []oldVerticeArr;
oldVerticeArr = new Vertex[vertice_index];
for(int i = 0; i < vertice_index; i++) {
oldVerticeArr[i] = newVerticeArr[i];
oldVerticeArr[i].normal = Vector3(0,0,0);
}
delete []oldAdjVerticeArr;
oldAdjVerticeArr = new AdjVertice[vertice_index];
for(int i = 0; i < vertice_index; i++) {
oldAdjVerticeArr[i] = newAdjVerticeArr[i];
}
/**********compute normals********************/
//std::cout<<"comput normals"<<"\n";
Vector3 tempPoint1, tempPoint2, tempPoint3, normalVec;
for( int i = 0; i < num_triangles; i++) {
//std::cout<<"triangle nums:"<<i<<":"<<num_triangles<<"\n";
index1 = oldTriangleArr[i].vertices[0];
index2 = oldTriangleArr[i].vertices[1];
index3 = oldTriangleArr[i].vertices[2];
//std::cout<<"index123:"<<index1<<" + "<<index2<<" + "<<index3<<" total num:" << num_vertex<<"\n";
tempPoint1 = oldVerticeArr[index1].position;
tempPoint2 = oldVerticeArr[index2].position;
tempPoint3 = oldVerticeArr[index3].position;
normalVec = cross((tempPoint2 - tempPoint1),(tempPoint3 - tempPoint1));
oldVerticeArr[index1].normal += normalVec;
oldVerticeArr[index2].normal += normalVec;
oldVerticeArr[index3].normal += normalVec;
}
for( int i = 0; i < num_vertice; i++) {
oldVerticeArr[i].normal = normalize(oldVerticeArr[i].normal);
}
setDisplayList();
}
