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); } }
struct ImBuf * seq_stripelem_cache_get( SeqRenderData context, struct Sequence * seq, float cfra, seq_stripelem_ibuf_t type) { seqCacheKey key; seqCacheEntry * e; if (!seq) { return NULL; } if (!entrypool) { seq_stripelem_cache_init(); } key.seq = seq; key.context = context; key.cfra = cfra - seq->start; key.type = type; e = (seqCacheEntry*) BLI_ghash_lookup(hash, &key); if (e && e->ibuf) { IMB_refImBuf(e->ibuf); MEM_CacheLimiter_touch(e->c_handle); return e->ibuf; } return NULL; }
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; }
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; }
Base *BKE_view_layer_base_find(ViewLayer *view_layer, Object *ob) { if (!view_layer->object_bases_hash) { view_layer_bases_hash_create(view_layer); } return BLI_ghash_lookup(view_layer->object_bases_hash, ob); }
GPUFunction *GPU_lookup_function(const char *name) { if (!FUNCTION_HASH) { FUNCTION_HASH = BLI_ghash_str_new("GPU_lookup_function gh"); gpu_parse_functions_string(FUNCTION_HASH, glsl_material_library); } return (GPUFunction*)BLI_ghash_lookup(FUNCTION_HASH, (void *)name); }
int rna_builtin_properties_lookup_string(PointerRNA *ptr, const char *key, PointerRNA *r_ptr) { StructRNA *srna; PropertyRNA *prop; PointerRNA propptr= {{NULL}}; srna= ptr->type; do { if(srna->cont.prophash) { prop= BLI_ghash_lookup(srna->cont.prophash, (void*)key); if(prop) { propptr.type= &RNA_Property; propptr.data= prop; *r_ptr= propptr; return TRUE; } } else { for(prop=srna->cont.properties.first; prop; prop=prop->next) { if(!(prop->flag & PROP_BUILTIN) && strcmp(prop->identifier, key)==0) { propptr.type= &RNA_Property; propptr.data= prop; *r_ptr= propptr; return TRUE; } } } } while((srna=srna->base)); /* this was used pre 2.5beta0, now ID property access uses python's * getitem style access * - ob["foo"] rather than ob.foo */ #if 0 if(ptr->data) { IDProperty *group, *idp; group= RNA_struct_idprops(ptr, 0); if(group) { for(idp=group->data.group.first; idp; idp=idp->next) { if(strcmp(idp->name, key) == 0) { propptr.type= &RNA_Property; propptr.data= idp; *r_ptr= propptr; return TRUE; } } } } #endif return FALSE; }
static bArgument *lookUp(struct bArgs *ba, const char *arg, int pass, int case_str) { bAKey key; key.case_str = case_str; key.pass = pass; key.arg = arg; return BLI_ghash_lookup(ba->items, &key); }
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); }
/** * Return a pointer to the pose channel of the given name * from this pose. */ bPoseChannel *BKE_pose_channel_find_name(const bPose *pose, const char *name) { if (ELEM(NULL, pose, name) || (name[0] == '\0')) return NULL; if (pose->chanhash) return BLI_ghash_lookup(pose->chanhash, (const void *)name); return BLI_findstring(&((const bPose *)pose)->chanbase, name, offsetof(bPoseChannel, name)); }
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; }
bool IMB_moviecache_has_frame(MovieCache *cache, void *userkey) { MovieCacheKey key; MovieCacheItem *item; key.cache_owner = cache; key.userkey = userkey; item = (MovieCacheItem *)BLI_ghash_lookup(cache->hash, &key); return item != NULL; }
GPUFunction *GPU_lookup_function(const char *name) { if (!FUNCTION_HASH) { FUNCTION_HASH = BLI_ghash_str_new("GPU_lookup_function gh"); gpu_parse_functions_string(FUNCTION_HASH, glsl_material_library); /*FUNCTION_PROTOTYPES = gpu_generate_function_prototyps(FUNCTION_HASH); FUNCTION_LIB = GPU_shader_create_lib(datatoc_gpu_shader_material_glsl);*/ } return (GPUFunction*)BLI_ghash_lookup(FUNCTION_HASH, (void *)name); }
static TseGroup *BKE_outliner_treehash_lookup_group(GHash *th, short type, short nr, struct ID *id) { TreeStoreElem tse_template; tse_template.type = type; tse_template.nr = type ? nr : 0; // we're picky! :) tse_template.id = id; BLI_assert(th); return BLI_ghash_lookup(th, &tse_template); }
Icon *BKE_icon_get(int icon_id) { Icon *icon = NULL; icon = BLI_ghash_lookup(gIcons, SET_INT_IN_POINTER(icon_id)); if (!icon) { printf("%s: Internal error, no icon for icon ID: %d\n", __func__, icon_id); return NULL; } return icon; }
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); }
bool BKE_pose_channels_is_valid(const bPose *pose) { if (pose->chanhash) { bPoseChannel *pchan; for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) { if (BLI_ghash_lookup(pose->chanhash, pchan->name) != pchan) { return false; } } } return true; }
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 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); } }
/* 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)); } }
MenuType *WM_menutype_find(const char *idname, int quiet) { MenuType* mt; if (idname[0]) { mt= BLI_ghash_lookup(menutypes_hash, idname); if(mt) return mt; } if(!quiet) printf("search for unknown menutype %s\n", idname); return NULL; }
/** * Helper function for #postEditBoneDuplicate, * return the destination pchan from the original. */ static bPoseChannel *pchan_duplicate_map(const bPose *pose, GHash *name_map, bPoseChannel *pchan_src) { bPoseChannel *pchan_dst = NULL; const char *name_src = pchan_src->name; const char *name_dst = BLI_ghash_lookup(name_map, name_src); if (name_dst) { pchan_dst = BKE_pose_channel_find_name(pose, name_dst); } if (pchan_dst == NULL) { pchan_dst = pchan_src; } return pchan_dst; }
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)++; }
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; } }
uiListType *WM_uilisttype_find(const char *idname, bool quiet) { uiListType *ult; if (idname[0]) { ult = BLI_ghash_lookup(uilisttypes_hash, idname); if (ult) { return ult; } } if (!quiet) { printf("search for unknown uilisttype %s\n", idname); } return NULL; }
int sample_sss(Render *re, Material *mat, const float co[3], float color[3]) { if (re->sss_hash) { SSSData *sss= BLI_ghash_lookup(re->sss_hash, mat); if (sss) { scatter_tree_sample(sss->tree, co, color); return 1; } else { color[0]= 0.0f; color[1]= 0.0f; color[2]= 0.0f; } } return 0; }
/* create an id for a new icon and make sure that ids from deleted icons get reused * after the integer number range is used up */ static int get_next_free_id(void) { int startId = gFirstIconId; /* if we haven't used up the int number range, we just return the next int */ if (gNextIconId >= gFirstIconId) return gNextIconId++; /* now we try to find the smallest icon id not stored in the gIcons hash */ while (BLI_ghash_lookup(gIcons, SET_INT_IN_POINTER(startId)) && startId >= gFirstIconId) startId++; /* if we found a suitable one that isn't used yet, return it */ if (startId >= gFirstIconId) return startId; /* fail */ return 0; }
void BKE_icon_changed(int id) { Icon *icon = NULL; if (!id || G.background) return; icon = BLI_ghash_lookup(gIcons, SET_INT_IN_POINTER(id)); if (icon) { PreviewImage *prv = BKE_previewimg_id_ensure((ID *)icon->obj); /* all previews changed */ if (prv) { int i; for (i = 0; i < NUM_ICON_SIZES; ++i) { prv->flag[i] |= PRV_CHANGED; prv->changed_timestamp[i]++; } } } }
const char *BPY_app_translations_py_pgettext(const char *msgctxt, const char *msgid) { #define STATIC_LOCALE_SIZE 32 /* Should be more than enough! */ GHashKey *key; static char locale[STATIC_LOCALE_SIZE] = ""; const char *tmp; /* Just in case, should never happen! */ if (!_translations) return msgid; tmp = BLF_lang_get(); if (strcmp(tmp, locale) || !_translations_cache) { PyGILState_STATE _py_state; BLI_strncpy(locale, tmp, STATIC_LOCALE_SIZE); /* Locale changed or cache does not exist, refresh the whole cache! */ /* This func may be called from C (i.e. outside of python interpreter 'context'). */ _py_state = PyGILState_Ensure(); _build_translations_cache(_translations->py_messages, locale); PyGILState_Release(_py_state); } /* And now, simply create the key (context, messageid) and find it in the cached dict! */ key = _ghashutil_keyalloc(msgctxt, msgid); tmp = BLI_ghash_lookup(_translations_cache, key); _ghashutil_keyfree((void *)key); return tmp ? tmp : msgid; #undef STATIC_LOCALE_SIZE }