自学教程：C++ BLI_findindex函数代码示例

static void rna_Action_fcurve_remove(bAction *act, ReportList *reports, PointerRNA *fcu_ptr){    FCurve *fcu = fcu_ptr->data;    if (fcu->grp) {        if (BLI_findindex(&act->groups, fcu->grp) == -1) {            BKE_reportf(reports, RPT_ERROR, "F-Curve's action group '%s' not found in action '%s'",                        fcu->grp->name, act->id.name + 2);            return;        }        action_groups_remove_channel(act, fcu);        free_fcurve(fcu);        RNA_POINTER_INVALIDATE(fcu_ptr);    }    else {        if (BLI_findindex(&act->curves, fcu) == -1) {            BKE_reportf(reports, RPT_ERROR, "F-Curve not found in action '%s'", act->id.name + 2);            return;        }        BLI_remlink(&act->curves, fcu);        free_fcurve(fcu);        RNA_POINTER_INVALIDATE(fcu_ptr);    }}

/* Get the index of the Keying Set provided, for the given Scene */int ANIM_scene_get_keyingset_index(Scene *scene, KeyingSet *ks){	int index;		/* if no KeyingSet provided, have none */	if (ks == NULL)		return 0;		/* check if the KeyingSet exists in scene list */	if (scene) {		/* get index and if valid, return 		 *	- (absolute) Scene KeyingSets are from (>= 1)		 */		index = BLI_findindex(&scene->keyingsets, ks);		if (index != -1)			return (index + 1);	}		/* still here, so try builtins list too 	 *	- builtins are from (<= -1)	 *	- none/invalid is (= 0)	 */	index = BLI_findindex(&builtin_keyingsets, ks);	if (index != -1)		return -(index + 1);	else		return 0;}

static char *rna_MetaElement_path(PointerRNA *ptr){	MetaBall *mb = ptr->id.data;	MetaElem *ml = ptr->data;	int index = -1;	if (mb->editelems)		index = BLI_findindex(mb->editelems, ml);	if (index == -1)		index = BLI_findindex(&mb->elems, ml);	if (index == -1)		return NULL;	return BLI_sprintfN("elements[%d]", index);}

int BKE_linestyle_color_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m){	if (BLI_findindex(&linestyle->color_modifiers, m) == -1)		return -1;	switch (m->type) {		case LS_MODIFIER_ALONG_STROKE:			MEM_freeN(((LineStyleColorModifier_AlongStroke *)m)->color_ramp);			break;		case LS_MODIFIER_DISTANCE_FROM_CAMERA:			MEM_freeN(((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp);			break;		case LS_MODIFIER_DISTANCE_FROM_OBJECT:			MEM_freeN(((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp);			break;		case LS_MODIFIER_MATERIAL:			MEM_freeN(((LineStyleColorModifier_Material *)m)->color_ramp);			break;		case LS_MODIFIER_TANGENT:			MEM_freeN(((LineStyleColorModifier_Tangent *)m)->color_ramp);			break;		case LS_MODIFIER_NOISE:			MEM_freeN(((LineStyleColorModifier_Noise *)m)->color_ramp);			break;		case LS_MODIFIER_CREASE_ANGLE:			MEM_freeN(((LineStyleColorModifier_CreaseAngle *)m)->color_ramp);			break;		case LS_MODIFIER_CURVATURE_3D:			MEM_freeN(((LineStyleColorModifier_Curvature_3D *)m)->color_ramp);			break;	}	BLI_freelinkN(&linestyle->color_modifiers, m);	return 0;}

int BKE_linestyle_thickness_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m){	if (BLI_findindex(&linestyle->thickness_modifiers, m) == -1)		return -1;	switch (m->type) {		case LS_MODIFIER_ALONG_STROKE:			curvemapping_free(((LineStyleThicknessModifier_AlongStroke *)m)->curve);			break;		case LS_MODIFIER_DISTANCE_FROM_CAMERA:			curvemapping_free(((LineStyleThicknessModifier_DistanceFromCamera *)m)->curve);			break;		case LS_MODIFIER_DISTANCE_FROM_OBJECT:			curvemapping_free(((LineStyleThicknessModifier_DistanceFromObject *)m)->curve);			break;		case LS_MODIFIER_MATERIAL:			curvemapping_free(((LineStyleThicknessModifier_Material *)m)->curve);			break;		case LS_MODIFIER_CALLIGRAPHY:			break;		case LS_MODIFIER_TANGENT:			curvemapping_free(((LineStyleThicknessModifier_Tangent *)m)->curve);			break;		case LS_MODIFIER_NOISE:			break;		case LS_MODIFIER_CREASE_ANGLE:			break;		case LS_MODIFIER_CURVATURE_3D:			break;	}	BLI_freelinkN(&linestyle->thickness_modifiers, m);	return 0;}

static void set_vertex_channel(float *channel, float time, struct Scene *scene, struct FluidObject *fobj, int i){	Object *ob = fobj->object;	FluidsimModifierData *fluidmd = (FluidsimModifierData *)modifiers_findByType(ob, eModifierType_Fluidsim);	float *verts;	int *tris=NULL, numVerts=0, numTris=0;	int modifierIndex = BLI_findindex(&ob->modifiers, fluidmd);	int framesize = (3*fobj->numVerts) + 1;	int j;		if (channel == NULL)		return;		initElbeemMesh(scene, ob, &numVerts, &verts, &numTris, &tris, 1, modifierIndex);		/* don't allow mesh to change number of verts in anim sequence */	if (numVerts != fobj->numVerts) {		MEM_freeN(channel);		channel = NULL;		return;	}		/* fill frame of channel with vertex locations */	for (j=0; j < (3*numVerts); j++) {		channel[i*framesize + j] = verts[j];	}	channel[i*framesize + framesize-1] = time;		MEM_freeN(verts);	MEM_freeN(tris);}

bNodeSocket *ntreeCompositOutputFileAddSocket(bNodeTree *ntree, bNode *node, const char *name, ImageFormatData *im_format){	NodeImageMultiFile *nimf = node->storage;	bNodeSocket *sock = nodeAddSocket(ntree, node, SOCK_IN, "", SOCK_RGBA);		/* create format data for the input socket */	NodeImageMultiFileSocket *sockdata = MEM_callocN(sizeof(NodeImageMultiFileSocket), "socket image format");	sock->storage = sockdata;		BLI_strncpy_utf8(sockdata->path, name, sizeof(sockdata->path));	ntreeCompositOutputFileUniquePath(&node->inputs, sock, name, '_');	BLI_strncpy_utf8(sockdata->layer, name, sizeof(sockdata->layer));	ntreeCompositOutputFileUniqueLayer(&node->inputs, sock, name, '_');		if (im_format) {		sockdata->format= *im_format;		if (BKE_imtype_is_movie(sockdata->format.imtype)) {			sockdata->format.imtype= R_IMF_IMTYPE_OPENEXR;		}	}	else		BKE_imformat_defaults(&sockdata->format);	/* use node data format by default */	sockdata->use_node_format = TRUE;		nimf->active_input = BLI_findindex(&node->inputs, sock);		return sock;}

/* Remove the given bone-group (expects 'virtual' index (+1 one, used by active_group etc.)) * index might be invalid ( < 1), in which case it will be find from grp. */void BKE_pose_remove_group(bPose *pose, bActionGroup *grp, const int index){	bPoseChannel *pchan;	int idx = index;		if (idx < 1) {		idx = BLI_findindex(&pose->agroups, grp) + 1;	}		BLI_assert(idx > 0);		/* adjust group references (the trouble of using indices!):	 *  - firstly, make sure nothing references it	 *  - also, make sure that those after this item get corrected	 */	for (pchan = pose->chanbase.first; pchan; pchan = pchan->next) {		if (pchan->agrp_index == idx)			pchan->agrp_index = 0;		else if (pchan->agrp_index > idx)			pchan->agrp_index--;	}	/* now, remove it from the pose */	BLI_freelinkN(&pose->agroups, grp);	if (pose->active_group >= idx) {		const bool has_groups = !BLI_listbase_is_empty(&pose->agroups);		pose->active_group--;		if (pose->active_group == 0 && has_groups) {			pose->active_group = 1;		}		else if (pose->active_group < 0 || !has_groups) {			pose->active_group = 0;		}	}}

static int rna_GPencil_active_layer_index_get(PointerRNA *ptr){	bGPdata *gpd = (bGPdata *)ptr->id.data;	bGPDlayer *gpl = gpencil_layer_getactive(gpd);		return BLI_findindex(&gpd->layers, gpl);}

static int tree_element_active_sequence(bContext *C, Scene *scene, TreeElement *te, TreeStoreElem *UNUSED(tselem), int set){	Sequence *seq = (Sequence *) te->directdata;	Editing *ed = BKE_sequencer_editing_get(scene, FALSE);	if (set) {		/* only check on setting */		if (BLI_findindex(ed->seqbasep, seq) != -1) {			if (set == 2) {				BKE_sequencer_active_set(scene, NULL);			}			ED_sequencer_deselect_all(scene);			if (set == 2 && seq->flag & SELECT) {				seq->flag &= ~SELECT;			}			else {				seq->flag |= SELECT;				BKE_sequencer_active_set(scene, seq);			}		}		WM_event_add_notifier(C, NC_SCENE | ND_SEQUENCER | NA_SELECTED, scene);	}	else {		if (ed->act_seq == seq && seq->flag & SELECT) {			return 1;		}	}	return(0);}

static uiBlock *ui_block_func_PIE(bContext *UNUSED(C), uiPopupBlockHandle *handle, void *arg_pie){	uiBlock *block;	uiPieMenu *pie = arg_pie;	int minwidth, width, height;	minwidth = 50;	block = pie->block_radial;	/* in some cases we create the block before the region,	 * so we set it delayed here if necessary */	if (BLI_findindex(&handle->region->uiblocks, block) == -1)		UI_block_region_set(block, handle->region);	UI_block_layout_resolve(block, &width, &height);	UI_block_flag_enable(block, UI_BLOCK_LOOP | UI_BLOCK_NUMSELECT);	block->minbounds = minwidth;	block->bounds = 1;	block->mx = 0;	block->my = 0;	block->bounds_type = UI_BLOCK_BOUNDS_PIE_CENTER;	block->pie_data.pie_center_spawned[0] = pie->mx;	block->pie_data.pie_center_spawned[1] = pie->my;	return pie->block_radial;}

int BKE_linestyle_geometry_modifier_remove(FreestyleLineStyle *linestyle, LineStyleModifier *m){	if (BLI_findindex(&linestyle->geometry_modifiers, m) == -1)		return -1;	BLI_freelinkN(&linestyle->geometry_modifiers, m);	return 0;}

void buttons_texture_context_compute(const bContext *C, SpaceProperties *sbuts){  /* gather available texture users in context. runs on every draw of   * properties editor, before the buttons are created. */  ButsContextTexture *ct = sbuts->texuser;  ID *pinid = sbuts->pinid;  if (!ct) {    ct = MEM_callocN(sizeof(ButsContextTexture), "ButsContextTexture");    sbuts->texuser = ct;  }  else {    BLI_freelistN(&ct->users);  }  buttons_texture_users_from_context(&ct->users, C, sbuts);  if (pinid && GS(pinid->name) == ID_TE) {    ct->user = NULL;    ct->texture = (Tex *)pinid;  }  else {    /* set one user as active based on active index */    if (ct->index >= BLI_listbase_count_at_most(&ct->users, ct->index + 1)) {      ct->index = 0;    }    ct->user = BLI_findlink(&ct->users, ct->index);    ct->texture = NULL;    if (ct->user) {      if (ct->user->ptr.data) {        PointerRNA texptr;        Tex *tex;        /* get texture datablock pointer if it's a property */        texptr = RNA_property_pointer_get(&ct->user->ptr, ct->user->prop);        tex = (RNA_struct_is_a(texptr.type, &RNA_Texture)) ? texptr.data : NULL;        ct->texture = tex;      }      else if (ct->user->node && !(ct->user->node->flag & NODE_ACTIVE_TEXTURE)) {        ButsTextureUser *user;        /* detect change of active texture node in same node tree, in that         * case we also automatically switch to the other node */        for (user = ct->users.first; user; user = user->next) {          if (user->ntree == ct->user->ntree && user->node != ct->user->node) {            if (user->node->flag & NODE_ACTIVE_TEXTURE) {              ct->user = user;              ct->index = BLI_findindex(&ct->users, user);              break;            }          }        }      }    }  }}

static void rna_RenderSlot_clear(ID *id, RenderSlot *slot, ImageUser *iuser){  Image *image = (Image *)id;  int index = BLI_findindex(&image->renderslots, slot);  BKE_image_clear_renderslot(image, iuser, index);  WM_main_add_notifier(NC_IMAGE | ND_DISPLAY, image);}

/** * Checks that /a vlink is linked into listbase, removing it from there if so. */bool BLI_remlink_safe(ListBase *listbase, void *vlink){	if (BLI_findindex(listbase, vlink) != -1) {		BLI_remlink(listbase, vlink);		return true;	}	else {		return false;	}}

int BKE_sequence_modifier_remove(Sequence *seq, SequenceModifierData *smd){	if (BLI_findindex(&seq->modifiers, smd) == -1)		return FALSE;	BLI_remlink(&seq->modifiers, smd);	BKE_sequence_modifier_free(smd);	return TRUE;}

void text_drawcache_tag_update(SpaceText *st, int full){	/* this happens if text editor ops are caled from python */	if (st == NULL)		return;			if (st->drawcache) {		DrawCache *drawcache = (DrawCache *)st->drawcache;		Text *txt = st->text;		if (drawcache->update_flag) {			/* happens when tagging update from space listener */			/* should do nothing to prevent locally tagged cache be fully recalculated */			return;		}		if (!full) {			int sellno = BLI_findindex(&txt->lines, txt->sell);			int curlno = BLI_findindex(&txt->lines, txt->curl);			if (curlno < sellno) {				drawcache->valid_head = curlno;				drawcache->valid_tail = drawcache->nlines - sellno - 1;			}			else {				drawcache->valid_head = sellno;				drawcache->valid_tail = drawcache->nlines - curlno - 1;			}			/* quick cache recalculation is also used in delete operator,			 * which could merge lines which are adjacent to current selection lines			 * expand recalculate area to this lines */			if (drawcache->valid_head > 0) drawcache->valid_head--;			if (drawcache->valid_tail > 0) drawcache->valid_tail--;		}		else {			drawcache->valid_head = 0;			drawcache->valid_tail = 0;		}		drawcache->update_flag = 1;	}}

bool BKE_sequence_modifier_remove(Sequence *seq, SequenceModifierData *smd){	if (BLI_findindex(&seq->modifiers, smd) == -1)		return false;	BLI_remlink(&seq->modifiers, smd);	BKE_sequence_modifier_free(smd);	return true;}

int BLI_remlink_safe(ListBase *listbase, void *vlink){	if (BLI_findindex(listbase, vlink) != -1) {		BLI_remlink(listbase, vlink);		return 1;	}	else {		return 0;	}}

static void rna_MaskLayer_active_spline_set(PointerRNA *ptr, PointerRNA value){	MaskLayer *masklay = (MaskLayer *)ptr->data;	MaskSpline *spline = (MaskSpline *)value.data;	int index = BLI_findindex(&masklay->splines, spline);	if (index >= 0)		masklay->act_spline = spline;	else		masklay->act_spline = NULL;}

static void ED_object_shape_key_add(bContext *C, Object *ob, const bool from_mix){	KeyBlock *kb;	if ((kb = BKE_object_shapekey_insert(ob, NULL, from_mix))) {		Key *key = BKE_key_from_object(ob);		/* for absolute shape keys, new keys may not be added last */		ob->shapenr = BLI_findindex(&key->block, kb) + 1;		WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);	}}

int rna_object_shapekey_index_set(ID *id, PointerRNA value, int current){	Key *key = rna_ShapeKey_find_key(id);	if (key) {		int a = BLI_findindex(&key->block, value.data);		if (a != -1) return a;	}		return current;}

void WM_keymap_remove_item(wmKeyMap *keymap, wmKeyMapItem *kmi){	if(BLI_findindex(&keymap->items, kmi) != -1) {		if(kmi->ptr) {			WM_operator_properties_free(kmi->ptr);			MEM_freeN(kmi->ptr);		}		BLI_freelinkN(&keymap->items, kmi);		WM_keyconfig_update_tag(keymap, kmi);	}}

/** * /note, ideally we can get the area from the context, * there are a few places however where this isn't practical. */ScrArea *BKE_screen_find_area_from_space(struct bScreen *sc, SpaceLink *sl){	ScrArea *sa;	for (sa = sc->areabase.first; sa; sa = sa->next) {		if (BLI_findindex(&sa->spacedata, sl) != -1) {			break;		}	}	return sa;}

static void rna_render_slots_active_set(PointerRNA *ptr,                                        PointerRNA value,                                        struct ReportList *UNUSED(reports)){  Image *image = (Image *)ptr->id.data;  if (value.id.data == image) {    RenderSlot *slot = (RenderSlot *)value.data;    int index = BLI_findindex(&image->renderslots, slot);    if (index != -1)      image->render_slot = index;  }}

static void sequence_cb(int event, TreeElement *te, TreeStoreElem *tselem, void *scene_ptr){	Sequence *seq = (Sequence *)te->directdata;	if (event == 1) {		Scene *scene = (Scene *)scene_ptr;		Editing *ed = BKE_sequencer_editing_get(scene, false);		if (BLI_findindex(ed->seqbasep, seq) != -1) {			ED_sequencer_select_sequence_single(scene, seq, true);		}	}	(void)tselem;}

static void rna_Mask_layers_remove(Mask *mask, ReportList *reports, PointerRNA *masklay_ptr){	MaskLayer *masklay = masklay_ptr->data;	if (BLI_findindex(&mask->masklayers, masklay) == -1) {		BKE_reportf(reports, RPT_ERROR, "Mask layer '%s' not found in mask '%s'", masklay->name, mask->id.name + 2);		return;	}	BKE_mask_layer_remove(mask, masklay);	RNA_POINTER_INVALIDATE(masklay_ptr);	WM_main_add_notifier(NC_MASK | NA_EDITED, mask);}