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

/* note, doesnt run exit() call WM_exit() for that */void WM_exit_ext(bContext *C, const bool do_python){    wmWindowManager *wm = C ? CTX_wm_manager(C) : NULL;    BKE_sound_exit();    /* first wrap up running stuff, we assume only the active WM is running */    /* modal handlers are on window level freed, others too? */    /* note; same code copied in wm_files.c */    if (C && wm) {        wmWindow *win;        if (!G.background) {            if ((U.uiflag2 & USER_KEEP_SESSION) || BKE_undo_is_valid(NULL)) {                /* save the undo state as quit.blend */                char filename[FILE_MAX];                bool has_edited;                int fileflags = G.fileflags & ~(G_FILE_COMPRESS | G_FILE_AUTOPLAY | G_FILE_HISTORY);                BLI_make_file_string("/", filename, BKE_tempdir_base(), BLENDER_QUIT_FILE);                has_edited = ED_editors_flush_edits(C, false);                if ((has_edited && BLO_write_file(CTX_data_main(C), filename, fileflags, NULL, NULL)) ||                        BKE_undo_save_file(filename))                {                    printf("Saved session recovery to '%s'/n", filename);                }            }        }        WM_jobs_kill_all(wm);        for (win = wm->windows.first; win; win = win->next) {            CTX_wm_window_set(C, win);  /* needed by operator close callbacks */            WM_event_remove_handlers(C, &win->handlers);            WM_event_remove_handlers(C, &win->modalhandlers);            ED_screen_exit(C, win, win->screen);        }    }    BKE_addon_pref_type_free();    wm_operatortype_free();    wm_dropbox_free();    WM_menutype_free();    WM_uilisttype_free();    /* all non-screen and non-space stuff editors did, like editmode */    if (C)        ED_editors_exit(C);//	XXX//	BIF_GlobalReebFree();//	BIF_freeRetarget();    BIF_freeTemplates(C);    free_openrecent();    BKE_mball_cubeTable_free();    /* render code might still access databases */    RE_FreeAllRender();    RE_engines_exit();    ED_preview_free_dbase();  /* frees a Main dbase, before free_blender! */    if (C && wm)        wm_free_reports(C);  /* before free_blender! - since the ListBases get freed there */    BKE_sequencer_free_clipboard(); /* sequencer.c */    BKE_tracking_clipboard_free();    BKE_mask_clipboard_free();#ifdef WITH_COMPOSITOR    COM_deinitialize();#endif    free_blender();  /* blender.c, does entire library and spacetypes *///	free_matcopybuf();    free_anim_copybuf();    free_anim_drivers_copybuf();    free_fmodifiers_copybuf();    ED_gpencil_strokes_copybuf_free();    ED_clipboard_posebuf_free();    BKE_node_clipboard_clear();    BLF_exit();#ifdef WITH_INTERNATIONAL    BLF_free_unifont();    BLF_free_unifont_mono();    BLT_lang_free();#endif    ANIM_keyingset_infos_exit();//	free_txt_data();//.........这里部分代码省略.........

/* join armature exec is exported for use in object->join objects operator... */int join_armature_exec(bContext *C, wmOperator *op){	Main *bmain = CTX_data_main(C);	Scene *scene = CTX_data_scene(C);	Object  *ob = CTX_data_active_object(C);	bArmature *arm = (ob) ? ob->data : NULL;	bPose *pose, *opose;	bPoseChannel *pchan, *pchann;	EditBone *curbone;	float mat[4][4], oimat[4][4];	bool ok = false;		/*	Ensure we're not in editmode and that the active object is an armature*/	if (!ob || ob->type != OB_ARMATURE)		return OPERATOR_CANCELLED;	if (!arm || arm->edbo)		return OPERATOR_CANCELLED;		CTX_DATA_BEGIN(C, Base *, base, selected_editable_bases)	{		if (base->object == ob) {			ok = true;			break;		}	}	CTX_DATA_END;	/* that way the active object is always selected */	if (ok == false) {		BKE_report(op->reports, RPT_WARNING, "Active object is not a selected armature");		return OPERATOR_CANCELLED;	}	/* Get editbones of active armature to add editbones to */	ED_armature_to_edit(arm);		/* get pose of active object and move it out of posemode */	pose = ob->pose;	ob->mode &= ~OB_MODE_POSE;	CTX_DATA_BEGIN(C, Base *, base, selected_editable_bases)	{		if ((base->object->type == OB_ARMATURE) && (base->object != ob)) {			bArmature *curarm = base->object->data;						/* Make a list of editbones in current armature */			ED_armature_to_edit(base->object->data);						/* Get Pose of current armature */			opose = base->object->pose;			base->object->mode &= ~OB_MODE_POSE;			//BASACT->flag &= ~OB_MODE_POSE;						/* Find the difference matrix */			invert_m4_m4(oimat, ob->obmat);			mul_m4_m4m4(mat, oimat, base->object->obmat);						/* Copy bones and posechannels from the object to the edit armature */			for (pchan = opose->chanbase.first; pchan; pchan = pchann) {				pchann = pchan->next;				curbone = ED_armature_bone_find_name(curarm->edbo, pchan->name);								/* Get new name */				unique_editbone_name(arm->edbo, curbone->name, NULL);								/* Transform the bone */				{					float premat[4][4];					float postmat[4][4];					float difmat[4][4];					float imat[4][4];					float temp[3][3];										/* Get the premat */					ED_armature_ebone_to_mat3(curbone, temp);										unit_m4(premat); /* mul_m4_m3m4 only sets 3x3 part */					mul_m4_m3m4(premat, temp, mat);										mul_m4_v3(mat, curbone->head);					mul_m4_v3(mat, curbone->tail);										/* Get the postmat */					ED_armature_ebone_to_mat3(curbone, temp);					copy_m4_m3(postmat, temp);										/* Find the roll */					invert_m4_m4(imat, premat);					mul_m4_m4m4(difmat, imat, postmat);										curbone->roll -= (float)atan2(difmat[2][0], difmat[2][2]);				}								/* Fix Constraints and Other Links to this Bone and Armature */				joined_armature_fix_links(ob, base->object, pchan, curbone);								/* Rename pchan */				BLI_strncpy(pchan->name, curbone->name, sizeof(pchan->name));				//.........这里部分代码省略.........

void ED_preview_shader_job(const bContext *C,                           void *owner,                           ID *id,                           ID *parent,                           MTex *slot,                           int sizex,                           int sizey,                           int method){  Object *ob = CTX_data_active_object(C);  wmJob *wm_job;  ShaderPreview *sp;  Scene *scene = CTX_data_scene(C);  short id_type = GS(id->name);  /* Use workspace render only for buttons Window,   * since the other previews are related to the datablock. */  if (!check_engine_supports_preview(scene)) {    return;  }  /* Only texture node preview is supported with Cycles. */  if (method == PR_NODE_RENDER && id_type != ID_TE) {    return;  }  ED_preview_ensure_dbase();  wm_job = WM_jobs_get(CTX_wm_manager(C),                       CTX_wm_window(C),                       owner,                       "Shader Preview",                       WM_JOB_EXCL_RENDER,                       WM_JOB_TYPE_RENDER_PREVIEW);  sp = MEM_callocN(sizeof(ShaderPreview), "shader preview");  /* customdata for preview thread */  sp->scene = scene;  sp->depsgraph = CTX_data_depsgraph(C);  sp->owner = owner;  sp->sizex = sizex;  sp->sizey = sizey;  sp->pr_method = method;  sp->id = id;  sp->id_copy = duplicate_ids(id);  sp->own_id_copy = true;  sp->parent = parent;  sp->slot = slot;  sp->bmain = CTX_data_main(C);  Material *ma = NULL;  /* hardcoded preview .blend for Eevee + Cycles, this should be solved   * once with custom preview .blend path for external engines */  /* grease pencil use its own preview file */  if (GS(id->name) == ID_MA) {    ma = (Material *)id;  }  if ((ma == NULL) || (ma->gp_style == NULL)) {    sp->pr_main = G_pr_main;  }  else {    sp->pr_main = G_pr_main_grease_pencil;  }  if (ob && ob->totcol) {    copy_v4_v4(sp->color, ob->color);  }  else {    ARRAY_SET_ITEMS(sp->color, 0.0f, 0.0f, 0.0f, 1.0f);  }  /* setup job */  WM_jobs_customdata_set(wm_job, sp, shader_preview_free);  WM_jobs_timer(wm_job, 0.1, NC_MATERIAL, NC_MATERIAL);  WM_jobs_callbacks(wm_job, common_preview_startjob, NULL, shader_preview_updatejob, NULL);  WM_jobs_start(CTX_wm_manager(C), wm_job);}

/* using context, starts job */static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event){	/* new render clears all callbacks */	Main *mainp;	Scene *scene = CTX_data_scene(C);	SceneRenderLayer *srl = NULL;	View3D *v3d = CTX_wm_view3d(C);	Render *re;	wmJob *steve;	RenderJob *rj;	Image *ima;	int jobflag;	const short is_animation = RNA_boolean_get(op->ptr, "animation");	const short is_write_still = RNA_boolean_get(op->ptr, "write_still");	struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;	const char *name;		/* only one render job at a time */	if (WM_jobs_test(CTX_wm_manager(C), scene))		return OPERATOR_CANCELLED;	if (!RE_is_rendering_allowed(scene, camera_override, op->reports)) {		return OPERATOR_CANCELLED;	}	if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {		BKE_report(op->reports, RPT_ERROR, "Can't write a single file with an animation format selected");		return OPERATOR_CANCELLED;	}			/* stop all running jobs, currently previews frustrate Render */	WM_jobs_stop_all(CTX_wm_manager(C));	/* get main */	if (G.rt == 101) {		/* thread-safety experiment, copy main from the undo buffer */		mainp = BKE_undo_get_main(&scene);	}	else		mainp = CTX_data_main(C);	/* cancel animation playback */	if (ED_screen_animation_playing(CTX_wm_manager(C)))		ED_screen_animation_play(C, 0, 0);		/* handle UI stuff */	WM_cursor_wait(1);	/* flush multires changes (for sculpt) */	multires_force_render_update(CTX_data_active_object(C));	/* cleanup sequencer caches before starting user triggered render.	 * otherwise, invalidated cache entries can make their way into	 * the output rendering. We can't put that into RE_BlenderFrame,	 * since sequence rendering can call that recursively... (peter) */	seq_stripelem_cache_cleanup();	/* get editmode results */	ED_object_exit_editmode(C, 0);  /* 0 = does not exit editmode */	// store spare	// get view3d layer, local layer, make this nice api call to render	// store spare	/* ensure at least 1 area shows result */	render_view_open(C, event->x, event->y);	jobflag = WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS;		/* custom scene and single layer re-render */	screen_render_scene_layer_set(op, mainp, &scene, &srl);	if (RNA_struct_property_is_set(op->ptr, "layer"))		jobflag |= WM_JOB_SUSPEND;	/* job custom data */	rj = MEM_callocN(sizeof(RenderJob), "render job");	rj->main = mainp;	rj->scene = scene;	rj->win = CTX_wm_window(C);	rj->srl = srl;	rj->camera_override = camera_override;	rj->lay = (v3d) ? v3d->lay : scene->lay;	rj->anim = is_animation;	rj->write_still = is_write_still && !is_animation;	rj->iuser.scene = scene;	rj->iuser.ok = 1;	rj->reports = op->reports;	/* setup job */	if (RE_seq_render_active(scene, &scene->r)) name = "Sequence Render";	else name = "Render";	steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, name, jobflag);	WM_jobs_customdata(steve, rj, render_freejob);	WM_jobs_timer(steve, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);	WM_jobs_callbacks(steve, render_startjob, NULL, NULL, render_endjob);	/* get a render result image, and make sure it is empty *///.........这里部分代码省略.........

static int open_exec(bContext *C, wmOperator *op){	SpaceClip *sc = CTX_wm_space_clip(C);	bScreen *screen = CTX_wm_screen(C);	Main *bmain = CTX_data_main(C);	PropertyPointerRNA *pprop;	PointerRNA idptr;	MovieClip *clip = NULL;	char str[FILE_MAX];	if (RNA_collection_length(op->ptr, "files")) {		PointerRNA fileptr;		PropertyRNA *prop;		char dir_only[FILE_MAX], file_only[FILE_MAX];		bool relative = RNA_boolean_get(op->ptr, "relative_path");		RNA_string_get(op->ptr, "directory", dir_only);		if (relative)			BLI_path_rel(dir_only, G.main->name);		prop = RNA_struct_find_property(op->ptr, "files");		RNA_property_collection_lookup_int(op->ptr, prop, 0, &fileptr);		RNA_string_get(&fileptr, "name", file_only);		BLI_join_dirfile(str, sizeof(str), dir_only, file_only);	}	else {		BKE_report(op->reports, RPT_ERROR, "No files selected to be opened");		return OPERATOR_CANCELLED;	}	/* default to frame 1 if there's no scene in context */	errno = 0;	clip = BKE_movieclip_file_add(bmain, str);	if (!clip) {		if (op->customdata)			MEM_freeN(op->customdata);		BKE_reportf(op->reports, RPT_ERROR, "Cannot read '%s': %s", str,		            errno ? strerror(errno) : TIP_("unsupported movie clip format"));		return OPERATOR_CANCELLED;	}	if (!op->customdata)		open_init(C, op);	/* hook into UI */	pprop = op->customdata;	if (pprop->prop) {		/* when creating new ID blocks, use is already 1, but RNA		 * pointer se also increases user, so this compensates it */		clip->id.us--;		RNA_id_pointer_create(&clip->id, &idptr);		RNA_property_pointer_set(&pprop->ptr, pprop->prop, idptr);		RNA_property_update(C, &pprop->ptr, pprop->prop);	}	else if (sc) {		ED_space_clip_set_clip(C, screen, sc, clip);	}	WM_event_add_notifier(C, NC_MOVIECLIP | NA_ADDED, clip);	MEM_freeN(op->customdata);	return OPERATOR_FINISHED;}

static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op){	Main *bmain = CTX_data_main(C);	OGLRender *oglrender = op->customdata;	Scene *scene = oglrender->scene;	ImBuf *ibuf, *ibuf_save = NULL;	void *lock;	char name[FILE_MAX];	int ok = 0;	const short view_context = (oglrender->v3d != NULL);	Object *camera = NULL;	int is_movie;	/* go to next frame */	if (CFRA < oglrender->nfra)		CFRA++;	while (CFRA < oglrender->nfra) {		unsigned int lay = screen_opengl_layers(oglrender);		if (lay & 0xFF000000)			lay &= 0xFF000000;		BKE_scene_update_for_newframe(bmain, scene, lay);		CFRA++;	}	is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype);	if (!is_movie) {		BKE_makepicstring(name, scene->r.pic, oglrender->bmain->name, scene->r.cfra, &scene->r.im_format, scene->r.scemode & R_EXTENSION, TRUE);		if ((scene->r.mode & R_NO_OVERWRITE) && BLI_exists(name)) {			BKE_reportf(op->reports, RPT_INFO, "Skipping existing frame /"%s/"", name);			ok = true;			goto finally;		}	}	WM_cursor_time(oglrender->win, scene->r.cfra);	BKE_scene_update_for_newframe(bmain, scene, screen_opengl_layers(oglrender));	if (view_context) {		if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera && oglrender->v3d->scenelock) {			/* since BKE_scene_update_for_newframe() is used rather			 * then ED_update_for_newframe() the camera needs to be set */			if (BKE_scene_camera_switch_update(scene)) {				oglrender->v3d->camera = scene->camera;			}			camera = oglrender->v3d->camera;		}	}	else {		BKE_scene_camera_switch_update(scene);		camera = scene->camera;	}	/* render into offscreen buffer */	screen_opengl_render_apply(oglrender);	/* save to disk */	ibuf = BKE_image_acquire_ibuf(oglrender->ima, &oglrender->iuser, &lock);	if (ibuf) {		int needs_free = FALSE;		ibuf_save = ibuf;		if (is_movie || !BKE_imtype_requires_linear_float(scene->r.im_format.imtype)) {			ibuf_save = IMB_colormanagement_imbuf_for_write(ibuf, true, true, &scene->view_settings,			                                                &scene->display_settings, &scene->r.im_format);			needs_free = TRUE;		}		/* color -> grayscale */		/* editing directly would alter the render view */		if (scene->r.im_format.planes == R_IMF_PLANES_BW) {			ImBuf *ibuf_bw = IMB_dupImBuf(ibuf_save);			IMB_color_to_bw(ibuf_bw);			if (needs_free)				IMB_freeImBuf(ibuf_save);			ibuf_save = ibuf_bw;		}		else {			/* this is lightweight & doesnt re-alloc the buffers, only do this			 * to save the correct bit depth since the image is always RGBA */			ImBuf *ibuf_cpy = IMB_allocImBuf(ibuf_save->x, ibuf_save->y, scene->r.im_format.planes, 0);			ibuf_cpy->rect = ibuf_save->rect;			ibuf_cpy->rect_float = ibuf_save->rect_float;			ibuf_cpy->zbuf_float = ibuf_save->zbuf_float;			if (needs_free) {				ibuf_cpy->mall = ibuf_save->mall;				ibuf_save->mall = 0;//.........这里部分代码省略.........

extern "C" void StartKetsjiShell(struct bContext *C, struct ARegion *ar, rcti *cam_frame, int always_use_expand_framing){	/* context values */	struct wmWindowManager *wm= CTX_wm_manager(C);	struct wmWindow *win= CTX_wm_window(C);	struct Scene *startscene= CTX_data_scene(C);	struct Main* maggie1= CTX_data_main(C);	RAS_Rect area_rect;	area_rect.SetLeft(cam_frame->xmin);	area_rect.SetBottom(cam_frame->ymin);	area_rect.SetRight(cam_frame->xmax);	area_rect.SetTop(cam_frame->ymax);	int exitrequested = KX_EXIT_REQUEST_NO_REQUEST;	Main* blenderdata = maggie1;	char* startscenename = startscene->id.name+2;	char pathname[FILE_MAXDIR+FILE_MAXFILE], oldsce[FILE_MAXDIR+FILE_MAXFILE];	STR_String exitstring = "";	BlendFileData *bfd= NULL;	BLI_strncpy(pathname, blenderdata->name, sizeof(pathname));	BLI_strncpy(oldsce, G.main->name, sizeof(oldsce));#ifdef WITH_PYTHON	resetGamePythonPath(); // need this so running a second time wont use an old blendfiles path	setGamePythonPath(G.main->name);	// Acquire Python's GIL (global interpreter lock)	// so we can safely run Python code and API calls	PyGILState_STATE gilstate = PyGILState_Ensure();		PyObject *pyGlobalDict = PyDict_New(); /* python utility storage, spans blend file loading */#endif		bgl::InitExtensions(true);	// VBO code for derived mesh is not compatible with BGE (couldn't find why), so disable	int disableVBO = (U.gameflags & USER_DISABLE_VBO);	U.gameflags |= USER_DISABLE_VBO;	// Globals to be carried on over blender files	GlobalSettings gs;	gs.matmode= startscene->gm.matmode;	gs.glslflag= startscene->gm.flag;	do	{		View3D *v3d= CTX_wm_view3d(C);		RegionView3D *rv3d= CTX_wm_region_view3d(C);		// get some preferences		SYS_SystemHandle syshandle = SYS_GetSystem();		bool properties	= (SYS_GetCommandLineInt(syshandle, "show_properties", 0) != 0);		bool usefixed = (SYS_GetCommandLineInt(syshandle, "fixedtime", 0) != 0);		bool profile = (SYS_GetCommandLineInt(syshandle, "show_profile", 0) != 0);		bool frameRate = (SYS_GetCommandLineInt(syshandle, "show_framerate", 0) != 0);		bool animation_record = (SYS_GetCommandLineInt(syshandle, "animation_record", 0) != 0);		bool displaylists = (SYS_GetCommandLineInt(syshandle, "displaylists", 0) != 0) && GPU_display_list_support();#ifdef WITH_PYTHON		bool nodepwarnings = (SYS_GetCommandLineInt(syshandle, "ignore_deprecation_warnings", 0) != 0);#endif		// bool novertexarrays = (SYS_GetCommandLineInt(syshandle, "novertexarrays", 0) != 0);		bool mouse_state = startscene->gm.flag & GAME_SHOW_MOUSE;		bool restrictAnimFPS = startscene->gm.flag & GAME_RESTRICT_ANIM_UPDATES;		if (animation_record) usefixed= false; /* override since you don't want to run full-speed for sim recording */		// create the canvas and rasterizer		RAS_ICanvas* canvas = new KX_BlenderCanvas(wm, win, area_rect, ar);				// default mouse state set on render panel		if (mouse_state)			canvas->SetMouseState(RAS_ICanvas::MOUSE_NORMAL);		else			canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE);		// Setup vsync		int previous_vsync = canvas->GetSwapInterval();		if (startscene->gm.vsync == VSYNC_ADAPTIVE)			canvas->SetSwapInterval(-1);		else			canvas->SetSwapInterval((startscene->gm.vsync == VSYNC_ON) ? 1 : 0);		RAS_IRasterizer* rasterizer = NULL;		//Don't use displaylists with VBOs		//If auto starts using VBOs, make sure to check for that here		if (displaylists && startscene->gm.raster_storage != RAS_STORE_VBO)			rasterizer = new RAS_ListRasterizer(canvas, true, startscene->gm.raster_storage);		else			rasterizer = new RAS_OpenGLRasterizer(canvas, startscene->gm.raster_storage);		RAS_IRasterizer::MipmapOption mipmapval = rasterizer->GetMipmapping();				// create the inputdevices		KX_BlenderKeyboardDevice* keyboarddevice = new KX_BlenderKeyboardDevice();		KX_BlenderMouseDevice* mousedevice = new KX_BlenderMouseDevice();		//.........这里部分代码省略.........

//.........这里部分代码省略.........	}	context_dict_back = CTX_py_dict_get(C);	CTX_py_dict_set(C, (void *)context_dict);	Py_XINCREF(context_dict); /* so we done loose it */	if (WM_operator_poll_context((bContext *)C, ot, context) == false) {		const char *msg = CTX_wm_operator_poll_msg_get(C);		PyErr_Format(PyExc_RuntimeError,		             "Operator bpy.ops.%.200s.poll() %.200s",		             opname, msg ? msg : "failed, context is incorrect");		CTX_wm_operator_poll_msg_set(C, NULL); /* better set to NULL else it could be used again */		error_val = -1;	}	else {		WM_operator_properties_create_ptr(&ptr, ot);		WM_operator_properties_sanitize(&ptr, 0);		if (kw && PyDict_Size(kw))			error_val = pyrna_pydict_to_props(&ptr, kw, 0, "Converting py args to operator properties: ");		if (error_val == 0) {			ReportList *reports;			reports = MEM_mallocN(sizeof(ReportList), "wmOperatorReportList");			BKE_reports_init(reports, RPT_STORE | RPT_OP_HOLD); /* own so these don't move into global reports */#ifdef BPY_RELEASE_GIL			/* release GIL, since a thread could be started from an operator			 * that updates a driver */			/* note: I have not seen any examples of code that does this			 * so it may not be officially supported but seems to work ok. */			{				PyThreadState *ts = PyEval_SaveThread();#endif				operator_ret = WM_operator_call_py(C, ot, context, &ptr, reports, is_undo);#ifdef BPY_RELEASE_GIL				/* regain GIL */				PyEval_RestoreThread(ts);			}#endif			error_val = BPy_reports_to_error(reports, PyExc_RuntimeError, false);			/* operator output is nice to have in the terminal/console too */			if (!BLI_listbase_is_empty(&reports->list)) {				Report *report;				for (report = reports->list.first; report; report = report->next) {					PySys_WriteStdout("%s: %s/n", report->typestr, report->message);				}			}				BKE_reports_clear(reports);			if ((reports->flag & RPT_FREE) == 0) {				MEM_freeN(reports);			}		}		WM_operator_properties_free(&ptr);#if 0		/* if there is some way to know an operator takes args we should use this */		{			/* no props */			if (kw != NULL) {				PyErr_Format(PyExc_AttributeError,				             "Operator /"%s/" does not take any args",				             opname);				return NULL;			}			WM_operator_name_call(C, opname, WM_OP_EXEC_DEFAULT, NULL);		}#endif	}	/* restore with original context dict, probably NULL but need this for nested operator calls */	Py_XDECREF(context_dict);	CTX_py_dict_set(C, (void *)context_dict_back);	if (error_val == -1) {		return NULL;	}	/* when calling  bpy.ops.wm.read_factory_settings() bpy.data's main pointer is freed by clear_globals(),	 * further access will crash blender. setting context is not needed in this case, only calling because this	 * function corrects bpy.data (internal Main pointer) */	BPY_modules_update(C);	/* needed for when WM_OT_read_factory_settings us called from within a script */	bpy_import_main_set(CTX_data_main(C));	/* return operator_ret as a bpy enum */	return pyrna_enum_bitfield_to_py(operator_return_items, operator_ret);}

static bool python_script_exec(        bContext *C, const char *fn, struct Text *text,        struct ReportList *reports, const bool do_jump){	Main *bmain_old = CTX_data_main(C);	PyObject *main_mod = NULL;	PyObject *py_dict = NULL, *py_result = NULL;	PyGILState_STATE gilstate;	BLI_assert(fn || text);	if (fn == NULL && text == NULL) {		return 0;	}	bpy_context_set(C, &gilstate);	PyC_MainModule_Backup(&main_mod);	if (text) {		char fn_dummy[FILE_MAXDIR];		bpy_text_filename_get(fn_dummy, sizeof(fn_dummy), text);		if (text->compiled == NULL) {   /* if it wasn't already compiled, do it now */			char *buf;			PyObject *fn_dummy_py;			fn_dummy_py = PyC_UnicodeFromByte(fn_dummy);			buf = txt_to_buf(text);			text->compiled = Py_CompileStringObject(buf, fn_dummy_py, Py_file_input, NULL, -1);			MEM_freeN(buf);			Py_DECREF(fn_dummy_py);			if (PyErr_Occurred()) {				if (do_jump) {					python_script_error_jump_text(text);				}				BPY_text_free_code(text);			}		}		if (text->compiled) {			py_dict = PyC_DefaultNameSpace(fn_dummy);			py_result =  PyEval_EvalCode(text->compiled, py_dict, py_dict);		}	}	else {		FILE *fp = BLI_fopen(fn, "r");		if (fp) {			py_dict = PyC_DefaultNameSpace(fn);#ifdef _WIN32			/* Previously we used PyRun_File to run directly the code on a FILE			 * object, but as written in the Python/C API Ref Manual, chapter 2,			 * 'FILE structs for different C libraries can be different and			 * incompatible'.			 * So now we load the script file data to a buffer */			{				const char *pystring =				        "ns = globals().copy()/n"				        "with open(__file__, 'rb') as f: exec(compile(f.read(), __file__, 'exec'), ns)";				fclose(fp);				py_result = PyRun_String(pystring, Py_file_input, py_dict, py_dict);			}#else			py_result = PyRun_File(fp, fn, Py_file_input, py_dict, py_dict);			fclose(fp);#endif		}		else {			PyErr_Format(PyExc_IOError,			             "Python file /"%s/" could not be opened: %s",			             fn, strerror(errno));			py_result = NULL;		}	}	if (!py_result) {		if (text) {			if (do_jump) {				/* ensure text is valid before use, the script may have freed its self */				Main *bmain_new = CTX_data_main(C);				if ((bmain_old == bmain_new) && (BLI_findindex(&bmain_new->text, text) != -1)) {					python_script_error_jump_text(text);				}			}		}		BPy_errors_to_report(reports);	}	else {		Py_DECREF(py_result);	}	if (py_dict) {//.........这里部分代码省略.........

static bool screen_opengl_render_init(bContext *C, wmOperator *op){	/* new render clears all callbacks */	wmWindowManager *wm = CTX_wm_manager(C);	wmWindow *win = CTX_wm_window(C);	Scene *scene = CTX_data_scene(C);	ScrArea *prevsa = CTX_wm_area(C);	ARegion *prevar = CTX_wm_region(C);	GPUOffScreen *ofs;	OGLRender *oglrender;	int sizex, sizey;	bool is_view_context = RNA_boolean_get(op->ptr, "view_context");	const bool is_animation = RNA_boolean_get(op->ptr, "animation");	const bool is_sequencer = RNA_boolean_get(op->ptr, "sequencer");	const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");	char err_out[256] = "unknown";	if (G.background) {		BKE_report(op->reports, RPT_ERROR, "Cannot use OpenGL render in background mode (no opengl context)");		return false;	}	/* only one render job at a time */	if (WM_jobs_test(wm, scene, WM_JOB_TYPE_RENDER))		return false;	if (is_sequencer) {		is_view_context = false;	}	else {		/* ensure we have a 3d view */		if (!ED_view3d_context_activate(C)) {			RNA_boolean_set(op->ptr, "view_context", false);			is_view_context = false;		}		if (!is_view_context && scene->camera == NULL) {			BKE_report(op->reports, RPT_ERROR, "Scene has no camera");			return false;		}	}	if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {		BKE_report(op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");		return false;	}	/* stop all running jobs, except screen one. currently previews frustrate Render */	WM_jobs_kill_all_except(wm, CTX_wm_screen(C));	/* create offscreen buffer */	sizex = (scene->r.size * scene->r.xsch) / 100;	sizey = (scene->r.size * scene->r.ysch) / 100;	/* corrects render size with actual size, not every card supports non-power-of-two dimensions */	ofs = GPU_offscreen_create(sizex, sizey, err_out);	if (!ofs) {		BKE_reportf(op->reports, RPT_ERROR, "Failed to create OpenGL off-screen buffer, %s", err_out);		return false;	}	/* allocate opengl render */	oglrender = MEM_callocN(sizeof(OGLRender), "OGLRender");	op->customdata = oglrender;	oglrender->ofs = ofs;	oglrender->sizex = sizex;	oglrender->sizey = sizey;	oglrender->bmain = CTX_data_main(C);	oglrender->scene = scene;	oglrender->cfrao = scene->r.cfra;	oglrender->write_still = is_write_still && !is_animation;	oglrender->is_sequencer = is_sequencer;	if (is_sequencer) {		oglrender->sseq = CTX_wm_space_seq(C);	}	oglrender->prevsa = prevsa;	oglrender->prevar = prevar;	if (is_view_context) {		ED_view3d_context_user_region(C, &oglrender->v3d, &oglrender->ar); /* so quad view renders camera */		oglrender->rv3d = oglrender->ar->regiondata;		/* MUST be cleared on exit */		oglrender->scene->customdata_mask_modal = ED_view3d_datamask(oglrender->scene, oglrender->v3d);		/* apply immediately in case we're rendering from a script,		 * running notifiers again will overwrite */		oglrender->scene->customdata_mask |= oglrender->scene->customdata_mask_modal;		if (oglrender->v3d->fx_settings.fx_flag & (GPU_FX_FLAG_DOF | GPU_FX_FLAG_SSAO)) {			oglrender->fx = GPU_fx_compositor_create();		}	}//.........这里部分代码省略.........

static int view3d_layers_exec(bContext *C, wmOperator *op){	Scene *scene = CTX_data_scene(C);	ScrArea *sa = CTX_wm_area(C);	View3D *v3d = sa->spacedata.first;	int nr = RNA_int_get(op->ptr, "nr");	const bool toggle = RNA_boolean_get(op->ptr, "toggle");		if (nr < 0)		return OPERATOR_CANCELLED;	if (nr == 0) {		/* all layers */		if (!v3d->lay_prev)			v3d->lay_prev = 1;		if (toggle && v3d->lay == ((1 << 20) - 1)) {			/* return to active layer only */			v3d->lay = v3d->lay_prev;			view3d_layers_editmode_ensure(scene, v3d);		}		else {			v3d->lay_prev = v3d->lay;			v3d->lay |= (1 << 20) - 1;		}	}	else {		int bit;		nr--;		if (RNA_boolean_get(op->ptr, "extend")) {			if (toggle && v3d->lay & (1 << nr) && (v3d->lay & ~(1 << nr)))				v3d->lay &= ~(1 << nr);			else				v3d->lay |= (1 << nr);		}		else {			v3d->lay = (1 << nr);		}		view3d_layers_editmode_ensure(scene, v3d);		/* set active layer, ensure to always have one */		if (v3d->lay & (1 << nr))			v3d->layact = 1 << nr;		else if ((v3d->lay & v3d->layact) == 0) {			for (bit = 0; bit < 32; bit++) {				if (v3d->lay & (1 << bit)) {					v3d->layact = 1 << bit;					break;				}			}		}	}		if (v3d->scenelock) handle_view3d_lock(C);		DAG_on_visible_update(CTX_data_main(C), false);	ED_area_tag_redraw(sa);		return OPERATOR_FINISHED;}

static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op){	Main *bmain = CTX_data_main(C);	OGLRender *oglrender = op->customdata;	Scene *scene = oglrender->scene;	char name[FILE_MAX];	bool ok = false;	const bool view_context = (oglrender->v3d != NULL);	bool is_movie;	RenderResult *rr;	/* go to next frame */	if (CFRA < oglrender->nfra)		CFRA++;	while (CFRA < oglrender->nfra) {		unsigned int lay = screen_opengl_layers(oglrender);		if (lay & 0xFF000000)			lay &= 0xFF000000;		BKE_scene_update_for_newframe(bmain->eval_ctx, bmain, scene, lay);		CFRA++;	}	is_movie = BKE_imtype_is_movie(scene->r.im_format.imtype);	if (!is_movie) {		BKE_image_path_from_imformat(		        name, scene->r.pic, oglrender->bmain->name, scene->r.cfra,		        &scene->r.im_format, (scene->r.scemode & R_EXTENSION) != 0, true, NULL);		if ((scene->r.mode & R_NO_OVERWRITE) && BLI_exists(name)) {			BKE_reportf(op->reports, RPT_INFO, "Skipping existing frame /"%s/"", name);			ok = true;			goto finally;		}	}	WM_cursor_time(oglrender->win, scene->r.cfra);	BKE_scene_update_for_newframe(bmain->eval_ctx, bmain, scene, screen_opengl_layers(oglrender));	if (view_context) {		if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera && oglrender->v3d->scenelock) {			/* since BKE_scene_update_for_newframe() is used rather			 * then ED_update_for_newframe() the camera needs to be set */			if (BKE_scene_camera_switch_update(scene)) {				oglrender->v3d->camera = scene->camera;			}		}	}	else {		BKE_scene_camera_switch_update(scene);	}	/* render into offscreen buffer */	screen_opengl_render_apply(oglrender);	/* save to disk */	rr = RE_AcquireResultRead(oglrender->re);	if (is_movie) {		ok = RE_WriteRenderViewsMovie(oglrender->reports, rr, scene, &scene->r, oglrender->mh, oglrender->sizex,		                              oglrender->sizey, oglrender->movie_ctx_arr, oglrender->totvideos, PRVRANGEON != 0);		if (ok) {			printf("Append frame %d", scene->r.cfra);			BKE_reportf(op->reports, RPT_INFO, "Appended frame: %d", scene->r.cfra);		}	}	else {		BKE_render_result_stamp_info(scene, scene->camera, rr, false);		ok = RE_WriteRenderViewsImage(op->reports, rr, scene, true, name);		if (ok) {			printf("Saved: %s", name);			BKE_reportf(op->reports, RPT_INFO, "Saved file: %s", name);		}		else {			printf("Write error: cannot save %s/n", name);			BKE_reportf(op->reports, RPT_ERROR, "Write error: cannot save %s", name);		}	}	RE_ReleaseResult(oglrender->re);	/* movie stats prints have no line break */	printf("/n");finally:  /* Step the frame and bail early if needed */	/* go to next frame */	oglrender->nfra += scene->r.frame_step;	/* stop at the end or on error */	if (CFRA >= PEFRA || !ok) {		screen_opengl_render_end(C, op->customdata);		return 0;	}//.........这里部分代码省略.........

/* name can be a dynamic string */void BKE_write_undo(bContext *C, const char *name){	uintptr_t maxmem, totmem, memused;	int nr /*, success */ /* UNUSED */;	UndoElem *uel;		if ((U.uiflag & USER_GLOBALUNDO) == 0) {		return;	}	if (U.undosteps == 0) {		return;	}		/* remove all undos after (also when curundo == NULL) */	while (undobase.last != curundo) {		uel = undobase.last;		BLI_remlink(&undobase, uel);		BLO_free_memfile(&uel->memfile);		MEM_freeN(uel);	}		/* make new */	curundo = uel = MEM_callocN(sizeof(UndoElem), "undo file");	BLI_strncpy(uel->name, name, sizeof(uel->name));	BLI_addtail(&undobase, uel);		/* and limit amount to the maximum */	nr = 0;	uel = undobase.last;	while (uel) {		nr++;		if (nr == U.undosteps) break;		uel = uel->prev;	}	if (uel) {		while (undobase.first != uel) {			UndoElem *first = undobase.first;			BLI_remlink(&undobase, first);			/* the merge is because of compression */			BLO_merge_memfile(&first->memfile, &first->next->memfile);			MEM_freeN(first);		}	}	/* disk save version */	if (UNDO_DISK) {		static int counter = 0;		char filepath[FILE_MAX];		char numstr[32];		int fileflags = G.fileflags & ~(G_FILE_HISTORY); /* don't do file history on undo */		/* calculate current filepath */		counter++;		counter = counter % U.undosteps;			BLI_snprintf(numstr, sizeof(numstr), "%d.blend", counter);		BLI_make_file_string("/", filepath, BLI_temporary_dir(), numstr);			/* success = */ /* UNUSED */ BLO_write_file(CTX_data_main(C), filepath, fileflags, NULL, NULL);				BLI_strncpy(curundo->str, filepath, sizeof(curundo->str));	}	else {		MemFile *prevfile = NULL;				if (curundo->prev) prevfile = &(curundo->prev->memfile);				memused = MEM_get_memory_in_use();		/* success = */ /* UNUSED */ BLO_write_file_mem(CTX_data_main(C), prevfile, &curundo->memfile, G.fileflags);		curundo->undosize = MEM_get_memory_in_use() - memused;	}	if (U.undomemory != 0) {		/* limit to maximum memory (afterwards, we can't know in advance) */		totmem = 0;		maxmem = ((uintptr_t)U.undomemory) * 1024 * 1024;		/* keep at least two (original + other) */		uel = undobase.last;		while (uel && uel->prev) {			totmem += uel->undosize;			if (totmem > maxmem) break;			uel = uel->prev;		}		if (uel) {			if (uel->prev && uel->prev->prev)				uel = uel->prev;			while (undobase.first != uel) {				UndoElem *first = undobase.first;				BLI_remlink(&undobase, first);				/* the merge is because of compression */				BLO_merge_memfile(&first->memfile, &first->next->memfile);				MEM_freeN(first);			}		}//.........这里部分代码省略.........

static void wm_draw_window_offscreen(bContext *C, wmWindow *win, bool stereo){  Main *bmain = CTX_data_main(C);  wmWindowManager *wm = CTX_wm_manager(C);  bScreen *screen = WM_window_get_active_screen(win);  /* Draw screen areas into own frame buffer. */  ED_screen_areas_iter(win, screen, sa)  {    CTX_wm_area_set(C, sa);    /* Compute UI layouts for dynamically size regions. */    for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {      if (ar->visible && ar->do_draw && ar->type && ar->type->layout) {        CTX_wm_region_set(C, ar);        ED_region_do_layout(C, ar);        CTX_wm_region_set(C, NULL);      }    }    ED_area_update_region_sizes(wm, win, sa);    if (sa->flag & AREA_FLAG_ACTIVE_TOOL_UPDATE) {      if ((1 << sa->spacetype) & WM_TOOLSYSTEM_SPACE_MASK) {        WM_toolsystem_update_from_context(C, CTX_wm_workspace(C), CTX_data_view_layer(C), sa);      }      sa->flag &= ~AREA_FLAG_ACTIVE_TOOL_UPDATE;    }    /* Then do actual drawing of regions. */    for (ARegion *ar = sa->regionbase.first; ar; ar = ar->next) {      if (ar->visible && ar->do_draw) {        CTX_wm_region_set(C, ar);        bool use_viewport = wm_region_use_viewport(sa, ar);        if (stereo && wm_draw_region_stereo_set(bmain, sa, ar, STEREO_LEFT_ID)) {          wm_draw_region_buffer_create(ar, true, use_viewport);          for (int view = 0; view < 2; view++) {            eStereoViews sview;            if (view == 0) {              sview = STEREO_LEFT_ID;            }            else {              sview = STEREO_RIGHT_ID;              wm_draw_region_stereo_set(bmain, sa, ar, sview);            }            wm_draw_region_bind(ar, view);            ED_region_do_draw(C, ar);            wm_draw_region_unbind(ar, view);          }        }        else {          wm_draw_region_buffer_create(ar, false, use_viewport);          wm_draw_region_bind(ar, 0);          ED_region_do_draw(C, ar);          wm_draw_region_unbind(ar, 0);        }        ar->do_draw = false;        CTX_wm_region_set(C, NULL);      }    }    wm_area_mark_invalid_backbuf(sa);    CTX_wm_area_set(C, NULL);  }

/* using context, starts job */static int screen_render_invoke(bContext *C, wmOperator *op, const wmEvent *event){	/* new render clears all callbacks */	Main *mainp;	Scene *scene = CTX_data_scene(C);	SceneRenderLayer *srl = NULL;	Render *re;	wmJob *wm_job;	RenderJob *rj;	Image *ima;	int jobflag;	const bool is_animation = RNA_boolean_get(op->ptr, "animation");	const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");	const bool use_viewport = RNA_boolean_get(op->ptr, "use_viewport");	View3D *v3d = use_viewport ? CTX_wm_view3d(C) : NULL;	struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;	const char *name;	ScrArea *sa;		/* only one render job at a time */	if (WM_jobs_test(CTX_wm_manager(C), scene, WM_JOB_TYPE_RENDER))		return OPERATOR_CANCELLED;	if (RE_force_single_renderlayer(scene))		WM_event_add_notifier(C, NC_SCENE | ND_RENDER_OPTIONS, NULL);	if (!RE_is_rendering_allowed(scene, camera_override, op->reports)) {		return OPERATOR_CANCELLED;	}	if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {		BKE_report(op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");		return OPERATOR_CANCELLED;	}		/* stop all running jobs, except screen one. currently previews frustrate Render */	WM_jobs_kill_all_except(CTX_wm_manager(C), CTX_wm_screen(C));	/* get main */	if (G.debug_value == 101) {		/* thread-safety experiment, copy main from the undo buffer */		mainp = BKE_undo_get_main(&scene);	}	else		mainp = CTX_data_main(C);	/* cancel animation playback */	if (ED_screen_animation_playing(CTX_wm_manager(C)))		ED_screen_animation_play(C, 0, 0);		/* handle UI stuff */	WM_cursor_wait(1);	/* flush sculpt and editmode changes */	ED_editors_flush_edits(C, true);	/* cleanup sequencer caches before starting user triggered render.	 * otherwise, invalidated cache entries can make their way into	 * the output rendering. We can't put that into RE_BlenderFrame,	 * since sequence rendering can call that recursively... (peter) */	BKE_sequencer_cache_cleanup();	// store spare	// get view3d layer, local layer, make this nice api call to render	// store spare	/* ensure at least 1 area shows result */	sa = render_view_open(C, event->x, event->y);	jobflag = WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS;		/* custom scene and single layer re-render */	screen_render_scene_layer_set(op, mainp, &scene, &srl);	if (RNA_struct_property_is_set(op->ptr, "layer"))		jobflag |= WM_JOB_SUSPEND;	/* job custom data */	rj = MEM_callocN(sizeof(RenderJob), "render job");	rj->main = mainp;	rj->scene = scene;	rj->current_scene = rj->scene;	rj->srl = srl;	rj->camera_override = camera_override;	rj->lay_override = 0;	rj->anim = is_animation;	rj->write_still = is_write_still && !is_animation;	rj->iuser.scene = scene;	rj->iuser.ok = 1;	rj->reports = op->reports;	rj->orig_layer = 0;	rj->last_layer = 0;	rj->sa = sa;	BKE_color_managed_display_settings_copy(&rj->display_settings, &scene->display_settings);	BKE_color_managed_view_settings_copy(&rj->view_settings, &scene->view_settings);	if (sa) {		SpaceImage *sima = sa->spacedata.first;//.........这里部分代码省略.........

void unpack_menu(bContext *C, const char *opname, const char *id_name, const char *abs_name, const char *folder, struct PackedFile *pf){	Main *bmain = CTX_data_main(C);	PointerRNA props_ptr;	uiPopupMenu *pup;	uiLayout *layout;	char line[FILE_MAX + 100];	wmOperatorType *ot = WM_operatortype_find(opname, 1);	pup = UI_popup_menu_begin(C, IFACE_("Unpack File"), ICON_NONE);	layout = UI_popup_menu_layout(pup);	uiItemFullO_ptr(	        layout, ot, IFACE_("Remove Pack"), ICON_NONE,	        NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);	RNA_enum_set(&props_ptr, "method", PF_REMOVE);	RNA_string_set(&props_ptr, "id", id_name);	if (G.relbase_valid) {		char local_name[FILE_MAXDIR + FILE_MAX], fi[FILE_MAX];		BLI_split_file_part(abs_name, fi, sizeof(fi));		BLI_snprintf(local_name, sizeof(local_name), "//%s/%s", folder, fi);		if (!STREQ(abs_name, local_name)) {			switch (checkPackedFile(BKE_main_blendfile_path(bmain), local_name, pf)) {				case PF_NOFILE:					BLI_snprintf(line, sizeof(line), IFACE_("Create %s"), local_name);					uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);					RNA_enum_set(&props_ptr, "method", PF_WRITE_LOCAL);					RNA_string_set(&props_ptr, "id", id_name);					break;				case PF_EQUAL:					BLI_snprintf(line, sizeof(line), IFACE_("Use %s (identical)"), local_name);					//uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_USE_LOCAL);					uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);					RNA_enum_set(&props_ptr, "method", PF_USE_LOCAL);					RNA_string_set(&props_ptr, "id", id_name);					break;				case PF_DIFFERS:					BLI_snprintf(line, sizeof(line), IFACE_("Use %s (differs)"), local_name);					//uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_USE_LOCAL);					uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);					RNA_enum_set(&props_ptr, "method", PF_USE_LOCAL);					RNA_string_set(&props_ptr, "id", id_name);					BLI_snprintf(line, sizeof(line), IFACE_("Overwrite %s"), local_name);					//uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_WRITE_LOCAL);					uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);					RNA_enum_set(&props_ptr, "method", PF_WRITE_LOCAL);					RNA_string_set(&props_ptr, "id", id_name);					break;			}		}	}	switch (checkPackedFile(BKE_main_blendfile_path(bmain), abs_name, pf)) {		case PF_NOFILE:			BLI_snprintf(line, sizeof(line), IFACE_("Create %s"), abs_name);			//uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_WRITE_ORIGINAL);			uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);			RNA_enum_set(&props_ptr, "method", PF_WRITE_ORIGINAL);			RNA_string_set(&props_ptr, "id", id_name);			break;		case PF_EQUAL:			BLI_snprintf(line, sizeof(line), IFACE_("Use %s (identical)"), abs_name);			//uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_USE_ORIGINAL);			uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);			RNA_enum_set(&props_ptr, "method", PF_USE_ORIGINAL);			RNA_string_set(&props_ptr, "id", id_name);			break;		case PF_DIFFERS:			BLI_snprintf(line, sizeof(line), IFACE_("Use %s (differs)"), abs_name);			//uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_USE_ORIGINAL);			uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);			RNA_enum_set(&props_ptr, "method", PF_USE_ORIGINAL);			RNA_string_set(&props_ptr, "id", id_name);			BLI_snprintf(line, sizeof(line), IFACE_("Overwrite %s"), abs_name);			//uiItemEnumO_ptr(layout, ot, line, 0, "method", PF_WRITE_ORIGINAL);			uiItemFullO_ptr(layout, ot, line, ICON_NONE, NULL, WM_OP_EXEC_DEFAULT, 0, &props_ptr);			RNA_enum_set(&props_ptr, "method", PF_WRITE_ORIGINAL);			RNA_string_set(&props_ptr, "id", id_name);			break;	}	UI_popup_menu_end(C, pup);}

/* add new node connected to this socket, or replace an existing one */static void node_socket_add_replace(const bContext *C, bNodeTree *ntree, bNode *node_to, bNodeSocket *sock_to,                                    int type, NodeLinkItem *item){	bNode *node_from;	bNodeSocket *sock_from_tmp;	bNode *node_prev = NULL;	/* unlink existing node */	if (sock_to->link) {		node_prev = sock_to->link->fromnode;		nodeRemLink(ntree, sock_to->link);	}	/* find existing node that we can use */	for (node_from = ntree->nodes.first; node_from; node_from = node_from->next)		if (node_from->type == type)			break;	if (node_from)		if (node_from->inputs.first || node_from->typeinfo->draw_buttons || node_from->typeinfo->draw_buttons_ex)			node_from = NULL;	if (node_prev && node_prev->type == type && node_link_item_compare(node_prev, item)) {		/* keep the previous node if it's the same type */		node_from = node_prev;	}	else if (!node_from) {		node_from = nodeAddStaticNode(C, ntree, type);		node_from->locx = node_to->locx - (node_from->typeinfo->width + 50);		node_from->locy = node_to->locy;				node_link_item_apply(node_from, item);	}	nodeSetActive(ntree, node_from);	/* add link */	sock_from_tmp = BLI_findlink(&node_from->outputs, item->socket_index);	nodeAddLink(ntree, node_from, sock_from_tmp, node_to, sock_to);	sock_to->flag &= ~SOCK_COLLAPSED;	/* copy input sockets from previous node */	if (node_prev && node_from != node_prev) {		bNodeSocket *sock_prev, *sock_from;		for (sock_prev = node_prev->inputs.first; sock_prev; sock_prev = sock_prev->next) {			for (sock_from = node_from->inputs.first; sock_from; sock_from = sock_from->next) {				if (nodeCountSocketLinks(ntree, sock_from) >= sock_from->limit)					continue;				if (STREQ(sock_prev->name, sock_from->name) && sock_prev->type == sock_from->type) {					bNodeLink *link = sock_prev->link;					if (link && link->fromnode) {						nodeAddLink(ntree, link->fromnode, link->fromsock, node_from, sock_from);						nodeRemLink(ntree, link);					}					node_socket_copy_default_value(sock_from, sock_prev);				}			}		}		/* also preserve mapping for texture nodes */		if (node_from->typeinfo->nclass == NODE_CLASS_TEXTURE &&		    node_prev->typeinfo->nclass == NODE_CLASS_TEXTURE)		{			memcpy(node_from->storage, node_prev->storage, sizeof(NodeTexBase));		}		/* remove node */		node_remove_linked(ntree, node_prev);	}	nodeUpdate(ntree, node_from);	nodeUpdate(ntree, node_to);	ntreeUpdateTree(CTX_data_main(C), ntree);	ED_node_tag_update_nodetree(CTX_data_main(C), ntree);}

/* convert a given grease-pencil layer to a 3d-curve representation (using current view if appropriate) */static void gp_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bGPDlayer *gpl, int mode,                              int norm_weights, float rad_fac, int link_strokes, tGpTimingData *gtd){	struct Main *bmain = CTX_data_main(C);	Scene *scene = CTX_data_scene(C);	bGPDframe *gpf = gpencil_layer_getframe(gpl, CFRA, 0);	bGPDstroke *gps, *prev_gps = NULL;	Object *ob;	Curve *cu;	Nurb *nu = NULL;	Base *base_orig = BASACT, *base_new = NULL;	float minmax_weights[2] = {1.0f, 0.0f};	/* camera framing */	rctf subrect, *subrect_ptr = NULL;		/* error checking */	if (ELEM3(NULL, gpd, gpl, gpf))		return;		/* only convert if there are any strokes on this layer's frame to convert */	if (gpf->strokes.first == NULL)		return;	/* initialize camera framing */	if (gp_camera_view_subrect(C, &subrect)) {		subrect_ptr = &subrect;	}		/* init the curve object (remove rotation and get curve data from it)	 *	- must clear transforms set on object, as those skew our results	 */	ob = BKE_object_add_only_object(bmain, OB_CURVE, gpl->info);	cu = ob->data = BKE_curve_add(bmain, gpl->info, OB_CURVE);	base_new = BKE_scene_base_add(scene, ob);	cu->flag |= CU_3D;		gtd->inittime = ((bGPDstroke *)gpf->strokes.first)->inittime;		/* add points to curve */	for (gps = gpf->strokes.first; gps; gps = gps->next) {		/* Detect new strokes created because of GP_STROKE_BUFFER_MAX reached,		 * and stitch them to previous one.		 */		int stitch = FALSE;				if (prev_gps) {			bGPDspoint *pt1 = prev_gps->points + prev_gps->totpoints - 1;			bGPDspoint *pt2 = gps->points;						if ((pt1->x == pt2->x) && (pt1->y == pt2->y)) {				stitch = TRUE;			}		}				/* Decide whether we connect this stroke to previous one */		if (!(stitch || link_strokes)) {			nu = NULL;		}				switch (mode) {			case GP_STROKECONVERT_PATH: 				gp_stroke_to_path(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch, gtd);				break;			case GP_STROKECONVERT_CURVE:			case GP_STROKECONVERT_POLY:  /* convert after */				gp_stroke_to_bezier(C, gpl, gps, cu, subrect_ptr, &nu, minmax_weights, rad_fac, stitch, gtd);				break;			default:				BLI_assert(!"invalid mode");				break;		}		prev_gps = gps;	}	/* If link_strokes, be sure first and last points have a zero weight/size! */	if (link_strokes) {		gp_stroke_finalize_curve_endpoints(cu);	}		/* Update curve's weights, if needed */	if (norm_weights && ((minmax_weights[0] > 0.0f) || (minmax_weights[1] < 1.0f))) {		gp_stroke_norm_curve_weights(cu, minmax_weights);	}	/* Create the path animation, if needed */	gp_stroke_path_animation(C, reports, cu, gtd);	if (mode == GP_STROKECONVERT_POLY) {		for (nu = cu->nurb.first; nu; nu = nu->next) {			BKE_nurb_type_convert(nu, CU_POLY, false);		}	}	/* set the layer and select */	base_new->lay  = ob->lay  = base_orig ? base_orig->lay : scene->lay;	base_new->flag = ob->flag = base_new->flag | SELECT;}

void SkinInfo::link_armature(bContext *C, Object *ob, std::map<COLLADAFW::UniqueId, COLLADAFW::Node *>& joint_by_uid,                             TransformReader *tm){	Main *bmain = CTX_data_main(C);	Scene *scene = CTX_data_scene(C);	ModifierData *md = ED_object_modifier_add(NULL, bmain, scene, ob, NULL, eModifierType_Armature);	ArmatureModifierData *amd = (ArmatureModifierData *)md;	amd->object = ob_arm;	copy_m4_m4(ob->obmat, bind_shape_matrix);	BKE_object_apply_mat4(ob, ob->obmat, 0, 0);#if 1	bc_set_parent(ob, ob_arm, C);#else	Object workob;	ob->parent = ob_arm;	ob->partype = PAROBJECT;	BKE_object_workob_calc_parent(scene, ob, &workob);	invert_m4_m4(ob->parentinv, workob.obmat);	ob->recalc |= OB_RECALC_OB | OB_RECALC_DATA;	DAG_scene_sort(bmain, scene);	DAG_ids_flush_update(bmain, 0);	WM_event_add_notifier(C, NC_OBJECT | ND_TRANSFORM, NULL);#endif	amd->deformflag = ARM_DEF_VGROUP;	// create all vertex groups	std::vector<JointData>::iterator it;	int joint_index;	for (it = joint_data.begin(), joint_index = 0; it != joint_data.end(); it++, joint_index++) {		const char *name = "Group";		// skip joints that have invalid UID		if ((*it).joint_uid == COLLADAFW::UniqueId::INVALID) continue;				// name group by joint node name				if (joint_by_uid.find((*it).joint_uid) != joint_by_uid.end()) {			name = bc_get_joint_name(joint_by_uid[(*it).joint_uid]);		}		ED_vgroup_add_name(ob, (char *)name);	}	// <vcount> - number of joints per vertex - joints_per_vertex	// <v> - [[bone index, weight index] * joints per vertex] * vertices - weight indices	// ^ bone index can be -1 meaning weight toward bind shape, how to express this in Blender?	// for each vertex in weight indices	//	for each bone index in vertex	//		add vertex to group at group index	//		treat group index -1 specially	// get def group by index with BLI_findlink	for (unsigned int vertex = 0, weight = 0; vertex < joints_per_vertex.getCount(); vertex++) {		unsigned int limit = weight + joints_per_vertex[vertex];		for (; weight < limit; weight++) {			int joint = joint_indices[weight], joint_weight = weight_indices[weight];			// -1 means "weight towards the bind shape", we just don't assign it to any group			if (joint != -1) {				bDeformGroup *def = (bDeformGroup *)BLI_findlink(&ob->defbase, joint);				ED_vgroup_vert_add(ob, def, vertex, weights[joint_weight], WEIGHT_REPLACE);			}		}	}}

/* separate selected bones into their armature */static int separate_armature_exec(bContext *C, wmOperator *op){	Main *bmain = CTX_data_main(C);	Scene *scene = CTX_data_scene(C);	Object *obedit = CTX_data_edit_object(C);	Object *oldob, *newob;	Base *oldbase, *newbase;		/* sanity checks */	if (obedit == NULL)		return OPERATOR_CANCELLED;		/* set wait cursor in case this takes a while */	WM_cursor_wait(1);		/* we are going to do this as follows (unlike every other instance of separate):	 *	1. exit editmode +posemode for active armature/base. Take note of what this is.	 *	2. duplicate base - BASACT is the new one now	 *	3. for each of the two armatures, enter editmode -> remove appropriate bones -> exit editmode + recalc	 *	4. fix constraint links	 *	5. make original armature active and enter editmode	 */	/* 1) only edit-base selected */	/* TODO: use context iterators for this? */	CTX_DATA_BEGIN(C, Base *, base, visible_bases)	{		if (base->object == obedit) base->flag |= SELECT;		else base->flag &= ~SELECT;	}	CTX_DATA_END;		/* 1) store starting settings and exit editmode */	oldob = obedit;	oldbase = BASACT;	oldob->mode &= ~OB_MODE_POSE;	//oldbase->flag &= ~OB_POSEMODE;		ED_armature_from_edit(obedit->data);	ED_armature_edit_free(obedit->data);		/* 2) duplicate base */	newbase = ED_object_add_duplicate(bmain, scene, oldbase, USER_DUP_ARM); /* only duplicate linked armature */	DAG_relations_tag_update(bmain);	newob = newbase->object;	newbase->flag &= ~SELECT;			/* 3) remove bones that shouldn't still be around on both armatures */	separate_armature_bones(oldob, 1);	separate_armature_bones(newob, 0);			/* 4) fix links before depsgraph flushes */ // err... or after?	separated_armature_fix_links(oldob, newob);		DAG_id_tag_update(&oldob->id, OB_RECALC_DATA);  /* this is the original one */	DAG_id_tag_update(&newob->id, OB_RECALC_DATA);  /* this is the separated one */			/* 5) restore original conditions */	obedit = oldob;		ED_armature_to_edit(obedit->data);		BKE_report(op->reports, RPT_INFO, "Separated bones");	/* note, notifier might evolve */	WM_event_add_notifier(C, NC_OBJECT | ND_POSE, obedit);		/* recalc/redraw + cleanup */	WM_cursor_wait(0);		return OPERATOR_FINISHED;}

static int load_file(int UNUSED(argc), const char **argv, void *data){	bContext *C = data;	/* Make the path absolute because its needed for relative linked blends to be found */	char filename[FILE_MAX];	/* note, we could skip these, but so far we always tried to load these files */	if (argv[0][0] == '-') {		fprintf(stderr, "unknown argument, loading as file: %s/n", argv[0]);	}	BLI_strncpy(filename, argv[0], sizeof(filename));	BLI_path_cwd(filename);	if (G.background) {		int retval;		BLI_callback_exec(CTX_data_main(C), NULL, BLI_CB_EVT_LOAD_PRE);		retval = BKE_read_file(C, filename, NULL);		/* we successfully loaded a blend file, get sure that		 * pointcache works */		if (retval != BKE_READ_FILE_FAIL) {			wmWindowManager *wm = CTX_wm_manager(C);			Main *bmain = CTX_data_main(C);			/* special case, 2.4x files */			if (wm == NULL && BLI_listbase_is_empty(&bmain->wm)) {				extern void wm_add_default(bContext *C);				/* wm_add_default() needs the screen to be set. */				CTX_wm_screen_set(C, bmain->screen.first);				wm_add_default(C);			}			CTX_wm_manager_set(C, NULL); /* remove wm to force check */			WM_check(C);			G.relbase_valid = 1;			if (CTX_wm_manager(C) == NULL) CTX_wm_manager_set(C, wm);  /* reset wm */			/* WM_file_read would call normally */			ED_editors_init(C);			DAG_on_visible_update(bmain, true);			BKE_scene_update_tagged(bmain->eval_ctx, bmain, CTX_data_scene(C));		}		else {			/* failed to load file, stop processing arguments */			return -1;		}		/* WM_file_read() runs normally but since we're in background mode do here */#ifdef WITH_PYTHON		/* run any texts that were loaded in and flagged as modules */		BPY_python_reset(C);#endif		BLI_callback_exec(CTX_data_main(C), NULL, BLI_CB_EVT_LOAD_POST);		/* happens for the UI on file reading too (huh? (ton))*/		// XXX		BKE_reset_undo();		//			BKE_write_undo("original");	/* save current state */	}	else {		/* we are not running in background mode here, but start blender in UI mode with		 * a file - this should do everything a 'load file' does */		ReportList reports;		BKE_reports_init(&reports, RPT_PRINT);		WM_file_autoexec_init(filename);		WM_file_read(C, filename, &reports);		BKE_reports_clear(&reports);	}	G.file_loaded = 1;	return 0;}

static int ED_object_shape_key_remove(bContext *C, Object *ob){	Main *bmain= CTX_data_main(C);	KeyBlock *kb, *rkb;	Key *key;	//IpoCurve *icu;	key= ob_get_key(ob);	if(key==NULL)		return 0;		kb= BLI_findlink(&key->block, ob->shapenr-1);	if(kb) {		for(rkb= key->block.first; rkb; rkb= rkb->next)			if(rkb->relative == ob->shapenr-1)				rkb->relative= 0;		BLI_remlink(&key->block, kb);		key->totkey--;		if(key->refkey== kb) {			key->refkey= key->block.first;			if(key->refkey) {				/* apply new basis key on original data */				switch(ob->type) {					case OB_MESH:						key_to_mesh(key->refkey, ob->data);						break;					case OB_CURVE:					case OB_SURF:						key_to_curve(key->refkey, ob->data, BKE_curve_nurbs(ob->data));						break;					case OB_LATTICE:						key_to_latt(key->refkey, ob->data);						break;				}			}		}					if(kb->data) MEM_freeN(kb->data);		MEM_freeN(kb);				for(kb= key->block.first; kb; kb= kb->next)			if(kb->adrcode>=ob->shapenr)				kb->adrcode--;		#if 0 // XXX old animation system		if(key->ipo) {						for(icu= key->ipo->curve.first; icu; icu= icu->next) {				if(icu->adrcode==ob->shapenr-1) {					BLI_remlink(&key->ipo->curve, icu);					free_ipo_curve(icu);					break;				}			}			for(icu= key->ipo->curve.first; icu; icu= icu->next) 				if(icu->adrcode>=ob->shapenr)					icu->adrcode--;		}#endif // XXX old animation system						if(ob->shapenr>1) ob->shapenr--;	}		if(key->totkey==0) {		if(GS(key->from->name)==ID_ME) ((Mesh *)key->from)->key= NULL;		else if(GS(key->from->name)==ID_CU) ((Curve *)key->from)->key= NULL;		else if(GS(key->from->name)==ID_LT) ((Lattice *)key->from)->key= NULL;		free_libblock_us(&(bmain->key), key);	}		DAG_id_tag_update(&ob->id, OB_RECALC_DATA);	WM_event_add_notifier(C, NC_OBJECT|ND_DRAW, ob);	return 1;}

bool WM_init_game(bContext *C){    wmWindowManager *wm = CTX_wm_manager(C);    wmWindow *win;    ScrArea *sa;    ARegion *ar = NULL;    Scene *scene = CTX_data_scene(C);    if (!scene) {        /* XXX, this should not be needed. */        Main *bmain = CTX_data_main(C);        scene = bmain->scene.first;    }    win = wm->windows.first;    /* first to get a valid window */    if (win)        CTX_wm_window_set(C, win);    sa = BKE_screen_find_big_area(CTX_wm_screen(C), SPACE_VIEW3D, 0);    ar = BKE_area_find_region_type(sa, RGN_TYPE_WINDOW);    /* if we have a valid 3D view */    if (sa && ar) {        ARegion *arhide;        CTX_wm_area_set(C, sa);        CTX_wm_region_set(C, ar);        /* disable quad view */        if (ar->alignment == RGN_ALIGN_QSPLIT)            WM_operator_name_call(C, "SCREEN_OT_region_quadview", WM_OP_EXEC_DEFAULT, NULL);        /* toolbox, properties panel and header are hidden */        for (arhide = sa->regionbase.first; arhide; arhide = arhide->next) {            if (arhide->regiontype != RGN_TYPE_WINDOW) {                if (!(arhide->flag & RGN_FLAG_HIDDEN)) {                    ED_region_toggle_hidden(C, arhide);                }            }        }        /* full screen the area */        if (!sa->full) {            ED_screen_state_toggle(C, win, sa, SCREENMAXIMIZED);        }        /* Fullscreen */        if ((scene->gm.playerflag & GAME_PLAYER_FULLSCREEN)) {            WM_operator_name_call(C, "WM_OT_window_fullscreen_toggle", WM_OP_EXEC_DEFAULT, NULL);            wm_get_screensize(&ar->winrct.xmax, &ar->winrct.ymax);            ar->winx = ar->winrct.xmax + 1;            ar->winy = ar->winrct.ymax + 1;        }        else {            GHOST_RectangleHandle rect = GHOST_GetClientBounds(win->ghostwin);            ar->winrct.ymax = GHOST_GetHeightRectangle(rect);            ar->winrct.xmax = GHOST_GetWidthRectangle(rect);            ar->winx = ar->winrct.xmax + 1;            ar->winy = ar->winrct.ymax + 1;            GHOST_DisposeRectangle(rect);        }        WM_operator_name_call(C, "VIEW3D_OT_game_start", WM_OP_EXEC_DEFAULT, NULL);        BKE_sound_exit();        return true;    }    else {        ReportTimerInfo *rti;        BKE_report(&wm->reports, RPT_ERROR, "No valid 3D View found, game auto start is not possible");        /* After adding the report to the global list, reset the report timer. */        WM_event_remove_timer(wm, NULL, wm->reports.reporttimer);        /* Records time since last report was added */        wm->reports.reporttimer = WM_event_add_timer(wm, CTX_wm_window(C), TIMER, 0.02);        rti = MEM_callocN(sizeof(ReportTimerInfo), "ReportTimerInfo");        wm->reports.reporttimer->customdata = rti;        return false;    }}