NL3D::CMRMBuilder Class Reference

#include <mrm_builder.h>

---

Detailed Description

The class for building MRMs.

Author:

Lionel Berenguier

Nevrax France

Date:

2000

Definition at line 52 of file mrm_builder.h.

Top Level methods.
typedef std::map< CAttributeKey, sint >	TAttributeMap
CRGBA	attToColor (const CVectorH &att) const
NLMISC::CUVW	attToUvw (const CVectorH &att) const
void	buildMeshBuildMrm (const CMRMMeshFinal &finalMRM, CMeshMRMSkinnedGeom::CMeshBuildMRM &mbuild, uint32 vbFlags, uint32 nbMats, const CMesh::CMeshBuild &mb)
void	buildMeshBuildMrm (const CMRMMeshFinal &finalMRM, CMeshMRMGeom::CMeshBuildMRM &mbuild, uint32 vbFlags, uint32 nbMats, const CMesh::CMeshBuild &mb)
uint32	buildMrmBaseMesh (const CMesh::CMeshBuild &mbuild, CMRMMesh &baseMesh)
sint	findInsertAttributeInBaseMesh (CMRMMesh &baseMesh, sint attId, sint vertexId, const CVectorH &att)
sint	findInsertColorInBaseMesh (CMRMMesh &baseMesh, sint attId, sint vertexId, CRGBA col)
sint	findInsertNormalInBaseMesh (CMRMMesh &baseMesh, sint attId, sint vertexId, const CVector &normal)
sint	findInsertUvwInBaseMesh (CMRMMesh &baseMesh, sint attId, sint vertexId, const NLMISC::CUVW &uvw)
void	normalizeBaseMeshSkin (CMRMMesh &baseMesh) const
CMesh::CSkinWeight	normalizeSkinWeight (const CMesh::CSkinWeight &sw) const
TAttributeMap	_AttributeMap [NL3D_MRM_MAX_ATTRIB]
MRM Level Variables.
typedef std::map< CMRMWedgeGeom, sint, CGeomPred >	TGeomMap
TGeomMap	_GeomMap
Mesh Interfaces computing
bool	buildMRMSewingMeshes (const CMesh::CMeshBuild &mbuild, uint nWantedLods, uint divisor)
uint	_CurrentLodComputed
bool	_HasMeshInterfaces
std::vector< CMRMSewingMesh >	_SewingMeshes
Public Member Functions
	CMRMBuilder ()
	Constructor.
void	compileMRM (const CMesh::CMeshBuild &mbuild, std::vector< CMesh::CMeshBuild * > &bsList, const CMRMParameters &params, CMeshMRMSkinnedGeom::CMeshBuildMRM &mrmMesh, uint numMaxMaterial)
void	compileMRM (const CMesh::CMeshBuild &mbuild, std::vector< CMesh::CMeshBuild * > &bsList, const CMRMParameters &params, CMeshMRMGeom::CMeshBuildMRM &mrmMesh, uint numMaxMaterial)
Private Member Functions
void	computeBsVerticesAttributes (std::vector< CMRMMesh > &srcBsMeshs, std::vector< CMRMMesh > &srcBsMeshsMod)
void	makeCoarserBS (std::vector< CMRMBlendShape > &csBsMeshs)
MRM Level Methods.
void	buildAllLods (const CMRMMesh &baseMesh, std::vector< CMRMMeshGeom > &lodMeshs, uint nWantedLods=10, uint divisor=50)
void	buildBlendShapes (CMRMMesh &baseMesh, std::vector< CMesh::CMeshBuild * > &bsList, uint32 VertexFlags)
void	buildFinalMRM (std::vector< CMRMMeshGeom > &lodMeshs, CMRMMeshFinal &finalMRM)
Collapse methods.
sint	collapseEdge (const CMRMEdge &edge)
CMesh::CSkinWeight	collapseSkinWeight (const CMesh::CSkinWeight &sw1, const CMesh::CSkinWeight &sw2, float InterValue) const
bool	faceShareWedges (CMRMFaceBuild *face, sint attribId, sint numVertex1, sint numVertex2)
sint	followVertex (sint i)
sint	followWedge (sint attribId, sint i)
void	insertFaceIntoEdgeList (CMRMFaceBuild &tmpf)
void	removeFaceFromEdgeList (CMRMFaceBuild &f)
Mesh Level methods.
void	collapseEdges (sint nWantedFaces)
void	init (const CMRMMesh &baseMesh)
void	makeFromMesh (const CMRMMesh &baseMesh, CMRMMeshGeom &lodMesh, CMRMMesh &coarserMesh, sint nWantedFaces)
	this is the root call to compute a single lodMesh and the coarserMesh from a baseMesh.
void	makeLODMesh (CMRMMeshGeom &lodMesh)
void	saveCoarserMesh (CMRMMesh &coarserMesh)
Edge Cost methods.
float	computeEdgeCost (const CMRMEdge &edge)
bool	edgeContinue (const CMRMEdge &edge)
bool	edgeNearUniqueMatFace (const CMRMEdge &edge)
float	getDeltaFaceNormals (sint numvertex)
bool	vertexClosed (sint numvertex)
bool	vertexContinue (sint numvertex)
bool	vertexHasOneMaterial (sint numvertex)
bool	vertexHasOneWedge (sint numvertex)
Private Attributes
Mesh Level Tmp Values.
bool	_Skinned
CMRMParameters::TSkinReduction	_SkinReduction
	If the current build is skinned, control the quality of the skinning redcution.
TEdgeMap	EdgeCollapses
sint	NumAttributes
std::vector< CMRMAttribute >	TmpAttributes [NL3D_MRM_MAX_ATTRIB]
std::vector< CMRMFaceBuild >	TmpFaces
std::vector< CMRMVertex >	TmpVertices

---

Member Typedef Documentation

typedef std::map<CAttributeKey, sint> NL3D::CMRMBuilder::TAttributeMap [private]

Definition at line 228 of file mrm_builder.h.

typedef std::map<CMRMWedgeGeom, sint, CGeomPred> NL3D::CMRMBuilder::TGeomMap [private]

Definition at line 179 of file mrm_builder.h.

---

Constructor & Destructor Documentation

NL3D::CMRMBuilder::CMRMBuilder (   )

Constructor. Definition at line 859 of file mrm_builder.cpp. References _HasMeshInterfaces, and NumAttributes. { NumAttributes= 0; _Skinned= false; _HasMeshInterfaces= false; }

---

Member Function Documentation

CRGBA NL3D::CMRMBuilder::attToColor (  const CVectorH &  att  )  const [private]

Definition at line 1709 of file mrm_builder.cpp. References NLMISC::CRGBA::A, NLMISC::CRGBA::B, NLMISC::clamp(), NLMISC::CRGBA::G, NLMISC::CRGBA::R, uint, uint8, NLMISC::CVectorH::w, NLMISC::CVectorH::x, NLMISC::CVectorH::y, and NLMISC::CVectorH::z. Referenced by buildMeshBuildMrm(). { CRGBA ret; float tmp; tmp= att.x; clamp(tmp, 0, 255); ret.R= (uint8)(uint)tmp; tmp= att.y; clamp(tmp, 0, 255); ret.G= (uint8)(uint)tmp; tmp= att.z; clamp(tmp, 0, 255); ret.B= (uint8)(uint)tmp; tmp= att.w; clamp(tmp, 0, 255); ret.A= (uint8)(uint)tmp; return ret; }

NLMISC::CUVW NL3D::CMRMBuilder::attToUvw (  const CVectorH &  att  )  const [private]

Definition at line 1727 of file mrm_builder.cpp. References NLMISC::CVectorH::x, NLMISC::CVectorH::y, and NLMISC::CVectorH::z. Referenced by buildMeshBuildMrm(). { return CUVW(att.x, att.y, att.z); }

void NL3D::CMRMBuilder::buildAllLods (  const CMRMMesh &  baseMesh, std::vector< CMRMMeshGeom > &  lodMeshs, uint  nWantedLods = 10, uint  divisor = 50 )  [private]

build all LODs from a baseMesh. NB: the coarsestMesh is stored in lodMeshs[0], and has no geomorph info since it is the coarsest mesh. nWantedLods are created (including the coarsestMesh). Parameters: lodMeshs  array created by the function (size of nWantedlods). nWantedLods  number of LODs wanted. divisor  the coarsestMesh will have baseMesh.Faces.size()/divisor faces. Definition at line 1287 of file mrm_builder.cpp. References _CurrentLodComputed, NL3D::CMRMMesh::Faces, init(), makeFromMesh(), nlassert, sint, and uint. Referenced by compileMRM(). { sint nFaces= baseMesh.Faces.size(); sint nBaseFaces; sint i; CMRMMesh srcMesh = baseMesh; // coarsest LOD will have those number of faces. nBaseFaces=nFaces/divisor; nBaseFaces=max(nBaseFaces,4); // must have at least 2 LOD to be really intersting. But the rest of the process work too with only one Lod!! nlassert(nWantedLods>=1); lodMeshs.resize(nWantedLods); // If only one lod asked, must init some Tmp Global values (like NumAttributes) if(nWantedLods==1) { _CurrentLodComputed= 0; init(baseMesh); } // must fill all LODs, from end to start. do not proces last lod since it will be the coarsest mesh. for(i=nWantedLods-1;i>0;i--) { sint nbWantedFaces; // for sewing computing _CurrentLodComputed= i; // Linear. nbWantedFaces= nBaseFaces + (nFaces-nBaseFaces) * (i-1)/(nWantedLods-1); nbWantedFaces=max(nbWantedFaces,4); // Build this LOD. CMRMMesh csMesh; // The mesh makeFromMesh(srcMesh, lodMeshs[i], csMesh, nbWantedFaces); // next mesh to process is csMesh. srcMesh = csMesh; } // the first lodMedsh gets the coarsest mesh. lodMeshs[0]= srcMesh; }

void NL3D::CMRMBuilder::buildBlendShapes (  CMRMMesh &  baseMesh, std::vector< CMesh::CMeshBuild * > &  bsList, uint32  VertexFlags )  [private]

build the blend shapes in the same way we constructed the base mesh mrm Definition at line 2912 of file mrm_builder.cpp. References NLMISC::CRGBA::A, NL3D::CMRMCorner::Attributes, NL3D::CMRMMesh::Attributes, NLMISC::CRGBA::B, NL3D::CMRMMesh::BlendShapes, NL3D::CMesh::CCorner::Color, NL3D::CMRMMesh::Faces, NLMISC::CRGBA::G, nlassert, NL3D::CMesh::CCorner::Normal, NL3D::CMRMMesh::NumAttributes, NLMISC::CRGBA::R, NL3D::CMesh::CCorner::Specular, NLMISC::CUVW::U, uint32, NL3D::CMesh::CCorner::Uvws, NLMISC::CUVW::V, NL3D::CMRMMesh::Vertices, NLMISC::CUVW::W, NLMISC::CVectorH::w, NLMISC::CVector::x, NLMISC::CVectorH::x, NLMISC::CVector::y, NLMISC::CVectorH::y, NLMISC::CVector::z, and NLMISC::CVectorH::z. Referenced by compileMRM(). { uint32 i, j, k, m, destIndex; uint32 attId; CVectorH vh; vector<CMRMBlendShape> &bsMeshes= baseMesh.BlendShapes; bsMeshes.resize (bsList.size()); for (i = 0; i < bsList.size(); ++i) { // Construct a blend shape like a mrm mesh nlassert (baseMesh.Vertices.size() == bsList[i]->Vertices.size()); bsMeshes[i].Vertices.resize (baseMesh.Vertices.size()); bsMeshes[i].Vertices = bsList[i]->Vertices; bsMeshes[i].NumAttributes = baseMesh.NumAttributes; for (j = 0; j < (uint32)bsMeshes[i].NumAttributes; ++j) bsMeshes[i].Attributes[j].resize(baseMesh.Attributes[j].size()); // For all corners parse the faces (given by the baseMesh) and construct blend shape mrm meshes for (j = 0; j < baseMesh.Faces.size(); ++j) for (k = 0; k < 3; ++k) { const CMesh::CCorner &srcCorner = bsList[i]->Faces[j].Corner[k]; CMRMCorner &neutralCorner = baseMesh.Faces[j].Corner[k]; attId= 0; if (VertexFlags & CVertexBuffer::NormalFlag) { destIndex = neutralCorner.Attributes[attId]; vh.x = srcCorner.Normal.x; vh.y = srcCorner.Normal.y; vh.z = srcCorner.Normal.z; vh.w = 0.0f; bsMeshes[i].Attributes[attId].operator[](destIndex) = vh; attId++; } if (VertexFlags & CVertexBuffer::PrimaryColorFlag) { destIndex = neutralCorner.Attributes[attId]; vh.x = srcCorner.Color.R; vh.y = srcCorner.Color.G; vh.z = srcCorner.Color.B; vh.w = srcCorner.Color.A; bsMeshes[i].Attributes[attId].operator[](destIndex) = vh; attId++; } if (VertexFlags & CVertexBuffer::SecondaryColorFlag) { destIndex = neutralCorner.Attributes[attId]; vh.x = srcCorner.Specular.R; vh.y = srcCorner.Specular.G; vh.z = srcCorner.Specular.B; vh.w = srcCorner.Specular.A; bsMeshes[i].Attributes[attId].operator[](destIndex) = vh; attId++; } for (m = 0; m < CVertexBuffer::MaxStage; ++m) { if (VertexFlags & (CVertexBuffer::TexCoord0Flag<<m)) { destIndex = neutralCorner.Attributes[attId]; vh.x = srcCorner.Uvws[m].U; vh.y = srcCorner.Uvws[m].V; vh.z = srcCorner.Uvws[m].W; vh.w = 0.0f; bsMeshes[i].Attributes[attId].operator[](destIndex) = vh; attId++; } } } } }

void NL3D::CMRMBuilder::buildFinalMRM (  std::vector< CMRMMeshGeom > &  lodMeshs, CMRMMeshFinal &  finalMRM )  [private]

given a list of LODs, compress/reorganize data, and store in finalMRM mesh. Definition at line 1336 of file mrm_builder.cpp. References _GeomMap, NL3D::CMRMCorner::Attributes, NL3D::CMRMMesh::Attributes, NL3D::CMRMMeshFinal::CWedge::Attributes, NL3D::CMRMMesh::BlendShapes, NL3D::CMRMMeshGeom::CoarserFaces, NL3D::CMRMFace::Corner, NL3D::CMRMWedgeGeom::End, NL3D::CMRMMeshFinal::CLod::Faces, NL3D::CMRMMesh::Faces, NL3D::CMRMMeshFinal::findInsertWedge(), NL3D::CMRMMeshFinal::CLod::Geomorphs, NL3D::CMRMMeshFinal::Lods, NL3D::CMRMFace::MaterialId, NL3D::CMRMMeshFinal::CFace::MaterialId, NL3D::CMRMMeshFinal::MRMBlendShapesFinals, NL3D::CMRMMeshFinal::NGeomSpace, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, NL3D::CMRMMeshFinal::CWedge::NSkinMatUsed, NumAttributes, NL3D::CMRMMeshFinal::NumAttributes, NL3D::CMRMMeshFinal::reset(), sint, NL3D::CMRMMeshFinal::Skinned, NL3D::CMRMMesh::SkinWeights, NL3D::CMRMWedgeGeom::Start, NL3D::CMRMCorner::Vertex, NL3D::CMRMMeshFinal::CWedge::Vertex, NL3D::CMRMMeshFinal::CWedge::VertexSkin, NL3D::CMRMMesh::Vertices, NL3D::CMRMCorner::WedgeEndId, NL3D::CMRMCorner::WedgeGeomId, NL3D::CMRMMeshFinal::CFace::WedgeId, NL3D::CMRMMeshFinal::CMRMBlendShapeFinal::Wedges, NL3D::CMRMMeshFinal::Wedges, NL3D::CMRMCorner::WedgeStartId, and NL3D::CMesh::CSkinWeight::Weights. Referenced by compileMRM(). { sint i,j; sint lodId, attId; sint nLods= lodMeshs.size(); // Init. // =============== finalMRM.reset(); finalMRM.NumAttributes= NumAttributes; finalMRM.Skinned= _Skinned; CMRMMeshFinal::CWedge::NumAttributesToCompare= NumAttributes; CMRMMeshFinal::CWedge::CompareSkinning= _Skinned; finalMRM.Lods.resize(nLods); // Build Wedges, and faces index. // =============== // for all lods. for(lodId=0; lodId<nLods; lodId++) { CMRMMeshGeom &lodMesh= lodMeshs[lodId]; CMRMMeshGeom &lodMeshPrec= lodMeshs[lodId==0?0:lodId-1]; // for all face corner. for(i=0; i<(sint)lodMesh.Faces.size();i++) { // The current face. CMRMFace &face= lodMesh.Faces[i]; // the current face, but which points to the prec LOD vertices/attributes. CMRMFace &faceCoarser= lodMesh.CoarserFaces[i]; // for 3 corners. for(j=0;j<3;j++) { CMRMCorner &corner= face.Corner[j]; CMRMCorner &cornerCoarser= faceCoarser.Corner[j]; // start and end wedge (geomorph), maybe same. CMRMMeshFinal::CWedge wedgeStart; CMRMMeshFinal::CWedge wedgeEnd; // fill wedgeStart with values from lodMesh. wedgeStart.Vertex= lodMesh.Vertices[corner.Vertex]; if(_Skinned) wedgeStart.VertexSkin= lodMesh.SkinWeights[corner.Vertex]; for(attId=0; attId<NumAttributes; attId++) { wedgeStart.Attributes[attId]= lodMesh.Attributes[attId][corner.Attributes[attId]]; } // if geomorph possible (ie not lod 0). if(lodId>0) { // fill wedgeEnd with values from coarser lodMesh. wedgeEnd.Vertex= lodMeshPrec.Vertices[cornerCoarser.Vertex]; if(_Skinned) wedgeEnd.VertexSkin= lodMeshPrec.SkinWeights[cornerCoarser.Vertex]; for(attId=0; attId<NumAttributes; attId++) { wedgeEnd.Attributes[attId]= lodMeshPrec.Attributes[attId][cornerCoarser.Attributes[attId]]; } } else { // no geomorph. wedgeEnd= wedgeStart; } // find/insert wedge, and get Ids. NB: if start/end same, same indices. sint wedgeStartId= finalMRM.findInsertWedge(wedgeStart); sint wedgeEndId= finalMRM.findInsertWedge(wedgeEnd); // store in TmpCorner. corner.WedgeStartId= wedgeStartId; corner.WedgeEndId= wedgeEndId; } } // Here, the number of wedge indicate the max number of wedge this LOD needs. finalMRM.Lods[lodId].NWedges= finalMRM.Wedges.size(); } // Count NBWedges necessary for geomorph, and compute Dest geomorph wedges ids. // =============== // the number of geomorph required for one LOD. sint sglmGeom; // the number of geomorph required for all LOD (max of sglmGeom). sint sglmGeomMax= 0; // Do not process lod 0, since no geomorph. for(lodId=1; lodId<nLods; lodId++) { CMRMMeshGeom &lodMesh= lodMeshs[lodId]; // reset the GeomMap, the one which indicate if we have already inserted a geomorph. _GeomMap.clear(); sglmGeom= 0; // for all face corner. for(i=0; i<(sint)lodMesh.Faces.size();i++) { // The current face. CMRMFace &face= lodMesh.Faces[i]; // for 3 corners. for(j=0;j<3;j++) { CMRMCorner &corner= face.Corner[j]; // if not same wedge Ids, this is a geomorphed wedge. if(corner.WedgeStartId != corner.WedgeEndId) { // search if it exist yet in the set. CMRMWedgeGeom geom; geom.Start= corner.WedgeStartId; geom.End= corner.WedgeEndId; sint geomDest= sglmGeom; // if don't find this geom in the set, then it is a new one. TGeomMap::const_iterator it= _GeomMap.find(geom); if(it == _GeomMap.end()) { _GeomMap.insert( make_pair(geom, geomDest) ); sglmGeom++; } else geomDest= it->second; // store this Geom Id in the corner. corner.WedgeGeomId= geomDest; } } } // take the max. sglmGeomMax= max(sglmGeomMax, sglmGeom); } // inform the finalMRM. finalMRM.NGeomSpace= sglmGeomMax; // decal all wedges/ face index. // =============== // insert an empty space for dest geomorph. finalMRM.Wedges.insert(finalMRM.Wedges.begin(), sglmGeomMax, CMRMMeshFinal::CWedge()); // Parse all faces corner of All lods, and decal Start/End Wedge index. for(lodId=0; lodId<nLods; lodId++) { CMRMMeshGeom &lodMesh= lodMeshs[lodId]; // for all face corner. for(i=0; i<(sint)lodMesh.Faces.size();i++) { // The current face. CMRMFace &face= lodMesh.Faces[i]; // for 3 corners. for(j=0;j<3;j++) { CMRMCorner &corner= face.Corner[j]; // decal indices. corner.WedgeStartId+= sglmGeomMax; corner.WedgeEndId+= sglmGeomMax; } } // increment too the number of wedge required for this Lod. finalMRM.Lods[lodId].NWedges+= sglmGeomMax; } // fill faces. // =============== // Parse all faces corner of All lods, and build Faces/Geomorphs.. for(lodId=0; lodId<nLods; lodId++) { CMRMMeshGeom &lodMesh= lodMeshs[lodId]; CMRMMeshFinal::CLod &lodDest= finalMRM.Lods[lodId]; // alloc final faces of this LOD. lodDest.Faces.resize(lodMesh.Faces.size()); // reset the GeomMap, the one which indicate if we have already inserted a geomorph. _GeomMap.clear(); // for all face corner. for(i=0; i<(sint)lodMesh.Faces.size();i++) { // The current face. CMRMFace &face= lodMesh.Faces[i]; // The dest face. CMRMMeshFinal::CFace &faceDest= lodDest.Faces[i]; // fill good material. faceDest.MaterialId= face.MaterialId; // for 3 corners. for(j=0;j<3;j++) { CMRMCorner &corner= face.Corner[j]; // if not same wedge Ids, this is a geomorphed wedge. if(corner.WedgeStartId != corner.WedgeEndId) { // geomorph, so point to geomorphed wedge. faceDest.WedgeId[j]= corner.WedgeGeomId; // Build the geomorph, add it to the list (if not yet inserted). CMRMWedgeGeom geom; geom.Start= corner.WedgeStartId; geom.End= corner.WedgeEndId; // if don't find this geom in the set, then it is a new one. TGeomMap::const_iterator it= _GeomMap.find(geom); if(it == _GeomMap.end()) { // mark it as inserted. _GeomMap.insert( make_pair(geom, corner.WedgeGeomId) ); // and we must insert this geom in the array. nlassert( corner.WedgeGeomId==(sint)lodDest.Geomorphs.size() ); lodDest.Geomorphs.push_back(geom); } } else { // no geomorph, so just point to good wedge. faceDest.WedgeId[j]= corner.WedgeStartId; } } } } // process all wedges, and compute NSkinMatUsed, skipping geomorphs. // =============== // NB: this works because weights are sorted from biggest to lowest. if(_Skinned) { for(i=finalMRM.NGeomSpace; i<(sint)finalMRM.Wedges.size();i++) { CMRMMeshFinal::CWedge &wedge= finalMRM.Wedges[i]; for(j=0; j<NL3D_MESH_SKINNING_MAX_MATRIX; j++) { if(wedge.VertexSkin.Weights[j]==0) break; } nlassert(j>0); wedge.NSkinMatUsed= j; } } // Blend Shape Stuff finalMRM.MRMBlendShapesFinals.resize (lodMeshs[0].BlendShapes.size()); for (lodId = 0; lodId < nLods; ++lodId) { CMRMMeshGeom &lodMesh= lodMeshs[lodId]; CMRMMeshGeom &lodMeshPrec= lodMeshs[lodId==0?0:lodId-1]; // for all face corner. for (i = 0; i < (sint)lodMesh.Faces.size(); ++i) { // The current face. CMRMFace &face = lodMesh.Faces[i]; // the current face, but which points to the prec LOD vertices/attributes. CMRMFace &faceCoarser = lodMesh.CoarserFaces[i]; // for 3 corners. for (j = 0; j < 3; ++j) { CMRMCorner &corner = face.Corner[j]; CMRMCorner &cornerCoarser = faceCoarser.Corner[j]; sint startDestIndex = corner.WedgeStartId; for (sint k = 0; k < (sint)finalMRM.MRMBlendShapesFinals.size(); ++k) { CMRMMeshFinal::CMRMBlendShapeFinal &rBSFinal = finalMRM.MRMBlendShapesFinals[k]; rBSFinal.Wedges.resize (finalMRM.Wedges.size()); // Fill WedgeStart used by this corner. rBSFinal.Wedges[startDestIndex].Vertex = lodMesh.BlendShapes[k].Vertices[corner.Vertex]; for (attId = 0; attId < NumAttributes; ++attId) { rBSFinal.Wedges[startDestIndex].Attributes[attId] = lodMesh.BlendShapes[k].Attributes[attId][corner.Attributes[attId]]; } // If geomorph, must fill the end too if(lodId>0 && corner.WedgeStartId != corner.WedgeEndId) { sint endDestIndex = corner.WedgeEndId; rBSFinal.Wedges[endDestIndex].Vertex = lodMeshPrec.BlendShapes[k].Vertices[cornerCoarser.Vertex]; for (attId = 0; attId < NumAttributes; ++attId) { rBSFinal.Wedges[endDestIndex].Attributes[attId] = lodMeshPrec.BlendShapes[k].Attributes[attId][cornerCoarser.Attributes[attId]]; } } } } } } }

void NL3D::CMRMBuilder::buildMeshBuildMrm (  const CMRMMeshFinal &  finalMRM, CMeshMRMSkinnedGeom::CMeshBuildMRM &  mbuild, uint32  vbFlags, uint32  nbMats, const CMesh::CMeshBuild &  mb )  [private]

from a final MRM Mesh representation, compute a CMeshBuildMRM. This is the last stage of the algo. Parameters: vbFlags  the vertex format returned by earlier call too buildMrmBaseMesh(). nbMats  the number of materials of original MeshBuild. Definition at line 2414 of file mrm_builder.cpp. References NLMISC::CRGBAF::A, NL3D::CVertexBuffer::addValueEx(), NL3D::CMRMMeshFinal::CWedge::Attributes, attToColor(), attToUvw(), NLMISC::CRGBAF::B, NL3D::CMeshMRMSkinnedGeom::CMeshBuildMRM::BlendShapes, NL3D::CVertexBuffer::clearValueEx(), NL3D::CBlendShape::deltaCol, NL3D::CBlendShape::deltaNorm, NL3D::CBlendShape::deltaPos, NL3D::CBlendShape::deltaTgSpace, NL3D::CBlendShape::deltaUV, NL3D::CMRMMeshFinal::CLod::Faces, NLMISC::CRGBAF::G, NL3D::CMRMMeshFinal::CLod::Geomorphs, NL3D::CMeshMRMSkinnedGeom::CLod::Geomorphs, NL3D::CMeshMRMSkinnedGeom::CLod::InfluencedVertices, NL3D::CVertexBuffer::initEx(), NL3D::CMRMMeshFinal::Lods, NL3D::CMeshMRMSkinnedGeom::CMeshBuildMRM::Lods, NL3D::CMesh::CSkinWeight::MatrixId, NL3D::CMeshMRMSkinnedGeom::CLod::MatrixInfluences, NL3D::CMesh::CMeshBuild::MeshVertexProgram, NL3D::CMRMMeshFinal::MRMBlendShapesFinals, NL3D::CMRMMeshFinal::NGeomSpace, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, NLMISC::CVector::norm(), NL3D::CMesh::CMeshBuild::NumCoords, NL3D::CMRMMeshFinal::CLod::NWedges, NL3D::CMeshMRMSkinnedGeom::CLod::NWedges, NLMISC::CRGBAF::R, NL3D::CMeshMRMSkinnedGeom::CLod::RdrPass, NL3D::CVertexBuffer::setColor(), NL3D::CVertexBuffer::setNormalCoord(), NL3D::CVertexBuffer::setNumVertices(), NL3D::CVertexBuffer::setSpecular(), NL3D::CVertexBuffer::setTexCoord(), NL3D::CVertexBuffer::setUVRouting(), NL3D::CVertexBuffer::setValueFloat3Ex(), NL3D::CVertexBuffer::setVertexCoord(), NL3D::CVertexBuffer::setVertexFormat(), sint, sint32, NL3D::CMeshMRMSkinnedGeom::CMeshBuildMRM::Skinned, NL3D::CMeshMRMSkinnedGeom::CMeshBuildMRM::SkinWeights, NLMISC::CUV::U, NLMISC::CUVW::U, uint, uint32, NL3D::CMesh::CMeshBuild::UVRouting, NLMISC::CUV::V, NLMISC::CUVW::V, NL3D::CMeshMRMSkinnedGeom::CMeshBuildMRM::VBuffer, NL3D::CMRMMeshFinal::CWedge::Vertex, NL3D::CMRMMeshFinal::CWedge::VertexSkin, NL3D::CBlendShape::VertRefs, NLMISC::CVectorH::w, NLMISC::CUVW::W, NL3D::CMRMMeshFinal::Wedges, NL3D::CMesh::CSkinWeight::Weights, NLMISC::CVectorH::x, NLMISC::CVectorH::y, and NLMISC::CVectorH::z. { sint i,j,k; sint attId; // reset the mbuild. mbuild= CMeshMRMSkinnedGeom::CMeshBuildMRM(); // Setup VB. bool useFormatExt = false; // Check wether there are texture coordinates with more than 2 compnents, which force us to use an extended vertex format for (k = 0; k < CVertexBuffer::MaxStage; ++k) { if ( (vbFlags & (CVertexBuffer::TexCoord0Flag << k)) && mb.NumCoords[k] != 2) { useFormatExt = true; break; } } uint numTexCoordUsed = 0; for (k = 0; k < CVertexBuffer::MaxStage; ++k) { if (vbFlags & (CVertexBuffer::TexCoord0Flag << k)) { numTexCoordUsed = k; } } if (!useFormatExt) { // setup standard format mbuild.VBuffer.setVertexFormat(vbFlags); } else // setup extended format { mbuild.VBuffer.clearValueEx(); if (vbFlags & CVertexBuffer::PositionFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::Position, CVertexBuffer::Float3); if (vbFlags & CVertexBuffer::NormalFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::Normal, CVertexBuffer::Float3); if (vbFlags & CVertexBuffer::PrimaryColorFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::PrimaryColor, CVertexBuffer::UChar4); if (vbFlags & CVertexBuffer::SecondaryColorFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::SecondaryColor, CVertexBuffer::UChar4); if (vbFlags & CVertexBuffer::WeightFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::Weight, CVertexBuffer::Float4); if (vbFlags & CVertexBuffer::PaletteSkinFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::PaletteSkin, CVertexBuffer::UChar4); if (vbFlags & CVertexBuffer::FogFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::Fog, CVertexBuffer::Float1); for (k = 0; k < CVertexBuffer::MaxStage; ++k) { if (vbFlags & (CVertexBuffer::TexCoord0Flag << k)) { switch(mb.NumCoords[k]) { case 2: mbuild.VBuffer.addValueEx((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), CVertexBuffer::Float2); break; case 3: mbuild.VBuffer.addValueEx((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), CVertexBuffer::Float3); break; default: nlassert(0); break; } } } mbuild.VBuffer.initEx(); } // Copy the UVRouting for (i=0; i<CVertexBuffer::MaxStage; i++) { mbuild.VBuffer.setUVRouting (i, mb.UVRouting[i]); } // Setup the VertexBuffer. // ======================== // resize the VB. mbuild.VBuffer.setNumVertices(finalMRM.Wedges.size()); // Setup SkinWeights. if(_Skinned) mbuild.SkinWeights.resize(finalMRM.Wedges.size()); // fill the VB. for(i=0; i<(sint)finalMRM.Wedges.size(); i++) { const CMRMMeshFinal::CWedge &wedge= finalMRM.Wedges[i]; // setup Vertex. mbuild.VBuffer.setVertexCoord(i, wedge.Vertex); // seutp attributes. attId= 0; // For all activated attributes in mbuild, retriev the attribute from the finalMRM. if(vbFlags & CVertexBuffer::NormalFlag) { mbuild.VBuffer.setNormalCoord(i, wedge.Attributes[attId] ); attId++; } if(vbFlags & CVertexBuffer::PrimaryColorFlag) { mbuild.VBuffer.setColor(i, attToColor(wedge.Attributes[attId]) ); attId++; } if(vbFlags & CVertexBuffer::SecondaryColorFlag) { mbuild.VBuffer.setSpecular(i, attToColor(wedge.Attributes[attId]) ); attId++; } for(k=0; k<CVertexBuffer::MaxStage;k++) { if(vbFlags & (CVertexBuffer::TexCoord0Flag<<k)) { switch(mb.NumCoords[k]) { case 2: mbuild.VBuffer.setTexCoord(i, k, (CUV) attToUvw(wedge.Attributes[attId]) ); break; case 3: { CUVW uvw = attToUvw(wedge.Attributes[attId]); mbuild.VBuffer.setValueFloat3Ex((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), i, uvw.U, uvw.V, uvw.W); } break; default: nlassert(0); break; } attId++; } } // Setup SkinWeights. if(_Skinned) { mbuild.SkinWeights[i]= wedge.VertexSkin; } } // Build Lods. // ======================== // resize mbuild.Lods.resize(finalMRM.Lods.size()); // fill. for(i=0; i<(sint)finalMRM.Lods.size(); i++) { const CMRMMeshFinal::CLod &srcLod= finalMRM.Lods[i]; CMeshMRMSkinnedGeom::CLod &destLod= mbuild.Lods[i]; // Basic. //--------- // Copy NWedges infos. destLod.NWedges= srcLod.NWedges; // Copy Geomorphs infos. destLod.Geomorphs= srcLod.Geomorphs; // Reorder faces by rdrpass. //--------- // First count the number of faces used by this LOD for each material vector<sint> matCount; // resize, and reset to 0. matCount.clear(); matCount.resize(nbMats, 0); // For each face of this Lods, incr the mat face counter. for(j= 0; j<(sint)srcLod.Faces.size(); j++) { sint matId= srcLod.Faces[j].MaterialId; nlassert(matId>=0); nlassert(matId<(sint)nbMats); // increment the refcount of this material by this LOD. matCount[matId]++; } // Then for each material not empty, create a rdrPass, and ref it for this material. vector<sint> rdrPassIndex; // material to rdrPass map. rdrPassIndex.resize(nbMats); for(j=0; j<(sint)nbMats; j++) { if(matCount[j]==0) rdrPassIndex[j]= -1; else { // map material to rdrPass. sint idRdrPass= destLod.RdrPass.size(); rdrPassIndex[j]= idRdrPass; // create a rdrPass. destLod.RdrPass.push_back(CMeshMRMSkinnedGeom::CRdrPass()); // assign the good materialId to this rdrPass. destLod.RdrPass[idRdrPass].MaterialId= j; // reserve the array of faces of this rdrPass. destLod.RdrPass[idRdrPass].PBlock.reserve(3*matCount[j]); } } // Then for each face, add it to the good rdrPass of this Lod. for(j= 0; j<(sint)srcLod.Faces.size(); j++) { sint matId= srcLod.Faces[j].MaterialId; sint idRdrPass= rdrPassIndex[matId]; // add this face to the good rdrPass. sint w0= srcLod.Faces[j].WedgeId[0]; sint w1= srcLod.Faces[j].WedgeId[1]; sint w2= srcLod.Faces[j].WedgeId[2]; destLod.RdrPass[idRdrPass].PBlock.push_back (w0); destLod.RdrPass[idRdrPass].PBlock.push_back (w1); destLod.RdrPass[idRdrPass].PBlock.push_back (w2); } // Build skin info for this Lod. //--------- for(j=0; j<NL3D_MESH_SKINNING_MAX_MATRIX; j++) { destLod.InfluencedVertices[j].clear(); } destLod.MatrixInfluences.clear(); if(_Skinned) { // This is the set which tell what wedge has already been inserted. set<uint> wedgeInfSet; // First, build the list of vertices influenced by this Lod. for(j= 0; j<(sint)srcLod.Faces.size(); j++) { for(k=0; k<3; k++) { sint wedgeId= srcLod.Faces[j].WedgeId[k]; // If it is a geomorph if(wedgeId<finalMRM.NGeomSpace) { // add the start and end to the list (if not here). NB: wedgeId is both the id // of the dest wedge, and the id of the geomorph. sint wedgeStartId= destLod.Geomorphs[wedgeId].Start; sint wedgeEndId= destLod.Geomorphs[wedgeId].End; uint nMatUsedStart= finalMRM.Wedges[wedgeStartId].NSkinMatUsed; uint nMatUsedEnd= finalMRM.Wedges[wedgeEndId].NSkinMatUsed; // if insertion in the set work, add to the good array. if( wedgeInfSet.insert(wedgeStartId).second ) destLod.InfluencedVertices[nMatUsedStart-1].push_back(wedgeStartId); if( wedgeInfSet.insert(wedgeEndId).second ) destLod.InfluencedVertices[nMatUsedEnd-1].push_back(wedgeEndId); } else { uint nMatUsed= finalMRM.Wedges[wedgeId].NSkinMatUsed; // just add this wedge to the list (if not here). // if insertion in the set work, add to the array. if( wedgeInfSet.insert(wedgeId).second ) destLod.InfluencedVertices[nMatUsed-1].push_back(wedgeId); } } } // Optimisation: for better cache, sort the destLod.InfluencedVertices in increasing order. for(j=0; j<NL3D_MESH_SKINNING_MAX_MATRIX; j++) { sort(destLod.InfluencedVertices[j].begin(), destLod.InfluencedVertices[j].end()); } // Then Build the MatrixInfluences array, for all thoses Influenced Vertices only. // This is the map MatrixId -> MatrixInfId. map<uint, uint> matrixInfMap; // For all influenced vertices, flags matrix they use. uint iSkinMat; for(iSkinMat= 0; iSkinMat<NL3D_MESH_SKINNING_MAX_MATRIX; iSkinMat++) { for(j= 0; j<(sint)destLod.InfluencedVertices[iSkinMat].size(); j++) { uint wedgeId= destLod.InfluencedVertices[iSkinMat][j]; // take the original wedge. const CMRMMeshFinal::CWedge &wedge= finalMRM.Wedges[wedgeId]; // For all matrix with not null influence... for(k= 0; k<NL3D_MESH_SKINNING_MAX_MATRIX; k++) { float matWeight= wedge.VertexSkin.Weights[k]; // This check the validity of skin weights sort. If false, problem before in the algo. if((uint)k<iSkinMat+1) { nlassert( matWeight>0 ); } else { nlassert( matWeight==0 ); } // if not null influence. if(matWeight>0) { uint matId= wedge.VertexSkin.MatrixId[k]; // search/insert the matrixInfId. map<uint, uint>::iterator it= matrixInfMap.find(matId); if( it==matrixInfMap.end() ) { uint matInfId= destLod.MatrixInfluences.size(); matrixInfMap.insert( make_pair(matId, matInfId) ); // create the new MatrixInfluence. destLod.MatrixInfluences.push_back(matId); } } } } } } } // Indicate Skinning. mbuild.Skinned= _Skinned; bool useTgSpace = mb.MeshVertexProgram != NULL ? mb.MeshVertexProgram->needTangentSpace() : false; // Construct Blend Shapes mbuild.BlendShapes.resize (finalMRM.MRMBlendShapesFinals.size()); for (k = 0; k < (sint)mbuild.BlendShapes.size(); ++k) { CBlendShape &rBS = mbuild.BlendShapes[k]; sint32 nNbVertVB = finalMRM.Wedges.size(); bool bIsDeltaPos = false; rBS.deltaPos.resize (nNbVertVB, CVector(0.0f,0.0f,0.0f)); bool bIsDeltaNorm = false; rBS.deltaNorm.resize (nNbVertVB, CVector(0.0f,0.0f,0.0f)); bool bIsDeltaUV = false; rBS.deltaUV.resize (nNbVertVB, CUV(0.0f,0.0f)); bool bIsDeltaCol = false; rBS.deltaCol.resize (nNbVertVB, CRGBAF(0.0f,0.0f,0.0f,0.0f)); bool bIsDeltaTgSpace = false; if (useTgSpace) { rBS.deltaTgSpace.resize(nNbVertVB, CVector::Null); } rBS.VertRefs.resize (nNbVertVB, 0xffffffff); for (i = 0; i < nNbVertVB; i++) { const CMRMMeshFinal::CWedge &rWedgeRef = finalMRM.Wedges[i]; const CMRMMeshFinal::CWedge &rWedgeTar = finalMRM.MRMBlendShapesFinals[k].Wedges[i]; CVector delta = rWedgeTar.Vertex - rWedgeRef.Vertex; CVectorH attr; if (delta.norm() > 0.001f) { rBS.deltaPos[i] = delta; rBS.VertRefs[i] = i; bIsDeltaPos = true; } attId = 0; if (vbFlags & CVertexBuffer::NormalFlag) { attr = rWedgeRef.Attributes[attId]; CVector NormRef = CVector(attr.x, attr.y, attr.z); attr = rWedgeTar.Attributes[attId]; CVector NormTar = CVector(attr.x, attr.y, attr.z); delta = NormTar - NormRef; if (delta.norm() > 0.001f) { rBS.deltaNorm[i] = delta; rBS.VertRefs[i] = i; bIsDeltaNorm = true; } attId++; } if (vbFlags & CVertexBuffer::PrimaryColorFlag) { attr = rWedgeRef.Attributes[attId]; CRGBAF RGBARef = CRGBAF(attr.x/255.0f, attr.y/255.0f, attr.z/255.0f, attr.w/255.0f); attr = rWedgeTar.Attributes[attId]; CRGBAF RGBATar = CRGBAF(attr.x/255.0f, attr.y/255.0f, attr.z/255.0f, attr.w/255.0f); CRGBAF deltaRGBA = RGBATar - RGBARef; if ((deltaRGBA.R*deltaRGBA.R + deltaRGBA.G*deltaRGBA.G + deltaRGBA.B*deltaRGBA.B + deltaRGBA.A*deltaRGBA.A) > 0.0001f) { rBS.deltaCol[i] = deltaRGBA; rBS.VertRefs[i] = i; bIsDeltaCol = true; } attId++; } if (vbFlags & CVertexBuffer::SecondaryColorFlag) { // Nothing to do ! attId++; } // Do that only for the UV0 if (vbFlags & CVertexBuffer::TexCoord0Flag) { attr = rWedgeRef.Attributes[attId]; CUV UVRef = CUV(attr.x, attr.y); attr = rWedgeTar.Attributes[attId]; CUV UVTar = CUV(attr.x, attr.y); CUV deltaUV = UVTar - UVRef; if ((deltaUV.U*deltaUV.U + deltaUV.V*deltaUV.V) > 0.0001f) { rBS.deltaUV[i] = deltaUV; rBS.VertRefs[i] = i; bIsDeltaUV = true; } attId++; } if (useTgSpace) { attr = rWedgeRef.Attributes[attId]; CVector TgSpaceRef = CVector(attr.x, attr.y, attr.z); attr = rWedgeTar.Attributes[attId]; CVector TgSpaceTar = CVector(attr.x, attr.y, attr.z); delta = TgSpaceTar - TgSpaceRef; if (delta.norm() > 0.001f) { rBS.deltaTgSpace[i] = delta; rBS.VertRefs[i] = i; bIsDeltaTgSpace = true; } attId++; } } // End of all vertices added in blend shape // Delete unused items and calculate the number of vertex used (blended) sint32 nNbVertUsed = nNbVertVB; sint32 nDstPos = 0; for (j = 0; j < nNbVertVB; ++j) { if (rBS.VertRefs[j] == 0xffffffff) // Is vertex UNused { --nNbVertUsed; } else // Vertex used { if (nDstPos != j) { rBS.VertRefs[nDstPos] = rBS.VertRefs[j]; rBS.deltaPos[nDstPos] = rBS.deltaPos[j]; rBS.deltaNorm[nDstPos] = rBS.deltaNorm[j]; rBS.deltaUV[nDstPos] = rBS.deltaUV[j]; rBS.deltaCol[nDstPos] = rBS.deltaCol[j]; if (useTgSpace) { rBS.deltaTgSpace[nDstPos] = rBS.deltaTgSpace[j]; } } ++nDstPos; } } if (bIsDeltaPos) rBS.deltaPos.resize (nNbVertUsed); else rBS.deltaPos.resize (0); if (bIsDeltaNorm) rBS.deltaNorm.resize (nNbVertUsed); else rBS.deltaNorm.resize (0); if (bIsDeltaUV) rBS.deltaUV.resize (nNbVertUsed); else rBS.deltaUV.resize (0); if (bIsDeltaCol) rBS.deltaCol.resize (nNbVertUsed); else rBS.deltaCol.resize (0); if (bIsDeltaTgSpace) rBS.deltaTgSpace.resize (nNbVertUsed); else rBS.deltaTgSpace.resize (0); rBS.VertRefs.resize (nNbVertUsed); } }

void NL3D::CMRMBuilder::buildMeshBuildMrm (  const CMRMMeshFinal &  finalMRM, CMeshMRMGeom::CMeshBuildMRM &  mbuild, uint32  vbFlags, uint32  nbMats, const CMesh::CMeshBuild &  mb )  [private]

from a final MRM Mesh representation, compute a CMeshBuildMRM. This is the last stage of the algo. Parameters: vbFlags  the vertex format returned by earlier call too buildMrmBaseMesh(). nbMats  the number of materials of original MeshBuild. Definition at line 1918 of file mrm_builder.cpp. References NLMISC::CRGBAF::A, NL3D::CVertexBuffer::addValueEx(), NL3D::CMRMMeshFinal::CWedge::Attributes, attToColor(), attToUvw(), NLMISC::CRGBAF::B, NL3D::CMeshMRMGeom::CMeshBuildMRM::BlendShapes, NL3D::CVertexBuffer::clearValueEx(), NL3D::CBlendShape::deltaCol, NL3D::CBlendShape::deltaNorm, NL3D::CBlendShape::deltaPos, NL3D::CBlendShape::deltaTgSpace, NL3D::CBlendShape::deltaUV, NL3D::CMRMMeshFinal::CLod::Faces, NLMISC::CRGBAF::G, NL3D::CMRMMeshFinal::CLod::Geomorphs, NL3D::CMeshMRMGeom::CLod::Geomorphs, NL3D::CMeshMRMGeom::CLod::InfluencedVertices, NL3D::CVertexBuffer::initEx(), NL3D::CMRMMeshFinal::Lods, NL3D::CMeshMRMGeom::CMeshBuildMRM::Lods, NL3D::CMesh::CSkinWeight::MatrixId, NL3D::CMeshMRMGeom::CLod::MatrixInfluences, NL3D::CMesh::CMeshBuild::MeshVertexProgram, NL3D::CMRMMeshFinal::MRMBlendShapesFinals, NL3D::CMRMMeshFinal::NGeomSpace, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, NLMISC::CVector::norm(), NL3D::CMesh::CMeshBuild::NumCoords, NL3D::CMRMMeshFinal::CLod::NWedges, NL3D::CMeshMRMGeom::CLod::NWedges, NLMISC::CRGBAF::R, NL3D::CMeshMRMGeom::CLod::RdrPass, NL3D::CVertexBuffer::setColor(), NL3D::CVertexBuffer::setNormalCoord(), NL3D::CVertexBuffer::setNumVertices(), NL3D::CVertexBuffer::setSpecular(), NL3D::CVertexBuffer::setTexCoord(), NL3D::CVertexBuffer::setUVRouting(), NL3D::CVertexBuffer::setValueFloat3Ex(), NL3D::CVertexBuffer::setVertexCoord(), NL3D::CVertexBuffer::setVertexFormat(), sint, sint32, NL3D::CMeshMRMGeom::CMeshBuildMRM::Skinned, NL3D::CMeshMRMGeom::CMeshBuildMRM::SkinWeights, NLMISC::CUV::U, NLMISC::CUVW::U, uint, uint32, NL3D::CMesh::CMeshBuild::UVRouting, NLMISC::CUV::V, NLMISC::CUVW::V, NL3D::CMeshMRMGeom::CMeshBuildMRM::VBuffer, NL3D::CMRMMeshFinal::CWedge::Vertex, NL3D::CMRMMeshFinal::CWedge::VertexSkin, NL3D::CBlendShape::VertRefs, NLMISC::CVectorH::w, NLMISC::CUVW::W, NL3D::CMRMMeshFinal::Wedges, NL3D::CMesh::CSkinWeight::Weights, NLMISC::CVectorH::x, NLMISC::CVectorH::y, and NLMISC::CVectorH::z. Referenced by compileMRM(). { sint i,j,k; sint attId; // reset the mbuild. mbuild= CMeshMRMGeom::CMeshBuildMRM(); // Setup VB. bool useFormatExt = false; // Check wether there are texture coordinates with more than 2 compnents, which force us to use an extended vertex format for (k = 0; k < CVertexBuffer::MaxStage; ++k) { if ( (vbFlags & (CVertexBuffer::TexCoord0Flag << k)) && mb.NumCoords[k] != 2) { useFormatExt = true; break; } } uint numTexCoordUsed = 0; for (k = 0; k < CVertexBuffer::MaxStage; ++k) { if (vbFlags & (CVertexBuffer::TexCoord0Flag << k)) { numTexCoordUsed = k; } } if (!useFormatExt) { // setup standard format mbuild.VBuffer.setVertexFormat(vbFlags); } else // setup extended format { mbuild.VBuffer.clearValueEx(); if (vbFlags & CVertexBuffer::PositionFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::Position, CVertexBuffer::Float3); if (vbFlags & CVertexBuffer::NormalFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::Normal, CVertexBuffer::Float3); if (vbFlags & CVertexBuffer::PrimaryColorFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::PrimaryColor, CVertexBuffer::UChar4); if (vbFlags & CVertexBuffer::SecondaryColorFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::SecondaryColor, CVertexBuffer::UChar4); if (vbFlags & CVertexBuffer::WeightFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::Weight, CVertexBuffer::Float4); if (vbFlags & CVertexBuffer::PaletteSkinFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::PaletteSkin, CVertexBuffer::UChar4); if (vbFlags & CVertexBuffer::FogFlag) mbuild.VBuffer.addValueEx(CVertexBuffer::Fog, CVertexBuffer::Float1); for (k = 0; k < CVertexBuffer::MaxStage; ++k) { if (vbFlags & (CVertexBuffer::TexCoord0Flag << k)) { switch(mb.NumCoords[k]) { case 2: mbuild.VBuffer.addValueEx((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), CVertexBuffer::Float2); break; case 3: mbuild.VBuffer.addValueEx((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), CVertexBuffer::Float3); break; default: nlassert(0); break; } } } mbuild.VBuffer.initEx(); } // Copy the UVRouting for (i=0; i<CVertexBuffer::MaxStage; i++) { mbuild.VBuffer.setUVRouting (i, mb.UVRouting[i]); } // Setup the VertexBuffer. // ======================== // resize the VB. mbuild.VBuffer.setNumVertices(finalMRM.Wedges.size()); // Setup SkinWeights. if(_Skinned) mbuild.SkinWeights.resize(finalMRM.Wedges.size()); // fill the VB. for(i=0; i<(sint)finalMRM.Wedges.size(); i++) { const CMRMMeshFinal::CWedge &wedge= finalMRM.Wedges[i]; // setup Vertex. mbuild.VBuffer.setVertexCoord(i, wedge.Vertex); // seutp attributes. attId= 0; // For all activated attributes in mbuild, retriev the attribute from the finalMRM. if(vbFlags & CVertexBuffer::NormalFlag) { mbuild.VBuffer.setNormalCoord(i, wedge.Attributes[attId] ); attId++; } if(vbFlags & CVertexBuffer::PrimaryColorFlag) { mbuild.VBuffer.setColor(i, attToColor(wedge.Attributes[attId]) ); attId++; } if(vbFlags & CVertexBuffer::SecondaryColorFlag) { mbuild.VBuffer.setSpecular(i, attToColor(wedge.Attributes[attId]) ); attId++; } for(k=0; k<CVertexBuffer::MaxStage;k++) { if(vbFlags & (CVertexBuffer::TexCoord0Flag<<k)) { switch(mb.NumCoords[k]) { case 2: mbuild.VBuffer.setTexCoord(i, k, (CUV) attToUvw(wedge.Attributes[attId]) ); break; case 3: { CUVW uvw = attToUvw(wedge.Attributes[attId]); mbuild.VBuffer.setValueFloat3Ex((CVertexBuffer::TValue) (CVertexBuffer::TexCoord0 + k), i, uvw.U, uvw.V, uvw.W); } break; default: nlassert(0); break; } attId++; } } // Setup SkinWeights. if(_Skinned) { mbuild.SkinWeights[i]= wedge.VertexSkin; } } // Build Lods. // ======================== // resize mbuild.Lods.resize(finalMRM.Lods.size()); // fill. for(i=0; i<(sint)finalMRM.Lods.size(); i++) { const CMRMMeshFinal::CLod &srcLod= finalMRM.Lods[i]; CMeshMRMGeom::CLod &destLod= mbuild.Lods[i]; // Basic. //--------- // Copy NWedges infos. destLod.NWedges= srcLod.NWedges; // Copy Geomorphs infos. destLod.Geomorphs= srcLod.Geomorphs; // Reorder faces by rdrpass. //--------- // First count the number of faces used by this LOD for each material vector<sint> matCount; // resize, and reset to 0. matCount.clear(); matCount.resize(nbMats, 0); // For each face of this Lods, incr the mat face counter. for(j= 0; j<(sint)srcLod.Faces.size(); j++) { sint matId= srcLod.Faces[j].MaterialId; nlassert(matId>=0); nlassert(matId<(sint)nbMats); // increment the refcount of this material by this LOD. matCount[matId]++; } // Then for each material not empty, create a rdrPass, and ref it for this material. vector<sint> rdrPassIndex; // material to rdrPass map. rdrPassIndex.resize(nbMats); for(j=0; j<(sint)nbMats; j++) { if(matCount[j]==0) rdrPassIndex[j]= -1; else { // map material to rdrPass. sint idRdrPass= destLod.RdrPass.size(); rdrPassIndex[j]= idRdrPass; // create a rdrPass. destLod.RdrPass.push_back(CMeshMRMGeom::CRdrPass()); // assign the good materialId to this rdrPass. destLod.RdrPass[idRdrPass].MaterialId= j; // reserve the array of faces of this rdrPass. destLod.RdrPass[idRdrPass].PBlock.reserveTri(matCount[j]); } } // Then for each face, add it to the good rdrPass of this Lod. for(j= 0; j<(sint)srcLod.Faces.size(); j++) { sint matId= srcLod.Faces[j].MaterialId; sint idRdrPass= rdrPassIndex[matId]; // add this face to the good rdrPass. sint w0= srcLod.Faces[j].WedgeId[0]; sint w1= srcLod.Faces[j].WedgeId[1]; sint w2= srcLod.Faces[j].WedgeId[2]; destLod.RdrPass[idRdrPass].PBlock.addTri(w0, w1, w2); } // Build skin info for this Lod. //--------- for(j=0; j<NL3D_MESH_SKINNING_MAX_MATRIX; j++) { destLod.InfluencedVertices[j].clear(); } destLod.MatrixInfluences.clear(); if(_Skinned) { // This is the set which tell what wedge has already been inserted. set<uint> wedgeInfSet; // First, build the list of vertices influenced by this Lod. for(j= 0; j<(sint)srcLod.Faces.size(); j++) { for(k=0; k<3; k++) { sint wedgeId= srcLod.Faces[j].WedgeId[k]; // If it is a geomorph if(wedgeId<finalMRM.NGeomSpace) { // add the start and end to the list (if not here). NB: wedgeId is both the id // of the dest wedge, and the id of the geomorph. sint wedgeStartId= destLod.Geomorphs[wedgeId].Start; sint wedgeEndId= destLod.Geomorphs[wedgeId].End; uint nMatUsedStart= finalMRM.Wedges[wedgeStartId].NSkinMatUsed; uint nMatUsedEnd= finalMRM.Wedges[wedgeEndId].NSkinMatUsed; // if insertion in the set work, add to the good array. if( wedgeInfSet.insert(wedgeStartId).second ) destLod.InfluencedVertices[nMatUsedStart-1].push_back(wedgeStartId); if( wedgeInfSet.insert(wedgeEndId).second ) destLod.InfluencedVertices[nMatUsedEnd-1].push_back(wedgeEndId); } else { uint nMatUsed= finalMRM.Wedges[wedgeId].NSkinMatUsed; // just add this wedge to the list (if not here). // if insertion in the set work, add to the array. if( wedgeInfSet.insert(wedgeId).second ) destLod.InfluencedVertices[nMatUsed-1].push_back(wedgeId); } } } // Optimisation: for better cache, sort the destLod.InfluencedVertices in increasing order. for(j=0; j<NL3D_MESH_SKINNING_MAX_MATRIX; j++) { sort(destLod.InfluencedVertices[j].begin(), destLod.InfluencedVertices[j].end()); } // Then Build the MatrixInfluences array, for all thoses Influenced Vertices only. // This is the map MatrixId -> MatrixInfId. map<uint, uint> matrixInfMap; // For all influenced vertices, flags matrix they use. uint iSkinMat; for(iSkinMat= 0; iSkinMat<NL3D_MESH_SKINNING_MAX_MATRIX; iSkinMat++) { for(j= 0; j<(sint)destLod.InfluencedVertices[iSkinMat].size(); j++) { uint wedgeId= destLod.InfluencedVertices[iSkinMat][j]; // take the original wedge. const CMRMMeshFinal::CWedge &wedge= finalMRM.Wedges[wedgeId]; // For all matrix with not null influence... for(k= 0; k<NL3D_MESH_SKINNING_MAX_MATRIX; k++) { float matWeight= wedge.VertexSkin.Weights[k]; // This check the validity of skin weights sort. If false, problem before in the algo. if((uint)k<iSkinMat+1) { nlassert( matWeight>0 ); } else { nlassert( matWeight==0 ); } // if not null influence. if(matWeight>0) { uint matId= wedge.VertexSkin.MatrixId[k]; // search/insert the matrixInfId. map<uint, uint>::iterator it= matrixInfMap.find(matId); if( it==matrixInfMap.end() ) { uint matInfId= destLod.MatrixInfluences.size(); matrixInfMap.insert( make_pair(matId, matInfId) ); // create the new MatrixInfluence. destLod.MatrixInfluences.push_back(matId); } } } } } } } // Indicate Skinning. mbuild.Skinned= _Skinned; bool useTgSpace = mb.MeshVertexProgram != NULL ? mb.MeshVertexProgram->needTangentSpace() : false; // Construct Blend Shapes mbuild.BlendShapes.resize (finalMRM.MRMBlendShapesFinals.size()); for (k = 0; k < (sint)mbuild.BlendShapes.size(); ++k) { CBlendShape &rBS = mbuild.BlendShapes[k]; sint32 nNbVertVB = finalMRM.Wedges.size(); bool bIsDeltaPos = false; rBS.deltaPos.resize (nNbVertVB, CVector(0.0f,0.0f,0.0f)); bool bIsDeltaNorm = false; rBS.deltaNorm.resize (nNbVertVB, CVector(0.0f,0.0f,0.0f)); bool bIsDeltaUV = false; rBS.deltaUV.resize (nNbVertVB, CUV(0.0f,0.0f)); bool bIsDeltaCol = false; rBS.deltaCol.resize (nNbVertVB, CRGBAF(0.0f,0.0f,0.0f,0.0f)); bool bIsDeltaTgSpace = false; if (useTgSpace) { rBS.deltaTgSpace.resize(nNbVertVB, CVector::Null); } rBS.VertRefs.resize (nNbVertVB, 0xffffffff); for (i = 0; i < nNbVertVB; i++) { const CMRMMeshFinal::CWedge &rWedgeRef = finalMRM.Wedges[i]; const CMRMMeshFinal::CWedge &rWedgeTar = finalMRM.MRMBlendShapesFinals[k].Wedges[i]; CVector delta = rWedgeTar.Vertex - rWedgeRef.Vertex; CVectorH attr; if (delta.norm() > 0.001f) { rBS.deltaPos[i] = delta; rBS.VertRefs[i] = i; bIsDeltaPos = true; } attId = 0; if (vbFlags & CVertexBuffer::NormalFlag) { attr = rWedgeRef.Attributes[attId]; CVector NormRef = CVector(attr.x, attr.y, attr.z); attr = rWedgeTar.Attributes[attId]; CVector NormTar = CVector(attr.x, attr.y, attr.z); delta = NormTar - NormRef; if (delta.norm() > 0.001f) { rBS.deltaNorm[i] = delta; rBS.VertRefs[i] = i; bIsDeltaNorm = true; } attId++; } if (vbFlags & CVertexBuffer::PrimaryColorFlag) { attr = rWedgeRef.Attributes[attId]; CRGBAF RGBARef = CRGBAF(attr.x/255.0f, attr.y/255.0f, attr.z/255.0f, attr.w/255.0f); attr = rWedgeTar.Attributes[attId]; CRGBAF RGBATar = CRGBAF(attr.x/255.0f, attr.y/255.0f, attr.z/255.0f, attr.w/255.0f); CRGBAF deltaRGBA = RGBATar - RGBARef; if ((deltaRGBA.R*deltaRGBA.R + deltaRGBA.G*deltaRGBA.G + deltaRGBA.B*deltaRGBA.B + deltaRGBA.A*deltaRGBA.A) > 0.0001f) { rBS.deltaCol[i] = deltaRGBA; rBS.VertRefs[i] = i; bIsDeltaCol = true; } attId++; } if (vbFlags & CVertexBuffer::SecondaryColorFlag) { // Nothing to do ! attId++; } // Do that only for the UV0 if (vbFlags & CVertexBuffer::TexCoord0Flag) { attr = rWedgeRef.Attributes[attId]; CUV UVRef = CUV(attr.x, attr.y); attr = rWedgeTar.Attributes[attId]; CUV UVTar = CUV(attr.x, attr.y); CUV deltaUV = UVTar - UVRef; if ((deltaUV.U*deltaUV.U + deltaUV.V*deltaUV.V) > 0.0001f) { rBS.deltaUV[i] = deltaUV; rBS.VertRefs[i] = i; bIsDeltaUV = true; } attId++; } if (useTgSpace) { attr = rWedgeRef.Attributes[attId]; CVector TgSpaceRef = CVector(attr.x, attr.y, attr.z); attr = rWedgeTar.Attributes[attId]; CVector TgSpaceTar = CVector(attr.x, attr.y, attr.z); delta = TgSpaceTar - TgSpaceRef; if (delta.norm() > 0.001f) { rBS.deltaTgSpace[i] = delta; rBS.VertRefs[i] = i; bIsDeltaTgSpace = true; } attId++; } } // End of all vertices added in blend shape // Delete unused items and calculate the number of vertex used (blended) sint32 nNbVertUsed = nNbVertVB; sint32 nDstPos = 0; for (j = 0; j < nNbVertVB; ++j) { if (rBS.VertRefs[j] == 0xffffffff) // Is vertex UNused { --nNbVertUsed; } else // Vertex used { if (nDstPos != j) { rBS.VertRefs[nDstPos] = rBS.VertRefs[j]; rBS.deltaPos[nDstPos] = rBS.deltaPos[j]; rBS.deltaNorm[nDstPos] = rBS.deltaNorm[j]; rBS.deltaUV[nDstPos] = rBS.deltaUV[j]; rBS.deltaCol[nDstPos] = rBS.deltaCol[j]; if (useTgSpace) { rBS.deltaTgSpace[nDstPos] = rBS.deltaTgSpace[j]; } } ++nDstPos; } } if (bIsDeltaPos) rBS.deltaPos.resize (nNbVertUsed); else rBS.deltaPos.resize (0); if (bIsDeltaNorm) rBS.deltaNorm.resize (nNbVertUsed); else rBS.deltaNorm.resize (0); if (bIsDeltaUV) rBS.deltaUV.resize (nNbVertUsed); else rBS.deltaUV.resize (0); if (bIsDeltaCol) rBS.deltaCol.resize (nNbVertUsed); else rBS.deltaCol.resize (0); if (bIsDeltaTgSpace) rBS.deltaTgSpace.resize (nNbVertUsed); else rBS.deltaTgSpace.resize (0); rBS.VertRefs.resize (nNbVertUsed); } }

uint32 NL3D::CMRMBuilder::buildMrmBaseMesh (  const CMesh::CMeshBuild &  mbuild, CMRMMesh &  baseMesh )  [private]

from a meshBuild, compute a CMRMMesh. This is the first stage of the algo. Returns: the vertexFormat supported by CMRMBuilder. Definition at line 1734 of file mrm_builder.cpp. References _AttributeMap, _HasMeshInterfaces, NL3D::CMRMCorner::Attributes, NL3D::CMesh::CCorner::Color, NL3D::CMRMMesh::Faces, NL3D::CMesh::CMeshBuild::Faces, findInsertColorInBaseMesh(), findInsertNormalInBaseMesh(), findInsertUvwInBaseMesh(), NL3D::CMesh::CMeshBuild::InterfaceLinks, NL3D::CMRMMesh::InterfaceLinks, NL3D_MRM_MAX_ATTRIB, nlassert, NL3D::CMesh::CCorner::Normal, NL3D::CMRMMesh::NumAttributes, sint, NL3D::CMesh::CMeshBuild::SkinWeights, NL3D::CMRMMesh::SkinWeights, NL3D::CMesh::CCorner::Specular, uint, uint32, NL3D::CMesh::CCorner::Uvws, NL3D::CMRMCorner::Vertex, NL3D::CMesh::CMeshBuild::VertexFlags, NL3D::CMesh::CMeshBuild::Vertices, and NL3D::CMRMMesh::Vertices. Referenced by compileMRM(). { sint i,j,k; sint nFaces; sint attId; // build the supported VertexFormat. uint32 retVbFlags= CVertexBuffer::PositionFlag; // reset the baseMesh. baseMesh= CMRMMesh(); // reset Tmp. for(attId=0; attId<NL3D_MRM_MAX_ATTRIB;attId++) _AttributeMap[attId].clear(); // Compute number of attributes used by the MeshBuild. // ======================== // Compute too if(mbuild.VertexFlags & CVertexBuffer::NormalFlag) { baseMesh.NumAttributes++; retVbFlags|= CVertexBuffer::NormalFlag; } if(mbuild.VertexFlags & CVertexBuffer::PrimaryColorFlag) { baseMesh.NumAttributes++; retVbFlags|= CVertexBuffer::PrimaryColorFlag; } if(mbuild.VertexFlags & CVertexBuffer::SecondaryColorFlag) { baseMesh.NumAttributes++; retVbFlags|= CVertexBuffer::SecondaryColorFlag; } for(k=0; k<CVertexBuffer::MaxStage;k++) { uint flag=CVertexBuffer::TexCoord0Flag<<k; if(mbuild.VertexFlags & flag) { baseMesh.NumAttributes++; retVbFlags|=flag; } } nlassert(baseMesh.NumAttributes<=NL3D_MRM_MAX_ATTRIB); // Fill basics: Vertices and Faces materials / index to vertices. // ======================== // Just copy vertices. baseMesh.Vertices= mbuild.Vertices; // Just copy SkinWeights. if(_Skinned) baseMesh.SkinWeights= mbuild.SkinWeights; // Just copy InterfaceLinks if(_HasMeshInterfaces) baseMesh.InterfaceLinks= mbuild.InterfaceLinks; // Resize faces. nFaces= mbuild.Faces.size(); baseMesh.Faces.resize(nFaces); for(i=0; i<nFaces; i++) { // copy material Id. baseMesh.Faces[i].MaterialId= mbuild.Faces[i].MaterialId; // Copy Vertex index. for(j=0; j<3; j++) { baseMesh.Faces[i].Corner[j].Vertex= mbuild.Faces[i].Corner[j].Vertex; } } // Resolve attributes discontinuities and Fill attributes of the baseMesh. // ======================== // For all corners. for(i=0; i<nFaces; i++) { for(j=0; j<3; j++) { const CMesh::CCorner &srcCorner= mbuild.Faces[i].Corner[j]; CMRMCorner &destCorner= baseMesh.Faces[i].Corner[j]; attId= 0; // For all activated attributes in mbuild, find/insert the attribute in the baseMesh. // NB: 2 attributes are said to be different if they have not the same value OR if they don't lie // on the same vertex. This is very important for MRM computing. if(mbuild.VertexFlags & CVertexBuffer::NormalFlag) { destCorner.Attributes[attId]= findInsertNormalInBaseMesh(baseMesh, attId, destCorner.Vertex, srcCorner.Normal); attId++; } if(mbuild.VertexFlags & CVertexBuffer::PrimaryColorFlag) { destCorner.Attributes[attId]= findInsertColorInBaseMesh(baseMesh, attId, destCorner.Vertex, srcCorner.Color); attId++; } if(mbuild.VertexFlags & CVertexBuffer::SecondaryColorFlag) { destCorner.Attributes[attId]= findInsertColorInBaseMesh(baseMesh, attId, destCorner.Vertex, srcCorner.Specular); attId++; } for(k=0; k<CVertexBuffer::MaxStage;k++) { if(mbuild.VertexFlags & (CVertexBuffer::TexCoord0Flag<<k)) { destCorner.Attributes[attId]= findInsertUvwInBaseMesh(baseMesh, attId, destCorner.Vertex, srcCorner.Uvws[k]); attId++; } } } } // End. clear Tmp infos. // ======================== // reset Tmp. for(attId=0; attId<NL3D_MRM_MAX_ATTRIB;attId++) _AttributeMap[attId].clear(); return retVbFlags; }

bool NL3D::CMRMBuilder::buildMRMSewingMeshes (  const CMesh::CMeshBuild &  mbuild, uint  nWantedLods, uint  divisor )  [private]

Definition at line 3115 of file mrm_builder.cpp. References _SewingMeshes, NL3D::CMesh::CMeshBuild::InterfaceLinks, NL3D::CMesh::CMeshBuild::Interfaces, nlassert, uint, and NL3D::CMesh::CMeshBuild::Vertices. Referenced by compileMRM(). { nlassert(nWantedLods>=1); nlassert(divisor>=1); if(mbuild.Interfaces.size()==0) return false; // must have same size if(mbuild.InterfaceLinks.size()!=mbuild.Vertices.size()) return false; // **** For each interface, MRM-ize it and store. _SewingMeshes.resize(mbuild.Interfaces.size()); for(uint i=0;i<mbuild.Interfaces.size();i++) { _SewingMeshes[i].build(mbuild.Interfaces[i], nWantedLods, divisor); } return true; }

sint NL3D::CMRMBuilder::collapseEdge (  const CMRMEdge &  edge  )  [private]

Definition at line 499 of file mrm_builder.cpp. References _CurrentLodComputed, _HasMeshInterfaces, _SewingMeshes, NL3D::CMRMCorner::Attributes, NL3D::CMRMAttribute::BSCurrent, NL3D::CMRMVertex::BSCurrent, NL3D::CMRMFaceBuild::BSInterpolated, NL3D::CMRMAttribute::CollapsedTo, NL3D::CMRMVertex::CollapsedTo, collapseSkinWeight(), NL3D::CMRMFace::Corner, NL3D::CMRMAttribute::Current, NL3D::CMRMVertex::Current, NL3D::CMRMVertex::CurrentSW, NL3D::deleteElement(), EdgeCollapses, faceShareWedges(), NL3D::findElement(), NL3D::CMRMFaceBuild::getAssociatedWedge(), NL3D::CMesh::CInterfaceLink::InterfaceId, NL3D::CMRMVertex::InterfaceLink, NL3D::CMesh::CInterfaceLink::InterfaceVertexId, NL3D::CMRMFaceBuild::InterpolatedAttribute, NL3D::CMRMAttribute::InterpolatedFace, NL3D::CMRMSewingMesh::mustCollapseEdge(), NL3D::CMRMAttribute::NbSharedFaces, nlassert, NumAttributes, removeFaceFromEdgeList(), NL3D::CMRMAttribute::Shared, NL3D::CMRMVertex::SharedFaces, sint, TmpAttributes, TmpFaces, TmpVertices, uint, NL3D::CMRMEdge::v0, NL3D::CMRMEdge::v1, NL3D::CMRMCorner::Vertex, vertexClosed(), vertexContinue(), NLMISC::CVectorH::w, NLMISC::CVectorH::x, NLMISC::CVectorH::y, and NLMISC::CVectorH::z. Referenced by collapseEdges(). { sint i,j; float InterValue; sint edgeV1=edge.v0; sint edgeV2=edge.v1; // 0. collapse the vertices. //========================== // edge.Vertex1 kept, but morphed. // edge.Vertex2 deleted, and must know on which vertex it collapse. CMRMVertex &Vertex1=TmpVertices[edgeV1], &Vertex2=TmpVertices[edgeV2]; // Interpolation choice. // Default is to interpolate vertex 0 to the middle of the edge. InterValue=0.5; //InterValue=1; // **** If at least one vertex of the edge is on a mesh sewing interface, must change InterValue if( _HasMeshInterfaces && (Vertex1.InterfaceLink.InterfaceId>=0 || Vertex2.InterfaceLink.InterfaceId>=0) ) { // If this is an edge of a mesh sewing interface if(Vertex1.InterfaceLink.InterfaceId==Vertex2.InterfaceLink.InterfaceId) { // Then the edge is one of the sewing interface mesh. must do special things for it CMRMSewingMesh &sewingMesh= _SewingMeshes[Vertex1.InterfaceLink.InterfaceId]; // get the sewing edge id CMRMEdge sewingEdge; sewingEdge.v0= Vertex1.InterfaceLink.InterfaceVertexId; sewingEdge.v1= Vertex2.InterfaceLink.InterfaceVertexId; // Get the edge in the sewing mesh which is said to be collapsed uint vertToCollapse; sint collapseId= sewingMesh.mustCollapseEdge(_CurrentLodComputed, sewingEdge, vertToCollapse); // if exist if(collapseId>=0) { // if it is v0 which must collapse, then InterValue=1 if(vertToCollapse==(uint)sewingEdge.v0) InterValue= 1; else InterValue= 0; } else { // This should not happens. But it is still possible if this edge don't want to collapse but if their // is no more choice. Take a default value InterValue= 0; } } else { // must collapse to the vertex on the sewing interface (as if it was open) if(Vertex1.InterfaceLink.InterfaceId>=0) { // NB: it is possible that both vertices are on a different sewing interface... still collapse (must have to) InterValue= 0; } else { // Then Vertex2 is on a sewing interface, collapse to it InterValue= 1; } } } // **** Else, on special cases, it is much more efficient to interpolate at start or at end of edge. else { // If one vertex is "open", ie his shared faces do not represent a closed Fan, then interpolate to this one, // so the mesh has the same silhouette. bool vc1= vertexClosed(edgeV1); bool vc2= vertexClosed(edgeV2); if(!vc1 && vc2) InterValue=0; else if(vc1 && !vc2) InterValue=1; else { // Do the same test but with vertex continue: it is preferable to not move the boundaries // of a material, or a mapping. bool vc1= vertexContinue(edgeV1); bool vc2= vertexContinue(edgeV2); if(!vc1 && vc2) InterValue=0; if(vc1 && !vc2) InterValue=1; } } /*BENCH_TotalCollapses++; if(InterValue==0.5) BENCH_MiddleCollapses++;*/ // Collapse the Vertex. //======================== Vertex1.Current= Vertex1.Current*(1-InterValue) + Vertex2.Current*InterValue; for (i = 0; i < (sint)Vertex1.BSCurrent.size(); ++i) Vertex1.BSCurrent[i] = Vertex1.BSCurrent[i]*(1-InterValue) + Vertex2.BSCurrent[i]*InterValue; Vertex2.CollapsedTo= edgeV1; if(_Skinned) Vertex1.CurrentSW= collapseSkinWeight(Vertex1.CurrentSW, Vertex2.CurrentSW, InterValue); if( _HasMeshInterfaces ) Vertex1.InterfaceLink= InterValue<0.5f? Vertex1.InterfaceLink : Vertex2.InterfaceLink; // \todo yoyo: TODO_BUG: Don't know why, but vertices may point on deleted faces. // Temp: we destroy here thoses face from SharedFaces... for(i=0;i<(sint)Vertex1.SharedFaces.size();i++) { sint numFace= Vertex1.SharedFaces[i]; if(TmpFaces[numFace].Deleted) deleteElement(Vertex1.SharedFaces, numFace), i--; } for(i=0;i<(sint)Vertex2.SharedFaces.size();i++) { sint numFace= Vertex2.SharedFaces[i]; if(TmpFaces[numFace].Deleted) deleteElement(Vertex2.SharedFaces, numFace), i--; } // Build Neighbor faces. vector<sint> neighboorFaces; for(i=0;i<(sint)Vertex1.SharedFaces.size();i++) { sint numFace= Vertex1.SharedFaces[i]; if(!findElement(neighboorFaces, numFace)) neighboorFaces.push_back(numFace); } for(i=0;i<(sint)Vertex2.SharedFaces.size();i++) { sint numFace= Vertex2.SharedFaces[i]; if(!findElement(neighboorFaces, numFace)) neighboorFaces.push_back(numFace); } // Build faces which will be destroyed (may 1 or 2, maybe more for non conventionnal meshes). vector<sint> deletedFaces; for(i=0;i<(sint)Vertex1.SharedFaces.size();i++) { sint numFace= Vertex1.SharedFaces[i]; nlassert(!TmpFaces[numFace].Deleted); if(TmpFaces[numFace].hasVertex(edgeV2)) deletedFaces.push_back(numFace); } // 1. Collapse the wedges. //======================== // For ALL Attributes. for(sint attId=0;attId<NumAttributes;attId++) { // a/ Stock the wedge interpolation in each destroyed face. //------------------------------------------------------ for(i=0;i<(sint)deletedFaces.size();i++) { CMRMFaceBuild &face= TmpFaces[deletedFaces[i]]; CVectorH &w0= TmpAttributes[attId][ face.getAssociatedWedge(attId, edgeV1) ].Current; CVectorH &w1= TmpAttributes[attId][ face.getAssociatedWedge(attId, edgeV2) ].Current; CVectorH &itp= face.InterpolatedAttribute; itp.x= w0.x*(1-InterValue) + w1.x*InterValue; itp.y= w0.y*(1-InterValue) + w1.y*InterValue; itp.z= w0.z*(1-InterValue) + w1.z*InterValue; itp.w= w0.w*(1-InterValue) + w1.w*InterValue; for (j = 0; j < (sint)face.BSInterpolated.size(); ++j) { CVectorH &w0 = TmpAttributes[attId][face.getAssociatedWedge(attId, edgeV1)].BSCurrent[j]; CVectorH &w1 = TmpAttributes[attId][face.getAssociatedWedge(attId, edgeV2)].BSCurrent[j]; CVectorH &itb = face.BSInterpolated[j]; itb.x = w0.x*(1-InterValue) + w1.x*InterValue; itb.y = w0.y*(1-InterValue) + w1.y*InterValue; itb.z = w0.z*(1-InterValue) + w1.z*InterValue; itb.w = w0.w*(1-InterValue) + w1.w*InterValue; } } // b/ Build wedge list to be modify. //---------------------------------- vector<sint> wedges; for(i=0;i<(sint)neighboorFaces.size();i++) { CMRMFaceBuild &face= TmpFaces[neighboorFaces[i]]; sint numWedge; numWedge= face.getAssociatedWedge(attId, edgeV1); if(numWedge>=0 && !findElement(wedges, numWedge)) wedges.push_back(numWedge); numWedge= face.getAssociatedWedge(attId, edgeV2); if(numWedge>=0 && !findElement(wedges, numWedge)) wedges.push_back(numWedge); } // c/ Count numFaces which point on those wedges. (- deleted faces). //------------------------------------------------------------------ for(i=0;i<(sint)wedges.size();i++) { sint numWedge= wedges[i]; CMRMAttribute &wedge= TmpAttributes[attId][numWedge]; wedge.NbSharedFaces=0; wedge.Shared=false; // Count total ref count. for(j=0;j<(sint)neighboorFaces.size();j++) { if(TmpFaces[neighboorFaces[j]].hasWedge(attId, numWedge)) wedge.NbSharedFaces++; } // Minus deleted faces. for(j=0;j<(sint)deletedFaces.size();j++) { if(TmpFaces[deletedFaces[j]].hasWedge(attId, numWedge)) { wedge.NbSharedFaces--; wedge.Shared=true; wedge.InterpolatedFace=deletedFaces[j]; } } } // d/ Collapse wedge following 3 possibles cases. //----------------------------------------------- for(i=0;i<(sint)wedges.size();i++) { sint numWedge= wedges[i]; CMRMAttribute &wedge= TmpAttributes[attId][numWedge]; // if wedge not shared... if(!wedge.Shared) { // We've got an "exterior wedge" which lost no corner => do not merge it nor delete it. // Leave it as the same value (extrapolate it may not be a good solution). } else { // if wedge dissapears, notify. if(wedge.NbSharedFaces==0) { wedge.CollapsedTo=-2; // Do not change his value. (as specified in Hope article). } else { CMRMFaceBuild &face= TmpFaces[wedge.InterpolatedFace]; // Must interpolate it. wedge.Current= face.InterpolatedAttribute; wedge.BSCurrent = face.BSInterpolated; // Must merge the wedge of the second vertex on first // ONLY IF 2 interpolated wedges are shared and NbSharedFaces!=0. if( numWedge==face.getAssociatedWedge(attId, edgeV2) && faceShareWedges(&face, attId, edgeV1, edgeV2) ) { wedge.CollapsedTo= face.getAssociatedWedge(attId, edgeV1); } } } } } // 3. collapse faces. //=================== // delete face shared by edge. for(i=0;i<(sint)deletedFaces.size();i++) { sint numFace= deletedFaces[i]; TmpFaces[numFace].Deleted=true; // release edges from list. removeFaceFromEdgeList(TmpFaces[numFace]); // ivalid all it!! TmpFaces[numFace].invalidAllIts(EdgeCollapses); // delete from vertex1 and 2 the deleted faces. deleteElement( Vertex1.SharedFaces, numFace); deleteElement( Vertex2.SharedFaces, numFace); } // must ref correctly the faces. for(i=0;i<(sint)neighboorFaces.size();i++) { CMRMFaceBuild &face=TmpFaces[neighboorFaces[i]]; // good vertices if(face.Corner[0].Vertex ==edgeV2) face.Corner[0].Vertex=edgeV1; if(face.Corner[1].Vertex ==edgeV2) face.Corner[1].Vertex=edgeV1; if(face.Corner[2].Vertex ==edgeV2) face.Corner[2].Vertex=edgeV1; // nb: doesn't matter if deletedFaces are modified... // good wedges for(sint attId=0;attId<NumAttributes;attId++) { sint newWedge; newWedge= TmpAttributes[attId][ face.Corner[0].Attributes[attId] ].CollapsedTo; if(newWedge>=0) face.Corner[0].Attributes[attId]= newWedge; newWedge= TmpAttributes[attId][ face.Corner[1].Attributes[attId] ].CollapsedTo; if(newWedge>=0) face.Corner[1].Attributes[attId]= newWedge; newWedge= TmpAttributes[attId][ face.Corner[2].Attributes[attId] ].CollapsedTo; if(newWedge>=0) face.Corner[2].Attributes[attId]= newWedge; } // good edges. /* Those ones are updated in collapseEdges(): they are removed from the edgeCollapseList, then they are re-inserted with good Vertex indices. */ } // The vertex1 has now the shared env of vertex2. Vertex1.SharedFaces.insert(Vertex1.SharedFaces.end(), Vertex2.SharedFaces.begin(), Vertex2.SharedFaces.end()); return deletedFaces.size(); }

void NL3D::CMRMBuilder::collapseEdges (  sint  nWantedFaces  )  [private]

Definition at line 945 of file mrm_builder.cpp. References collapseEdge(), EdgeCollapses, insertFaceIntoEdgeList(), NL3D::CMRMFaceBuild::invalidEdgeIt(), NL3D::ItEdgeMap, nlassert, removeFaceFromEdgeList(), NL3D::CMRMVertex::SharedFaces, sint, TmpFaces, TmpVertices, NL3D::CMRMEdge::v0, NL3D::CMRMEdge::v1, and NL3D::CMRMFaceBuild::validEdgeIt(). Referenced by makeFromMesh(). { ItEdgeMap EdgeIt; sint nCurrentFaces=TmpFaces.size(); sint bug0=0,bug2=0,bug3=0; while(nCurrentFaces>nWantedFaces) { bug0++; EdgeIt= EdgeCollapses.begin(); if(EdgeIt== EdgeCollapses.end()) break; // 0. Look if edge already deleted //================================ CMRMEdge edge=(*EdgeIt).second; // Is it valid?? (ie his vertices exist yet??). if(TmpVertices[ edge.v0 ].CollapsedTo>=0 || TmpVertices[ edge.v1 ].CollapsedTo>=0) { // \todo yoyo: TODO_BUG: potential bug here... CMRMFaceBuild &f= *(EdgeIt->second.Face); nlassert(f.validEdgeIt(EdgeIt->second)); f.invalidEdgeIt(EdgeIt->second, EdgeCollapses); EdgeCollapses.erase(EdgeIt); bug2++; continue; } // \todo yoyo: TODO_BUG: potential bug here... // If a mesh is "open" it will crash if a "hole collapse"... if(edge.v0==edge.v1) { CMRMFaceBuild &f= *(EdgeIt->second.Face); nlassert(f.validEdgeIt(EdgeIt->second)); f.invalidEdgeIt(EdgeIt->second, EdgeCollapses); EdgeCollapses.erase(EdgeIt); bug3++; continue; } // 1. else, OK, collapse it!! //=========================== sint vertexCollapsed= edge.v0; nCurrentFaces-= collapseEdge(edge); // 2. Must reorder all his neighborhood. //====================================== CMRMVertex &vert=TmpVertices[vertexCollapsed]; sint i; // we delete from list modified edges, and we re-add them with their new value. for(i=0;i<(sint)vert.SharedFaces.size();i++) { CMRMFaceBuild &f= TmpFaces[vert.SharedFaces[i]]; removeFaceFromEdgeList(f); insertFaceIntoEdgeList(f); } } }

CMesh::CSkinWeight NL3D::CMRMBuilder::collapseSkinWeight (  const CMesh::CSkinWeight &  sw1, const CMesh::CSkinWeight &  sw2, float  InterValue )  const [private]

Definition at line 399 of file mrm_builder.cpp. References _SkinReduction, NL3D::CMesh::CSkinWeight::MatrixId, NL3D::CTmpVertexWeight::MatrixId, min, NL3D_MESH_SKINNING_MAX_MATRIX, nlassert, nlstop, uint, NL3D::CTmpVertexWeight::Weight, and NL3D::CMesh::CSkinWeight::Weights. Referenced by collapseEdge(). { // If fast interpolation. if(interValue==0) return sw1; if(interValue==1) return sw2; // else, must blend a skinWeight: must identify matrix which exist in the 2 sws, and add new ones. uint nbMats1=0; uint nbMats2=0; static vector<CTmpVertexWeight> sws; sws.reserve(NL3D_MESH_SKINNING_MAX_MATRIX * 2); sws.clear(); // For all weights of sw1. uint i; for(i=0; i<NL3D_MESH_SKINNING_MAX_MATRIX; i++) { CTmpVertexWeight vw; vw.MatrixId= sw1.MatrixId[i]; vw.Weight= sw1.Weights[i]*(1-interValue); // if this weight is not null. if(vw.Weight>0) { // add it to the list. sws.push_back(vw); } // For skinning reduction. if(sw1.Weights[i]>0) nbMats1++; } // For all weights of sw1. for(i=0; i<NL3D_MESH_SKINNING_MAX_MATRIX; i++) { CTmpVertexWeight vw; vw.MatrixId= sw2.MatrixId[i]; vw.Weight= sw2.Weights[i]*(interValue); // if this weight is not null. if(vw.Weight>0) { // add it or add influence to the matrix. vector<CTmpVertexWeight>::iterator it= find(sws.begin(), sws.end(), vw); if(it== sws.end()) sws.push_back(vw); else it->Weight+= vw.Weight; } // For skinning reduction. if(sw2.Weights[i]>0) nbMats2++; } // Then keep just the best. // sort by Weight decreasing order. sort(sws.begin(), sws.end()); // clamp the result to the wanted max matrix. uint nbMatsOut; switch(_SkinReduction) { case CMRMParameters::SkinReductionMin: nbMatsOut= min(nbMats1, nbMats2); break; case CMRMParameters::SkinReductionMax: nbMatsOut= max(nbMats1, nbMats2); break; case CMRMParameters::SkinReductionBest: nbMatsOut= min( (uint)sws.size(), (uint)NL3D_MESH_SKINNING_MAX_MATRIX ); break; default: nlstop; }; // For security. nbMatsOut= min(nbMatsOut, (uint)sws.size()); nlassert(nbMatsOut<=NL3D_MESH_SKINNING_MAX_MATRIX); // Then output the result to the skinWeight, normalizing. float sumWeight=0; for(i= 0; i<nbMatsOut; i++) { sumWeight+= sws[i].Weight; } CMesh::CSkinWeight ret; // Fill only needed matrix (other are rested in CMesh::CSkinWeight ctor). for(i= 0; i<nbMatsOut; i++) { ret.MatrixId[i]= sws[i].MatrixId; ret.Weights[i]= sws[i].Weight / sumWeight; } return ret; }

void NL3D::CMRMBuilder::compileMRM (  const CMesh::CMeshBuild &  mbuild, std::vector< CMesh::CMeshBuild * > &  bsList, const CMRMParameters &  params, CMeshMRMSkinnedGeom::CMeshBuildMRM &  mrmMesh, uint  numMaxMaterial )

Compile a MRM skinned mesh info. Parameters: mbuild  the input mesh params  the parameters of MRM process. mrmMesh  the result MRM mesh. Definition at line 3050 of file mrm_builder.cpp. References _HasMeshInterfaces, _SkinReduction, buildAllLods(), buildBlendShapes(), buildFinalMRM(), buildMeshBuildMrm(), buildMrmBaseMesh(), buildMRMSewingMeshes(), NL3D::CMeshMRMSkinnedGeom::CMeshBuildMRM::DistanceCoarsest, NL3D::CMeshMRMSkinnedGeom::CMeshBuildMRM::DistanceFinest, NL3D::CMeshMRMSkinnedGeom::CMeshBuildMRM::DistanceMiddle, nlassert, normalizeBaseMeshSkin(), params, NL3D::CMesh::CMeshBuild::SkinWeights, uint, uint32, NL3D::CMesh::CMeshBuild::VertexFlags, and NL3D::CMesh::CMeshBuild::Vertices. { // Temp data. CMRMMesh baseMesh; vector<CMRMMeshGeom> lodMeshs; CMRMMeshFinal finalMRM; vector<CMRMMeshFinal> finalBsMRM; uint32 vbFlags; nlassert(params.DistanceFinest>=0); nlassert(params.DistanceMiddle > params.DistanceFinest); nlassert(params.DistanceCoarsest > params.DistanceMiddle); // Copy some parameters. _SkinReduction= params.SkinReduction; // Skinning?? _Skinned= ((mbuild.VertexFlags & CVertexBuffer::PaletteSkinFlag)==CVertexBuffer::PaletteSkinFlag); // Skinning is OK only if SkinWeights are of same size as vertices. _Skinned= _Skinned && ( mbuild.Vertices.size()==mbuild.SkinWeights.size() ); // MeshInterface setuped ? _HasMeshInterfaces= buildMRMSewingMeshes(mbuild, params.NLods, params.Divisor); // from mbuild, build an internal MRM mesh representation. // vbFlags returned is the VBuffer format supported by CMRMBuilder. // NB: skinning is removed because skinning is made in software in CMeshMRMGeom. vbFlags= buildMrmBaseMesh(mbuild, baseMesh); // Construct all blend shapes in the same way we have constructed the basemesh mrm buildBlendShapes (baseMesh, bsList, vbFlags); // If skinned, must ensure that skin weights have weights in ascending order. if(_Skinned) { normalizeBaseMeshSkin(baseMesh); } // from this baseMesh, builds all LODs of the MRM, with geomorph info. NB: vertices/wedges are duplicated. buildAllLods ( baseMesh, lodMeshs, params.NLods, params.Divisor ); // From this array of LOD, build a finalMRM, by regrouping identical vertices/wedges, and compute index geomorphs. buildFinalMRM(lodMeshs, finalMRM); // From this finalMRM, build output: a CMeshBuildMRM. buildMeshBuildMrm(finalMRM, mrmMesh, vbFlags, numMaxMaterial, mbuild); // Copy degradation control params. mrmMesh.DistanceFinest= params.DistanceFinest; mrmMesh.DistanceMiddle= params.DistanceMiddle; mrmMesh.DistanceCoarsest= params.DistanceCoarsest; }

void NL3D::CMRMBuilder::compileMRM (  const CMesh::CMeshBuild &  mbuild, std::vector< CMesh::CMeshBuild * > &  bsList, const CMRMParameters &  params, CMeshMRMGeom::CMeshBuildMRM &  mrmMesh, uint  numMaxMaterial )

Compile a MRM mesh info. Parameters: mbuild  the input mesh params  the parameters of MRM process. mrmMesh  the result MRM mesh. Definition at line 2991 of file mrm_builder.cpp. References _HasMeshInterfaces, _SkinReduction, buildAllLods(), buildBlendShapes(), buildFinalMRM(), buildMeshBuildMrm(), buildMrmBaseMesh(), buildMRMSewingMeshes(), NL3D::CMeshMRMGeom::CMeshBuildMRM::DistanceCoarsest, NL3D::CMeshMRMGeom::CMeshBuildMRM::DistanceFinest, NL3D::CMeshMRMGeom::CMeshBuildMRM::DistanceMiddle, nlassert, normalizeBaseMeshSkin(), params, NL3D::CMesh::CMeshBuild::SkinWeights, uint, uint32, NL3D::CMesh::CMeshBuild::VertexFlags, and NL3D::CMesh::CMeshBuild::Vertices. Referenced by NL3D::CMeshMRMSkinnedGeom::build(), and NL3D::CMeshMRMGeom::build(). { // Temp data. CMRMMesh baseMesh; vector<CMRMMeshGeom> lodMeshs; CMRMMeshFinal finalMRM; vector<CMRMMeshFinal> finalBsMRM; uint32 vbFlags; nlassert(params.DistanceFinest>=0); nlassert(params.DistanceMiddle > params.DistanceFinest); nlassert(params.DistanceCoarsest > params.DistanceMiddle); // Copy some parameters. _SkinReduction= params.SkinReduction; // Skinning?? _Skinned= ((mbuild.VertexFlags & CVertexBuffer::PaletteSkinFlag)==CVertexBuffer::PaletteSkinFlag); // Skinning is OK only if SkinWeights are of same size as vertices. _Skinned= _Skinned && ( mbuild.Vertices.size()==mbuild.SkinWeights.size() ); // MeshInterface setuped ? _HasMeshInterfaces= buildMRMSewingMeshes(mbuild, params.NLods, params.Divisor); // from mbuild, build an internal MRM mesh representation. // vbFlags returned is the VBuffer format supported by CMRMBuilder. // NB: skinning is removed because skinning is made in software in CMeshMRMGeom. vbFlags= buildMrmBaseMesh(mbuild, baseMesh); // Construct all blend shapes in the same way we have constructed the basemesh mrm buildBlendShapes (baseMesh, bsList, vbFlags); // If skinned, must ensure that skin weights have weights in ascending order. if(_Skinned) { normalizeBaseMeshSkin(baseMesh); } // from this baseMesh, builds all LODs of the MRM, with geomorph info. NB: vertices/wedges are duplicated. buildAllLods ( baseMesh, lodMeshs, params.NLods, params.Divisor ); // From this array of LOD, build a finalMRM, by regrouping identical vertices/wedges, and compute index geomorphs. buildFinalMRM(lodMeshs, finalMRM); // From this finalMRM, build output: a CMeshBuildMRM. buildMeshBuildMrm(finalMRM, mrmMesh, vbFlags, numMaxMaterial, mbuild); // Copy degradation control params. mrmMesh.DistanceFinest= params.DistanceFinest; mrmMesh.DistanceMiddle= params.DistanceMiddle; mrmMesh.DistanceCoarsest= params.DistanceCoarsest; }

void NL3D::CMRMBuilder::computeBsVerticesAttributes (  std::vector< CMRMMesh > &  srcBsMeshs, std::vector< CMRMMesh > &  srcBsMeshsMod )  [private]

float NL3D::CMRMBuilder::computeEdgeCost (  const CMRMEdge &  edge  )  [private]

Definition at line 244 of file mrm_builder.cpp. References _CurrentLodComputed, _HasMeshInterfaces, _SewingMeshes, edgeContinue(), edgeNearUniqueMatFace(), getDeltaFaceNormals(), NL3D::CMRMSewingMesh::getNumCollapseEdge(), NL3D::CMRMSewingMesh::mustCollapseEdge(), sint, TmpVertices, uint, NL3D::CMRMEdge::v0, NL3D::CMRMEdge::v1, and vertexContinue(). Referenced by insertFaceIntoEdgeList(). { sint v1= edge.v0; sint v2= edge.v1; // more expensive is the edge, later it will collapse. // **** standard cost // compute size of the edge. float cost=(TmpVertices[v1].Current-TmpVertices[v2].Current).norm(); // compute "curvature" of the edge. float faceCost= (getDeltaFaceNormals(v1)+getDeltaFaceNormals(v2)); // totally plane faces (faceCost==0) must be collapsed with respect to size (and not random if cost==0). // else we may have Plane Mesh (like flags) that will collapse in a very ugly way. faceCost= max(faceCost, 0.01f); // modulate size with curvature. cost*= faceCost; // Like H.Hope, add a weight on discontinuities.. if( !vertexContinue(v1) && !vertexContinue(v2) ) { // Nb: don't do this on discontinuities edges, unless the unique material face will collapse (pffiou!!). if( edgeContinue(edge) || edgeNearUniqueMatFace(edge) ) cost*=4; } // **** Interface Sewing cost if(_HasMeshInterfaces) { // if the 2 vertices comes from a Sewing Interface mesh (must be a real interface id) sint meshSewingId= TmpVertices[v1].InterfaceLink.InterfaceId; if( meshSewingId>=0 && TmpVertices[v2].InterfaceLink.InterfaceId>=0 ) { // if the 2 vertices comes from the same Sewing Interface mesh if( meshSewingId == TmpVertices[v2].InterfaceLink.InterfaceId ) { // Then the edge is one of the sewing interface mesh. must do special things for it CMRMSewingMesh &sewingMesh= _SewingMeshes[meshSewingId]; uint dummy; // get the sewing edge id CMRMEdge sewingEdge; sewingEdge.v0= TmpVertices[v1].InterfaceLink.InterfaceVertexId; sewingEdge.v1= TmpVertices[v2].InterfaceLink.InterfaceVertexId; // if the current sewing lod want to collapse this edge sint collapseId= sewingMesh.mustCollapseEdge(_CurrentLodComputed, sewingEdge, dummy); if(collapseId>=0) { // Then set a negative priority (ie will collapse as soon as possible). from -N to -1. // NB: sort them according to collapseId cost= (float)(-sewingMesh.getNumCollapseEdge(_CurrentLodComputed) + collapseId); } else { // This edge must not collapse at this Lod, set an infinite priority (hope will never collapse). cost= FLT_MAX; } } else { /* The edge is between 2 interfaces but not the same. If we collide it we'll have holes! This problem arise if space beetween interfaces is small. eg: if we setup an interface beetween hair and head, and an other one beetween head and torso, then we'll have this problem in the back of the neck. The solution is to make a big big cost to hope we'll never collide them (else Holes...)!! Don't use FLT_MAX to still have a correct order if we don't have choice... */ cost*= 10000; } } } return cost; }

bool NL3D::CMRMBuilder::edgeContinue (  const CMRMEdge &  edge  )  [private]

Definition at line 169 of file mrm_builder.cpp. References NumAttributes, NL3D::CMRMVertex::SharedFaces, sint, TmpFaces, TmpVertices, NL3D::CMRMEdge::v0, NL3D::CMRMEdge::v1, and w. Referenced by computeEdgeCost(), and edgeNearUniqueMatFace(). { sint v0= edge.v0; sint v1= edge.v1; CMRMVertex &Vertex1=TmpVertices[v0]; // build list sharing edge. vector<sint> deletedFaces; sint i; for(i=0;i<(sint)Vertex1.SharedFaces.size();i++) { sint numFace= Vertex1.SharedFaces[i]; if(TmpFaces[numFace].hasVertex(v1)) deletedFaces.push_back(numFace); } sint matId=-1; // test if faces have same material. for(i=0;i<(sint)deletedFaces.size();i++) { sint m; m= TmpFaces[deletedFaces[i]].MaterialId; if(matId>=0 && matId!=m) return false; else matId=m; } // test if faces have same wedge (for all att). for(sint attId=0;attId<NumAttributes;attId++) { sint numwedge1=-1,numwedge2=-1; for(i=0;i<(sint)deletedFaces.size();i++) { sint w; w= TmpFaces[deletedFaces[i]].getAssociatedWedge(attId, v0); if(numwedge1>=0 && numwedge1!=w) return false; else numwedge1=w; w= TmpFaces[deletedFaces[i]].getAssociatedWedge(attId, v1); if(numwedge2>=0 && numwedge2!=w) return false; else numwedge2=w; } } return true; }

bool NL3D::CMRMBuilder::edgeNearUniqueMatFace (  const CMRMEdge &  edge  )  [private]

Definition at line 214 of file mrm_builder.cpp. References edgeContinue(), NL3D::CMRMFaceBuild::getEdge(), NL3D::CMRMVertex::SharedFaces, sint, TmpFaces, TmpVertices, NL3D::CMRMEdge::v0, and NL3D::CMRMEdge::v1. Referenced by computeEdgeCost(). { sint v0= edge.v0; sint v1= edge.v1; CMRMVertex &Vertex1=TmpVertices[v0]; // build list sharing edge. vector<sint> deletedFaces; sint i; for(i=0;i<(sint)Vertex1.SharedFaces.size();i++) { sint numFace= Vertex1.SharedFaces[i]; if(TmpFaces[numFace].hasVertex(v1)) deletedFaces.push_back(numFace); } // test if faces are not isolated OneMaterial faces. for(i=0;i<(sint)deletedFaces.size();i++) { CMRMFaceBuild &f=TmpFaces[deletedFaces[i]]; if( !edgeContinue(f.getEdge(0)) && !edgeContinue(f.getEdge(1)) && !edgeContinue(f.getEdge(2))) return true; } return false; }

bool NL3D::CMRMBuilder::faceShareWedges (  CMRMFaceBuild *  face, sint  attribId, sint  numVertex1, sint  numVertex2 )  [private]

Definition at line 333 of file mrm_builder.cpp. References NL3D::CMRMFaceBuild::getAssociatedWedge(), NL3D::CMRMAttribute::NbSharedFaces, NL3D::CMRMAttribute::Shared, sint, and TmpAttributes. Referenced by collapseEdge(). { sint numWedge1= face->getAssociatedWedge(attribId, numVertex1); sint numWedge2= face->getAssociatedWedge(attribId, numVertex2); if(numWedge1<0) return false; if(numWedge2<0) return false; CMRMAttribute &w1= TmpAttributes[attribId][numWedge1]; CMRMAttribute &w2= TmpAttributes[attribId][numWedge2]; return w1.Shared && w2.Shared && w1.NbSharedFaces>0 && w2.NbSharedFaces>0; }

sint NL3D::CMRMBuilder::findInsertAttributeInBaseMesh (  CMRMMesh &  baseMesh, sint  attId, sint  vertexId, const CVectorH &  att )  [private]

Definition at line 1648 of file mrm_builder.cpp. References _AttributeMap, NL3D::CMRMBuilder::CAttributeKey::Attribute, NL3D::CMRMMesh::Attributes, sint, and NL3D::CMRMBuilder::CAttributeKey::VertexId. Referenced by findInsertColorInBaseMesh(), findInsertNormalInBaseMesh(), and findInsertUvwInBaseMesh(). { // find this attribute in the map. CAttributeKey key; key.VertexId= vertexId; key.Attribute= att; TAttributeMap::iterator it= _AttributeMap[attId].find(key); // if attribute not found in the map, then insert a new one. if(it==_AttributeMap[attId].end()) { sint idx= baseMesh.Attributes[attId].size(); // insert into the array. baseMesh.Attributes[attId].push_back(att); // insert into the map. _AttributeMap[attId].insert(make_pair(key, idx)); return idx; } else { // return the one found. return it->second; } }

sint NL3D::CMRMBuilder::findInsertColorInBaseMesh (  CMRMMesh &  baseMesh, sint  attId, sint  vertexId, CRGBA  col )  [private]

Definition at line 1685 of file mrm_builder.cpp. References NLMISC::CRGBA::A, NLMISC::CRGBA::B, findInsertAttributeInBaseMesh(), NLMISC::CRGBA::G, NLMISC::CRGBA::R, sint, NLMISC::CVectorH::w, NLMISC::CVectorH::x, NLMISC::CVectorH::y, and NLMISC::CVectorH::z. Referenced by buildMrmBaseMesh(). { CVectorH att; att.x= col.R; att.y= col.G; att.z= col.B; att.w= col.A; return findInsertAttributeInBaseMesh(baseMesh, attId, vertexId, att); }

sint NL3D::CMRMBuilder::findInsertNormalInBaseMesh (  CMRMMesh &  baseMesh, sint  attId, sint  vertexId, const CVector &  normal )  [private]

Definition at line 1675 of file mrm_builder.cpp. References findInsertAttributeInBaseMesh(), sint, and NLMISC::CVectorH::w. Referenced by buildMrmBaseMesh(). { CVectorH att; att= normal; att.w= 0; return findInsertAttributeInBaseMesh(baseMesh, attId, vertexId, att); }

sint NL3D::CMRMBuilder::findInsertUvwInBaseMesh (  CMRMMesh &  baseMesh, sint  attId, sint  vertexId, const NLMISC::CUVW &  uvw )  [private]

Definition at line 1697 of file mrm_builder.cpp. References findInsertAttributeInBaseMesh(), sint, NLMISC::CUVW::U, NLMISC::CUVW::V, NLMISC::CVectorH::w, NLMISC::CUVW::W, NLMISC::CVectorH::x, NLMISC::CVectorH::y, and NLMISC::CVectorH::z. Referenced by buildMrmBaseMesh(). { CVectorH att; att.x= uvw.U; att.y= uvw.V; att.z= uvw.W; att.w= 0; return findInsertAttributeInBaseMesh(baseMesh, attId, vertexId, att); }

sint NL3D::CMRMBuilder::followVertex (  sint  i  )  [private]

Definition at line 832 of file mrm_builder.cpp. References NL3D::CMRMVertex::CollapsedTo, sint, and TmpVertices. Referenced by makeLODMesh(). { CMRMVertex &vert=TmpVertices[i]; if(vert.CollapsedTo>=0) return followVertex(vert.CollapsedTo); else return i; }

sint NL3D::CMRMBuilder::followWedge (  sint  attribId, sint  i )  [private]

Definition at line 841 of file mrm_builder.cpp. References NL3D::CMRMAttribute::CollapsedTo, sint, and TmpAttributes. Referenced by makeLODMesh(). { CMRMAttribute &wedge= TmpAttributes[attribId][i]; if(wedge.CollapsedTo>=0) return followWedge(attribId, wedge.CollapsedTo); else return i; }

float NL3D::CMRMBuilder::getDeltaFaceNormals (  sint  numvertex  )  [private]

Definition at line 143 of file mrm_builder.cpp. References NL3D::CMRMVertex::Current, NLMISC::CVector::normalize(), NL3D::CMRMVertex::SharedFaces, sint, TmpFaces, and TmpVertices. Referenced by computeEdgeCost(). { // return a positive value of Somme(|DeltaNormals|) / NNormals. CMRMVertex &vert= TmpVertices[numvertex]; float delta=0; CVector refNormal; sint nfaces=vert.SharedFaces.size(); for(sint i=0;i<nfaces;i++) { CVector normal; CVector &v0= TmpVertices[TmpFaces[i].Corner[0].Vertex].Current; CVector &v1= TmpVertices[TmpFaces[i].Corner[1].Vertex].Current; CVector &v2= TmpVertices[TmpFaces[i].Corner[2].Vertex].Current; normal= (v1-v0)^(v2-v0); normal.normalize(); if(i==0) refNormal=normal; else delta+=(1-refNormal*normal); } if(nfaces<2) return 0; else return delta/(nfaces-1); }

void NL3D::CMRMBuilder::init (  const CMRMMesh &  baseMesh  )  [private]

Definition at line 867 of file mrm_builder.cpp. References _HasMeshInterfaces, NL3D::CMRMMesh::Attributes, NL3D::CMRMMesh::BlendShapes, NL3D::CMRMFace::Corner, EdgeCollapses, NL3D::CMRMMesh::Faces, insertFaceIntoEdgeList(), NL3D::CMRMMesh::InterfaceLinks, NL3D_MRM_MAX_ATTRIB, NL3D::CMRMMesh::NumAttributes, NumAttributes, sint, NL3D::CMRMMesh::SkinWeights, TmpAttributes, TmpFaces, TmpVertices, uint32, NL3D::CMRMCorner::Vertex, and NL3D::CMRMMesh::Vertices. Referenced by buildAllLods(), and makeFromMesh(). { sint i, attId; // First clear ALL. TmpVertices.clear(); for(attId=0;attId<NL3D_MRM_MAX_ATTRIB;attId++) { TmpAttributes[attId].clear(); } TmpFaces.clear(); EdgeCollapses.clear(); // resize. NumAttributes= baseMesh.NumAttributes; TmpVertices.resize(baseMesh.Vertices.size()); for(attId=0;attId<NumAttributes;attId++) { TmpAttributes[attId].resize(baseMesh.Attributes[attId].size()); } TmpFaces.resize(baseMesh.Faces.size()); // Then copy. for(i=0;i<(sint)baseMesh.Vertices.size();i++) { TmpVertices[i].Current= TmpVertices[i].Original= baseMesh.Vertices[i]; TmpVertices[i].BSCurrent.resize(baseMesh.BlendShapes.size()); for(uint32 j = 0; j <baseMesh.BlendShapes.size() ;++j) TmpVertices[i].BSCurrent[j]= baseMesh.BlendShapes[j].Vertices[i]; if(_Skinned) TmpVertices[i].CurrentSW= TmpVertices[i].OriginalSW= baseMesh.SkinWeights[i]; if(_HasMeshInterfaces) TmpVertices[i].InterfaceLink= baseMesh.InterfaceLinks[i]; } for(attId=0;attId<NumAttributes;attId++) { for(i=0;i<(sint)baseMesh.Attributes[attId].size();i++) { TmpAttributes[attId][i].Current= TmpAttributes[attId][i].Original= baseMesh.Attributes[attId][i]; TmpAttributes[attId][i].BSCurrent.resize(baseMesh.BlendShapes.size()); for(uint32 j = 0; j <baseMesh.BlendShapes.size() ;++j) TmpAttributes[attId][i].BSCurrent[j]= baseMesh.BlendShapes[j].Attributes[attId][i]; } } for(i=0;i<(sint)baseMesh.Faces.size();i++) { TmpFaces[i]= baseMesh.Faces[i]; TmpFaces[i].BSInterpolated.resize(baseMesh.BlendShapes.size()); } // Create vertices sharedFaces. for(i=0;i<(sint)TmpFaces.size();i++) { CMRMFaceBuild &face= TmpFaces[i]; TmpVertices[face.Corner[0].Vertex].SharedFaces.push_back(i); TmpVertices[face.Corner[1].Vertex].SharedFaces.push_back(i); TmpVertices[face.Corner[2].Vertex].SharedFaces.push_back(i); } // Compute EdgeCost. for(i=0;i<(sint)TmpFaces.size();i++) { CMRMFaceBuild &f= TmpFaces[i]; // At start, valid all edges. f. ValidIt0= true; f. ValidIt1= true; f. ValidIt2= true; insertFaceIntoEdgeList(f); } }

void NL3D::CMRMBuilder::insertFaceIntoEdgeList (  CMRMFaceBuild &  tmpf  )  [private]

Definition at line 347 of file mrm_builder.cpp. References computeEdgeCost(), EdgeCollapses, NL3D::CMRMFaceBuild::getEdge(), len, NL3D::CMRMFaceBuild::ValidIt0, NL3D::CMRMFaceBuild::ValidIt1, and NL3D::CMRMFaceBuild::ValidIt2. Referenced by collapseEdges(), and init(). { float len; if(f.ValidIt0) { len= computeEdgeCost(f.getEdge(0)); f. It0= EdgeCollapses.insert( TEdgeMap::value_type( len, CMRMEdgeFace(f.getEdge(0),&f) ) ); } if(f.ValidIt1) { len= computeEdgeCost(f.getEdge(1)); f. It1= EdgeCollapses.insert( TEdgeMap::value_type( len, CMRMEdgeFace(f.getEdge(1),&f) ) ); } if(f.ValidIt2) { len= computeEdgeCost(f.getEdge(2)); f. It2= EdgeCollapses.insert( TEdgeMap::value_type( len, CMRMEdgeFace(f.getEdge(2),&f) ) ); } }

void NL3D::CMRMBuilder::makeCoarserBS (  std::vector< CMRMBlendShape > &  csBsMeshs  )  [private]

Definition at line 1203 of file mrm_builder.cpp. References NL3D::CMRMBlendShape::Attributes, NL3D::CMRMAttribute::BSCurrent, NL3D::CMRMVertex::BSCurrent, NL3D::CMRMAttribute::CoarserIndex, NL3D::CMRMVertex::CoarserIndex, NumAttributes, NL3D::CMRMBlendShape::NumAttributes, sint32, TmpAttributes, TmpVertices, uint32, and NL3D::CMRMBlendShape::Vertices. Referenced by makeFromMesh(). { uint32 i, k; sint32 nSizeVert, nSizeAttr, attId; // Calculate size of vertices array nSizeVert = 0; for (i = 0; i < TmpVertices.size(); ++i) if(TmpVertices[i].CoarserIndex > nSizeVert) nSizeVert = TmpVertices[i].CoarserIndex; ++nSizeVert; for (k = 0; k < csBsMeshs.size(); ++k) { CMRMBlendShape &rBsCoarserMesh = csBsMeshs[k]; rBsCoarserMesh.Vertices.resize (nSizeVert); rBsCoarserMesh.NumAttributes = NumAttributes; // Vertices for(i = 0; i < TmpVertices.size(); ++i) { CMRMVertex &vert = TmpVertices[i]; if (vert.CoarserIndex != -1) { rBsCoarserMesh.Vertices[vert.CoarserIndex] = vert.BSCurrent[k]; } } for (attId = 0; attId < NumAttributes; attId++) { // Calculate size of attribute attId array nSizeAttr = 0; for(i = 0; i < TmpAttributes[attId].size(); i++) if (TmpAttributes[attId][i].CoarserIndex > nSizeAttr) nSizeAttr = TmpAttributes[attId][i].CoarserIndex; ++nSizeAttr; rBsCoarserMesh.Attributes[attId].resize (nSizeAttr); for (i = 0; i < TmpAttributes[attId].size(); i++) { CMRMAttribute &wedge = TmpAttributes[attId][i]; if (wedge.CoarserIndex != -1) { rBsCoarserMesh.Attributes[attId][wedge.CoarserIndex] = wedge.BSCurrent[k]; } } } } }

void NL3D::CMRMBuilder::makeFromMesh (  const CMRMMesh &  baseMesh, CMRMMeshGeom &  lodMesh, CMRMMesh &  coarserMesh, sint  nWantedFaces )  [private]

this is the root call to compute a single lodMesh and the coarserMesh from a baseMesh. Definition at line 1256 of file mrm_builder.cpp. References NL3D::CMRMMesh::BlendShapes, collapseEdges(), init(), makeCoarserBS(), makeLODMesh(), saveCoarserMesh(), and sint. Referenced by buildAllLods(). { // Init Tmp values in MRM builder. init(baseMesh); // compute MRM too next tgt face. collapseEdges(nWantedFaces); // save the coarser mesh. saveCoarserMesh(coarserMesh); // Build coarser BlendShapes. coarserMesh.BlendShapes.resize(baseMesh.BlendShapes.size()); makeCoarserBS(coarserMesh.BlendShapes); // build the lodMesh (baseMesh, with vertex/Attributes collapse infos). lodMesh= baseMesh; makeLODMesh(lodMesh); // end for this level. }

void NL3D::CMRMBuilder::makeLODMesh (  CMRMMeshGeom &  lodMesh  )  [private]

Definition at line 1108 of file mrm_builder.cpp. References NL3D::CMRMCorner::Attributes, NL3D::CMRMMeshGeom::CoarserFaces, NL3D::CMRMFace::Corner, followVertex(), followWedge(), index, nlassert, NumAttributes, sint, TmpAttributes, TmpVertices, and NL3D::CMRMCorner::Vertex. Referenced by makeFromMesh(). { sint i,j,attId,index,coidx; // for all faces of this mesh, find target in the coarser mesh. for(i=0;i<(sint)lodMesh.CoarserFaces.size();i++) { CMRMFace &face= lodMesh.CoarserFaces[i]; // For 3 corners. for(j=0;j<3;j++) { // Vertex. // The index is yet the index in the finer mesh. index= face.Corner[j].Vertex; // the index in the coarser mesh is vert.CoarserIndex. coidx= TmpVertices[index].CoarserIndex; // but if this vertex is collapsed, must find the good index (yet in the finer mesh) if(coidx==-1) { // find to which we must collapse. index= followVertex(index); // and so we have the coarser index. this one must be valid. coidx= TmpVertices[index].CoarserIndex; nlassert(coidx>=0); } // update corner of CoarserFace. face.Corner[j].Vertex= coidx; // Do exactly same thing for all attributes. for(attId=0;attId<NumAttributes;attId++) { index= face.Corner[j].Attributes[attId]; coidx= TmpAttributes[attId][index].CoarserIndex; if(coidx==-1) { index= followWedge(attId, index); coidx= TmpAttributes[attId][index].CoarserIndex; nlassert(coidx>=0); } face.Corner[j].Attributes[attId]= coidx; } } } }

void NL3D::CMRMBuilder::normalizeBaseMeshSkin (  CMRMMesh &  baseMesh  )  const [private]

Definition at line 1905 of file mrm_builder.cpp. References nlassert, normalizeSkinWeight(), NL3D::CMRMMesh::SkinWeights, and uint. Referenced by compileMRM(). { nlassert(_Skinned); for(uint i=0; i<baseMesh.SkinWeights.size(); i++) { baseMesh.SkinWeights[i]= normalizeSkinWeight(baseMesh.SkinWeights[i]); } }

CMesh::CSkinWeight NL3D::CMRMBuilder::normalizeSkinWeight (  const CMesh::CSkinWeight &  sw  )  const [private]

Definition at line 1858 of file mrm_builder.cpp. References NL3D::CMesh::CSkinWeight::MatrixId, NL3D::CTmpVertexWeight::MatrixId, NL3D_MESH_SKINNING_MAX_MATRIX, uint, NL3D::CTmpVertexWeight::Weight, and NL3D::CMesh::CSkinWeight::Weights. Referenced by normalizeBaseMeshSkin(). { uint nbMats= 0; static vector<CTmpVertexWeight> sws; sws.reserve(NL3D_MESH_SKINNING_MAX_MATRIX); sws.clear(); // For all weights of sw1. uint i; for(i=0; i<NL3D_MESH_SKINNING_MAX_MATRIX; i++) { CTmpVertexWeight vw; vw.MatrixId= sw.MatrixId[i]; vw.Weight= sw.Weights[i]; // if this weight is not null. if(vw.Weight>0) { // add it to the list. sws.push_back(vw); nbMats++; } } // sort by Weight decreasing order. sort(sws.begin(), sws.end()); // Then output the result to the skinWeight, normalizing. float sumWeight=0; for(i= 0; i<nbMats; i++) { sumWeight+= sws[i].Weight; } CMesh::CSkinWeight ret; // Fill only needed matrix (other are rested in CMesh::CSkinWeight ctor). for(i= 0; i<nbMats; i++) { ret.MatrixId[i]= sws[i].MatrixId; ret.Weights[i]= sws[i].Weight / sumWeight; } return ret; }

void NL3D::CMRMBuilder::removeFaceFromEdgeList (  CMRMFaceBuild &  f  )  [private]

Definition at line 367 of file mrm_builder.cpp. References EdgeCollapses, NL3D::CMRMFaceBuild::It0, NL3D::CMRMFaceBuild::It1, NL3D::CMRMFaceBuild::It2, NL3D::CMRMFaceBuild::ValidIt0, NL3D::CMRMFaceBuild::ValidIt1, and NL3D::CMRMFaceBuild::ValidIt2. Referenced by collapseEdge(), and collapseEdges(). { if(f.ValidIt0) EdgeCollapses.erase(f.It0); if(f.ValidIt1) EdgeCollapses.erase(f.It1); if(f.ValidIt2) EdgeCollapses.erase(f.It2); }

void NL3D::CMRMBuilder::saveCoarserMesh (  CMRMMesh &  coarserMesh  )  [private]

Definition at line 1010 of file mrm_builder.cpp. References _HasMeshInterfaces, NL3D::CMRMCorner::Attributes, NL3D::CMRMMesh::Attributes, NL3D::CMRMAttribute::CoarserIndex, NL3D::CMRMVertex::CoarserIndex, NL3D::CMRMAttribute::CollapsedTo, NL3D::CMRMVertex::CollapsedTo, NL3D::CMRMFace::Corner, NL3D::CMRMAttribute::Current, NL3D::CMRMVertex::Current, NL3D::CMRMVertex::CurrentSW, NL3D::CMRMFaceBuild::Deleted, NL3D::CMRMMesh::Faces, index, NL3D::CMRMVertex::InterfaceLink, NL3D::CMRMMesh::InterfaceLinks, NL3D::CMRMFace::MaterialId, NL3D_MRM_MAX_ATTRIB, nlassert, NumAttributes, NL3D::CMRMMesh::NumAttributes, sint, NL3D::CMRMMesh::SkinWeights, TmpAttributes, TmpFaces, TmpVertices, NL3D::CMRMCorner::Vertex, and NL3D::CMRMMesh::Vertices. Referenced by makeFromMesh(). { sint i,attId,index; // First clear ALL. coarserMesh.Vertices.clear(); coarserMesh.SkinWeights.clear(); coarserMesh.InterfaceLinks.clear(); for(attId=0;attId<NL3D_MRM_MAX_ATTRIB;attId++) { coarserMesh.Attributes[attId].clear(); } coarserMesh.Faces.clear(); coarserMesh.NumAttributes= NumAttributes; // Vertices. //========== index=0; for(i=0;i<(sint)TmpVertices.size();i++) { CMRMVertex &vert=TmpVertices[i]; if(vert.CollapsedTo==-1) // if exist yet. { vert.CoarserIndex=index; coarserMesh.Vertices.push_back(vert.Current); if(_Skinned) coarserMesh.SkinWeights.push_back(vert.CurrentSW); if(_HasMeshInterfaces) coarserMesh.InterfaceLinks.push_back(vert.InterfaceLink); index++; } else vert.CoarserIndex=-1; // indicate that this vertex no more exist and is to be geomorphed to an other. } // Attributes. //============ for(attId=0;attId<NumAttributes;attId++) { index=0; for(i=0;i<(sint)TmpAttributes[attId].size();i++) { CMRMAttribute &wedge= TmpAttributes[attId][i]; if(wedge.CollapsedTo==-1) // if exist yet. { wedge.CoarserIndex=index; coarserMesh.Attributes[attId].push_back(wedge.Current); index++; } else if(wedge.CollapsedTo==-2) // else if totaly destroyed. { // Insert this wedge in the coarser mesh. // NB: the coarser mesh faces do not use it anymore, but FinerMesh use it // for geomorph (LODMesh.CoarserFaces may point to it). // NB: look at buildFinalMRM(), it works fine for all cases. wedge.CoarserIndex=index; coarserMesh.Attributes[attId].push_back(wedge.Current); index++; } else wedge.CoarserIndex=-1; // indicate that this wedge no more exist and is to be geomorphed to an other. } } // Faces. //======= for(i=0;i<(sint)TmpFaces.size();i++) { CMRMFaceBuild &face=TmpFaces[i]; if(!face.Deleted) { CMRMFace newFace; // Material. newFace.MaterialId= face.MaterialId; for(sint j=0;j<3;j++) { // Vertex. newFace.Corner[j].Vertex= TmpVertices[face.Corner[j].Vertex].CoarserIndex; nlassert(newFace.Corner[j].Vertex>=0); // Attributes. for(attId=0;attId<NumAttributes;attId++) { sint oldidx= face.Corner[j].Attributes[attId]; newFace.Corner[j].Attributes[attId]= TmpAttributes[attId][oldidx].CoarserIndex; nlassert(newFace.Corner[j].Attributes[attId]>=0); } } coarserMesh.Faces.push_back(newFace); } } }

bool NL3D::CMRMBuilder::vertexClosed (  sint  numvertex  )  [private]

Definition at line 108 of file mrm_builder.cpp. References NL3D::CMRMFace::Corner, NL3D::CMRMFaceBuild::getEdge(), NL3D::CMRMVertex::SharedFaces, sint, TmpFaces, TmpVertices, and NL3D::CMRMCorner::Vertex. Referenced by collapseEdge(). { CMRMVertex &vert= TmpVertices[numvertex]; map<CMRMEdge, sint> EdgeShare; // Init to 0. sint i; for(i=0;i<(sint)vert.SharedFaces.size();i++) { CMRMFaceBuild &f=TmpFaces[vert.SharedFaces[i]]; EdgeShare[f.getEdge(0)]= 0; EdgeShare[f.getEdge(1)]= 0; EdgeShare[f.getEdge(2)]= 0; } // Inc count. for(i=0;i<(sint)vert.SharedFaces.size();i++) { CMRMFaceBuild &f=TmpFaces[vert.SharedFaces[i]]; EdgeShare[f.getEdge(0)]++; EdgeShare[f.getEdge(1)]++; EdgeShare[f.getEdge(2)]++; } // Test open edges. for(i=0;i<(sint)vert.SharedFaces.size();i++) { CMRMFaceBuild &f=TmpFaces[vert.SharedFaces[i]]; sint v0= f.Corner[0].Vertex; sint v1= f.Corner[1].Vertex; sint v2= f.Corner[2].Vertex; if(EdgeShare[f.getEdge(0)]<2 && (v0==numvertex || v1==numvertex)) return false; if(EdgeShare[f.getEdge(1)]<2 && (v1==numvertex || v2==numvertex)) return false; if(EdgeShare[f.getEdge(2)]<2 && (v0==numvertex || v2==numvertex)) return false; } return true; }

bool NL3D::CMRMBuilder::vertexContinue (  sint  numvertex  )  [private]

Definition at line 103 of file mrm_builder.cpp. References sint, vertexHasOneMaterial(), and vertexHasOneWedge(). Referenced by collapseEdge(), and computeEdgeCost(). { return vertexHasOneWedge(numvertex) && vertexHasOneMaterial(numvertex); }

bool NL3D::CMRMBuilder::vertexHasOneMaterial (  sint  numvertex  )  [private]

Definition at line 90 of file mrm_builder.cpp. References NL3D::CMRMVertex::SharedFaces, sint, TmpFaces, and TmpVertices. Referenced by vertexContinue(). { sint matId=-1; CMRMVertex &vert= TmpVertices[numvertex]; for(sint i=0;i<(sint)vert.SharedFaces.size();i++) { sint m= TmpFaces[vert.SharedFaces[i]].MaterialId; if(matId>=0 && matId!=m) return false; else matId=m; } return true; }

bool NL3D::CMRMBuilder::vertexHasOneWedge (  sint  numvertex  )  [private]

Definition at line 74 of file mrm_builder.cpp. References NumAttributes, NL3D::CMRMVertex::SharedFaces, sint, TmpFaces, TmpVertices, and w. Referenced by vertexContinue(). { CMRMVertex &vert= TmpVertices[numvertex]; for(sint attId=0;attId<NumAttributes;attId++) { sint numwedge=-1; for(sint i=0;i<(sint)vert.SharedFaces.size();i++) { sint w= TmpFaces[vert.SharedFaces[i]].getAssociatedWedge(attId, numvertex); if(numwedge>=0 && numwedge!=w) return false; else numwedge=w; } } return true; }

---

Field Documentation

TAttributeMap NL3D::CMRMBuilder::_AttributeMap[NL3D_MRM_MAX_ATTRIB] [private]

Definition at line 229 of file mrm_builder.h. Referenced by buildMrmBaseMesh(), and findInsertAttributeInBaseMesh().

uint NL3D::CMRMBuilder::_CurrentLodComputed [private]

Definition at line 154 of file mrm_builder.h. Referenced by buildAllLods(), collapseEdge(), and computeEdgeCost().

TGeomMap NL3D::CMRMBuilder::_GeomMap [private]

Definition at line 180 of file mrm_builder.h. Referenced by buildFinalMRM().

bool NL3D::CMRMBuilder::_HasMeshInterfaces [private]

Definition at line 150 of file mrm_builder.h. Referenced by buildMrmBaseMesh(), CMRMBuilder(), collapseEdge(), compileMRM(), computeEdgeCost(), init(), and saveCoarserMesh().

std::vector<CMRMSewingMesh> NL3D::CMRMBuilder::_SewingMeshes [private]

Definition at line 152 of file mrm_builder.h. Referenced by buildMRMSewingMeshes(), collapseEdge(), and computeEdgeCost().

bool NL3D::CMRMBuilder::_Skinned [private]

Definition at line 101 of file mrm_builder.h.

CMRMParameters::TSkinReduction NL3D::CMRMBuilder::_SkinReduction [private]

If the current build is skinned, control the quality of the skinning redcution. Definition at line 103 of file mrm_builder.h. Referenced by collapseSkinWeight(), and compileMRM().

TEdgeMap NL3D::CMRMBuilder::EdgeCollapses [private]

Definition at line 98 of file mrm_builder.h. Referenced by collapseEdge(), collapseEdges(), init(), insertFaceIntoEdgeList(), and removeFaceFromEdgeList().

sint NL3D::CMRMBuilder::NumAttributes [private]

Definition at line 94 of file mrm_builder.h. Referenced by buildFinalMRM(), CMRMBuilder(), collapseEdge(), edgeContinue(), init(), makeCoarserBS(), makeLODMesh(), saveCoarserMesh(), and vertexHasOneWedge().

std::vector<CMRMAttribute> NL3D::CMRMBuilder::TmpAttributes[NL3D_MRM_MAX_ATTRIB] [private]

Definition at line 92 of file mrm_builder.h. Referenced by collapseEdge(), faceShareWedges(), followWedge(), init(), makeCoarserBS(), makeLODMesh(), and saveCoarserMesh().

std::vector<CMRMFaceBuild> NL3D::CMRMBuilder::TmpFaces [private]

Definition at line 96 of file mrm_builder.h. Referenced by collapseEdge(), collapseEdges(), edgeContinue(), edgeNearUniqueMatFace(), getDeltaFaceNormals(), init(), saveCoarserMesh(), vertexClosed(), vertexHasOneMaterial(), and vertexHasOneWedge().

std::vector<CMRMVertex> NL3D::CMRMBuilder::TmpVertices [private]

Definition at line 90 of file mrm_builder.h. Referenced by collapseEdge(), collapseEdges(), computeEdgeCost(), edgeContinue(), edgeNearUniqueMatFace(), followVertex(), getDeltaFaceNormals(), init(), makeCoarserBS(), makeLODMesh(), saveCoarserMesh(), vertexClosed(), vertexHasOneMaterial(), and vertexHasOneWedge().

---

The documentation for this class was generated from the following files:

• mrm_builder.h
• mrm_builder.cpp

---