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;
}
/* 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);
}
/* 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);
}
/**
* Return icon id of given preview, or create new icon if not found.
*/
int BKE_icon_preview_ensure(PreviewImage *preview)
{
Icon *new_icon = NULL;
if (!preview || G.background)
return 0;
if (preview->icon_id)
return preview->icon_id;
preview->icon_id = get_next_free_id();
if (!preview->icon_id) {
printf("%s: Internal error - not enough IDs\n", __func__);
return 0;
}
new_icon = MEM_mallocN(sizeof(Icon), __func__);
new_icon->obj = preview;
new_icon->type = 0; /* Special, tags as non-ID icon/preview. */
/* next two lines make sure image gets created */
new_icon->drawinfo = NULL;
new_icon->drawinfo_free = NULL;
BLI_ghash_insert(gIcons, SET_INT_IN_POINTER(preview->icon_id), new_icon);
return preview->icon_id;
}
int BKE_icon_getid(struct ID* id)
{
Icon* new_icon = NULL;
if (!id || G.background)
return 0;
if (id->icon_id)
return id->icon_id;
id->icon_id = get_next_free_id();
if (!id->icon_id){
printf("BKE_icon_getid: Internal error - not enough IDs\n");
return 0;
}
new_icon = MEM_callocN(sizeof(Icon), "texicon");
new_icon->obj = id;
new_icon->type = GS(id->name);
/* next two lines make sure image gets created */
new_icon->drawinfo = NULL;
new_icon->drawinfo_free = NULL;
BLI_ghash_insert(gIcons, SET_INT_IN_POINTER(id->icon_id), new_icon);
return id->icon_id;
}
void UI_editsource_active_but_test(uiBut *but)
{
extern void PyC_FileAndNum_Safe(const char **filename, int *lineno);
struct uiEditSourceButStore *but_store= MEM_callocN(sizeof(uiEditSourceButStore), __func__);
const char *fn;
int lineno= -1;
#if 0
printf("comparing buttons: '%s' == '%s'\n",
but->drawstr, ui_editsource_info->but_orig.drawstr);
#endif
PyC_FileAndNum_Safe(&fn, &lineno);
if (lineno != -1) {
BLI_strncpy(but_store->py_dbg_fn, fn,
sizeof(but_store->py_dbg_fn));
but_store->py_dbg_ln= lineno;
}
else {
but_store->py_dbg_fn[0]= '\0';
but_store->py_dbg_ln= -1;
}
BLI_ghash_insert(ui_editsource_info->hash, but, but_store);
}
BME_TransData *BME_assign_transdata(BME_TransData_Head *td, BME_Mesh *bm, BME_Vert *v,
float *co, float *org, float *vec, float *loc,
float factor, float weight, float maxfactor, float *max) {
BME_TransData *vtd;
int is_new = 0;
if (v == NULL) return NULL;
if ((vtd = BLI_ghash_lookup(td->gh, v)) == NULL && bm != NULL) {
vtd = BLI_memarena_alloc(td->ma, sizeof(*vtd));
BLI_ghash_insert(td->gh, v, vtd);
td->len++;
is_new = 1;
}
vtd->bm = bm;
vtd->v = v;
if (co != NULL) VECCOPY(vtd->co,co);
if (org == NULL && is_new) { VECCOPY(vtd->org,v->co); } /* default */
else if (org != NULL) VECCOPY(vtd->org,org);
if (vec != NULL) {
VECCOPY(vtd->vec,vec);
normalize_v3(vtd->vec);
}
vtd->loc = loc;
vtd->factor = factor;
vtd->weight = weight;
vtd->maxfactor = maxfactor;
vtd->max = max;
return vtd;
}
static bool ghash_insert_link(
GHash *gh, void *key, void *val, bool use_test,
MemArena *mem_arena)
{
struct LinkBase *ls_base;
LinkNode *ls;
ls_base = BLI_ghash_lookup(gh, key);
if (ls_base) {
if (use_test && (BLI_linklist_index(ls_base->list, key) != -1)) {
return false;
}
}
else {
ls_base = BLI_memarena_alloc(mem_arena, sizeof(*ls_base));
ls_base->list = NULL;
ls_base->list_len = 0;
BLI_ghash_insert(gh, key, ls_base);
}
ls = BLI_memarena_alloc(mem_arena, sizeof(*ls));
ls->next = ls_base->list;
ls->link = val;
ls_base->list = ls;
ls_base->list_len += 1;
return true;
}
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);
}
}
static void internalAdd(struct bArgs *ba, const char *arg, int pass,
int case_str, BA_ArgCallback cb, void *data, bArgDoc *d)
{
bArgument *a;
bAKey *key;
a = lookUp(ba, arg, pass, case_str);
if (a) {
printf("WARNING: conflicting argument\n");
printf("\ttrying to add '%s' on pass %i, %scase sensitive\n",
arg, pass, case_str == 1 ? "not " : "");
printf("\tconflict with '%s' on pass %i, %scase sensitive\n\n",
a->key->arg, (int)a->key->pass, a->key->case_str == 1 ? "not " : "");
}
a = MEM_callocN(sizeof(bArgument), "bArgument");
key = MEM_callocN(sizeof(bAKey), "bAKey");
key->arg = arg;
key->pass = pass;
key->case_str = case_str;
a->key = key;
a->func = cb;
a->data = data;
a->doc = d;
BLI_ghash_insert(ba->items, key, a);
}
/* OB_DUPLIVERTS - FONT */
static Object *find_family_object(const char *family, size_t family_len, unsigned int ch, GHash *family_gh)
{
Object **ob_pt;
Object *ob;
void *ch_key = SET_UINT_IN_POINTER(ch);
if ((ob_pt = (Object **)BLI_ghash_lookup_p(family_gh, ch_key))) {
ob = *ob_pt;
}
else {
char ch_utf8[7];
size_t ch_utf8_len;
ch_utf8_len = BLI_str_utf8_from_unicode(ch, ch_utf8);
ch_utf8[ch_utf8_len] = '\0';
ch_utf8_len += 1; /* compare with null terminator */
for (ob = G.main->object.first; ob; ob = ob->id.next) {
if (STREQLEN(ob->id.name + 2 + family_len, ch_utf8, ch_utf8_len)) {
if (STREQLEN(ob->id.name + 2, family, family_len)) {
break;
}
}
}
/* inserted value can be NULL, just to save searches in future */
BLI_ghash_insert(family_gh, ch_key, ob);
}
return ob;
}
static void gpu_parse_functions_string(GHash *hash, char *code)
{
GPUFunction *function;
int i, type, qual;
while ((code = strstr(code, "void "))) {
function = MEM_callocN(sizeof(GPUFunction), "GPUFunction");
code = gpu_str_skip_token(code, NULL, 0);
code = gpu_str_skip_token(code, function->name, MAX_FUNCTION_NAME);
/* get parameters */
while (*code && *code != ')') {
/* test if it's an input or output */
qual = FUNCTION_QUAL_IN;
if (gpu_str_prefix(code, "out "))
qual = FUNCTION_QUAL_OUT;
if (gpu_str_prefix(code, "inout "))
qual = FUNCTION_QUAL_INOUT;
if ((qual != FUNCTION_QUAL_IN) || gpu_str_prefix(code, "in "))
code = gpu_str_skip_token(code, NULL, 0);
/* test for type */
type= 0;
for (i=1; i<=16; i++) {
if (GPU_DATATYPE_STR[i] && gpu_str_prefix(code, GPU_DATATYPE_STR[i])) {
type= i;
break;
}
}
if (!type && gpu_str_prefix(code, "sampler2DShadow"))
type= GPU_SHADOW2D;
if (!type && gpu_str_prefix(code, "sampler2D"))
type= GPU_TEX2D;
if (type) {
/* add paramater */
code = gpu_str_skip_token(code, NULL, 0);
code = gpu_str_skip_token(code, NULL, 0);
function->paramqual[function->totparam]= qual;
function->paramtype[function->totparam]= type;
function->totparam++;
}
else {
fprintf(stderr, "GPU invalid function parameter in %s.\n", function->name);
break;
}
}
if (function->name[0] == '\0' || function->totparam == 0) {
fprintf(stderr, "GPU functions parse error.\n");
MEM_freeN(function);
break;
}
BLI_ghash_insert(hash, function->name, function);
}
}
static void debug_data_insert(SimDebugData *debug_data, SimDebugElement *elem)
{
SimDebugElement *old_elem = BLI_ghash_lookup(debug_data->gh, elem);
if (old_elem) {
*old_elem = *elem;
MEM_freeN(elem);
}
else
BLI_ghash_insert(debug_data->gh, elem, elem);
}
/**
* Removes the hash for quick lookup of channels, must
* be done when adding/removing channels.
*/
void BKE_pose_channels_hash_make(bPose *pose)
{
if (!pose->chanhash) {
bPoseChannel *pchan;
pose->chanhash = BLI_ghash_str_new("make_pose_chan gh");
for (pchan = pose->chanbase.first; pchan; pchan = pchan->next)
BLI_ghash_insert(pose->chanhash, pchan->name, pchan);
}
}
void make_pose_channels_hash(bPose *pose)
{
if(!pose->chanhash) {
bPoseChannel *pchan;
pose->chanhash= BLI_ghash_new(BLI_ghashutil_strhash, BLI_ghashutil_strcmp, "make_pose_chan gh");
for(pchan=pose->chanbase.first; pchan; pchan=pchan->next)
BLI_ghash_insert(pose->chanhash, pchan->name, pchan);
}
}
static ListBase *edge_isect_ls_ensure(GHash *isect_hash, ScanFillEdge *eed)
{
ListBase *e_ls;
e_ls = BLI_ghash_lookup(isect_hash, eed);
if (e_ls == NULL) {
e_ls = MEM_callocN(sizeof(ListBase), __func__);
BLI_ghash_insert(isect_hash, eed, e_ls);
}
return e_ls;
}
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;
}
}
void BKE_icon_set(int icon_id, struct Icon *icon)
{
Icon *old_icon = NULL;
old_icon = BLI_ghash_lookup(gIcons, SET_INT_IN_POINTER(icon_id));
if (old_icon) {
printf("BKE_icon_set: Internal error, icon already set: %d\n", icon_id);
return;
}
BLI_ghash_insert(gIcons, SET_INT_IN_POINTER(icon_id), icon);
}
/* assign only one texid per buffer to avoid sampling the same texture twice */
static void codegen_set_texid(GHash *bindhash, GPUInput *input, int *texid, void *key)
{
if (BLI_ghash_haskey(bindhash, key)) {
/* Reuse existing texid */
input->texid = GET_INT_FROM_POINTER(BLI_ghash_lookup(bindhash, key));
}
else {
/* Allocate new texid */
input->texid = *texid;
(*texid)++;
input->bindtex = true;
BLI_ghash_insert(bindhash, key, SET_INT_IN_POINTER(input->texid));
}
}
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 tracks_map_insert(TracksMap *map, MovieTrackingTrack *track, void *customdata)
{
MovieTrackingTrack new_track = *track;
new_track.markers = MEM_dupallocN(new_track.markers);
map->tracks[map->ptr] = new_track;
if (customdata)
memcpy(&map->customdata[map->ptr * map->customdata_size], customdata, map->customdata_size);
BLI_ghash_insert(map->hash, &map->tracks[map->ptr], track);
map->ptr++;
}
/**
* Generate a PreviewImage from given file path, using thumbnails management, if not yet existing.
*/
PreviewImage *BKE_previewimg_cached_thumbnail_read(
const char *name, const char *path, const int source, bool force_update)
{
PreviewImage *prv = NULL;
void **prv_p;
prv_p = BLI_ghash_lookup_p(gCachedPreviews, name);
if (prv_p) {
prv = *prv_p;
BLI_assert(prv);
}
if (prv && force_update) {
const char *prv_deferred_data = PRV_DEFERRED_DATA(prv);
if (((int)prv_deferred_data[0] == source) && STREQ(&prv_deferred_data[1], path)) {
/* If same path, no need to re-allocate preview, just clear it up. */
BKE_previewimg_clear(prv);
}
else {
BKE_previewimg_free(&prv);
}
}
if (!prv) {
/* We pack needed data for lazy loading (source type, in a single char, and path). */
const size_t deferred_data_size = strlen(path) + 2;
char *deferred_data;
prv = previewimg_create_ex(deferred_data_size);
deferred_data = PRV_DEFERRED_DATA(prv);
deferred_data[0] = source;
memcpy(&deferred_data[1], path, deferred_data_size - 1);
force_update = true;
}
if (force_update) {
if (prv_p) {
*prv_p = prv;
}
else {
BLI_ghash_insert(gCachedPreviews, BLI_strdup(name), prv);
}
}
return prv;
}
static void strand_shade_refcount(StrandShadeCache *cache, StrandSegment *sseg, StrandVert *svert)
{
GHashPair pair = strand_shade_hash_pair(sseg->obi, svert);
GHashPair *key;
int *refcount= BLI_ghash_lookup(cache->refcounthash, &pair);
if (!refcount) {
key= BLI_memarena_alloc(cache->memarena, sizeof(GHashPair));
*key = pair;
refcount= BLI_memarena_alloc(cache->memarena, sizeof(int));
*refcount= 1;
BLI_ghash_insert(cache->refcounthash, key, refcount);
}
else
(*refcount)++;
}
/**
* Return icon id of given preview, or create new icon if not found.
*/
int BKE_icon_preview_ensure(ID *id, PreviewImage *preview)
{
Icon *new_icon = NULL;
if (!preview || G.background)
return 0;
if (id) {
BLI_assert(BKE_previewimg_id_ensure(id) == preview);
}
if (preview->icon_id) {
BLI_assert(!id || !id->icon_id || id->icon_id == preview->icon_id);
return preview->icon_id;
}
if (id && id->icon_id) {
preview->icon_id = id->icon_id;
return preview->icon_id;
}
preview->icon_id = get_next_free_id();
if (!preview->icon_id) {
printf("%s: Internal error - not enough IDs\n", __func__);
return 0;
}
/* Ensure we synchronize ID icon_id with its previewimage if available, and generate suitable 'ID' icon. */
if (id) {
id->icon_id = preview->icon_id;
return icon_id_ensure_create_icon(id);
}
new_icon = MEM_mallocN(sizeof(Icon), __func__);
new_icon->obj = preview;
new_icon->type = 0; /* Special, tags as non-ID icon/preview. */
/* next two lines make sure image gets created */
new_icon->drawinfo = NULL;
new_icon->drawinfo_free = NULL;
BLI_ghash_insert(gIcons, SET_INT_IN_POINTER(preview->icon_id), new_icon);
return preview->icon_id;
}
static int icon_id_ensure_create_icon(struct ID *id)
{
Icon *new_icon = NULL;
new_icon = MEM_mallocN(sizeof(Icon), __func__);
new_icon->obj = id;
new_icon->type = GS(id->name);
/* next two lines make sure image gets created */
new_icon->drawinfo = NULL;
new_icon->drawinfo_free = NULL;
BLI_ghash_insert(gIcons, SET_INT_IN_POINTER(id->icon_id), new_icon);
return id->icon_id;
}
static void setMPolyMaterial(ExportMeshData *export_data,
MPoly *mpoly,
int which_orig_mesh)
{
Object *orig_object;
GHash *material_hash;
Material *orig_mat;
if (which_orig_mesh == CARVE_MESH_LEFT) {
/* No need to change materian index for faces from left operand */
return;
}
material_hash = export_data->material_hash;
orig_object = which_object(export_data, which_orig_mesh);
/* Set material, based on lookup in hash table. */
orig_mat = give_current_material(orig_object, mpoly->mat_nr + 1);
if (orig_mat) {
/* For faces from right operand check if there's requested material
* in the left operand. And if it is, use index of that material,
* otherwise fallback to first material (material with index=0).
*/
if (!BLI_ghash_haskey(material_hash, orig_mat)) {
int a, mat_nr;
mat_nr = 0;
for (a = 0; a < export_data->ob_left->totcol; a++) {
if (give_current_material(export_data->ob_left, a + 1) == orig_mat) {
mat_nr = a;
break;
}
}
BLI_ghash_insert(material_hash, orig_mat, SET_INT_IN_POINTER(mat_nr));
mpoly->mat_nr = mat_nr;
}
else
mpoly->mat_nr = GET_INT_FROM_POINTER(BLI_ghash_lookup(material_hash, orig_mat));
}
else {
mpoly->mat_nr = 0;
}
}
void postEditBoneDuplicate(struct ListBase *editbones, Object *ob)
{
if (ob->pose == NULL) {
return;
}
BKE_pose_channels_hash_free(ob->pose);
BKE_pose_channels_hash_make(ob->pose);
GHash *name_map = BLI_ghash_str_new(__func__);
for (EditBone *ebone_src = editbones->first; ebone_src; ebone_src = ebone_src->next) {
EditBone *ebone_dst = ebone_src->temp.ebone;
if (!ebone_dst) {
ebone_dst = ED_armature_bone_get_mirrored(editbones, ebone_src);
}
if (ebone_dst) {
BLI_ghash_insert(name_map, ebone_src->name, ebone_dst->name);
}
}
for (EditBone *ebone_src = editbones->first; ebone_src; ebone_src = ebone_src->next) {
EditBone *ebone_dst = ebone_src->temp.ebone;
if (ebone_dst) {
bPoseChannel *pchan_src = BKE_pose_channel_find_name(ob->pose, ebone_src->name);
if (pchan_src) {
bPoseChannel *pchan_dst = BKE_pose_channel_find_name(ob->pose, ebone_dst->name);
if (pchan_dst) {
if (pchan_src->custom_tx) {
pchan_dst->custom_tx = pchan_duplicate_map(ob->pose, name_map, pchan_src->custom_tx);
}
if (pchan_src->bbone_prev) {
pchan_dst->bbone_prev = pchan_duplicate_map(ob->pose, name_map, pchan_src->bbone_prev);
}
if (pchan_src->bbone_next) {
pchan_dst->bbone_next = pchan_duplicate_map(ob->pose, name_map, pchan_src->bbone_next);
}
}
}
}
}
BLI_ghash_free(name_map, NULL, NULL);
}
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);
}
static void view_layer_bases_hash_create(ViewLayer *view_layer)
{
static ThreadMutex hash_lock = BLI_MUTEX_INITIALIZER;
if (view_layer->object_bases_hash == NULL) {
BLI_mutex_lock(&hash_lock);
if (view_layer->object_bases_hash == NULL) {
view_layer->object_bases_hash = BLI_ghash_new(
BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, __func__);
for (Base *base = view_layer->object_bases.first; base; base = base->next) {
if (base->object) {
BLI_ghash_insert(view_layer->object_bases_hash, base->object, base);
}
}
}
BLI_mutex_unlock(&hash_lock);
}
}
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);
}
