毕业设计view.cpp

毕业设计作品

					}
				}
				else 
				{
					/* v */
					sscanf(buf, "%d", &v);
					T(numtriangles).vindices[0] = v;
					fscanf(file, "%d", &v);
					T(numtriangles).vindices[1] = v;
					fscanf(file, "%d", &v);
					T(numtriangles).vindices[2] = v;
					group->triangles[group->numtriangles++] = numtriangles;
					numtriangles++;
					while(fscanf(file, "%d", &v) > 0)
					{
						T(numtriangles).vindices[0] = T(numtriangles-1).vindices[0];
						T(numtriangles).vindices[1] = T(numtriangles-1).vindices[2];
						T(numtriangles).vindices[2] = v;
						group->triangles[group->numtriangles++] = numtriangles;
						numtriangles++;
					}
				}
				break;
				
    default:
		fgets(buf, sizeof(buf), file);
		break;
    }
  }

#if 0
  printf(" Memory: %d bytes\n",
	  numvertices  * 3*sizeof(GLfloat) +
	  numnormals   * 3*sizeof(GLfloat) * (numnormals ? 1 : 0) +
	  numtexcoords * 3*sizeof(GLfloat) * (numtexcoords ? 1 : 0) +
	  numtriangles * sizeof(GLMtriangle));
#endif
}

GLfloat CMyView::glmUnitize(GLMmodel* model)
{
	GLuint  i;
	GLfloat maxx, minx, maxy, miny, maxz, minz;
	GLfloat cx, cy, cz, w, h, d;
	GLfloat scale;
	
	assert(model);
	assert(model->vertices);
	
	maxx = minx = model->vertices[3 + 0];
	maxy = miny = model->vertices[3 + 1];
	maxz = minz = model->vertices[3 + 2];

	for (i = 1; i <= model->numvertices; i++)
	{
		if (maxx < model->vertices[3 * i + 0])
		{
			maxx = model->vertices[3 * i + 0];
		}
		
		if (minx > model->vertices[3 * i + 0])
		{
			minx = model->vertices[3 * i + 0];
		}		
		
		if (maxy < model->vertices[3 * i + 1])
		{
			maxy = model->vertices[3 * i + 1];
		}
		
		if (miny > model->vertices[3 * i + 1])
		{
			miny = model->vertices[3 * i + 1];
		}
		
		if (maxz < model->vertices[3 * i + 2])
		{
			maxz = model->vertices[3 * i + 2];
		}
		
		if (minz > model->vertices[3 * i + 2])
		{
			minz = model->vertices[3 * i + 2];
		}
		
	}

  /* 计算模型的高度、宽度和深度 */
	w = glmAbs(maxx) + glmAbs(minx);
	h = glmAbs(maxy) + glmAbs(miny);
	d = glmAbs(maxz) + glmAbs(minz);

  /* 计算模型的中心位置 */
	cx = (maxx + minx) / 2.0f;
	cy = (maxy + miny) / 2.0f;
	cz = (maxz + minz) / 2.0f;
	
	/* 计算序列化系数 */
	scale = 2.0f / glmMax(glmMax(w, h), d);

  /* 围绕中心平移和缩放 */
	for (i = 1; i <= model->numvertices; i++)
	{
		model->vertices[3 * i + 0] -= cx;
		model->vertices[3 * i + 1] -= cy;
		model->vertices[3 * i + 2] -= cz;
		model->vertices[3 * i + 0] *= scale;
		model->vertices[3 * i + 1] *= scale;
		model->vertices[3 * i + 2] *= scale;
	}
	
	return scale;
}

GLvoid CMyView::glmDimensions(GLMmodel* model, GLfloat* dimensions)
{
	GLuint i;
	GLfloat maxx, minx, maxy, miny, maxz, minz;
	
	assert(model);
	assert(model->vertices);
	assert(dimensions);
	
	maxx = minx = model->vertices[3 + 0];
	maxy = miny = model->vertices[3 + 1];
	maxz = minz = model->vertices[3 + 2];

	for (i = 1; i <= model->numvertices; i++)
	{
		if (maxx < model->vertices[3 * i + 0])
		{
			maxx = model->vertices[3 * i + 0];
		}
			
		if (minx > model->vertices[3 * i + 0])
		{
			minx = model->vertices[3 * i + 0];
		}			
		
		if (maxy < model->vertices[3 * i + 1])
		{
			maxy = model->vertices[3 * i + 1];
		}			

		if (miny > model->vertices[3 * i + 1])
		{
			miny = model->vertices[3 * i + 1];
		}			
		
		if (maxz < model->vertices[3 * i + 2])
		{
			maxz = model->vertices[3 * i + 2];
		}
			

		if (minz > model->vertices[3 * i + 2])
		{
			minz = model->vertices[3 * i + 2];
		}
		
	}

  /* 计算模型的宽度、高度和深度 */
	dimensions[0] = glmAbs(maxx) + glmAbs(minx);
	dimensions[1] = glmAbs(maxy) + glmAbs(miny);
	dimensions[2] = glmAbs(maxz) + glmAbs(minz);
}

/* 缩放模型 */
GLvoid CMyView::glmScale(GLMmodel* model, GLfloat scale)
{
	GLuint i;
	
	for (i = 1; i <= model->numvertices; i++)
	{
		model->vertices[3 * i + 0] *= scale;
		model->vertices[3 * i + 1] *= scale;
		model->vertices[3 * i + 2] *= scale;
	}
}

GLvoid CMyView::glmReverseWinding(GLMmodel* model)
{
	GLuint i, swap;
	
	assert(model);
	
	for (i = 0; i < model->numtriangles; i++)
	{
		swap = T(i).vindices[0];
		T(i).vindices[0] = T(i).vindices[2];
		T(i).vindices[2] = swap;
		
		if (model->numnormals)
		{
			swap = T(i).nindices[0];
			T(i).nindices[0] = T(i).nindices[2];
			T(i).nindices[2] = swap;
		}
		
		if (model->numtexcoords)
		{
			swap = T(i).tindices[0];
			T(i).tindices[0] = T(i).tindices[2];
			T(i).tindices[2] = swap;
		}
	}

  /* 将面法向量取反 */
	for (i = 1; i <= model->numfacetnorms; i++)
	{
		model->facetnorms[3 * i + 0] = -model->facetnorms[3 * i + 0];
		model->facetnorms[3 * i + 1] = -model->facetnorms[3 * i + 1];
		model->facetnorms[3 * i + 2] = -model->facetnorms[3 * i + 2];
	}

  /* 将顶点法向量取反 */
	for (i = 1; i <= model->numnormals; i++)
	{
		model->normals[3 * i + 0] = -model->normals[3 * i + 0];
		model->normals[3 * i + 1] = -model->normals[3 * i + 1];
		model->normals[3 * i + 2] = -model->normals[3 * i + 2];
	}
}

GLvoid CMyView::glmFacetNormals(GLMmodel* model)
{
	GLuint  i;
	GLfloat u[3];
	GLfloat v[3];
	
	assert(model);
	assert(model->vertices);
  
	if (model->facetnorms)
	{
		free(model->facetnorms);
	}		

  /* 为新的面法向量分配内存 */
	model->numfacetnorms = model->numtriangles;
	model->facetnorms = (GLfloat*)malloc(sizeof(GLfloat) *
		3 * (model->numfacetnorms + 1));
	
	for (i = 0; i < model->numtriangles; i++)
	{
		model->triangles[i].findex = i+1;
		
		u[0] = model->vertices[3 * T(i).vindices[1] + 0] -
			model->vertices[3 * T(i).vindices[0] + 0];
		u[1] = model->vertices[3 * T(i).vindices[1] + 1] -
			model->vertices[3 * T(i).vindices[0] + 1];
		u[2] = model->vertices[3 * T(i).vindices[1] + 2] -
			model->vertices[3 * T(i).vindices[0] + 2];
		
		v[0] = model->vertices[3 * T(i).vindices[2] + 0] -
			model->vertices[3 * T(i).vindices[0] + 0];
		v[1] = model->vertices[3 * T(i).vindices[2] + 1] -
			model->vertices[3 * T(i).vindices[0] + 1];
		v[2] = model->vertices[3 * T(i).vindices[2] + 2] -
			model->vertices[3 * T(i).vindices[0] + 2];
		
		glmCross(u, v, &model->facetnorms[3 * (i+1)]);
		glmNormalize(&model->facetnorms[3 * (i+1)]);
	}
}

GLvoid CMyView::glmVertexNormals(GLMmodel* model, GLfloat angle)
{
	GLMnode*  node;
	GLMnode*  tail;
	GLMnode** members;
	GLfloat*  normals;
	GLuint    numnormals;
	GLfloat   average[3];
	GLfloat   dot, cos_angle;
	GLuint    i, avg;
	
	assert(model);
	assert(model->facetnorms);

	cos_angle = fcos(angle * M_PI / 180.0f);
	
	if (model->normals)		
	{
		free(model->normals);
	}
	
	/* 为新法向量分配内存 */
	model->numnormals = model->numtriangles * 3; 
	model->normals = (GLfloat*)malloc(sizeof(GLfloat)* 3* (model->numnormals+1));
	
	members = (GLMnode**)malloc(sizeof(GLMnode*) * (model->numvertices + 1));

	for (i = 1; i <= model->numvertices; i++)
	{
		members[i] = NULL;
	}
	
  /* 为每个三角形创建节点 */
	for (i = 0; i < model->numtriangles; i++)
	{
		node = (GLMnode*)malloc(sizeof(GLMnode));
		node->index = i;
		node->next  = members[T(i).vindices[0]];
		members[T(i).vindices[0]] = node;
		
		node = (GLMnode*)malloc(sizeof(GLMnode));
		node->index = i;
		node->next  = members[T(i).vindices[1]];
		members[T(i).vindices[1]] = node;
		
		node = (GLMnode*)malloc(sizeof(GLMnode));
		node->index = i;
		node->next  = members[T(i).vindices[2]];
		members[T(i).vindices[2]] = node;
	}
	
	/* 计算每个顶点的平均法向量 */
	numnormals = 1;
	for (i = 1; i <= model->numvertices; i++)
	{
		node = members[i];
		if (!node)
		{
			fprintf(stderr, "glmVertexNormals(): vertex w/o a triangle\n");
		}
		
		average[0] = 0.0; average[1] = 0.0; average[2] = 0.0;
		avg = 0;
		
		while (node)
		{
			dot = glmDot(&model->facetnorms[3 * T(node->index).findex],
				&model->facetnorms[3 * T(members[i]->index).findex]);
			if (dot > cos_angle)
			{
				node->averaged = GL_TRUE;
				average[0] += model->facetnorms[3 * T(node->index).findex + 0];
				average[1] += model->facetnorms[3 * T(node->index).findex + 1];
				average[2] += model->facetnorms[3 * T(node->index).findex + 2];
				avg = 1;			
			}
			else
			{
				node->averaged = GL_FALSE;
			}
			node = node->next;
		}
		
		if (avg)
		{			
			glmNormalize(average);
			
			model->normals[3 * numnormals + 0] = average[0];
			model->normals[3 * numnormals + 1] = average[1];
			model->normals[3 * numnormals + 2] = average[2];
			avg = numnormals;
			numnormals++;
		}
		
		node = members[i];

		while (node)
		{
			if (node->averaged)
			{
				/* 如果这个法向量已经平均化，则使用这个法向量 */
				if (T(node->index).vindices[0] == i)
				{
					T(node->index).nindices[0] = avg;
				}
				else if (T(node->index).vindices[1] == i)
				{
					T(node->index).nindices[1] = avg;
				}
				else if (T(node->index).vindices[2] == i)
				{
					T(node->index).nindices[2] = avg;
				}
			}
			else
			{
				model->normals[3 * numnormals + 0] = 
					model->facetnorms[3 * T(node->index).findex + 0];
				model->normals[3 * numnormals + 1] = 
					model->facetnorms[3 * T(node->index).findex + 1];
				model->normals[3 * numnormals + 2] = 
					model->facetnorms[3 * T(node->index).findex + 2];
				if (T(node->index).vindices[0] == i)
				{
					T(node->index).nindices[0] = numnormals;
				}					
				else if (T(node->index).vindices[1] == i)
				{
					T(node->index).nindices[1] = numnormals;
				}					
				else if (T(node->index).vindices[2] == i)
				{
					T(node->index).nindices[2] = numnormals;
				}
				
				numnormals++;
			}
			node = node->next;
		}
	}
	
	model->numnormals = numnormals - 1;

  /* 释放成员信息 */
	for (i = 1; i <= model->numvertices; i++)
	{
		node = members[i];
		while (node)
		{
			tail = node;
			node = node->next;
			free(tail);
		}
	}
	free(members);

	normals = model->normals;
	model->normals = (GLfloat*)malloc(sizeof(GLfloat)* 3* (model->numnormals+1));

	for (i = 1; i <= model->numnormals; i++)
	{
		model->normals[3 * i + 0] = normals[3 * i + 0];
		model->normals[3 * i + 1] = normals[3 * i + 1];
		model->normals[3 * i + 2] = normals[3 * i + 2];
	}
	free(normals);
}


GLvoid CMyView::glmLinearTexture(GLMmodel* model)
{
	GLMgroup *group;
	GLfloat dimensions[3];
	GLfloat x, y, scalefactor;
	GLuint i;
	
	assert(model);
	
	if (model->texcoords)
	{
		free(model->texcoords);
	}
    
	model->numtexcoords = model->numvertices;
	model->texcoords=(GLfloat*)malloc(sizeof(GLfloat)*2*(model->numtexcoords+1));
	
	glmDimensions(model, dimensions);
	scalefactor = 2.0f / 
		glmAbs(glmMax(glmMax(dimensions[0], dimensions[1]), dimensions[2]));
	
	for(i = 1; i <= model->numvertices; i++)
	{
		x = model->vertices[3 * i + 0] * scalefactor;
		y = model->vertices[3 * i + 2] * scalefactor;
		model->texcoords[2 * i + 0] = (x + 1.0f) / 2.0f;
		model->texcoords[2 * i + 1] = (y + 1.0f) / 2.0f;
	}
	
	group = model->groups;

	while(group)
	{
		for(i = 0; i < group->numtriangles; i++)
		{
			T(group->triangles[i]).tindices[0] = T(group->triangles[i]).vindices[0];
			T(group->triangles[i]).tindices[1] = T(group->triangles[i]).vindices[1];
			T(group->triangles[i]).tindices[2] = T(group->triangles[i]).vindices[2];
		}
		
		group = group->next;
	}

#if 0
	printf("glmLinearTexture(): generated %d linear texture coordinates\n",
		model->numtexcoords);
#endif
}

GLvoid CMyView::glmSpheremapTexture(GLMmodel* model)
{
	GLMgroup* group;
	GLfloat theta, phi, rho, x, y, z, r;
	GLuint i;
	
	assert(model);
	assert(model->normals);
	
	if (model->texcoords)
	{
		free(model->texcoords);
	}
    
	model->numtexcoords = model->numnormals;
	model->texcoords=(GLfloat*)malloc(sizeof(GLfloat)*2*(model->numtexcoords+1));
	
	for (i = 1; i <= model->numnormals; i++)
	{
		z = model->normals[3 * i + 0];	
		y = model->normals[3 * i + 1];
		x = model->normals[3 * i + 2];
		r = fsqrt((x * x) + (y * y));
		rho = fsqrt((r * r) + (z * z));