void MeshTopoData::ApplyMapping(PatchMesh &patch, int mapChannel)
{
//get from mesh
if (!patch.getMapSupport(mapChannel) )
{
patch.setNumMaps (mapChannel+1);
}
TVPatch *tvFace = patch.tvPatches[mapChannel];
int tvFaceCount = patch.numPatches;
if (patch.selLevel!=PATCH_PATCH)
{
//copy into mesh struct
if (!tvFace)
{
// Create tvfaces and init to 0
patch.setNumMapPatches(mapChannel,patch.getNumPatches());
tvFace = patch.tvPatches[mapChannel];
for (int k=0; k<patch.getNumPatches(); k++)
{
for (int j=0; j<TVMaps.f[k]->count; j++)
{
tvFace[k].tv[j] = 0;
tvFace[k].interiors[j] = 0;
tvFace[k].handles[j*2] = 0;
tvFace[k].handles[j*2+1] = 0;
}
}
}
for (int k=0; k<tvFaceCount; k++)
{
if (k < TVMaps.f.Count())
{
tvFace[k].tv[0] = TVMaps.f[k]->t[0];
tvFace[k].tv[1] = TVMaps.f[k]->t[1];
tvFace[k].tv[2] = TVMaps.f[k]->t[2];
if (TVMaps.f[k]->count == 4) tvFace[k].tv[3] = TVMaps.f[k]->t[3];
if (TVMaps.f[k]->flags & FLAG_CURVEDMAPPING)
{
patch.patches[k].flags &= ~PATCH_LINEARMAPPING;
if (TVMaps.f[k]->vecs)
{
for (int m = 0;m < TVMaps.f[k]->count;m++)
{
if (TVMaps.f[k]->flags & FLAG_INTERIOR)
{
tvFace[k].interiors[m] = TVMaps.f[k]->vecs->interiors[m];
}
tvFace[k].handles[m*2] = TVMaps.f[k]->vecs->handles[m*2];
tvFace[k].handles[m*2+1] = TVMaps.f[k]->vecs->handles[m*2+1];
}
}
}
else patch.patches[k].flags |= PATCH_LINEARMAPPING;
}
else{
tvFace[k].tv[0] = 0;
tvFace[k].tv[1] = 0;
tvFace[k].tv[2] = 0;
if (TVMaps.f[k]->count == 4) tvFace[k].tv[3] = 0;
for (int m = 0;m < TVMaps.f[k]->count;m++)
{
tvFace[k].interiors[m] = 0;
tvFace[k].handles[m*2] = 0;
tvFace[k].handles[m*2+1] = 0;
}
}
}
//match verts
patch.setNumMapVerts (mapChannel,TVMaps.v.Count());
PatchTVert *tVerts = patch.tVerts[mapChannel];
for (int k=0; k<TVMaps.v.Count(); k++)
tVerts[k].p = GetTVVert(k);
}
else
{
//copy into mesh struct
if (!tvFace)
{
// Create tvfaces and init to 0
patch.setNumMapPatches (mapChannel,patch.getNumPatches());
tvFace = patch.tvPatches[mapChannel];
for (int k=0; k<patch.getNumPatches(); k++)
{
for (int j=0; j<TVMaps.f[k]->count; j++)
{
tvFace[k].tv[j] = 0;
tvFace[k].interiors[j] = 0;
tvFace[k].handles[j*2] = 0;
tvFace[k].handles[j*2+1] = 0;
}
}
}
int offset = patch.getNumMapVerts (mapChannel);
for (int k=0; k<tvFaceCount; k++)
{
//copy if face is selected
if (patch.patchSel[k])
{
tvFace[k].tv[0] = TVMaps.f[k]->t[0]+offset;
tvFace[k].tv[1] = TVMaps.f[k]->t[1]+offset;
tvFace[k].tv[2] = TVMaps.f[k]->t[2]+offset;
if (TVMaps.f[k]->count == 4) tvFace[k].tv[3] = TVMaps.f[k]->t[3]+offset;
if (TVMaps.f[k]->flags & FLAG_CURVEDMAPPING)
{
patch.patches[k].flags &= ~PATCH_LINEARMAPPING;
if (TVMaps.f[k]->vecs)
{
for (int m = 0;m < TVMaps.f[k]->count;m++)
{
if (TVMaps.f[k]->flags & FLAG_INTERIOR)
{
tvFace[k].interiors[m] = TVMaps.f[k]->vecs->interiors[m]+offset;
}
tvFace[k].handles[m*2] = TVMaps.f[k]->vecs->handles[m*2]+offset;
tvFace[k].handles[m*2+1] = TVMaps.f[k]->vecs->handles[m*2+1]+offset;
}
}
}
else patch.patches[k].flags |= PATCH_LINEARMAPPING;
}
}
//match verts
patch.setNumMapVerts (mapChannel,TVMaps.v.Count()+offset,TRUE);
PatchTVert *tVerts = patch.tVerts[mapChannel];
for ( int k=0; k<TVMaps.v.Count(); k++)
tVerts[k+offset].p = GetTVVert(k);
}
RemoveDeadVerts(&patch,mapChannel);
}
void MeshTopoData::SetCache(PatchMesh &patch, int mapChannel)
{
FreeCache();
this->patch = new PatchMesh(patch);
//build TVMAP and edge data
mFSelPrevious.SetSize(patch.patchSel.GetSize());
mFSelPrevious = patch.patchSel;
if ( (patch.selLevel==PATCH_PATCH) && (patch.patchSel.NumberSet() == 0) )
{
TVMaps.SetCountFaces(0);
TVMaps.v.SetCount(0);
TVMaps.FreeEdges();
TVMaps.FreeGeomEdges();
mVSel.SetSize(0);
mESel.SetSize(0);
mFSel.SetSize(0);
mGESel.SetSize(0);
mGVSel.SetSize(0);
return;
}
//loop through all maps
//get channel from mesh
TVMaps.channel = mapChannel;
//get from mesh based on cahne
PatchTVert *tVerts = NULL;
TVPatch *tvFace = NULL;
if (!patch.getMapSupport(mapChannel))
{
patch.setNumMaps(mapChannel+1);
}
tVerts = patch.tVerts[mapChannel];
tvFace = patch.tvPatches[mapChannel];
if (patch.selLevel!=PATCH_PATCH )
{
//copy into our structs
TVMaps.SetCountFaces(patch.getNumPatches());
TVMaps.v.SetCount(patch.getNumMapVerts(mapChannel));
mVSel.SetSize(patch.getNumMapVerts (mapChannel));
TVMaps.geomPoints.SetCount(patch.getNumVerts()+patch.getNumVecs());
for (int j=0; j<TVMaps.f.Count(); j++)
{
TVMaps.f[j]->flags = 0;
int pcount = 3;
if (patch.patches[j].type == PATCH_QUAD)
{
pcount = 4;
}
TVMaps.f[j]->t = new int[pcount];
TVMaps.f[j]->v = new int[pcount];
if (tvFace == NULL)
{
TVMaps.f[j]->t[0] = 0;
TVMaps.f[j]->t[1] = 0;
TVMaps.f[j]->t[2] = 0;
if (pcount ==4) TVMaps.f[j]->t[3] = 0;
TVMaps.f[j]->FaceIndex = j;
TVMaps.f[j]->MatID = patch.getPatchMtlIndex(j);
TVMaps.f[j]->flags = 0;
TVMaps.f[j]->count = pcount;
TVMaps.f[j]->vecs = NULL;
UVW_TVVectorClass *tempv = NULL;
//new an instance
if (!(patch.patches[j].flags & PATCH_AUTO))
TVMaps.f[j]->flags |= FLAG_INTERIOR;
if (!(patch.patches[j].flags & PATCH_LINEARMAPPING))
{
tempv = new UVW_TVVectorClass();
TVMaps.f[j]->flags |= FLAG_CURVEDMAPPING;
}
TVMaps.f[j]->vecs = tempv;
for (int k = 0; k < pcount; k++)
{
int index = patch.patches[j].v[k];
TVMaps.f[j]->v[k] = index;
TVMaps.geomPoints[index] = patch.verts[index].p;
//do handles and interiors
//check if linear
if (!(patch.patches[j].flags & PATCH_LINEARMAPPING))
{
//do geometric points
index = patch.patches[j].interior[k];
TVMaps.f[j]->vecs->vinteriors[k] =patch.getNumVerts()+index;
index = patch.patches[j].vec[k*2];
TVMaps.f[j]->vecs->vhandles[k*2] =patch.getNumVerts()+index;
index = patch.patches[j].vec[k*2+1];
TVMaps.f[j]->vecs->vhandles[k*2+1] =patch.getNumVerts()+index;
// do texture points do't need to since they don't exist in this case
TVMaps.f[j]->vecs->interiors[k] =0;
TVMaps.f[j]->vecs->handles[k*2] =0;
TVMaps.f[j]->vecs->handles[k*2+1] =0;
}
}
}
else
{
TVMaps.f[j]->t[0] = tvFace[j].tv[0];
TVMaps.f[j]->t[1] = tvFace[j].tv[1];
TVMaps.f[j]->t[2] = tvFace[j].tv[2];
if (pcount ==4) TVMaps.f[j]->t[3] = tvFace[j].tv[3];
TVMaps.f[j]->FaceIndex = j;
TVMaps.f[j]->MatID = patch.getPatchMtlIndex(j);
TVMaps.f[j]->flags = 0;
TVMaps.f[j]->count = pcount;
TVMaps.f[j]->vecs = NULL;
UVW_TVVectorClass *tempv = NULL;
if (!(patch.patches[j].flags & PATCH_AUTO))
TVMaps.f[j]->flags |= FLAG_INTERIOR;
//new an instance
if (!(patch.patches[j].flags & PATCH_LINEARMAPPING))
{
BOOL mapLinear = FALSE;
for (int tvCount = 0; tvCount < patch.patches[j].type*2; tvCount++)
{
if (tvFace[j].handles[tvCount] < 0) mapLinear = TRUE;
}
if (!(patch.patches[j].flags & PATCH_AUTO))
{
for (int tvCount = 0; tvCount < patch.patches[j].type; tvCount++)
{
if (tvFace[j].interiors[tvCount] < 0) mapLinear = TRUE;
}
}
if (!mapLinear)
{
tempv = new UVW_TVVectorClass();
TVMaps.f[j]->flags |= FLAG_CURVEDMAPPING;
}
}
TVMaps.f[j]->vecs = tempv;
if ((patch.selLevel==PATCH_PATCH ) && (patch.patchSel[j] == 0))
TVMaps.f[j]->flags |= FLAG_DEAD;
for (int k = 0; k < pcount; k++)
{
int index = patch.patches[j].v[k];
TVMaps.f[j]->v[k] = index;
TVMaps.geomPoints[index] = patch.verts[index].p;
// TVMaps.f[j].pt[k] = patch.verts[index].p;
//do handles and interiors
//check if linear
if (TVMaps.f[j]->flags & FLAG_CURVEDMAPPING)
{
//do geometric points
index = patch.patches[j].interior[k];
TVMaps.f[j]->vecs->vinteriors[k] =patch.getNumVerts()+index;
index = patch.patches[j].vec[k*2];
TVMaps.f[j]->vecs->vhandles[k*2] =patch.getNumVerts()+index;
index = patch.patches[j].vec[k*2+1];
TVMaps.f[j]->vecs->vhandles[k*2+1] =patch.getNumVerts()+index;
// do texture points do't need to since they don't exist in this case
if (TVMaps.f[j]->flags & FLAG_INTERIOR)
{
index = tvFace[j].interiors[k];
TVMaps.f[j]->vecs->interiors[k] =index;
}
index = tvFace[j].handles[k*2];
TVMaps.f[j]->vecs->handles[k*2] =index;
index = tvFace[j].handles[k*2+1];
TVMaps.f[j]->vecs->handles[k*2+1] =index;
}
}
}
}
for (int geomvecs =0; geomvecs < patch.getNumVecs(); geomvecs++)
{
TVMaps.geomPoints[geomvecs+patch.getNumVerts()] = patch.vecs[geomvecs].p;
}
for ( int j=0; j<TVMaps.v.Count(); j++)
{
TVMaps.v[j].SetFlag(0);
if (tVerts)
TVMaps.v[j].SetP(tVerts[j]);
else TVMaps.v[j].SetP(Point3(0.0f,0.0f,0.0f));
TVMaps.v[j].SetInfluence(0.0f);
TVMaps.v[j].SetControlID(-1);
}
if (tvFace == NULL) BuildInitialMapping(&patch);
TVMaps.mSystemLockedFlag.SetSize(TVMaps.v.Count());
TVMaps.mSystemLockedFlag.ClearAll();
}
else
{
//copy into our structs
TVMaps.SetCountFaces(patch.getNumPatches());
TVMaps.v.SetCount(patch.getNumMapVerts (mapChannel));
mVSel.SetSize(patch.getNumMapVerts (mapChannel));
TVMaps.geomPoints.SetCount(patch.getNumVerts()+patch.getNumVecs());
for (int j=0; j<TVMaps.f.Count(); j++)
{
TVMaps.f[j]->flags = 0;
int pcount = 3;
if (patch.patches[j].type == PATCH_QUAD)
{
pcount = 4;
}
TVMaps.f[j]->t = new int[pcount];
TVMaps.f[j]->v = new int[pcount];
if (tvFace == NULL)
{
TVMaps.f[j]->t[0] = 0;
TVMaps.f[j]->t[1] = 0;
TVMaps.f[j]->t[2] = 0;
if (pcount == 4) TVMaps.f[j]->t[3] = 0;
TVMaps.f[j]->FaceIndex = j;
TVMaps.f[j]->MatID = patch.patches[j].getMatID();
if (patch.patchSel[j])
TVMaps.f[j]->flags = 0;
else TVMaps.f[j]->flags = FLAG_DEAD;
TVMaps.f[j]->count = pcount;
TVMaps.f[j]->vecs = NULL;
UVW_TVVectorClass *tempv = NULL;
if (!(patch.patches[j].flags & PATCH_AUTO))
TVMaps.f[j]->flags |= FLAG_INTERIOR;
//new an instance
if (!(patch.patches[j].flags & PATCH_LINEARMAPPING))
{
tempv = new UVW_TVVectorClass();
TVMaps.f[j]->flags |= FLAG_CURVEDMAPPING;
}
TVMaps.f[j]->vecs = tempv;
for (int k = 0; k < pcount; k++)
{
int index = patch.patches[j].v[k];
TVMaps.f[j]->v[k] = index;
TVMaps.geomPoints[index] = patch.verts[index].p;
// TVMaps.f[j].pt[k] = patch.verts[index].p;
//check if linear
if (!(patch.patches[j].flags & PATCH_LINEARMAPPING))
{
//do geometric points
index = patch.patches[j].interior[k];
TVMaps.f[j]->vecs->vinteriors[k] =patch.getNumVerts()+index;
index = patch.patches[j].vec[k*2];
TVMaps.f[j]->vecs->vhandles[k*2] =patch.getNumVerts()+index;
index = patch.patches[j].vec[k*2+1];
TVMaps.f[j]->vecs->vhandles[k*2+1] =patch.getNumVerts()+index;
// do texture points do't need to since they don't exist in this case
TVMaps.f[j]->vecs->interiors[k] =0;
TVMaps.f[j]->vecs->handles[k*2] =0;
TVMaps.f[j]->vecs->handles[k*2+1] =0;
}
}
}
else
{
TVMaps.f[j]->t[0] = tvFace[j].tv[0];
TVMaps.f[j]->t[1] = tvFace[j].tv[1];
TVMaps.f[j]->t[2] = tvFace[j].tv[2];
if (pcount == 4) TVMaps.f[j]->t[3] = tvFace[j].tv[3];
TVMaps.f[j]->FaceIndex = j;
TVMaps.f[j]->MatID = patch.patches[j].getMatID();
if (patch.patchSel[j])
TVMaps.f[j]->flags = 0;
else TVMaps.f[j]->flags = FLAG_DEAD;
int pcount = 3;
if (patch.patches[j].type == PATCH_QUAD)
{
pcount = 4;
}
TVMaps.f[j]->count = pcount;
TVMaps.f[j]->vecs = NULL;
UVW_TVVectorClass *tempv = NULL;
if (!(patch.patches[j].flags & PATCH_AUTO))
TVMaps.f[j]->flags |= FLAG_INTERIOR;
//new an instance
if (!(patch.patches[j].flags & PATCH_LINEARMAPPING))
{
BOOL mapLinear = FALSE;
for (int tvCount = 0; tvCount < patch.patches[j].type*2; tvCount++)
{
if (tvFace[j].handles[tvCount] < 0) mapLinear = TRUE;
}
if (!(patch.patches[j].flags & PATCH_AUTO))
{
for (int tvCount = 0; tvCount < patch.patches[j].type; tvCount++)
{
if (tvFace[j].interiors[tvCount] < 0) mapLinear = TRUE;
}
}
if (!mapLinear)
{
tempv = new UVW_TVVectorClass();
TVMaps.f[j]->flags |= FLAG_CURVEDMAPPING;
}
}
TVMaps.f[j]->vecs = tempv;
for (int k = 0; k < pcount; k++)
{
int index = patch.patches[j].v[k];
TVMaps.f[j]->v[k] = index;
TVMaps.geomPoints[index] = patch.verts[index].p;
// TVMaps.f[j].pt[k] = patch.verts[index].p;
//do handles and interiors
//check if linear
if (TVMaps.f[j]->flags & FLAG_CURVEDMAPPING)
{
//do geometric points
index = patch.patches[j].interior[k];
TVMaps.f[j]->vecs->vinteriors[k] =patch.getNumVerts()+index;
index = patch.patches[j].vec[k*2];
TVMaps.f[j]->vecs->vhandles[k*2] =patch.getNumVerts()+index;
index = patch.patches[j].vec[k*2+1];
TVMaps.f[j]->vecs->vhandles[k*2+1] =patch.getNumVerts()+index;
// do texture points do't need to since they don't exist in this case
if (TVMaps.f[j]->flags & FLAG_INTERIOR)
{
index = tvFace[j].interiors[k];
TVMaps.f[j]->vecs->interiors[k] =index;
}
index = tvFace[j].handles[k*2];
TVMaps.f[j]->vecs->handles[k*2] =index;
index = tvFace[j].handles[k*2+1];
TVMaps.f[j]->vecs->handles[k*2+1] =index;
}
}
}
}
for (int j =0; j < patch.getNumVecs(); j++)
{
TVMaps.geomPoints[j+patch.getNumVerts()] = patch.vecs[j].p;
}
for (int j=0; j<TVMaps.v.Count(); j++)
{
// TVMaps.v[j].SystemLocked(TRUE);
if (tVerts)
TVMaps.v[j].SetP(tVerts[j]);
else TVMaps.v[j].SetP(Point3(.0f,0.0f,0.0f));
//check if vertex for this face selected
TVMaps.v[j].SetInfluence(0.0f);
TVMaps.v[j].SetControlID(-1);
}
if (tvFace == NULL) BuildInitialMapping(&patch);
TVMaps.mSystemLockedFlag.SetSize(TVMaps.v.Count());
TVMaps.mSystemLockedFlag.SetAll();
for (int j=0; j<TVMaps.f.Count(); j++)
{
if (!(TVMaps.f[j]->flags & FLAG_DEAD))
{
int a;
a = TVMaps.f[j]->t[0];
TVMaps.v[a].SetFlag(0);
TVMaps.mSystemLockedFlag.Set(a,FALSE);
a = TVMaps.f[j]->t[1];
TVMaps.v[a].SetFlag(0);
TVMaps.mSystemLockedFlag.Set(a,FALSE);
a = TVMaps.f[j]->t[2];
TVMaps.v[a].SetFlag(0);
TVMaps.mSystemLockedFlag.Set(a,FALSE);
if (TVMaps.f[j]->count > 3)
{
a = TVMaps.f[j]->t[3];
TVMaps.v[a].SetFlag(0);
TVMaps.mSystemLockedFlag.Set(a,FALSE);
}
if ( (TVMaps.f[j]->flags & FLAG_CURVEDMAPPING) && (TVMaps.f[j]->vecs))
{
for (int m =0; m < TVMaps.f[j]->count; m++)
{
int hid = TVMaps.f[j]->vecs->handles[m*2];
TVMaps.v[hid].SetFlag(0) ;
TVMaps.mSystemLockedFlag.Set(hid,FALSE);
hid = TVMaps.f[j]->vecs->handles[m*2+1];
TVMaps.v[hid].SetFlag(0) ;
TVMaps.mSystemLockedFlag.Set(hid,FALSE);
}
if (TVMaps.f[j]->flags & FLAG_INTERIOR)
{
for (int m =0; m < TVMaps.f[j]->count; m++)
{
int iid = TVMaps.f[j]->vecs->interiors[m];
TVMaps.v[iid].SetFlag(0);
TVMaps.mSystemLockedFlag.Set(iid,FALSE);
}
}
}
}
}
}
}
