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

void BKE_linestyle_init(FreestyleLineStyle *linestyle){	BLI_assert(MEMCMP_STRUCT_OFS_IS_ZERO(linestyle, id));	linestyle->panel = LS_PANEL_STROKES;	linestyle->r = linestyle->g = linestyle->b = 0.0f;	linestyle->alpha = 1.0f;	linestyle->thickness = 3.0f;	linestyle->thickness_position = LS_THICKNESS_CENTER;	linestyle->thickness_ratio = 0.5f;	linestyle->flag = LS_SAME_OBJECT | LS_NO_SORTING | LS_TEXTURE;	linestyle->chaining = LS_CHAINING_PLAIN;	linestyle->rounds = 3;	linestyle->min_angle = DEG2RADF(0.0f);	linestyle->max_angle = DEG2RADF(0.0f);	linestyle->min_length = 0.0f;	linestyle->max_length = 10000.0f;	linestyle->split_length = 100;	linestyle->chain_count = 10;	linestyle->sort_key = LS_SORT_KEY_DISTANCE_FROM_CAMERA;	linestyle->integration_type = LS_INTEGRATION_MEAN;	linestyle->texstep = 1.0f;	linestyle->pr_texture = TEX_PR_TEXTURE;	BLI_listbase_clear(&linestyle->color_modifiers);	BLI_listbase_clear(&linestyle->alpha_modifiers);	BLI_listbase_clear(&linestyle->thickness_modifiers);	BLI_listbase_clear(&linestyle->geometry_modifiers);	BKE_linestyle_geometry_modifier_add(linestyle, NULL, LS_MODIFIER_SAMPLING);	linestyle->caps = LS_CAPS_BUTT;}

/** * Only copy internal data of Collection ID from source * to already allocated/initialized destination. * You probably never want to use that directly, * use #BKE_id_copy or #BKE_id_copy_ex for typical needs. * * WARNING! This function will not handle ID user count! * * /param flag: Copying options (see BKE_library.h's LIB_ID_COPY_... flags for more). */void BKE_collection_copy_data(Main *bmain,                              Collection *collection_dst,                              const Collection *collection_src,                              const int flag){  /* Do not copy collection's preview (same behavior as for objects). */  if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0 && false) { /* XXX TODO temp hack */    BKE_previewimg_id_copy(&collection_dst->id, &collection_src->id);  }  else {    collection_dst->preview = NULL;  }  collection_dst->flag &= ~COLLECTION_HAS_OBJECT_CACHE;  BLI_listbase_clear(&collection_dst->object_cache);  BLI_listbase_clear(&collection_dst->gobject);  BLI_listbase_clear(&collection_dst->children);  BLI_listbase_clear(&collection_dst->parents);  for (CollectionChild *child = collection_src->children.first; child; child = child->next) {    collection_child_add(collection_dst, child->collection, flag, false);  }  for (CollectionObject *cob = collection_src->gobject.first; cob; cob = cob->next) {    collection_object_add(bmain, collection_dst, cob->ob, flag, false);  }}

static void default_linestyle_settings(FreestyleLineStyle *linestyle){	linestyle->panel = LS_PANEL_STROKES;	linestyle->r = linestyle->g = linestyle->b = 0.0f;	linestyle->alpha = 1.0f;	linestyle->thickness = 3.0f;	linestyle->thickness_position = LS_THICKNESS_CENTER;	linestyle->thickness_ratio = 0.5f;	linestyle->flag = LS_SAME_OBJECT | LS_NO_SORTING;	linestyle->chaining = LS_CHAINING_PLAIN;	linestyle->rounds = 3;	linestyle->min_angle = DEG2RADF(0.0f);	linestyle->max_angle = DEG2RADF(0.0f);	linestyle->min_length = 0.0f;	linestyle->max_length = 10000.0f;	linestyle->split_length = 100;	linestyle->sort_key = LS_SORT_KEY_DISTANCE_FROM_CAMERA;	linestyle->integration_type = LS_INTEGRATION_MEAN;	BLI_listbase_clear(&linestyle->color_modifiers);	BLI_listbase_clear(&linestyle->alpha_modifiers);	BLI_listbase_clear(&linestyle->thickness_modifiers);	BLI_listbase_clear(&linestyle->geometry_modifiers);	BKE_add_linestyle_geometry_modifier(linestyle, LS_MODIFIER_SAMPLING);	linestyle->caps = LS_CAPS_BUTT;}

void BLI_scanfill_end(ScanFillContext *sf_ctx){	BLI_memarena_free(sf_ctx->arena);	sf_ctx->arena = NULL;	BLI_listbase_clear(&sf_ctx->fillvertbase);	BLI_listbase_clear(&sf_ctx->filledgebase);	BLI_listbase_clear(&sf_ctx->fillfacebase);}

void BLI_scanfill_end_arena(ScanFillContext *sf_ctx, MemArena *arena){	BLI_memarena_clear(arena);	BLI_assert(sf_ctx->arena == arena);	BLI_listbase_clear(&sf_ctx->fillvertbase);	BLI_listbase_clear(&sf_ctx->filledgebase);	BLI_listbase_clear(&sf_ctx->fillfacebase);}

static void copy_particle_edit(Scene *scene, Object *ob, ParticleSystem *psys, ParticleSystem *psys_from){	PTCacheEdit *edit_from = psys_from->edit, *edit;	ParticleData *pa;	KEY_K;	POINT_P;		if (!edit_from)		return;		edit = MEM_dupallocN(edit_from);	edit->psys = psys;	psys->edit = edit;		edit->pathcache = NULL;	BLI_listbase_clear(&edit->pathcachebufs);		edit->emitter_field = NULL;	edit->emitter_cosnos = NULL;		BLI_listbase_clear(&edit->undo);	edit->curundo = NULL;		edit->points = MEM_dupallocN(edit_from->points);	pa = psys->particles;	LOOP_POINTS {		HairKey *hkey = pa->hair;				point->keys= MEM_dupallocN(point->keys);		LOOP_KEYS {			key->co = hkey->co;			key->time = &hkey->time;			key->flag = hkey->editflag;			if (!(psys->flag & PSYS_GLOBAL_HAIR)) {				key->flag |= PEK_USE_WCO;				hkey->editflag |= PEK_USE_WCO;			}						hkey++;		}				pa++;	}	update_world_cos(ob, edit);		UI_GetThemeColor3ubv(TH_EDGE_SELECT, edit->sel_col);	UI_GetThemeColor3ubv(TH_WIRE, edit->nosel_col);		recalc_lengths(edit);	recalc_emitter_field(ob, psys);	PE_update_object(scene, ob, true);		PTCacheUndo_clear(edit);	PE_undo_push(scene, "Original");}

/* Bake */void RE_bake_engine_set_engine_parameters(Render *re, Main *bmain, Scene *scene){	re->scene = scene;	re->main = bmain;	re->r = scene->r;	/* prevent crash when freeing the scene	 * but it potentially leaves unfreed memory blocks	 * not sure how to fix this yet -- dfelinto */	BLI_listbase_clear(&re->r.layers);	BLI_listbase_clear(&re->r.views);}

/* make a copy of a given gpencil datablock */bGPdata *gpencil_data_duplicate(bGPdata *src, bool internal_copy){    bGPDlayer *gpl, *gpld;    bGPdata *dst;    /* error checking */    if (src == NULL)        return NULL;    /* make a copy of the base-data */    if (internal_copy) {        /* make a straight copy for undo buffers used during stroke drawing */        dst = MEM_dupallocN(src);    }    else {        /* make a copy when others use this */        dst = BKE_libblock_copy(&src->id);    }    /* copy layers */    BLI_listbase_clear(&dst->layers);    for (gpl = src->layers.first; gpl; gpl = gpl->next) {        /* make a copy of source layer and its data */        gpld = gpencil_layer_duplicate(gpl);        BLI_addtail(&dst->layers, gpld);    }    /* return new */    return dst;}

// XXX find some header to put this in!void free_anim_copybuf(void){	tAnimCopybufItem *aci, *acn;		/* free each buffer element */	for (aci = animcopybuf.first; aci; aci = acn) {		acn = aci->next;				/* free keyframes */		if (aci->bezt) 			MEM_freeN(aci->bezt);					/* free RNA-path */		if (aci->rna_path)			MEM_freeN(aci->rna_path);					/* free ourself */		BLI_freelinkN(&animcopybuf, aci);	}		/* restore initial state */	BLI_listbase_clear(&animcopybuf);	animcopy_firstframe = 999999999.0f;	animcopy_lastframe = -999999999.0f;}

World *localize_world(World *wrld){	World *wrldn;	int a;		wrldn = BKE_libblock_copy_nolib(&wrld->id, false);		for (a = 0; a < MAX_MTEX; a++) {		if (wrld->mtex[a]) {			wrldn->mtex[a] = MEM_mallocN(sizeof(MTex), "localize_world");			memcpy(wrldn->mtex[a], wrld->mtex[a], sizeof(MTex));			/* free world decrements */			id_us_plus((ID *)wrldn->mtex[a]->tex);		}	}	if (wrld->nodetree)		wrldn->nodetree = ntreeLocalize(wrld->nodetree);		wrldn->preview = NULL;		BLI_listbase_clear(&wrldn->gpumaterial);		return wrldn;}

World *BKE_world_copy(World *wrld){	World *wrldn;	int a;		wrldn = BKE_libblock_copy(&wrld->id);		for (a = 0; a < MAX_MTEX; a++) {		if (wrld->mtex[a]) {			wrldn->mtex[a] = MEM_mallocN(sizeof(MTex), "BKE_world_copy");			memcpy(wrldn->mtex[a], wrld->mtex[a], sizeof(MTex));			id_us_plus((ID *)wrldn->mtex[a]->tex);		}	}	if (wrld->nodetree) {		wrldn->nodetree = ntreeCopyTree(wrld->nodetree);	}		if (wrld->preview)		wrldn->preview = BKE_previewimg_copy(wrld->preview);	BLI_listbase_clear(&wrldn->gpumaterial);	if (wrld->id.lib) {		BKE_id_lib_local_paths(G.main, wrld->id.lib, &wrldn->id);	}	return wrldn;}

/* Duplicate all of the F-Modifiers in the Modifier stacks */void copy_fmodifiers(ListBase *dst, const ListBase *src){  FModifier *fcm, *srcfcm;  if (ELEM(NULL, dst, src)) {    return;  }  BLI_listbase_clear(dst);  BLI_duplicatelist(dst, src);  for (fcm = dst->first, srcfcm = src->first; fcm && srcfcm;       srcfcm = srcfcm->next, fcm = fcm->next) {    const FModifierTypeInfo *fmi = fmodifier_get_typeinfo(fcm);    /* make a new copy of the F-Modifier's data */    fcm->data = MEM_dupallocN(fcm->data);    fcm->curve = NULL;    /* only do specific constraints if required */    if (fmi && fmi->copy_data) {      fmi->copy_data(fcm, srcfcm);    }  }}

void BLI_init_threads(ListBase *threadbase, void *(*do_thread)(void *), int tot){	int a;	if (threadbase != NULL && tot > 0) {		BLI_listbase_clear(threadbase);			if (tot > RE_MAX_THREAD) tot = RE_MAX_THREAD;		else if (tot < 1) tot = 1;			for (a = 0; a < tot; a++) {			ThreadSlot *tslot = MEM_callocN(sizeof(ThreadSlot), "threadslot");			BLI_addtail(threadbase, tslot);			tslot->do_thread = do_thread;			tslot->avail = 1;		}	}		if (thread_levels == 0) {		MEM_set_lock_callback(BLI_lock_malloc_thread, BLI_unlock_malloc_thread);#ifdef USE_APPLE_OMP_FIX		/* workaround for Apple gcc 4.2.1 omp vs background thread bug,		 * we copy gomp thread local storage pointer to setting it again		 * inside the thread that we start */		thread_tls_data = pthread_getspecific(gomp_tls_key);#endif	}	thread_levels++;}

static void userdef_free_keymaps(UserDef *userdef){  for (wmKeyMap *km = userdef->user_keymaps.first, *km_next; km; km = km_next) {    km_next = km->next;    for (wmKeyMapDiffItem *kmdi = km->diff_items.first; kmdi; kmdi = kmdi->next) {      if (kmdi->add_item) {        keymap_item_free(kmdi->add_item);        MEM_freeN(kmdi->add_item);      }      if (kmdi->remove_item) {        keymap_item_free(kmdi->remove_item);        MEM_freeN(kmdi->remove_item);      }    }    for (wmKeyMapItem *kmi = km->items.first; kmi; kmi = kmi->next) {      keymap_item_free(kmi);    }    BLI_freelistN(&km->diff_items);    BLI_freelistN(&km->items);    MEM_freeN(km);  }  BLI_listbase_clear(&userdef->user_keymaps);}

/* part of wm_window.c api */wmWindow *wm_window_copy(bContext *C, wmWindow *win_src){    wmWindow *win_dst = wm_window_new(C);    win_dst->posx = win_src->posx + 10;    win_dst->posy = win_src->posy;    win_dst->sizex = win_src->sizex;    win_dst->sizey = win_src->sizey;    /* duplicate assigns to window */    win_dst->screen = ED_screen_duplicate(win_dst, win_src->screen);    BLI_strncpy(win_dst->screenname, win_dst->screen->id.name + 2, sizeof(win_dst->screenname));    win_dst->screen->winid = win_dst->winid;    win_dst->screen->do_refresh = true;    win_dst->screen->do_draw = true;    win_dst->drawmethod = U.wmdrawmethod;    BLI_listbase_clear(&win_dst->drawdata);    *win_dst->stereo3d_format = *win_src->stereo3d_format;    return win_dst;}

void BKE_list_modifier_color_ramps(FreestyleLineStyle *linestyle, ListBase *listbase){	LineStyleModifier *m;	ColorBand *color_ramp;	LinkData *link;	BLI_listbase_clear(listbase);	for (m = (LineStyleModifier *)linestyle->color_modifiers.first; m; m = m->next) {		switch (m->type) {			case LS_MODIFIER_ALONG_STROKE:				color_ramp = ((LineStyleColorModifier_AlongStroke *)m)->color_ramp;				break;			case LS_MODIFIER_DISTANCE_FROM_CAMERA:				color_ramp = ((LineStyleColorModifier_DistanceFromCamera *)m)->color_ramp;				break;			case LS_MODIFIER_DISTANCE_FROM_OBJECT:				color_ramp = ((LineStyleColorModifier_DistanceFromObject *)m)->color_ramp;				break;			case LS_MODIFIER_MATERIAL:				color_ramp = ((LineStyleColorModifier_Material *)m)->color_ramp;				break;			default:				continue;		}		link = (LinkData *) MEM_callocN(sizeof(LinkData), "link to color ramp");		link->data = color_ramp;		BLI_addtail(listbase, link);	}}

void wm_history_file_read(void){	char name[FILE_MAX];	LinkNode *l, *lines;	struct RecentFile *recent;	const char *line;	int num;	const char * const cfgdir = BKE_appdir_folder_id(BLENDER_USER_CONFIG, NULL);	if (!cfgdir) return;	BLI_make_file_string("/", name, cfgdir, BLENDER_HISTORY_FILE);	lines = BLI_file_read_as_lines(name);	BLI_listbase_clear(&G.recent_files);	/* read list of recent opened files from recent-files.txt to memory */	for (l = lines, num = 0; l && (num < U.recent_files); l = l->next) {		line = l->link;		/* don't check if files exist, causes slow startup for remote/external drives */		if (line[0]) {			recent = (RecentFile *)MEM_mallocN(sizeof(RecentFile), "RecentFile");			BLI_addtail(&(G.recent_files), recent);			recent->filepath = BLI_strdup(line);			num++;		}	}		BLI_file_free_lines(lines);}

/* make a copy of a given gpencil layer */bGPDlayer *gpencil_layer_duplicate(bGPDlayer *src){	bGPDframe *gpf, *gpfd;	bGPDlayer *dst;		/* error checking */	if (src == NULL)		return NULL;			/* make a copy of source layer */	dst = MEM_dupallocN(src);	dst->prev = dst->next = NULL;		/* copy frames */	BLI_listbase_clear(&dst->frames);	for (gpf = src->frames.first; gpf; gpf = gpf->next) {		/* make a copy of source frame */		gpfd = gpencil_frame_duplicate(gpf);		BLI_addtail(&dst->frames, gpfd);				/* if source frame was the current layer's 'active' frame, reassign that too */		if (gpf == dst->actframe)			dst->actframe = gpfd;	}		/* return new layer */	return dst;}

/* Remove the given channel from all groups */void action_groups_remove_channel(bAction *act, FCurve *fcu){	/* sanity checks */	if (ELEM(NULL, act, fcu))		return;		/* check if any group used this directly */	if (fcu->grp) {		bActionGroup *agrp = fcu->grp;				if (agrp->channels.first == agrp->channels.last) {			if (agrp->channels.first == fcu) {				BLI_listbase_clear(&agrp->channels);			}		}		else if (agrp->channels.first == fcu) {			if ((fcu->next) && (fcu->next->grp == agrp))				agrp->channels.first = fcu->next;			else				agrp->channels.first = NULL;		}		else if (agrp->channels.last == fcu) {			if ((fcu->prev) && (fcu->prev->grp == agrp))				agrp->channels.last = fcu->prev;			else				agrp->channels.last = NULL;		}				fcu->grp = NULL;	}		/* now just remove from list */	BLI_remlink(&act->curves, fcu);}

void screen_data_copy(bScreen *to, bScreen *from){  ScrVert *s1, *s2;  ScrEdge *se;  ScrArea *sa, *saf;  /* free contents of 'to', is from blenkernel screen.c */  BKE_screen_free(to);  to->flag = from->flag;  BLI_duplicatelist(&to->vertbase, &from->vertbase);  BLI_duplicatelist(&to->edgebase, &from->edgebase);  BLI_duplicatelist(&to->areabase, &from->areabase);  BLI_listbase_clear(&to->regionbase);  s2 = to->vertbase.first;  for (s1 = from->vertbase.first; s1; s1 = s1->next, s2 = s2->next) {    s1->newv = s2;  }  for (se = to->edgebase.first; se; se = se->next) {    se->v1 = se->v1->newv;    se->v2 = se->v2->newv;    BKE_screen_sort_scrvert(&(se->v1), &(se->v2));  }  saf = from->areabase.first;  for (sa = to->areabase.first; sa; sa = sa->next, saf = saf->next) {    sa->v1 = sa->v1->newv;    sa->v2 = sa->v2->newv;    sa->v3 = sa->v3->newv;    sa->v4 = sa->v4->newv;    BLI_listbase_clear(&sa->spacedata);    BLI_listbase_clear(&sa->regionbase);    BLI_listbase_clear(&sa->actionzones);    BLI_listbase_clear(&sa->handlers);    ED_area_data_copy(sa, saf, true);  }  /* put at zero (needed?) */  for (s1 = from->vertbase.first; s1; s1 = s1->next) {    s1->newv = NULL;  }}

void BKE_blender_user_menu_item_free_list(ListBase *lb){  for (bUserMenuItem *umi = lb->first, *umi_next; umi; umi = umi_next) {    umi_next = umi->next;    BKE_blender_user_menu_item_free(umi);  }  BLI_listbase_clear(lb);}

static void userdef_free_addons(UserDef *userdef){  for (bAddon *addon = userdef->addons.first, *addon_next; addon; addon = addon_next) {    addon_next = addon->next;    BKE_addon_free(addon);  }  BLI_listbase_clear(&userdef->addons);}

/* This function frees any MEM_calloc'ed copy/paste buffer data */void ED_gpencil_anim_copybuf_free(void){	free_gpencil_layers(&gp_anim_copybuf);	BLI_listbase_clear(&gp_anim_copybuf);		gp_anim_copy_firstframe =  999999999;	gp_anim_copy_lastframe  = -999999999;	gp_anim_copy_cfra       =  0;}

static void node_group_output_update(bNodeTree *ntree, bNode *node){	bNodeSocket *extsock = node->inputs.last;	bNodeLink *link, *linknext, *exposelink;	/* Adding a tree socket and verifying will remove the extension socket!	 * This list caches the existing links to the extension socket	 * so they can be recreated after verification.	 */	ListBase tmplinks;		/* find links to the extension socket and store them */	BLI_listbase_clear(&tmplinks);	for (link = ntree->links.first; link; link = linknext) {		linknext = link->next;		if (nodeLinkIsHidden(link))			continue;				if (link->tosock == extsock) {			bNodeLink *tlink = MEM_callocN(sizeof(bNodeLink), "temporary link");			*tlink = *link;			BLI_addtail(&tmplinks, tlink);						nodeRemLink(ntree, link);		}	}		/* find valid link to expose */	exposelink = NULL;	for (link = tmplinks.first; link; link = link->next) {		/* XXX Multiple sockets can be connected to the extension socket at once,		 * in that case the arbitrary first link determines name and type.		 * This could be improved by choosing the "best" type among all links,		 * whatever that means.		 */		if (link->fromsock->type != SOCK_CUSTOM) {			exposelink = link;			break;		}	}		if (exposelink) {		bNodeSocket *gsock, *newsock;				/* XXX what if connecting virtual to virtual socket?? */		gsock = ntreeAddSocketInterfaceFromSocket(ntree, exposelink->fromnode, exposelink->fromsock);				node_group_output_verify(ntree, node, (ID *)ntree);		newsock = node_group_output_find_socket(node, gsock->identifier);				/* redirect links to the extension socket */		for (link = tmplinks.first; link; link = link->next) {			nodeAddLink(ntree, link->fromnode, link->fromsock, node, newsock);		}	}		BLI_freelistN(&tmplinks);}

VChar *BLI_vfontchar_copy(const VChar *vchar_src, const int UNUSED(flag)){	VChar *vchar_dst = MEM_dupallocN(vchar_src);	BLI_listbase_clear(&vchar_dst->nurbsbase);	BKE_nurbList_duplicate(&vchar_dst->nurbsbase, &vchar_src->nurbsbase);	return vchar_dst;}

/* Paste the variables in the buffer to the given FCurve */bool ANIM_driver_vars_paste(ReportList *reports, FCurve *fcu, bool replace){	ChannelDriver *driver = (fcu) ? fcu->driver : NULL;	ListBase tmp_list = {NULL, NULL};		/* sanity checks */	if (BLI_listbase_is_empty(&driver_vars_copybuf)) {		BKE_report(reports, RPT_ERROR, "No driver variables in clipboard to paste");		return false;	}		if (ELEM(NULL, fcu, fcu->driver)) {		BKE_report(reports, RPT_ERROR, "Cannot paste driver variables without a driver");		return false;	}		/* 1) Make a new copy of the variables in the buffer - these will get pasted later... */	driver_variables_copy(&tmp_list, &driver_vars_copybuf);		/* 2) Prepare destination array */	if (replace) {		DriverVar *dvar, *dvarn;				/* Free all existing vars first - We aren't retaining anything */		for (dvar = driver->variables.first; dvar; dvar = dvarn) {			dvarn = dvar->next;			driver_free_variable_ex(driver, dvar);		}				BLI_listbase_clear(&driver->variables);	}		/* 3) Add new vars */	if (driver->variables.last) {		DriverVar *last = driver->variables.last;		DriverVar *first = tmp_list.first;				last->next = first;		first->prev = last;				driver->variables.last = tmp_list.last;	}	else {		driver->variables.first = tmp_list.first;		driver->variables.last = tmp_list.last;	}	#ifdef WITH_PYTHON	/* since driver variables are cached, the expression needs re-compiling too */	if (driver->type == DRIVER_TYPE_PYTHON)		driver->flag |= DRIVER_FLAG_RENAMEVAR;#endif		return true;}

static void envmap_free_render_copy(Render *envre){	envre->totvlak = 0;	envre->totvert = 0;	envre->tothalo = 0;	envre->totstrand = 0;	envre->totlamp = 0;	envre->totinstance = 0;	envre->sortedhalos = NULL;	BLI_listbase_clear(&envre->lights);	BLI_listbase_clear(&envre->objecttable);	BLI_listbase_clear(&envre->customdata_names);	envre->raytree = NULL;	BLI_listbase_clear(&envre->instancetable);	envre->objectinstance = NULL;	envre->qmcsamplers = NULL;		RE_FreeRender(envre);}

void defgroup_copy_list(ListBase *outbase, ListBase *inbase){	bDeformGroup *defgroup, *defgroupn;	BLI_listbase_clear(outbase);	for (defgroup = inbase->first; defgroup; defgroup = defgroup->next) {		defgroupn = defgroup_duplicate(defgroup);		BLI_addtail(outbase, defgroupn);	}}

void BKE_sequence_modifier_clear(Sequence *seq){	SequenceModifierData *smd, *smd_next;	for (smd = seq->modifiers.first; smd; smd = smd_next) {		smd_next = smd->next;		BKE_sequence_modifier_free(smd);	}	BLI_listbase_clear(&seq->modifiers);}