C++ Plane::GetVector方法代码示例

// In short, the reason for the complexity of this function is:
//  - creates a list of vertices where every vertex has a unique position (UV ignored)
//  - doesn't allow the same poly normal to be added to the same vertex twice
void PolyMesh::CalculateNormals()
{
	vector<Vector3> vertPos;
	vector<int> old2new;
	GenerateUniqueVectors(verts, vertPos, old2new);
	
	vector<vector<int> > new2old;
	new2old.resize(vertPos.size());
	for (unsigned int a=0;a<old2new.size();a++)
		new2old[old2new[a]].push_back(a);

	vector<std::vector<Vector3> > normals;
	normals.resize(vertPos.size());

	for (unsigned int a=0;a<poly.size();a++) {
		Poly *pl = poly[a];
		Plane plane;
		
		plane.MakePlane(
			vertPos[old2new[pl->verts[0]]],
			vertPos[old2new[pl->verts[1]]],
			vertPos[old2new[pl->verts[2]]]);

		Vector3 plnorm = plane.GetVector();
		for (unsigned int b=0;b<pl->verts.size();b++) {
			vector<Vector3>& norms = normals[old2new[pl->verts[b]]];
			unsigned int c;
			for (c=0;c<norms.size();c++)
				if (norms[c] == plnorm) break;

			if (c == norms.size())
				norms.push_back(plnorm);
		}
	}

	for (unsigned int a=0;a<normals.size();a++) {
		Vector3 sum;
		vector<Vector3>& vn = normals[a];
		for(unsigned int b=0;b<vn.size();b++)
			sum+=vn[b];

		if (sum.length()>0.0f)
			sum.normalize ();

		vector<int>& vlist=new2old[a];
		for(unsigned int b=0;b<vlist.size();b++)
			verts[vlist[b]].normal = sum;
	}
}

void MdlObject::CalculateNormals()
{
	vector<Vector3> normals;
	normals.resize(verts.size());

	for (int a=0;a<poly.size();a++) {
		Poly *pl = poly[a];
		Plane plane;
		
		plane.MakePlane(verts[pl->verts [0]].pos,verts[pl->verts[1]].pos,verts[pl->verts[2]].pos);
		for (int b=0;b<pl->verts.size();b++)
			normals[pl->verts[b]] += plane.GetVector ();
	}

	for (int a=0;a<verts.size();a++) {
		if (normals[a].length()>0.0f)
			normals[a].normalize ();
		verts[a].normal=normals[a];
	}
}

void PolyMesh::CalculateNormals2(float maxSmoothAngle)
{
	float ang_c = cosf (M_PI * maxSmoothAngle / 180.0f);
	vector<Vector3> vertPos;
	vector<int> old2new;
	GenerateUniqueVectors(verts, vertPos, old2new);

	vector<vector<int> > new2old;
	new2old.resize(vertPos.size());
	for (unsigned int a=0;a<old2new.size();a++)
		new2old[old2new[a]].push_back(a);

	// Calculate planes
	std::vector <Plane> polyPlanes;
	polyPlanes.resize (poly.size());
	for (unsigned int a=0;a<poly.size();a++)
		polyPlanes[a] = poly[a]->CalcPlane (verts);

	// Determine which faces are using which unique vertex
	std::vector <FaceVert> faceVerts; // one per unique vertex
	faceVerts.resize (old2new.size ());

	for (unsigned int a=0;a<poly.size();a++) {
		Poly *pl = poly[a];
		for (unsigned int v=0;v<pl->verts.size();v++)
			faceVerts[old2new[pl->verts[v]]].adjacentFaces.push_back (a);
	}

	// Calculate normals
	int cnorm = 0;
	for (unsigned int a=0;a<poly.size();a++) cnorm += poly[a]->verts.size();
	std::vector <Vector3> normals;
	normals.resize (cnorm);

	cnorm = 0;
	for (unsigned int a=0;a<poly.size();a++) {
		Poly *pl = poly[a];
		for (unsigned int v=0;v<pl->verts.size();v++) 
		{
			FaceVert& fv = faceVerts[old2new[pl->verts[v]]];
			std::vector<Vector3> vnormals;
			vnormals.push_back(polyPlanes[a].GetVector());
			for (unsigned int adj = 0; adj < fv.adjacentFaces.size(); adj ++)
			{
				// Same poly?
				if (fv.adjacentFaces [adj] == int(a))
					continue;

				Plane adjPlane = polyPlanes[fv.adjacentFaces[adj]];

				// Spring 3DO style smoothing
				float dot = adjPlane.GetVector ().dot (polyPlanes[a].GetVector());
			//	logger.Print("Dot: %f\n",dot);
				if (dot < ang_c) 
					continue;

				// see if the normal is unique for this vertex
				bool isUnique = true;
				for (unsigned int norm = 0; norm < vnormals.size(); norm ++) 
					if (vnormals[norm] == adjPlane.GetVector ()) 
					{
						isUnique = false;
						break;
					}
					
				if (isUnique)
					vnormals.push_back (adjPlane.GetVector());
			}
			Vector3 normal;
			for (unsigned int n=0;n<vnormals.size();n++)
				normal += vnormals[n];

			if (normal.length () > 0.0f)
				normal.normalize ();
			normals [cnorm ++] = normal;
		}
	}

	// Create a new set of vertices with the calculated normals
	std::vector <Vertex> newVertices;
	newVertices.reserve(poly.size()*4); // approximate
	cnorm = 0;
	for (unsigned int a=0;a<poly.size();a++) {
		Poly *pl = poly[a];
		for (unsigned int v=0;v<pl->verts.size();v++) {
			/*FaceVert &fv = faceVerts[old2new[pl->verts[v]]];*/
			Vertex nv = verts[pl->verts[v]];
			nv.normal = normals[cnorm++];
			newVertices.push_back (nv);
			pl->verts [v] = newVertices.size () - 1;
		}
	}

	// Optimize
	verts = newVertices;
	Optimize(&PolyMesh::IsEqualVertexTCNormal);
}