CFX_FontMgr::~CFX_FontMgr()
{
delete m_pBuiltinMapper;
FreeCache();
if (m_FTLibrary) {
FXFT_Done_FreeType(m_FTLibrary);
}
}
EditPolyData::~EditPolyData() {
DeleteAllOperations ();
FreeCache();
FreeNewSelection ();
ClearPolyOpData();
if (mpTemp != NULL) delete mpTemp;
if (mpTempOutput != NULL) delete mpTempOutput;
}
void VertexPaintData::SetCache(Mesh& m)
{
FreeCache();
mesh = new Mesh(m);
SynchVerts(m);
AllocColorData(mesh->getNumVerts());
}
void BasicImage::Resize(int w, int h) {
if(size.w > 0 && size.h > 0) {
delete[] buffer;
}
buffer = new unsigned int[w*h];
size.w = w;
size.h = h;
FreeCache();
SetFullAffectedRegion();
}
XtCacheRef *_XtGetResources(
register Widget w,
ArgList args,
Cardinal num_args,
XtTypedArgList typed_args,
Cardinal* num_typed_args)
{
XrmName *names, names_s[50];
XrmClass *classes, classes_s[50];
XrmQuark quark_cache[100];
XrmQuarkList quark_args;
WidgetClass wc;
ConstraintWidgetClass cwc;
XtCacheRef *cache_refs, *cache_refs_core;
Cardinal count;
wc = XtClass(w);
count = CountTreeDepth(w);
names = (XrmName*) XtStackAlloc (count * sizeof(XrmName), names_s);
classes = (XrmClass*) XtStackAlloc (count * sizeof(XrmClass), classes_s);
if (names == NULL || classes == NULL) _XtAllocError(NULL);
/* Get names, classes for widget and ancestors */
GetNamesAndClasses(w, names, classes);
/* Compile arg list into quarks */
CacheArgs(args, num_args, typed_args, *num_typed_args, quark_cache,
XtNumber(quark_cache), &quark_args);
/* Get normal resources */
LOCK_PROCESS;
cache_refs = GetResources(w, (char*)w, names, classes,
(XrmResourceList *) wc->core_class.resources,
wc->core_class.num_resources, quark_args, args, num_args,
typed_args, num_typed_args, XtIsWidget(w));
if (w->core.constraints != NULL) {
cwc = (ConstraintWidgetClass) XtClass(w->core.parent);
cache_refs_core =
GetResources(w, (char*)w->core.constraints, names, classes,
(XrmResourceList *) cwc->constraint_class.resources,
cwc->constraint_class.num_resources,
quark_args, args, num_args, typed_args, num_typed_args, False);
if (cache_refs_core) {
XtFree((char *)cache_refs_core);
}
}
FreeCache(quark_cache, quark_args);
UNLOCK_PROCESS;
XtStackFree((XtPointer)names, names_s);
XtStackFree((XtPointer)classes, classes_s);
return cache_refs;
} /* _XtGetResources */
short __stdcall FILClose(short n)
{
if(!IsValid(n))
return 0;
CloseHandle(lpFCB[n]->hdlFile);
FreeCache(n);
delete lpFCB[n]->lpCache;
delete lpFCB[n];
lpFCB[n] = NULL;
return 1;
}
VertexPaintData::~VertexPaintData()
{
FreeCache();
if (colordata) delete [] colordata;
if(nverts) delete [] nverts;
if(nvcverts) delete [] nvcverts;
nverts = NULL;
nvcverts = NULL;
colordata = NULL;
numColors = 0;
numnverts = 0;
numnvcverts = 0;
}
/*** fCacheMarks - Copy marks to a cache. Save caches contents if nec.
*
* Purpose:
*
* Before most mark operations can take place, the cache must contain
* the marks for the given file.
*
* Input:
* pFile - File to cache marks for.
*
* Output:
*
* Returns FALSE if the file has no marks, TRUE otherwise.
*
* Notes:
*
* On return the cache is usable whether or not the given file had marks.
*
*************************************************************************/
flagType
fCacheMarks (
PFILE pFile
) {
unsigned cbCache;
FILEMARKS UNALIGNED *Marks;
assert (pFile);
// First we make sure that the VM version of
// marks is updated for this file. fReadMarks
// return TRUE iff the file has marks and they
// are in VM.
//
if (fReadMarks (pFile)) {
// The marks are ready to be cached. First,
// let's see if they are already chached.
//
if (pFileCache == pFile) {
return TRUE;
}
// They're not. If the cache is currently
// being used, we save it and clear it.
//
FreeCache ();
// Finally, alloc a new cache, plop
// the marks into it and mark the
// cache in use.
//
Marks = (FILEMARKS *)(pFile->vaMarks);
pfmCache = (FILEMARKS *)ZEROMALLOC (cbCache = (unsigned)(Marks->cb) );
memmove((char *)pfmCache, pFile->vaMarks, cbCache);
pFileCache = pFile;
fCacheDirty = FALSE;
return TRUE;
} else { /* No marks, return FALSE */
return FALSE;
}
}
/*** DefineMark - Add new mark / update existing mark
*
* Purpose:
*
* This is called from the outside to create/update marks.
*
* Input:
* pszMark - Mark's name
* pFile - File the mark will be in
* y, x - File location of the mark (1-based)
* fTemp - True -> the mark is temporary
*
* Output: None.
*
*************************************************************************/
void
DefineMark (
char * pszMark,
PFILE pFile,
LINE y,
COL x,
flagType fTemp
) {
flagType fFirstMark = (flagType)!fCacheMarks (pFile);
if (fFirstMark) {
FreeCache ();
}
UpdMark (&pfmCache, pszMark, y, x, (flagType)(MF_DIRTY | (fTemp ? MF_TEMP : 0)));
if (fFirstMark) {
pFileCache = pFile;
(void)fFMtoPfile (pFile, pfmCache);
}
}
/* Resamples N input maps into 1 output map.
* For every pixel in the output map all input maps are scanned.
* The output value of the pixel is determined according to the
* cells of the input maps at the pixel location. With an optional
* percentage a minimum coverage area for a non MV can be given.
* Returns 0 if no error occurs, 1 otherwise.
*/
int SampleCont(
MAP *out, /* write-only output map */
MAP **in, /* read-only list input maps */
double percentage, /* min. percentage for non-MV */
size_t nrMaps, /* number of input maps */
size_t nrRows, /* number of rows */
size_t nrCols, /* number of columns */
BOOL aligned, /* maps are aligned */
REAL8 angle) /* angle of output map */
{
double r, c;
size_t nrCoverCells = (size_t)ceil((percentage / 100) * rasterSize
* rasterSize);
InitCache(out, in, nrMaps);
for(r = 0; r < nrRows; r++)
{
if(nrMaps > 1 && percentage > 0)
raster = NewRaster(nrCoverCells, rasterSize);
/* Print progress information if wanted */
AppRowProgress((int) r);
for(c = 0; c < nrCols; c++)
{ /* For every output cell */
if(CalcPixel(out, in, nrCoverCells, nrMaps, r, c, aligned, angle))
return 1; /* allocation failed */
}
}
AppEndRowProgress();
if(nrMaps > 1 && percentage > 0)
FreeRaster(raster);
FreeCache(nrMaps);
return 0; /* successfully terminated */
}
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);
}
}
}
}
}
}
}
void MeshTopoData::SetCache(MNMesh &mesh, int mapChannel)
{
FreeCache();
this->mnMesh = new MNMesh(mesh);
TVMaps.channel = mapChannel;
BitArray s;
mesh.getFaceSel(s);
mesh.getFaceSel(mFSelPrevious);
if ( (mesh.selLevel==MNM_SL_FACE) && (s == 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;
}
//get from mesh based on cahne
int numMaps = mesh.MNum ();
MNMapFace *tvFace=NULL;
Point3 *tVerts = NULL;
if (mapChannel >= numMaps)
{
}
else
{
tvFace = mesh.M(mapChannel)->f;
tVerts = mesh.M(mapChannel)->v;
}
if (mesh.selLevel!=MNM_SL_FACE)
{
//copy into our structs
TVMaps.SetCountFaces(mesh.FNum());
if (tVerts)
{
TVMaps.v.SetCount(mesh.M(mapChannel)->VNum());
mVSel.SetSize(mesh.M(mapChannel)->VNum());
}
else
{
TVMaps.v.SetCount(mesh.VNum());
mVSel.SetSize(mesh.VNum());
}
TVMaps.geomPoints.SetCount(mesh.VNum());
for (int j=0; j<TVMaps.f.Count(); j++)
{
TVMaps.f[j]->flags = 0;
int fct;
fct = mesh.f[j].deg;
if (mesh.f[j].GetFlag(MN_DEAD)) fct = 0;
if (fct > 0)
{
TVMaps.f[j]->t = new int[fct];
TVMaps.f[j]->v = new int[fct];
}
else
{
TVMaps.f[j]->t = NULL;
TVMaps.f[j]->v = NULL;
}
if (tvFace == NULL)
{
for (int k=0; k < fct;k++)
TVMaps.f[j]->t[k] = 0;
TVMaps.f[j]->FaceIndex = j;
TVMaps.f[j]->MatID = mesh.f[j].material;
TVMaps.f[j]->flags = 0;
TVMaps.f[j]->count = fct;
for (int k = 0; k < fct; k++)
{
int index = mesh.f[j].vtx[k];
TVMaps.f[j]->v[k] = index;
TVMaps.geomPoints[index] = mesh.v[index].p;
}
}
else
{
for (int k=0; k < fct;k++)
TVMaps.f[j]->t[k] = tvFace[j].tv[k];
TVMaps.f[j]->FaceIndex = j;
TVMaps.f[j]->MatID = mesh.f[j].material;
TVMaps.f[j]->flags = 0;
TVMaps.f[j]->count = fct;
for (int k = 0; k < fct; k++)
{
int index = mesh.f[j].vtx[k];
TVMaps.f[j]->v[k] = index;
TVMaps.geomPoints[index] = mesh.v[index].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(.0f,0.0f,0.0f));
TVMaps.v[j].SetInfluence(0.0f);
TVMaps.v[j].SetControlID(-1);
}
if (tvFace == NULL) BuildInitialMapping(&mesh);
TVMaps.mSystemLockedFlag.SetSize(TVMaps.v.Count());
TVMaps.mSystemLockedFlag.ClearAll();
}
else
{
//copy into our structs
TVMaps.SetCountFaces(mesh.FNum());
int tvVertCount = 0;
if (mapChannel < numMaps)
{
tvVertCount = mesh.M(mapChannel)->VNum();
}
TVMaps.v.SetCount(tvVertCount);
mVSel.SetSize(tvVertCount);
TVMaps.geomPoints.SetCount(mesh.VNum());
BitArray bs;
mesh.getFaceSel(bs);
for (int j=0; j<TVMaps.f.Count(); j++)
{
TVMaps.f[j]->flags = 0;
int fct;
fct = mesh.f[j].deg;
if (mesh.f[j].GetFlag(MN_DEAD)) fct = 0;
if (fct > 0)
{
TVMaps.f[j]->t = new int[fct];
TVMaps.f[j]->v = new int[fct];
}
else
{
TVMaps.f[j]->t = NULL;
TVMaps.f[j]->v = NULL;
}
if (tvFace == NULL)
{
for (int k=0; k < fct;k++)
TVMaps.f[j]->t[k] = 0;
TVMaps.f[j]->FaceIndex = j;
TVMaps.f[j]->MatID = mesh.f[j].material;
TVMaps.f[j]->count = fct;
if (bs[j])
TVMaps.f[j]->flags = 0;
else TVMaps.f[j]->flags = FLAG_DEAD;
for (int k = 0; k < fct; k++)
{
int index = mesh.f[j].vtx[k];
TVMaps.f[j]->v[k] = index;
TVMaps.geomPoints[index] = mesh.v[index].p;
}
}
else
{
for (int k=0; k < fct;k++)
TVMaps.f[j]->t[k] = tvFace[j].tv[k];
TVMaps.f[j]->FaceIndex = j;
TVMaps.f[j]->MatID = mesh.f[j].material;
TVMaps.f[j]->count = fct;
if (bs[j])
TVMaps.f[j]->flags = 0;
else TVMaps.f[j]->flags = FLAG_DEAD;
for ( int k = 0; k < fct; k++)
{
int index = mesh.f[j].vtx[k];
TVMaps.f[j]->v[k] = index;
TVMaps.geomPoints[index] = mesh.v[index].p;
}
}
}
for (int j=0; j<TVMaps.v.Count(); j++)
{
if (tVerts)
TVMaps.v[j].SetP(tVerts[j]);
else TVMaps.v[j].SetP(Point3(0.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(&mesh);
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;
for (int k =0 ; k < TVMaps.f[j]->count;k++)
{
a = TVMaps.f[j]->t[k];
TVMaps.v[a].SetFlag(0);
TVMaps.mSystemLockedFlag.Set(a,FALSE);
}
}
}
}
}
void FreeCache(SObject* parent)
{
parent->FreeCache();
for ( SObject* obj = parent->bottomChild; obj; obj = obj->above )
FreeCache(obj);
}
~EditFaceDataModData () { FreeCache (); }
CDCCache::~CDCCache()
{
FreeCache();
}
