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(); }