void seq_stripelem_cache_destruct(void)
{
if (!entrypool) {
return;
}
BLI_ghash_free(hash, HashKeyFree, HashValFree);
delete_MEM_CacheLimiter(limitor);
BLI_mempool_destroy(entrypool);
BLI_mempool_destroy(keypool);
}
static void outliner_storage_cleanup(SpaceOops *soops)
{
BLI_mempool *ts = soops->treestore;
if (ts) {
TreeStoreElem *tselem;
int unused = 0;
/* each element used once, for ID blocks with more users to have each a treestore */
BLI_mempool_iter iter;
BLI_mempool_iternew(ts, &iter);
while ((tselem = BLI_mempool_iterstep(&iter))) {
tselem->used = 0;
}
/* cleanup only after reading file or undo step, and always for
* RNA datablocks view in order to save memory */
if (soops->storeflag & SO_TREESTORE_CLEANUP) {
BLI_mempool_iternew(ts, &iter);
while ((tselem = BLI_mempool_iterstep(&iter))) {
if (tselem->id == NULL) unused++;
}
if (unused) {
if (BLI_mempool_count(ts) == unused) {
BLI_mempool_destroy(ts);
soops->treestore = NULL;
if (soops->treehash) {
BKE_treehash_free(soops->treehash);
soops->treehash = NULL;
}
}
else {
TreeStoreElem *tsenew;
BLI_mempool *new_ts = BLI_mempool_create(sizeof(TreeStoreElem), BLI_mempool_count(ts) - unused,
512, BLI_MEMPOOL_ALLOW_ITER);
BLI_mempool_iternew(ts, &iter);
while ((tselem = BLI_mempool_iterstep(&iter))) {
if (tselem->id) {
tsenew = BLI_mempool_alloc(new_ts);
*tsenew = *tselem;
}
}
BLI_mempool_destroy(ts);
soops->treestore = new_ts;
if (soops->treehash) {
/* update hash table to fix broken pointers */
BKE_treehash_rebuild_from_treestore(soops->treehash, soops->treestore);
}
}
}
}
}
}
void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp) {
int i;
if (keyfreefp || valfreefp) {
for (i=0; i<gh->nbuckets; i++) {
Entry *e;
for (e= gh->buckets[i]; e; ) {
Entry *n= e->next;
if (keyfreefp) keyfreefp(e->key);
if (valfreefp) valfreefp(e->val);
e= n;
}
}
}
MEM_freeN(gh->buckets);
BLI_mempool_destroy(gh->entrypool);
gh->buckets = NULL;
gh->nentries = 0;
gh->nbuckets = 0;
MEM_freeN(gh);
}
void BLI_edgehash_free(EdgeHash *eh, EdgeHashFreeFP valfreefp)
{
BLI_edgehash_clear(eh, valfreefp);
BLI_mempool_destroy(eh->epool);
MEM_freeN(eh->buckets);
MEM_freeN(eh);
}
void IMB_moviecache_free(MovieCache *cache)
{
PRINT("%s: cache '%s' free\n", __func__, cache->name);
BLI_ghash_free(cache->hash, moviecache_keyfree, moviecache_valfree);
BLI_mempool_destroy(cache->keys_pool);
BLI_mempool_destroy(cache->items_pool);
BLI_mempool_destroy(cache->userkeys_pool);
if (cache->points)
MEM_freeN(cache->points);
if (cache->last_userkey)
MEM_freeN(cache->last_userkey);
MEM_freeN(cache);
}
void BLI_edgehash_free(EdgeHash *eh, EdgeHashFreeFP valfreefp)
{
BLI_assert((int)eh->nentries == BLI_mempool_count(eh->epool));
if (valfreefp)
edgehash_free_cb(eh, valfreefp);
BLI_mempool_destroy(eh->epool);
MEM_freeN(eh->buckets);
MEM_freeN(eh);
}
void BME_free_mesh(BME_Mesh *bm)
{
BME_Vert *v;
BME_Edge *e;
BME_Loop *l;
BME_Poly *f;
for(v=bm->verts.first; v; v=v->next) CustomData_bmesh_free_block(&bm->vdata, &v->data);
for(e=bm->edges.first; e; e=e->next) CustomData_bmesh_free_block(&bm->edata, &e->data);
for(f=bm->polys.first; f; f=f->next){
CustomData_bmesh_free_block(&bm->pdata, &f->data);
l = f->loopbase;
do{
CustomData_bmesh_free_block(&bm->ldata, &l->data);
l = l->next;
}while(l!=f->loopbase);
}
/*Free custom data pools, This should probably go in CustomData_free?*/
if(bm->vdata.totlayer) BLI_mempool_destroy(bm->vdata.pool);
if(bm->edata.totlayer) BLI_mempool_destroy(bm->edata.pool);
if(bm->ldata.totlayer) BLI_mempool_destroy(bm->ldata.pool);
if(bm->pdata.totlayer) BLI_mempool_destroy(bm->pdata.pool);
/*free custom data*/
CustomData_free(&bm->vdata,0);
CustomData_free(&bm->edata,0);
CustomData_free(&bm->ldata,0);
CustomData_free(&bm->pdata,0);
/*destroy element pools*/
BLI_mempool_destroy(bm->vpool);
BLI_mempool_destroy(bm->epool);
BLI_mempool_destroy(bm->ppool);
BLI_mempool_destroy(bm->lpool);
MEM_freeN(bm);
}
/**
* \brief End Walker
*
* Frees a walker's worklist.
*/
void BMW_end(BMWalker *walker)
{
BLI_mempool_destroy(walker->worklist);
BLI_gset_free(walker->visit_set, NULL);
BLI_gset_free(walker->visit_set_alt, NULL);
}
void BME_CD_Free(BME_CustomData *data)
{
if(data->pool) BLI_mempool_destroy(data->pool);
}
/**
* \note This function sets the edge indices to invalid values.
*/
void BM_mesh_beautify_fill(
BMesh *bm, BMEdge **edge_array, const int edge_array_len,
const short flag, const short method,
const short oflag_edge, const short oflag_face)
{
Heap *eheap; /* edge heap */
HeapNode **eheap_table; /* edge index aligned table pointing to the eheap */
GSet **edge_state_arr = MEM_callocN((size_t)edge_array_len * sizeof(GSet *), __func__);
BLI_mempool *edge_state_pool = BLI_mempool_create(sizeof(EdRotState), 0, 512, BLI_MEMPOOL_NOP);
int i;
#ifdef DEBUG_TIME
TIMEIT_START(beautify_fill);
#endif
eheap = BLI_heap_new_ex((uint)edge_array_len);
eheap_table = MEM_mallocN(sizeof(HeapNode *) * (size_t)edge_array_len, __func__);
/* build heap */
for (i = 0; i < edge_array_len; i++) {
BMEdge *e = edge_array[i];
const float cost = bm_edge_calc_rotate_beauty(e, flag, method);
if (cost < 0.0f) {
eheap_table[i] = BLI_heap_insert(eheap, cost, e);
}
else {
eheap_table[i] = NULL;
}
BM_elem_index_set(e, i); /* set_dirty */
}
bm->elem_index_dirty |= BM_EDGE;
while (BLI_heap_is_empty(eheap) == false) {
BMEdge *e = BLI_heap_popmin(eheap);
i = BM_elem_index_get(e);
eheap_table[i] = NULL;
BLI_assert(BM_edge_face_count_is_equal(e, 2));
e = BM_edge_rotate(bm, e, false, BM_EDGEROT_CHECK_EXISTS);
BLI_assert(e == NULL || BM_edge_face_count_is_equal(e, 2));
if (LIKELY(e)) {
GSet *e_state_set = edge_state_arr[i];
/* add the new state into the set so we don't move into this state again
* note: we could add the previous state too but this isn't essential)
* for avoiding eternal loops */
EdRotState *e_state = BLI_mempool_alloc(edge_state_pool);
erot_state_current(e, e_state);
if (UNLIKELY(e_state_set == NULL)) {
edge_state_arr[i] = e_state_set = erot_gset_new(); /* store previous state */
}
BLI_assert(BLI_gset_haskey(e_state_set, (void *)e_state) == false);
BLI_gset_insert(e_state_set, e_state);
// printf(" %d -> %d, %d\n", i, BM_elem_index_get(e->v1), BM_elem_index_get(e->v2));
/* maintain the index array */
edge_array[i] = e;
BM_elem_index_set(e, i);
/* recalculate faces connected on the heap */
bm_edge_update_beauty_cost(e, eheap, eheap_table, edge_state_arr,
(const BMEdge **)edge_array, edge_array_len,
flag, method);
/* update flags */
if (oflag_edge) {
BMO_edge_flag_enable(bm, e, oflag_edge);
}
if (oflag_face) {
BMO_face_flag_enable(bm, e->l->f, oflag_face);
BMO_face_flag_enable(bm, e->l->radial_next->f, oflag_face);
}
}
}
BLI_heap_free(eheap, NULL);
MEM_freeN(eheap_table);
for (i = 0; i < edge_array_len; i++) {
if (edge_state_arr[i]) {
BLI_gset_free(edge_state_arr[i], NULL);
}
}
MEM_freeN(edge_state_arr);
BLI_mempool_destroy(edge_state_pool);
#ifdef DEBUG_TIME
TIMEIT_END(beautify_fill);
#endif
}
/**
* \brief End Walker
*
* Frees a walker's worklist.
*/
void BMW_end(BMWalker *walker)
{
BLI_mempool_destroy(walker->worklist);
BLI_ghash_free(walker->visithash, NULL, NULL);
BLI_ghash_free(walker->secvisithash, NULL, NULL);
}
