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

World *add_world(Main *bmain, const char *name){	World *wrld;	wrld = BKE_libblock_alloc(&bmain->world, ID_WO, name);		wrld->horr = 0.05f;	wrld->horg = 0.05f;	wrld->horb = 0.05f;	wrld->zenr = 0.01f;	wrld->zeng = 0.01f;	wrld->zenb = 0.01f;	wrld->skytype = 0;	wrld->stardist = 15.0f;	wrld->starsize = 2.0f;	wrld->exp = 0.0f;	wrld->exposure = wrld->range = 1.0f;	wrld->aodist = 10.0f;	wrld->aosamp = 5;	wrld->aoenergy = 1.0f;	wrld->ao_env_energy = 1.0f;	wrld->ao_indirect_energy = 1.0f;	wrld->ao_indirect_bounces = 1;	wrld->aobias = 0.05f;	wrld->ao_samp_method = WO_AOSAMP_HAMMERSLEY;	wrld->ao_approx_error = 0.25f;		wrld->preview = NULL;	wrld->miststa = 5.0f;	wrld->mistdist = 25.0f;	return wrld;}

/* used everywhere in blenkernel */void *BKE_libblock_copy(ID *id){    ID *idn;    ListBase *lb;    size_t idn_len;    lb = which_libbase(G.main, GS(id->name));    idn = BKE_libblock_alloc(lb, GS(id->name), id->name + 2);    assert(idn != NULL);    idn_len = MEM_allocN_len(idn);    if ((int)idn_len - (int)sizeof(ID) > 0) { /* signed to allow neg result */        const char *cp = (const char *)id;        char *cpn = (char *)idn;        memcpy(cpn + sizeof(ID), cp + sizeof(ID), idn_len - sizeof(ID));    }    id->newid = idn;    idn->flag |= LIB_NEW;    BKE_libblock_copy_data(idn, id, FALSE);    return idn;}

bSound *sound_new_file(struct Main *bmain, const char *filename){	bSound *sound = NULL;	char str[FILE_MAX];	char *path;	size_t len;	BLI_strncpy(str, filename, sizeof(str));	path = /*bmain ? bmain->name :*/ G.main->name;	BLI_path_abs(str, path);	len = strlen(filename);	while (len > 0 && filename[len - 1] != '/' && filename[len - 1] != '//')		len--;	sound = BKE_libblock_alloc(bmain, ID_SO, filename + len);	BLI_strncpy(sound->name, filename, FILE_MAX);	/* sound->type = SOUND_TYPE_FILE; */ /* XXX unused currently */	sound_load(bmain, sound);	if (!sound->playback_handle) {		BKE_libblock_free(bmain, sound);		sound = NULL;	}	return sound;}

bSound *sound_new_limiter(struct Main *bmain, bSound *source, float start, float end){	bSound *sound = NULL;	char name[MAX_ID_NAME + 5];	strcpy(name, "lim_");	strcpy(name + 4, source->id.name);	sound = BKE_libblock_alloc(bmain, ID_SO, name);	sound->child_sound = source;	sound->start = start;	sound->end = end;	sound->type = SOUND_TYPE_LIMITER;	sound_load(bmain, sound);	if (!sound->playback_handle)	{		BKE_libblock_free(bmain, sound);		sound = NULL;	}	return sound;}

/* Add new collection, without view layer syncing. */static Collection *collection_add(Main *bmain,                                  Collection *collection_parent,                                  const char *name_custom){  /* Determine new collection name. */  char name[MAX_NAME];  if (name_custom) {    STRNCPY(name, name_custom);  }  else {    BKE_collection_new_name_get(collection_parent, name);  }  /* Create new collection. */  Collection *collection = BKE_libblock_alloc(bmain, ID_GR, name, 0);  /* We increase collection user count when linking to Collections. */  id_us_min(&collection->id);  /* Optionally add to parent collection. */  if (collection_parent) {    collection_child_add(collection_parent, collection, 0, true);  }  return collection;}

bAction *add_empty_action(Main *bmain, const char name[]){	bAction *act;		act = BKE_libblock_alloc(bmain, ID_AC, name);		return act;}	

void *BKE_cachefile_add(Main *bmain, const char *name){	CacheFile *cache_file = BKE_libblock_alloc(bmain, ID_CF, name, 0);	BKE_cachefile_init(cache_file);	return cache_file;}

FreestyleLineStyle *BKE_linestyle_new(struct Main *bmain, const char *name){	FreestyleLineStyle *linestyle;	linestyle = (FreestyleLineStyle *)BKE_libblock_alloc(bmain, ID_LS, name);	BKE_linestyle_init(linestyle);	return linestyle;}

Lattice *BKE_lattice_add(Main *bmain, const char *name){  Lattice *lt;  lt = BKE_libblock_alloc(bmain, ID_LT, name, 0);  BKE_lattice_init(lt);  return lt;}

Lamp *BKE_lamp_add(Main *bmain, const char *name){	Lamp *la;	la =  BKE_libblock_alloc(bmain, ID_LA, name);	BKE_lamp_init(la);	return la;}

Tex *BKE_texture_add(Main *bmain, const char *name){	Tex *tex;	tex = BKE_libblock_alloc(bmain, ID_TE, name, 0);		BKE_texture_default(tex);		return tex;}

MetaBall *BKE_mball_add(Main *bmain, const char *name){	MetaBall *mb;	mb = BKE_libblock_alloc(bmain, ID_MB, name);	BKE_mball_init(mb);	return mb;}

Light *BKE_light_add(Main *bmain, const char *name){  Light *la;  la = BKE_libblock_alloc(bmain, ID_LA, name, 0);  BKE_light_init(la);  return la;}

void *BKE_speaker_add(Main *bmain, const char *name){  Speaker *spk;  spk = BKE_libblock_alloc(bmain, ID_SPK, name, 0);  BKE_speaker_init(spk);  return spk;}

void *BKE_camera_add(Main *bmain, const char *name){	Camera *cam;	cam =  BKE_libblock_alloc(bmain, ID_CA, name, 0);	BKE_camera_init(cam);	return cam;}

VFont *BKE_vfont_load(Main *bmain, const char *name){	char filename[FILE_MAXFILE];	VFont *vfont = NULL;	PackedFile *pf;	PackedFile *temp_pf = NULL;	int is_builtin;		if (STREQ(name, FO_BUILTIN_NAME)) {		BLI_strncpy(filename, name, sizeof(filename));				pf = get_builtin_packedfile();		is_builtin = TRUE;	}	else {		BLI_split_file_part(name, filename, sizeof(filename));		pf = newPackedFile(NULL, name, bmain->name);		temp_pf = newPackedFile(NULL, name, bmain->name);				is_builtin = FALSE;	}	if (pf) {		VFontData *vfd;		vfd = BLI_vfontdata_from_freetypefont(pf);		if (vfd) {			vfont = BKE_libblock_alloc(&bmain->vfont, ID_VF, filename);			vfont->data = vfd;			/* if there's a font name, use it for the ID name */			if (vfd->name[0] != '/0') {				BLI_strncpy(vfont->id.name + 2, vfd->name, sizeof(vfont->id.name) - 2);			}			BLI_strncpy(vfont->name, name, sizeof(vfont->name));			/* if autopack is on store the packedfile in de font structure */			if (!is_builtin && (G.fileflags & G_AUTOPACK)) {				vfont->packedfile = pf;			}			/* Do not add FO_BUILTIN_NAME to temporary listbase */			if (strcmp(filename, FO_BUILTIN_NAME)) {				vfont->temp_pf = temp_pf;			}		}		/* Free the packed file */		if (!vfont || vfont->packedfile != pf) {			freePackedFile(pf);		}	}		return vfont;}

Brush *BKE_brush_add(Main *bmain, const char *name, short ob_mode){	Brush *brush;	brush = BKE_libblock_alloc(bmain, ID_BR, name);	BKE_brush_init(brush);	brush->ob_mode = ob_mode;	return brush;}

FreestyleLineStyle *BKE_new_linestyle(const char *name, struct Main *main){	FreestyleLineStyle *linestyle;	if (!main)		main = G.main;	linestyle = (FreestyleLineStyle *)BKE_libblock_alloc(main, ID_LS, name);	default_linestyle_settings(linestyle);	return linestyle;}

Lattice *BKE_lattice_add(const char *name){	Lattice *lt;		lt = BKE_libblock_alloc(&G.main->latt, ID_LT, name);		lt->flag = LT_GRID;		lt->typeu = lt->typev = lt->typew = KEY_BSPLINE;		lt->def = MEM_callocN(sizeof(BPoint), "lattvert"); /* temporary */	BKE_lattice_resize(lt, 2, 2, 2, NULL);  /* creates a uniform lattice */			return lt;}

MetaBall *BKE_mball_add(Main *bmain, const char *name){    MetaBall *mb;    mb = BKE_libblock_alloc(bmain, ID_MB, name);    mb->size[0] = mb->size[1] = mb->size[2] = 1.0;    mb->texflag = MB_AUTOSPACE;    mb->wiresize = 0.4f;    mb->rendersize = 0.2f;    mb->thresh = 0.6f;    return mb;}

/* on startup, it adds all data, for matching */void wm_add_default(bContext *C){	wmWindowManager *wm = BKE_libblock_alloc(CTX_data_main(C), ID_WM, "WinMan");	wmWindow *win;	bScreen *screen = CTX_wm_screen(C); /* XXX from file read hrmf */		CTX_wm_manager_set(C, wm);	win = wm_window_new(C);	win->screen = screen;	screen->winid = win->winid;	BLI_strncpy(win->screenname, screen->id.name + 2, sizeof(win->screenname));		wm->winactive = win;	wm->file_saved = 1;	wm_window_make_drawable(wm, win); }

/* add a new gp-datablock */bGPdata *gpencil_data_addnew(const char name[]){	bGPdata *gpd;		/* allocate memory for a new block */	gpd = BKE_libblock_alloc(G.main, ID_GD, name);		/* initial settings */	gpd->flag = (GP_DATA_DISPINFO | GP_DATA_EXPAND);		/* for now, stick to view is also enabled by default	 * since this is more useful...	 */	gpd->flag |= GP_DATA_VIEWALIGN;		return gpd;}

bSound *BKE_sound_new_buffer(struct Main *bmain, bSound *source){	bSound *sound = NULL;	char name[MAX_ID_NAME + 5];	strcpy(name, "buf_");	strcpy(name + 4, source->id.name);	sound = BKE_libblock_alloc(bmain, ID_SO, name);	sound->child_sound = source;	sound->type = SOUND_TYPE_BUFFER;	sound_load(bmain, sound);	return sound;}

Brush *BKE_brush_add(Main *bmain, const char *name){	Brush *brush;	brush = BKE_libblock_alloc(bmain, ID_BR, name);	/* enable fake user by default */	brush->id.flag |= LIB_FAKEUSER;	brush_defaults(brush);	brush->sculpt_tool = SCULPT_TOOL_DRAW; /* sculpting defaults to the draw tool for new brushes */	/* the default alpha falloff curve */	BKE_brush_curve_preset(brush, CURVE_PRESET_SMOOTH);	return brush;}

void *BKE_camera_add(Main *bmain, const char *name){	Camera *cam;		cam =  BKE_libblock_alloc(bmain, ID_CA, name);	cam->lens = 35.0f;	cam->sensor_x = DEFAULT_SENSOR_WIDTH;	cam->sensor_y = DEFAULT_SENSOR_HEIGHT;	cam->clipsta = 0.1f;	cam->clipend = 100.0f;	cam->drawsize = 0.5f;	cam->ortho_scale = 6.0;	cam->flag |= CAM_SHOWPASSEPARTOUT;	cam->passepartalpha = 0.5f;		return cam;}

/* only image block itself */static MovieClip *movieclip_alloc(const char *name){    MovieClip *clip;    clip = BKE_libblock_alloc(&G.main->movieclip, ID_MC, name);    clip->aspx = clip->aspy = 1.0f;    BKE_tracking_init_settings(&clip->tracking);    clip->proxy.build_size_flag = IMB_PROXY_25;    clip->proxy.build_tc_flag = IMB_TC_RECORD_RUN |                                IMB_TC_FREE_RUN |                                IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN |                                IMB_TC_RECORD_RUN_NO_GAPS;    clip->proxy.quality = 90;    return clip;}

bSound *BKE_sound_new_file(struct Main *bmain, const char *filepath){	bSound *sound;	const char *path;	char str[FILE_MAX];	BLI_strncpy(str, filepath, sizeof(str));	path = /*bmain ? bmain->name :*/ G.main->name;	BLI_path_abs(str, path);	sound = BKE_libblock_alloc(bmain, ID_SO, BLI_path_basename(filepath));	BLI_strncpy(sound->name, filepath, FILE_MAX);	/* sound->type = SOUND_TYPE_FILE; */ /* XXX unused currently */	BKE_sound_load(bmain, sound);	return sound;}

Mesh *BKE_mesh_add(Main *bmain, const char *name){	Mesh *me;		me = BKE_libblock_alloc(&bmain->mesh, ID_ME, name);		me->size[0] = me->size[1] = me->size[2] = 1.0;	me->smoothresh = 30;	me->texflag = ME_AUTOSPACE;	me->flag = ME_TWOSIDED;	me->drawflag = ME_DRAWEDGES | ME_DRAWFACES | ME_DRAWCREASES;	CustomData_reset(&me->vdata);	CustomData_reset(&me->edata);	CustomData_reset(&me->fdata);	CustomData_reset(&me->pdata);	CustomData_reset(&me->ldata);	return me;}