static void strand_shade_get(Render *re, StrandShadeCache *cache, ShadeSample *ssamp, StrandSegment *sseg, StrandVert *svert)
{
StrandCacheEntry *entry;
StrandPoint p;
int *refcount;
GHashPair pair = strand_shade_hash_pair(sseg->obi, svert);
entry= BLI_ghash_lookup(cache->resulthash, &pair);
refcount= BLI_ghash_lookup(cache->refcounthash, &pair);
if (!entry) {
/* not shaded yet, shade and insert into hash */
p.t= (sseg->v[1] == svert)? 0.0f: 1.0f;
strand_eval_point(sseg, &p);
strand_shade_point(re, ssamp, sseg, svert, &p);
entry= MEM_callocN(sizeof(StrandCacheEntry), "StrandCacheEntry");
entry->pair = pair;
entry->shr = ssamp->shr[0];
BLI_ghash_insert(cache->resulthash, entry, entry);
}
else
/* already shaded, just copy previous result from hash */
ssamp->shr[0]= entry->shr;
/* lower reference count and remove if not needed anymore by any samples */
(*refcount)--;
if (*refcount == 0) {
BLI_ghash_remove(cache->resulthash, &pair, (GHashKeyFreeFP)MEM_freeN, NULL);
BLI_ghash_remove(cache->refcounthash, &pair, NULL, NULL);
}
}
/* Set the face's unique ID in the log */
static void bm_log_face_id_set(BMLog *log, BMFace *f, unsigned int id)
{
void *fid = SET_INT_IN_POINTER(id);
BLI_ghash_remove(log->id_to_elem, fid, NULL, NULL);
BLI_ghash_insert(log->id_to_elem, fid, f);
BLI_ghash_remove(log->elem_to_id, f, NULL, NULL);
BLI_ghash_insert(log->elem_to_id, f, fid);
}
/* Set the vertex's unique ID in the log */
static void bm_log_vert_id_set(BMLog *log, BMVert *v, unsigned int id)
{
void *vid = SET_INT_IN_POINTER(id);
BLI_ghash_remove(log->id_to_elem, vid, NULL, NULL);
BLI_ghash_insert(log->id_to_elem, vid, v);
BLI_ghash_remove(log->elem_to_id, v, NULL, NULL);
BLI_ghash_insert(log->elem_to_id, v, vid);
}
void strand_shade_unref(StrandShadeCache *cache, ObjectInstanceRen *obi, StrandVert *svert)
{
GHashPair pair = strand_shade_hash_pair(obi, svert);
int *refcount;
/* lower reference count and remove if not needed anymore by any samples */
refcount= BLI_ghash_lookup(cache->refcounthash, &pair);
(*refcount)--;
if (*refcount == 0) {
BLI_ghash_remove(cache->resulthash, &pair, (GHashKeyFreeFP)MEM_freeN, NULL);
BLI_ghash_remove(cache->refcounthash, &pair, NULL, NULL);
}
}
void BKE_icon_id_delete(struct ID *id)
{
if (!id->icon_id) return; /* no icon defined for library object */
BLI_ghash_remove(gIcons, SET_INT_IN_POINTER(id->icon_id), NULL, icon_free);
id->icon_id = 0;
}
bool *BKE_objdef_validmap_get(Object *ob, const int defbase_tot)
{
bDeformGroup *dg;
ModifierData *md;
bool *vgroup_validmap;
GHash *gh;
int i, step1 = 1;
//int defbase_tot = BLI_countlist(&ob->defbase);
if (ob->defbase.first == NULL) {
return NULL;
}
gh = BLI_ghash_str_new("BKE_objdef_validmap_get gh");
/* add all names to a hash table */
for (dg = ob->defbase.first; dg; dg = dg->next) {
BLI_ghash_insert(gh, dg->name, NULL);
}
BLI_assert(BLI_ghash_size(gh) == defbase_tot);
/* now loop through the armature modifiers and identify deform bones */
for (md = ob->modifiers.first; md; md = !md->next && step1 ? (step1 = 0), modifiers_getVirtualModifierList(ob) : md->next) {
if (!(md->mode & (eModifierMode_Realtime | eModifierMode_Virtual)))
continue;
if (md->type == eModifierType_Armature) {
ArmatureModifierData *amd = (ArmatureModifierData *) md;
if (amd->object && amd->object->pose) {
bPose *pose = amd->object->pose;
bPoseChannel *chan;
for (chan = pose->chanbase.first; chan; chan = chan->next) {
if (chan->bone->flag & BONE_NO_DEFORM)
continue;
if (BLI_ghash_remove(gh, chan->name, NULL, NULL)) {
BLI_ghash_insert(gh, chan->name, SET_INT_IN_POINTER(1));
}
}
}
}
}
vgroup_validmap = MEM_mallocN(sizeof(*vgroup_validmap) * defbase_tot, "wpaint valid map");
/* add all names to a hash table */
for (dg = ob->defbase.first, i = 0; dg; dg = dg->next, i++) {
vgroup_validmap[i] = (BLI_ghash_lookup(gh, dg->name) != NULL);
}
BLI_assert(i == BLI_ghash_size(gh));
BLI_ghash_free(gh, NULL, NULL);
return vgroup_validmap;
}
/**
* Update view layer collection tree from collections used in the scene.
* This is used when collections are removed or added, both while editing
* and on file loaded in case linked data changed or went missing.
*/
void BKE_layer_collection_sync(const Scene *scene, ViewLayer *view_layer)
{
if (!scene->master_collection) {
/* Happens for old files that don't have versioning applied yet. */
return;
}
/* Free cache. */
MEM_SAFE_FREE(view_layer->object_bases_array);
/* Create object to base hash if it does not exist yet. */
if (!view_layer->object_bases_hash) {
view_layer_bases_hash_create(view_layer);
}
/* Clear visible and selectable flags to be reset. */
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
base->flag &= ~g_base_collection_flags;
base->flag_from_collection &= ~g_base_collection_flags;
}
/* Generate new layer connections and object bases when collections changed. */
CollectionChild child = {NULL, NULL, scene->master_collection};
const ListBase collections = {&child, &child};
ListBase new_object_bases = {NULL, NULL};
const short parent_exclude = 0, parent_restrict = 0, parent_layer_restrict = 0;
layer_collection_sync(view_layer,
&collections,
&view_layer->layer_collections,
&new_object_bases,
parent_exclude,
parent_restrict,
parent_layer_restrict);
/* Any remaning object bases are to be removed. */
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
if (view_layer->basact == base) {
view_layer->basact = NULL;
}
if (base->object) {
BLI_ghash_remove(view_layer->object_bases_hash, base->object, NULL, NULL);
}
}
BLI_freelistN(&view_layer->object_bases);
view_layer->object_bases = new_object_bases;
/* Always set a valid active collection. */
LayerCollection *active = view_layer->active_collection;
if (active && (active->flag & LAYER_COLLECTION_EXCLUDE)) {
BKE_layer_collection_activate_parent(view_layer, active);
}
else if (active == NULL) {
view_layer->active_collection = view_layer->layer_collections.first;
}
}
void WM_uilisttype_freelink(uiListType *ult)
{
bool ok;
ok = BLI_ghash_remove(uilisttypes_hash, ult->idname, NULL, MEM_freeN);
BLI_assert(ok);
(void)ok;
}
void BKE_sim_debug_data_remove_element(unsigned int hash)
{
SimDebugElement dummy;
if (!_sim_debug_data)
return;
dummy.hash = hash;
BLI_ghash_remove(_sim_debug_data->gh, &dummy, NULL, debug_element_free);
}
void WM_menutype_freelink(MenuType *mt)
{
bool ok;
ok = BLI_ghash_remove(menutypes_hash, mt->idname, NULL, MEM_freeN);
BLI_assert(ok);
(void)ok;
}
static void do_moviecache_put(MovieCache *cache, void *userkey, ImBuf *ibuf, int need_lock)
{
MovieCacheKey *key;
MovieCacheItem *item;
if (!limitor)
IMB_moviecache_init();
IMB_refImBuf(ibuf);
key = BLI_mempool_alloc(cache->keys_pool);
key->cache_owner = cache;
key->userkey = BLI_mempool_alloc(cache->userkeys_pool);
memcpy(key->userkey, userkey, cache->keysize);
item = BLI_mempool_alloc(cache->items_pool);
PRINT("%s: cache '%s' put %p, item %p\n", __func__, cache-> name, ibuf, item);
item->ibuf = ibuf;
item->cache_owner = cache;
item->c_handle = NULL;
item->priority_data = NULL;
if (cache->getprioritydatafp) {
item->priority_data = cache->getprioritydatafp(userkey);
}
BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree);
BLI_ghash_insert(cache->hash, key, item);
if (cache->last_userkey) {
memcpy(cache->last_userkey, userkey, cache->keysize);
}
if (need_lock)
BLI_mutex_lock(&limitor_lock);
item->c_handle = MEM_CacheLimiter_insert(limitor, item);
MEM_CacheLimiter_ref(item->c_handle);
MEM_CacheLimiter_enforce_limits(limitor);
MEM_CacheLimiter_unref(item->c_handle);
if (need_lock)
BLI_mutex_unlock(&limitor_lock);
/* cache limiter can't remove unused keys which points to destoryed values */
check_unused_keys(cache);
if (cache->points) {
MEM_freeN(cache->points);
cache->points = NULL;
}
}
static unsigned int *imb_thread_cache_get_tile(ImThreadTileCache *cache, ImBuf *ibuf, int tx, int ty)
{
ImThreadTile *ttile, lookuptile;
ImGlobalTile *gtile, *replacetile;
int toffs= ibuf->xtiles*ty + tx;
/* test if it is already in our thread local cache */
if((ttile=cache->tiles.first)) {
/* check last used tile before going to hash */
if(ttile->ibuf == ibuf && ttile->tx == tx && ttile->ty == ty)
return ibuf->tiles[toffs];
/* find tile in hash */
lookuptile.ibuf = ibuf;
lookuptile.tx = tx;
lookuptile.ty = ty;
if((ttile=BLI_ghash_lookup(cache->tilehash, &lookuptile))) {
BLI_remlink(&cache->tiles, ttile);
BLI_addhead(&cache->tiles, ttile);
return ibuf->tiles[toffs];
}
}
/* not found, have to do slow lookup in global cache */
if(cache->unused.first == NULL) {
ttile= cache->tiles.last;
replacetile= ttile->global;
BLI_remlink(&cache->tiles, ttile);
BLI_ghash_remove(cache->tilehash, ttile, NULL, NULL);
}
else {
ttile= cache->unused.first;
replacetile= NULL;
BLI_remlink(&cache->unused, ttile);
}
BLI_addhead(&cache->tiles, ttile);
BLI_ghash_insert(cache->tilehash, ttile, ttile);
gtile= imb_global_cache_get_tile(ibuf, tx, ty, replacetile);
ttile->ibuf= gtile->ibuf;
ttile->tx= gtile->tx;
ttile->ty= gtile->ty;
ttile->global= gtile;
return ibuf->tiles[toffs];
}
void BKE_sim_debug_data_clear_category(const char *category)
{
int category_hash = (int)BLI_ghashutil_strhash_p(category);
if (!_sim_debug_data)
return;
if (_sim_debug_data->gh) {
GHashIterator iter;
BLI_ghashIterator_init(&iter, _sim_debug_data->gh);
while (!BLI_ghashIterator_done(&iter)) {
const SimDebugElement *elem = BLI_ghashIterator_getValue(&iter);
BLI_ghashIterator_step(&iter); /* removing invalidates the current iterator, so step before removing */
if (elem->category_hash == category_hash)
BLI_ghash_remove(_sim_debug_data->gh, elem, NULL, debug_element_free);
}
}
}
void seq_stripelem_cache_put(
SeqRenderData context, struct Sequence * seq,
float cfra, seq_stripelem_ibuf_t type, struct ImBuf * i)
{
seqCacheKey * key;
seqCacheEntry * e;
if (!i) {
return;
}
ibufs_in++;
if (!entrypool) {
seq_stripelem_cache_init();
}
key = (seqCacheKey*) BLI_mempool_alloc(keypool);
key->seq = seq;
key->context = context;
key->cfra = cfra - seq->start;
key->type = type;
/* Normally we want our own version, but start and end stills are duplicates of the original. */
if(ELEM(type, SEQ_STRIPELEM_IBUF_STARTSTILL, SEQ_STRIPELEM_IBUF_ENDSTILL)==0)
IMB_refImBuf(i);
e = (seqCacheEntry*) BLI_mempool_alloc(entrypool);
e->ibuf = i;
e->c_handle = NULL;
BLI_ghash_remove(hash, key, HashKeyFree, HashValFree);
BLI_ghash_insert(hash, key, e);
e->c_handle = MEM_CacheLimiter_insert(limitor, e);
MEM_CacheLimiter_ref(e->c_handle);
MEM_CacheLimiter_enforce_limits(limitor);
MEM_CacheLimiter_unref(e->c_handle);
}
void seq_stripelem_cache_put(
SeqRenderData context, struct Sequence * seq,
float cfra, seq_stripelem_ibuf_t type, struct ImBuf * i)
{
seqCacheKey * key;
seqCacheEntry * e;
if (!i) {
return;
}
ibufs_in++;
if (!entrypool) {
seq_stripelem_cache_init();
}
key = (seqCacheKey*) BLI_mempool_alloc(keypool);
key->seq = seq;
key->context = context;
key->cfra = cfra - seq->start;
key->type = type;
IMB_refImBuf(i);
e = (seqCacheEntry*) BLI_mempool_alloc(entrypool);
e->ibuf = i;
e->c_handle = NULL;
BLI_ghash_remove(hash, key, HashKeyFree, HashValFree);
BLI_ghash_insert(hash, key, e);
e->c_handle = MEM_CacheLimiter_insert(limitor, e);
MEM_CacheLimiter_ref(e->c_handle);
MEM_CacheLimiter_enforce_limits(limitor);
MEM_CacheLimiter_unref(e->c_handle);
}
void IMB_moviecache_cleanup(MovieCache *cache, bool (cleanup_check_cb) (ImBuf *ibuf, void *userkey, void *userdata), void *userdata)
{
GHashIterator *iter;
check_unused_keys(cache);
iter = BLI_ghashIterator_new(cache->hash);
while (!BLI_ghashIterator_done(iter)) {
MovieCacheKey *key = BLI_ghashIterator_getKey(iter);
MovieCacheItem *item = BLI_ghashIterator_getValue(iter);
BLI_ghashIterator_step(iter);
if (cleanup_check_cb(item->ibuf, key->userkey, userdata)) {
PRINT("%s: cache '%s' remove item %p\n", __func__, cache->name, item);
BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree);
}
}
BLI_ghashIterator_free(iter);
}
/* external free */
void imb_tile_cache_tile_free(ImBuf *ibuf, int tx, int ty)
{
ImGlobalTile *gtile, lookuptile;
BLI_mutex_lock(&GLOBAL_CACHE.mutex);
lookuptile.ibuf = ibuf;
lookuptile.tx = tx;
lookuptile.ty = ty;
gtile= BLI_ghash_lookup(GLOBAL_CACHE.tilehash, &lookuptile);
if(gtile) {
/* in case another thread is loading this */
while(gtile->loading)
;
BLI_ghash_remove(GLOBAL_CACHE.tilehash, gtile, NULL, NULL);
BLI_remlink(&GLOBAL_CACHE.tiles, gtile);
BLI_addtail(&GLOBAL_CACHE.unused, gtile);
}
BLI_mutex_unlock(&GLOBAL_CACHE.mutex);
}
static void check_unused_keys(MovieCache *cache)
{
GHashIterator *iter;
iter = BLI_ghashIterator_new(cache->hash);
while (!BLI_ghashIterator_done(iter)) {
MovieCacheKey *key = BLI_ghashIterator_getKey(iter);
MovieCacheItem *item = BLI_ghashIterator_getValue(iter);
int remove = 0;
BLI_ghashIterator_step(iter);
remove = !item->ibuf;
if (remove) {
PRINT("%s: cache '%s' remove item %p without buffer\n", __func__, cache->name, item);
}
if (remove)
BLI_ghash_remove(cache->hash, key, moviecache_keyfree, moviecache_valfree);
}
BLI_ghashIterator_free(iter);
}
void fmodifiers_storage_remove(FModifierStackStorage *storage, FModifier *fcm)
{
BLI_assert(storage != NULL);
BLI_ghash_remove((GHash *) storage, fcm, NULL, NULL);
}
/* seems messy, but thats what you get with not using pointers but channel names :) */
void ED_armature_bone_rename(bArmature *arm, const char *oldnamep, const char *newnamep)
{
Object *ob;
char newname[MAXBONENAME];
char oldname[MAXBONENAME];
/* names better differ! */
if (strncmp(oldnamep, newnamep, MAXBONENAME)) {
/* we alter newname string... so make copy */
BLI_strncpy(newname, newnamep, MAXBONENAME);
/* we use oldname for search... so make copy */
BLI_strncpy(oldname, oldnamep, MAXBONENAME);
/* now check if we're in editmode, we need to find the unique name */
if (arm->edbo) {
EditBone *eBone = ED_armature_bone_find_name(arm->edbo, oldname);
if (eBone) {
unique_editbone_name(arm->edbo, newname, NULL);
BLI_strncpy(eBone->name, newname, MAXBONENAME);
}
else {
return;
}
}
else {
Bone *bone = BKE_armature_find_bone_name(arm, oldname);
if (bone) {
unique_bone_name(arm, newname);
BLI_strncpy(bone->name, newname, MAXBONENAME);
}
else {
return;
}
}
/* do entire dbase - objects */
for (ob = G.main->object.first; ob; ob = ob->id.next) {
ModifierData *md;
/* we have the object using the armature */
if (arm == ob->data) {
Object *cob;
/* Rename the pose channel, if it exists */
if (ob->pose) {
bPoseChannel *pchan = BKE_pose_channel_find_name(ob->pose, oldname);
if (pchan) {
GHash *gh = ob->pose->chanhash;
/* remove the old hash entry, and replace with the new name */
if (gh) {
BLI_assert(BLI_ghash_haskey(gh, pchan->name));
BLI_ghash_remove(gh, pchan->name, NULL, NULL);
}
BLI_strncpy(pchan->name, newname, MAXBONENAME);
if (gh) {
BLI_ghash_insert(gh, pchan->name, pchan);
}
}
BLI_assert(BKE_pose_channels_is_valid(ob->pose) == true);
}
/* Update any object constraints to use the new bone name */
for (cob = G.main->object.first; cob; cob = cob->id.next) {
if (cob->constraints.first)
constraint_bone_name_fix(ob, &cob->constraints, oldname, newname);
if (cob->pose) {
bPoseChannel *pchan;
for (pchan = cob->pose->chanbase.first; pchan; pchan = pchan->next) {
constraint_bone_name_fix(ob, &pchan->constraints, oldname, newname);
}
}
}
}
/* See if an object is parented to this armature */
if (ob->parent && (ob->parent->data == arm)) {
if (ob->partype == PARBONE) {
/* bone name in object */
if (!strcmp(ob->parsubstr, oldname))
BLI_strncpy(ob->parsubstr, newname, MAXBONENAME);
}
}
if (modifiers_usesArmature(ob, arm)) {
bDeformGroup *dg = defgroup_find_name(ob, oldname);
if (dg) {
BLI_strncpy(dg->name, newname, MAXBONENAME);
}
}
/* fix modifiers that might be using this name */
for (md = ob->modifiers.first; md; md = md->next) {
switch (md->type) {
case eModifierType_Hook:
{
HookModifierData *hmd = (HookModifierData *)md;
if (hmd->object && (hmd->object->data == arm)) {
if (STREQ(hmd->subtarget, oldname))
BLI_strncpy(hmd->subtarget, newname, MAXBONENAME);
}
break;
}
case eModifierType_UVWarp:
{
UVWarpModifierData *umd = (UVWarpModifierData *)md;
if (umd->object_src && (umd->object_src->data == arm)) {
if (STREQ(umd->bone_src, oldname))
BLI_strncpy(umd->bone_src, newname, MAXBONENAME);
}
if (umd->object_dst && (umd->object_dst->data == arm)) {
if (STREQ(umd->bone_dst, oldname))
BLI_strncpy(umd->bone_dst, newname, MAXBONENAME);
}
break;
}
default:
break;
}
}
}
/* Fix all animdata that may refer to this bone - we can't just do the ones attached to objects, since
* other ID-blocks may have drivers referring to this bone [#29822]
*/
{
BKE_all_animdata_fix_paths_rename(&arm->id, "pose.bones", oldname, newname);
}
/* correct view locking */
{
bScreen *screen;
for (screen = G.main->screen.first; screen; screen = screen->id.next) {
ScrArea *sa;
/* add regions */
for (sa = screen->areabase.first; sa; sa = sa->next) {
SpaceLink *sl;
for (sl = sa->spacedata.first; sl; sl = sl->next) {
if (sl->spacetype == SPACE_VIEW3D) {
View3D *v3d = (View3D *)sl;
if (v3d->ob_centre && v3d->ob_centre->data == arm) {
if (!strcmp(v3d->ob_centre_bone, oldname)) {
BLI_strncpy(v3d->ob_centre_bone, newname, MAXBONENAME);
}
}
}
}
}
}
}
}
}
void WM_menutype_freelink(MenuType* mt)
{
BLI_ghash_remove(menutypes_hash, mt->idname, NULL, (GHashValFreeFP)MEM_freeN);
}
/**
* Selectively remove pose channels.
*/
void BKE_pose_channels_remove(
Object *ob,
bool (*filter_fn)(const char *bone_name, void *user_data), void *user_data)
{
/* Erase any associated pose channel, along with any references to them */
if (ob->pose) {
bPoseChannel *pchan, *pchan_next;
bConstraint *con;
for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan_next) {
pchan_next = pchan->next;
if (filter_fn(pchan->name, user_data)) {
/* Bone itself is being removed */
BKE_pose_channel_free(pchan);
if (ob->pose->chanhash) {
BLI_ghash_remove(ob->pose->chanhash, pchan->name, NULL, NULL);
}
BLI_freelinkN(&ob->pose->chanbase, pchan);
}
else {
/* Maybe something the bone references is being removed instead? */
for (con = pchan->constraints.first; con; con = con->next) {
const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(con);
ListBase targets = {NULL, NULL};
bConstraintTarget *ct;
if (cti && cti->get_constraint_targets) {
cti->get_constraint_targets(con, &targets);
for (ct = targets.first; ct; ct = ct->next) {
if (ct->tar == ob) {
if (ct->subtarget[0]) {
if (filter_fn(ct->subtarget, user_data)) {
con->flag |= CONSTRAINT_DISABLE;
ct->subtarget[0] = 0;
}
}
}
}
if (cti->flush_constraint_targets)
cti->flush_constraint_targets(con, &targets, 0);
}
}
if (pchan->bbone_prev) {
if (filter_fn(pchan->bbone_prev->name, user_data))
pchan->bbone_prev = NULL;
}
if (pchan->bbone_next) {
if (filter_fn(pchan->bbone_next->name, user_data))
pchan->bbone_next = NULL;
}
if (pchan->custom_tx) {
if (filter_fn(pchan->custom_tx->name, user_data))
pchan->custom_tx = NULL;
}
}
}
}
}
static ImGlobalTile *imb_global_cache_get_tile(ImBuf *ibuf, int tx, int ty, ImGlobalTile *replacetile)
{
ImGlobalTile *gtile, lookuptile;
BLI_mutex_lock(&GLOBAL_CACHE.mutex);
if(replacetile)
replacetile->refcount--;
/* find tile in global cache */
lookuptile.ibuf = ibuf;
lookuptile.tx = tx;
lookuptile.ty = ty;
gtile= BLI_ghash_lookup(GLOBAL_CACHE.tilehash, &lookuptile);
if(gtile) {
/* found tile. however it may be in the process of being loaded
by another thread, in that case we do stupid busy loop waiting
for the other thread to load the tile */
gtile->refcount++;
BLI_mutex_unlock(&GLOBAL_CACHE.mutex);
while(gtile->loading)
;
}
else {
/* not found, let's load it from disk */
/* first check if we hit the memory limit */
if(GLOBAL_CACHE.maxmem && GLOBAL_CACHE.totmem > GLOBAL_CACHE.maxmem) {
/* find an existing tile to unload */
for(gtile=GLOBAL_CACHE.tiles.last; gtile; gtile=gtile->prev)
if(gtile->refcount == 0 && gtile->loading == 0)
break;
}
if(gtile) {
/* found a tile to unload */
imb_global_cache_tile_unload(gtile);
BLI_ghash_remove(GLOBAL_CACHE.tilehash, gtile, NULL, NULL);
BLI_remlink(&GLOBAL_CACHE.tiles, gtile);
}
else {
/* allocate a new tile or reuse unused */
if(GLOBAL_CACHE.unused.first) {
gtile= GLOBAL_CACHE.unused.first;
BLI_remlink(&GLOBAL_CACHE.unused, gtile);
}
else
gtile= BLI_memarena_alloc(GLOBAL_CACHE.memarena, sizeof(ImGlobalTile));
}
/* setup new tile */
gtile->ibuf= ibuf;
gtile->tx= tx;
gtile->ty= ty;
gtile->refcount= 1;
gtile->loading= 1;
BLI_ghash_insert(GLOBAL_CACHE.tilehash, gtile, gtile);
BLI_addhead(&GLOBAL_CACHE.tiles, gtile);
/* mark as being loaded and unlock to allow other threads to load too */
GLOBAL_CACHE.totmem += sizeof(unsigned int)*ibuf->tilex*ibuf->tiley;
BLI_mutex_unlock(&GLOBAL_CACHE.mutex);
/* load from disk */
imb_global_cache_tile_load(gtile);
/* mark as done loading */
gtile->loading= 0;
}
return gtile;
}
