Differential D2919 Diff 9563 source/blender/editors/render/render_internal.c

Changeset View

Standalone View

source/blender/editors/render/render_internal.c

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines	typedef struct RenderJob {
Scene *scene;		Scene *scene;
SceneLayer *scene_layer;		SceneLayer *scene_layer;
Scene *current_scene;		Scene *current_scene;
/* TODO(sergey): Should not be needed once engine will have own		/* TODO(sergey): Should not be needed once engine will have own
* depsgraph and copy-on-write will be implemented.		* depsgraph and copy-on-write will be implemented.
*/		*/
Depsgraph *depsgraph;		Depsgraph *depsgraph;
Render *re;		Render *re;
SceneRenderLayer *srl;
struct Object *camera_override;		struct Object *camera_override;
int lay_override;		int lay_override;
bool v3d_override;		bool v3d_override;
bool anim, write_still;		bool anim, write_still;
Image *image;		Image *image;
ImageUser iuser;		ImageUser iuser;
bool image_outdated;		bool image_outdated;
short *stop;		short *stop;
▲ Show 20 Lines • Show All 136 Lines • ▼ Show 20 Lines	IMB_partial_display_buffer_update(ibuf, rectf, NULL,
rr->do_exr_tile);		rr->do_exr_tile);
}		}

/* **************************** render invoking *************** */		/* **************************** render invoking *************** */

/* set callbacks, exported to sequence render too.		/* set callbacks, exported to sequence render too.
* Only call in foreground (UI) renders. */		* Only call in foreground (UI) renders. */

static void screen_render_scene_layer_set(wmOperator op, Main mainp, Scene scene, SceneRenderLayer srl)		static void screen_render_scene_layer_set(wmOperator op, Main mainp, Scene scene, SceneLayer scene_layer)
{		{
/* single layer re-render */		/* single layer re-render */
if (RNA_struct_property_is_set(op->ptr, "scene")) {		if (RNA_struct_property_is_set(op->ptr, "scene")) {
Scene *scn;		Scene *scn;
char scene_name[MAX_ID_NAME - 2];		char scene_name[MAX_ID_NAME - 2];

RNA_string_get(op->ptr, "scene", scene_name);		RNA_string_get(op->ptr, "scene", scene_name);
scn = (Scene *)BLI_findstring(&mainp->scene, scene_name, offsetof(ID, name) + 2);		scn = (Scene *)BLI_findstring(&mainp->scene, scene_name, offsetof(ID, name) + 2);

if (scn) {		if (scn) {
/* camera switch wont have updated */		/* camera switch wont have updated */
scn->r.cfra = (*scene)->r.cfra;		scn->r.cfra = (*scene)->r.cfra;
BKE_scene_camera_switch_update(scn);		BKE_scene_camera_switch_update(scn);

*scene = scn;		*scene = scn;
}		}
}		}

if (RNA_struct_property_is_set(op->ptr, "layer")) {		if (RNA_struct_property_is_set(op->ptr, "layer")) {
SceneRenderLayer *rl;		SceneLayer *rl;
char rl_name[RE_MAXNAME];		char rl_name[RE_MAXNAME];

RNA_string_get(op->ptr, "layer", rl_name);		RNA_string_get(op->ptr, "layer", rl_name);
rl = (SceneRenderLayer )BLI_findstring(&(scene)->r.layers, rl_name, offsetof(SceneRenderLayer, name));		rl = (SceneLayer )BLI_findstring(&(scene)->render_layers, rl_name, offsetof(SceneLayer, name));

if (rl)		if (rl)
*srl = rl;		*scene_layer = rl;
}		}
}		}

/* executes blocking render */		/* executes blocking render */
static int screen_render_exec(bContext C, wmOperator op)		static int screen_render_exec(bContext C, wmOperator op)
{		{
Scene *scene = CTX_data_scene(C);		Scene *scene = CTX_data_scene(C);
SceneLayer *scene_layer = CTX_data_scene_layer(C);		SceneLayer *scene_layer = NULL;
Depsgraph *depsgraph = CTX_data_depsgraph(C);		Depsgraph *depsgraph = CTX_data_depsgraph(C);
SceneRenderLayer *srl = NULL;
Render *re;		Render *re;
Image *ima;		Image *ima;
View3D *v3d = CTX_wm_view3d(C);		View3D *v3d = CTX_wm_view3d(C);
Main *mainp = CTX_data_main(C);		Main *mainp = CTX_data_main(C);
unsigned int lay_override;		unsigned int lay_override;
const bool is_animation = RNA_boolean_get(op->ptr, "animation");		const bool is_animation = RNA_boolean_get(op->ptr, "animation");
const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");		const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;		struct Object *camera_override = v3d ? V3D_CAMERA_LOCAL(v3d) : NULL;

/* custom scene and single layer re-render */		/* custom scene and single layer re-render */
screen_render_scene_layer_set(op, mainp, &scene, &srl);		screen_render_scene_layer_set(op, mainp, &scene, &scene_layer);
		if (scene_layer == NULL) {
		scene_layer = CTX_data_scene_layer(C);
		}

if (!is_animation && is_write_still && BKE_imtype_is_movie(scene->r.im_format.imtype)) {		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");		BKE_report(op->reports, RPT_ERROR, "Cannot write a single file with an animation format selected");
return OPERATOR_CANCELLED;		return OPERATOR_CANCELLED;
}		}

re = RE_NewSceneRender(scene);		re = RE_NewSceneRender(scene);
RE_SetDepsgraph(re, CTX_data_depsgraph(C));		RE_SetDepsgraph(re, CTX_data_depsgraph(C));
Show All 13 Lines	static int screen_render_exec(bContext C, wmOperator op)
BKE_sequencer_cache_cleanup();		BKE_sequencer_cache_cleanup();

RE_SetReports(re, op->reports);		RE_SetReports(re, op->reports);

BLI_begin_threaded_malloc();		BLI_begin_threaded_malloc();
if (is_animation)		if (is_animation)
RE_BlenderAnim(re, mainp, scene, camera_override, lay_override, scene->r.sfra, scene->r.efra, scene->r.frame_step);		RE_BlenderAnim(re, mainp, scene, camera_override, lay_override, scene->r.sfra, scene->r.efra, scene->r.frame_step);
else		else
RE_BlenderFrame(re, mainp, scene, srl, camera_override, lay_override, scene->r.cfra, is_write_still);		RE_BlenderFrame(re, mainp, scene, scene_layer, camera_override, lay_override, scene->r.cfra, is_write_still);
BLI_end_threaded_malloc();		BLI_end_threaded_malloc();

RE_SetReports(re, NULL);		RE_SetReports(re, NULL);

// no redraw needed, we leave state as we entered it		// no redraw needed, we leave state as we entered it
ED_update_for_newframe(mainp, scene, scene_layer, depsgraph);		ED_update_for_newframe(mainp, scene, scene_layer, depsgraph);

WM_event_add_notifier(C, NC_SCENE \| ND_RENDER_RESULT, scene);		WM_event_add_notifier(C, NC_SCENE \| ND_RENDER_RESULT, scene);
▲ Show 20 Lines • Show All 260 Lines • ▼ Show 20 Lines	static void render_startjob(void rjv, short stop, short do_update, float progress)
rj->do_update = do_update;		rj->do_update = do_update;
rj->progress = progress;		rj->progress = progress;

RE_SetReports(rj->re, rj->reports);		RE_SetReports(rj->re, rj->reports);

if (rj->anim)		if (rj->anim)
RE_BlenderAnim(rj->re, rj->main, rj->scene, rj->camera_override, rj->lay_override, rj->scene->r.sfra, rj->scene->r.efra, rj->scene->r.frame_step);		RE_BlenderAnim(rj->re, rj->main, rj->scene, rj->camera_override, rj->lay_override, rj->scene->r.sfra, rj->scene->r.efra, rj->scene->r.frame_step);
else		else
RE_BlenderFrame(rj->re, rj->main, rj->scene, rj->srl, rj->camera_override, rj->lay_override, rj->scene->r.cfra, rj->write_still);		RE_BlenderFrame(rj->re, rj->main, rj->scene, rj->scene_layer, rj->camera_override, rj->lay_override, rj->scene->r.cfra, rj->write_still);

RE_SetReports(rj->re, NULL);		RE_SetReports(rj->re, NULL);
}		}

static void render_image_restore_layer(RenderJob *rj)		static void render_image_restore_layer(RenderJob *rj)
{		{
wmWindowManager *wm;		wmWindowManager *wm;

Show All 36 Lines	static void render_endjob(void *rjv)
}		}

/* XXX above function sets all tags in nodes */		/* XXX above function sets all tags in nodes */
ntreeCompositClearTags(rj->scene->nodetree);		ntreeCompositClearTags(rj->scene->nodetree);

/* potentially set by caller */		/* potentially set by caller */
rj->scene->r.scemode &= ~R_NO_FRAME_UPDATE;		rj->scene->r.scemode &= ~R_NO_FRAME_UPDATE;

if (rj->srl) {		if (rj->scene_layer) {
nodeUpdateID(rj->scene->nodetree, &rj->scene->id);		nodeUpdateID(rj->scene->nodetree, &rj->scene->id);
WM_main_add_notifier(NC_NODE \| NA_EDITED, rj->scene);		WM_main_add_notifier(NC_NODE \| NA_EDITED, rj->scene);
}		}

if (rj->sa) {		if (rj->sa) {
render_image_restore_layer(rj);		render_image_restore_layer(rj);
}		}

Show All 13 Lines	static void render_endjob(void *rjv)
*		*
* Perhaps proper way would be to toggle active render		* Perhaps proper way would be to toggle active render
* layer in image editor and job, so we always display		* layer in image editor and job, so we always display
* layer being currently rendered. But this is not so much		* layer being currently rendered. But this is not so much
* trivial at this moment, especially because of external		* trivial at this moment, especially because of external
* engine API, so lets use simple and robust way for now		* engine API, so lets use simple and robust way for now
* - sergey -		* - sergey -
*/		*/
if (rj->scene->r.layers.first != rj->scene->r.layers.last \|\|		if (rj->scene->render_layers.first != rj->scene->render_layers.last \|\|
rj->image_outdated)		rj->image_outdated)
{		{
void *lock;		void *lock;
Image *ima = rj->image;		Image *ima = rj->image;
ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);		ImBuf *ibuf = BKE_image_acquire_ibuf(ima, &rj->iuser, &lock);

if (ibuf)		if (ibuf)
ibuf->userflags \|= IB_DISPLAY_BUFFER_INVALID;		ibuf->userflags \|= IB_DISPLAY_BUFFER_INVALID;
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines	static void clean_viewport_memory(Main bmain, Scene scene)
}		}
}		}

/* using context, starts job */		/* using context, starts job */
static int screen_render_invoke(bContext C, wmOperator op, const wmEvent *event)		static int screen_render_invoke(bContext C, wmOperator op, const wmEvent *event)
{		{
/* new render clears all callbacks */		/* new render clears all callbacks */
Main *mainp;		Main *mainp;
		SceneLayer *scene_layer = NULL;
Scene *scene = CTX_data_scene(C);		Scene *scene = CTX_data_scene(C);
SceneRenderLayer *srl = NULL;
Render *re;		Render *re;
wmJob *wm_job;		wmJob *wm_job;
RenderJob *rj;		RenderJob *rj;
Image *ima;		Image *ima;
int jobflag;		int jobflag;
const bool is_animation = RNA_boolean_get(op->ptr, "animation");		const bool is_animation = RNA_boolean_get(op->ptr, "animation");
const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");		const bool is_write_still = RNA_boolean_get(op->ptr, "write_still");
const bool use_viewport = RNA_boolean_get(op->ptr, "use_viewport");		const bool use_viewport = RNA_boolean_get(op->ptr, "use_viewport");
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines	static int screen_render_invoke(bContext C, wmOperator op, const wmEvent *event)
// store spare		// store spare

/* ensure at least 1 area shows result */		/* ensure at least 1 area shows result */
sa = render_view_open(C, event->x, event->y, op->reports);		sa = render_view_open(C, event->x, event->y, op->reports);

jobflag = WM_JOB_EXCL_RENDER \| WM_JOB_PRIORITY \| WM_JOB_PROGRESS;		jobflag = WM_JOB_EXCL_RENDER \| WM_JOB_PRIORITY \| WM_JOB_PROGRESS;

/* custom scene and single layer re-render */		/* custom scene and single layer re-render */
screen_render_scene_layer_set(op, mainp, &scene, &srl);		screen_render_scene_layer_set(op, mainp, &scene, &scene_layer);
		if (scene_layer == NULL) {
		scene_layer = CTX_data_scene_layer(C);
		}

if (RNA_struct_property_is_set(op->ptr, "layer"))		if (RNA_struct_property_is_set(op->ptr, "layer"))
jobflag \|= WM_JOB_SUSPEND;		jobflag \|= WM_JOB_SUSPEND;

/* job custom data */		/* job custom data */
rj = MEM_callocN(sizeof(RenderJob), "render job");		rj = MEM_callocN(sizeof(RenderJob), "render job");
rj->main = mainp;		rj->main = mainp;
rj->scene = scene;		rj->scene = scene;
rj->current_scene = rj->scene;		rj->current_scene = rj->scene;
rj->scene_layer = CTX_data_scene_layer(C);		rj->scene_layer = scene_layer;
/* TODO(sergey): Render engine should be using own depsgraph. */		/* TODO(sergey): Render engine should be using own depsgraph. */
rj->depsgraph = CTX_data_depsgraph(C);		rj->depsgraph = CTX_data_depsgraph(C);
rj->srl = srl;
rj->camera_override = camera_override;		rj->camera_override = camera_override;
rj->lay_override = 0;		rj->lay_override = 0;
rj->anim = is_animation;		rj->anim = is_animation;
rj->write_still = is_write_still && !is_animation;		rj->write_still = is_write_still && !is_animation;
rj->iuser.scene = scene;		rj->iuser.scene = scene;
rj->iuser.ok = 1;		rj->iuser.ok = 1;
rj->reports = op->reports;		rj->reports = op->reports;
rj->orig_layer = 0;		rj->orig_layer = 0;
▲ Show 20 Lines • Show All 341 Lines • ▼ Show 20 Lines	if ((update_flag & (PR_UPDATE_RENDERSIZE \| PR_UPDATE_DATABASE \| PR_UPDATE_VIEW)) \|\| rstats->convertdone == 0) {
rdata.scemode \|= R_VIEWPORT_PREVIEW;		rdata.scemode \|= R_VIEWPORT_PREVIEW;

/* we do use layers, but only active */		/* we do use layers, but only active */
rdata.scemode \|= R_SINGLE_LAYER;		rdata.scemode \|= R_SINGLE_LAYER;

/* initalize always */		/* initalize always */
if (use_border) {		if (use_border) {
rdata.mode \|= R_BORDER;		rdata.mode \|= R_BORDER;
RE_InitState(re, NULL, &rdata, &rp->scene->view_render, NULL, rp->ar->winx, rp->ar->winy, &cliprct);		RE_InitState(re, NULL, &rdata, &rp->scene->render_layers, rp->scene->active_layer, &rp->scene->view_render, NULL, rp->ar->winx, rp->ar->winy, &cliprct);
}		}
else		else
RE_InitState(re, NULL, &rdata, &rp->scene->view_render, NULL, rp->ar->winx, rp->ar->winy, NULL);		RE_InitState(re, NULL, &rdata, &rp->scene->render_layers, rp->scene->active_layer, &rp->scene->view_render, NULL, rp->ar->winx, rp->ar->winy, NULL);
}		}

if (orth)		if (orth)
RE_SetOrtho(re, &viewplane, clipsta, clipend);		RE_SetOrtho(re, &viewplane, clipsta, clipend);
else		else
RE_SetWindow(re, &viewplane, clipsta, clipend);		RE_SetWindow(re, &viewplane, clipsta, clipend);

RE_SetPixelSize(re, pixsize);		RE_SetPixelSize(re, pixsize);
▲ Show 20 Lines • Show All 429 Lines • Show Last 20 Lines