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);
}
}
}
}
}
}
}
int EditPatchMod::DoAttach(INode *node, PatchMesh *attPatch, RPatchMesh *rattPatch, bool & canUndo)
{
ModContextList mcList;
INodeTab nodes;
if (!ip)
return 0;
ip->GetModContexts(mcList, nodes);
if (mcList.Count() != 1)
{
nodes.DisposeTemporary();
return 0;
}
EditPatchData *patchData =(EditPatchData*)mcList[0]->localData;
if (!patchData)
{
nodes.DisposeTemporary();
return 0;
}
patchData->BeginEdit(ip->GetTime());
// If the mesh isn't yet cached, this will cause it to get cached.
RPatchMesh *rpatch;
PatchMesh *patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
if (!patch)
{
nodes.DisposeTemporary();
return 0;
}
patchData->RecordTopologyTags(patch);
RecordTopologyTags();
// Transform the shape for attachment:
// If reorienting, just translate to align pivots
// Otherwise, transform to match our transform
Matrix3 attMat(1);
if (attachReorient)
{
Matrix3 thisTM = nodes[0]->GetNodeTM(ip->GetTime());
Matrix3 thisOTMBWSM = nodes[0]->GetObjTMBeforeWSM(ip->GetTime());
Matrix3 thisPivTM = thisTM * Inverse(thisOTMBWSM);
Matrix3 otherTM = node->GetNodeTM(ip->GetTime());
Matrix3 otherOTMBWSM = node->GetObjTMBeforeWSM(ip->GetTime());
Matrix3 otherPivTM = otherTM * Inverse(otherOTMBWSM);
Point3 otherObjOffset = node->GetObjOffsetPos();
attMat = Inverse(otherPivTM) * thisPivTM;
}
else
{
attMat = node->GetObjectTM(ip->GetTime()) *
Inverse(nodes[0]->GetObjectTM(ip->GetTime()));
}
// RB 3-17-96 : Check for mirroring
AffineParts parts;
decomp_affine(attMat, &parts);
if (parts.f < 0.0f)
{
int v[8], ct, ct2, j;
Point3 p[9];
for (int i = 0; i < attPatch->numPatches; i++)
{
// Re-order rpatch
if (attPatch->patches[i].type == PATCH_QUAD)
{
UI_PATCH rpatch=rattPatch->getUIPatch (i);
int ctU=rpatch.NbTilesU<<1;
int ctV=rpatch.NbTilesV<<1;
int nU;
for (nU=0; nU<ctU; nU++)
{
for (int nV=0; nV<ctV; nV++)
{
rattPatch->getUIPatch (i).getTileDesc (nU+nV*ctU)=rpatch.getTileDesc (ctU-1-nU+(ctV-1-nV)*ctU);
}
}
for (nU=0; nU<ctU+1; nU++)
{
for (int nV=0; nV<ctV+1; nV++)
{
rattPatch->getUIPatch (i).setColor (nU+nV*(ctU+1), rpatch.getColor (ctU-nU+(ctV-nV)*ctU));
}
}
}
// Re-order vertices
ct = attPatch->patches[i].type == PATCH_QUAD ? 4 : 3;
for (j = 0; j < ct; j++)
{
v[j] = attPatch->patches[i].v[j];
}
for (j = 0; j < ct; j++)
{
attPatch->patches[i].v[j] = v[ct - j - 1];
}
// Re-order vecs
ct = attPatch->patches[i].type == PATCH_QUAD ? 8 : 6;
ct2 = attPatch->patches[i].type == PATCH_QUAD ? 5 : 3;
for (j = 0; j < ct; j++)
{
v[j] = attPatch->patches[i].vec[j];
}
for (j = 0; j < ct; j++, ct2--)
{
if (ct2 < 0)
ct2 = ct - 1;
attPatch->patches[i].vec[j] = v[ct2];
}
// Re-order enteriors
if (attPatch->patches[i].type == PATCH_QUAD)
{
ct = 4;
for (j = 0; j < ct; j++)
{
v[j] = attPatch->patches[i].interior[j];
}
for (j = 0; j < ct; j++)
{
attPatch->patches[i].interior[j] = v[ct - j - 1];
}
}
// Re-order aux
if (attPatch->patches[i].type == PATCH_TRI)
{
ct = 9;
for (j = 0; j < ct; j++)
{
p[j] = attPatch->patches[i].aux[j];
}
for (j = 0; j < ct; j++)
{
attPatch->patches[i].aux[j] = p[ct - j - 1];
}
}
// Re-order TV faces if present
for (int chan = 0; chan < patch->getNumMaps(); ++chan)
{
if (attPatch->tvPatches[chan])
{
ct = 4;
for (j = 0; j < ct; j++)
{
v[j] = attPatch->tvPatches[chan][i].tv[j];
}
for (j = 0; j < ct; j++)
{
attPatch->tvPatches[chan][i].tv[j] = v[ct - j - 1];
}
}
}
}
}
int i;
for (i = 0; i < attPatch->numVerts; ++i)
attPatch->verts[i].p = attPatch->verts[i].p * attMat;
for (i = 0; i < attPatch->numVecs; ++i)
attPatch->vecs[i].p = attPatch->vecs[i].p * attMat;
attPatch->computeInteriors();
theHold.Begin();
// Combine the materials of the two nodes.
int mat2Offset = 0;
Mtl *m1 = nodes[0]->GetMtl();
Mtl *m2 = node->GetMtl();
bool condenseMe = FALSE;
if (m1 && m2 &&(m1 != m2))
{
if (attachMat == ATTACHMAT_IDTOMAT)
{
int ct = 1;
if (m1->IsMultiMtl())
ct = m1->NumSubMtls();
for (int i = 0; i < patch->numPatches; ++i)
{
int mtid = patch->getPatchMtlIndex(i);
if (mtid >= ct)
patch->setPatchMtlIndex(i, mtid % ct);
}
FitPatchIDsToMaterial(*attPatch, m2);
if (condenseMat)
condenseMe = TRUE;
}
// the theHold calls here were a vain attempt to make this all undoable.
// This should be revisited in the future so we don't have to use the SYSSET_CLEAR_UNDO.
theHold.Suspend();
if (attachMat == ATTACHMAT_MATTOID)
{
m1 = FitMaterialToPatchIDs(*patch, m1);
m2 = FitMaterialToPatchIDs(*attPatch, m2);
}
Mtl *multi = CombineMaterials(m1, m2, mat2Offset);
if (attachMat == ATTACHMAT_NEITHER)
mat2Offset = 0;
theHold.Resume();
// We can't be in face subobject mode, else we screw up the materials:
DWORD oldSL = patch->selLevel;
DWORD roldSL = patch->selLevel;
patch->selLevel = PATCH_OBJECT;
rpatch->SetSelLevel (EP_OBJECT);
nodes[0]->SetMtl(multi);
patch->selLevel = oldSL;
rpatch->SetSelLevel (roldSL);
m1 = multi;
canUndo = FALSE; // Absolutely cannot undo material combinations.
}
if (!m1 && m2)
{
// We can't be in face subobject mode, else we screw up the materials:
DWORD oldSL = patch->selLevel;
DWORD roldSL = rpatch->GetSelLevel();
patch->selLevel = PATCH_OBJECT;
rpatch->SetSelLevel (EP_OBJECT);
nodes[0]->SetMtl(m2);
patch->selLevel = oldSL;
rpatch->SetSelLevel (roldSL);
m1 = m2;
}
// Start a restore object...
if (theHold.Holding())
theHold.Put(new PatchRestore(patchData, this, patch, rpatch, "DoAttach"));
// Do the attach
patch->Attach(attPatch, mat2Offset);
rpatch->Attach(rattPatch, *patch);
patchData->UpdateChanges(patch, rpatch);
patchData->TempData(this)->Invalidate(PART_TOPO | PART_GEOM);
// Get rid of the original node
ip->DeleteNode(node);
ResolveTopoChanges();
theHold.Accept(GetString(IDS_TH_ATTACH));
if (m1 && condenseMe)
{
// Following clears undo stack.
patch = patchData->TempData(this)->GetPatch(ip->GetTime(), rpatch);
m1 = CondenseMatAssignments(*patch, m1);
}
nodes.DisposeTemporary();
ClearPatchDataFlag(mcList, EPD_BEENDONE);
NotifyDependents(FOREVER, PART_TOPO | PART_GEOM, REFMSG_CHANGE);
ip->RedrawViews(ip->GetTime(), REDRAW_NORMAL);
return 1;
}
