Differential D2919 Diff 9582 source/blender/render/intern/source/pipeline.c

Changeset View

Standalone View

source/blender/render/intern/source/pipeline.c

Show First 20 Lines • Show All 258 Lines • ▼ Show 20 Lines

RenderResult RE_MultilayerConvert(void exrhandle, const char *colorspace, bool predivide, int rectx, int recty)		RenderResult RE_MultilayerConvert(void exrhandle, const char *colorspace, bool predivide, int rectx, int recty)
{		{
return render_result_new_from_exr(exrhandle, colorspace, predivide, rectx, recty);		return render_result_new_from_exr(exrhandle, colorspace, predivide, rectx, recty);
}		}

RenderLayer render_get_active_layer(Render re, RenderResult *rr)		RenderLayer render_get_active_layer(Render re, RenderResult *rr)
{		{
RenderLayer *rl = BLI_findlink(&rr->layers, re->r.actlay);		RenderLayer *rl = BLI_findlink(&rr->layers, re->active_layer);

if (rl)		if (rl)
return rl;		return rl;
else		else
return rr->layers.first;		return rr->layers.first;
}		}

static int render_scene_needs_vector(Render *re)		static int render_scene_needs_vector(Render *re)
{		{
SceneRenderLayer *srl;		SceneLayer *scene_layer;
		for (scene_layer = re->render_layers.first; scene_layer; scene_layer = scene_layer->next)
for (srl = re->r.layers.first; srl; srl = srl->next)		if (scene_layer->flag & SCENE_LAYER_RENDER) {
if (!(srl->layflag & SCE_LAY_DISABLE))		if (scene_layer->passflag & SCE_PASS_VECTOR) {
if (srl->passflag & SCE_PASS_VECTOR)
return 1;		return 1;
		}
		}
return 0;		return 0;
}		}

static bool render_scene_has_layers_to_render(Scene *scene)		static bool render_scene_has_layers_to_render(Scene *scene)
{		{
SceneRenderLayer *srl;		SceneLayer *scene_layer;
for (srl = scene->r.layers.first; srl; srl = srl->next) {		for (scene_layer = scene->render_layers.first; scene_layer; scene_layer = scene_layer->next) {
if (!(srl->layflag & SCE_LAY_DISABLE)) {		if (scene_layer->flag & SCENE_LAYER_RENDER) {
return true;		return true;
}		}
}		}
return false;		return false;
}		}

/* *************************************************** */		/* *************************************************** */

▲ Show 20 Lines • Show All 279 Lines • ▼ Show 20 Lines
void RE_FreeRender(Render *re)		void RE_FreeRender(Render *re)
{		{
if (re->engine)		if (re->engine)
RE_engine_free(re->engine);		RE_engine_free(re->engine);

BLI_rw_mutex_end(&re->resultmutex);		BLI_rw_mutex_end(&re->resultmutex);
BLI_rw_mutex_end(&re->partsmutex);		BLI_rw_mutex_end(&re->partsmutex);

BLI_freelistN(&re->r.layers);		BLI_freelistN(&re->render_layers);
BLI_freelistN(&re->r.views);		BLI_freelistN(&re->r.views);

curvemapping_free_data(&re->r.mblur_shutter_curve);		curvemapping_free_data(&re->r.mblur_shutter_curve);

/* main dbase can already be invalid now, some database-free code checks it */		/* main dbase can already be invalid now, some database-free code checks it */
re->main = NULL;		re->main = NULL;
re->scene = NULL;		re->scene = NULL;
re->depsgraph = NULL;		re->depsgraph = NULL;
▲ Show 20 Lines • Show All 129 Lines • ▼ Show 20 Lines	static void re_init_resolution(Render re, Render source,
}		}

/* we clip faces with a minimum of 2 pixel boundary outside of image border. see zbuf.c */		/* we clip faces with a minimum of 2 pixel boundary outside of image border. see zbuf.c */
re->clipcrop = 1.0f + 2.0f / (float)(re->winx > re->winy ? re->winy : re->winx);		re->clipcrop = 1.0f + 2.0f / (float)(re->winx > re->winy ? re->winy : re->winx);
}		}

void render_copy_renderdata(RenderData to, RenderData from)		void render_copy_renderdata(RenderData to, RenderData from)
{		{
BLI_freelistN(&to->layers);
BLI_freelistN(&to->views);		BLI_freelistN(&to->views);
curvemapping_free_data(&to->mblur_shutter_curve);		curvemapping_free_data(&to->mblur_shutter_curve);

to = from;		to = from;

BLI_duplicatelist(&to->layers, &from->layers);
BLI_duplicatelist(&to->views, &from->views);		BLI_duplicatelist(&to->views, &from->views);
curvemapping_copy_data(&to->mblur_shutter_curve, &from->mblur_shutter_curve);		curvemapping_copy_data(&to->mblur_shutter_curve, &from->mblur_shutter_curve);
}		}

void render_copy_viewrender(ViewRender to, ViewRender from)		void render_copy_viewrender(ViewRender to, ViewRender from)
{		{
BKE_viewrender_copy(to, from);		BKE_viewrender_copy(to, from);
}		}

/* what doesn't change during entire render sequence */		/* what doesn't change during entire render sequence */
/* disprect is optional, if NULL it assumes full window render */		/* disprect is optional, if NULL it assumes full window render */
void RE_InitState(Render re, Render source, RenderData *rd,		void RE_InitState(Render re, Render source, RenderData *rd,
ViewRender view_render, SceneRenderLayer srl,		ListBase *render_layers, const int active_layer,
		ViewRender view_render, SceneLayer scene_layer,
int winx, int winy, rcti *disprect)		int winx, int winy, rcti *disprect)
{		{
bool had_freestyle = (re->r.mode & R_EDGE_FRS) != 0;		bool had_freestyle = (re->r.mode & R_EDGE_FRS) != 0;

re->ok = true; /* maybe flag */		re->ok = true; /* maybe flag */

re->i.starttime = PIL_check_seconds_timer();		re->i.starttime = PIL_check_seconds_timer();

/* copy render data and render layers for thread safety */		/* copy render data and render layers for thread safety */
render_copy_renderdata(&re->r, rd);		render_copy_renderdata(&re->r, rd);
render_copy_viewrender(&re->view_render, view_render);		render_copy_viewrender(&re->view_render, view_render);
		BLI_freelistN(&re->render_layers);
		BLI_duplicatelist(&re->render_layers, render_layers);
		re->active_layer = active_layer;

if (source) {		if (source) {
/* reuse border flags from source renderer */		/* reuse border flags from source renderer */
re->r.mode &= ~(R_BORDER \| R_CROP);		re->r.mode &= ~(R_BORDER \| R_CROP);
re->r.mode \|= source->r.mode & (R_BORDER \| R_CROP);		re->r.mode \|= source->r.mode & (R_BORDER \| R_CROP);

/* dimensions shall be shared between all renderers */		/* dimensions shall be shared between all renderers */
re->r.xsch = source->r.xsch;		re->r.xsch = source->r.xsch;
Show All 32 Lines	else {
/* check state variables, osa? */		/* check state variables, osa? */
if (re->r.mode & (R_OSA)) {		if (re->r.mode & (R_OSA)) {
re->osa = re->r.osa;		re->osa = re->r.osa;
if (re->osa > 16) re->osa = 16;		if (re->osa > 16) re->osa = 16;
}		}
else re->osa = 0;		else re->osa = 0;
}		}

if (srl) {		if (scene_layer) {
int index = BLI_findindex(&rd->layers, srl);		int index = BLI_findindex(render_layers, scene_layer);
if (index != -1) {		if (index != -1) {
re->r.actlay = index;		re->active_layer = index;
re->r.scemode \|= R_SINGLE_LAYER;		re->r.scemode \|= R_SINGLE_LAYER;
}		}
}		}

/* always call, checks for gamma, gamma tables and jitter too */		/* always call, checks for gamma, gamma tables and jitter too */
make_sample_tables(re);		make_sample_tables(re);

/* if preview render, we try to keep old result */		/* if preview render, we try to keep old result */
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);		BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);

if (re->r.scemode & (R_BUTS_PREVIEW\|R_VIEWPORT_PREVIEW)) {		if (re->r.scemode & (R_BUTS_PREVIEW\|R_VIEWPORT_PREVIEW)) {
if (had_freestyle \|\| (re->r.mode & R_EDGE_FRS)) {		if (had_freestyle \|\| (re->r.mode & R_EDGE_FRS)) {
/* freestyle manipulates render layers so always have to free */		/* freestyle manipulates render layers so always have to free */
render_result_free(re->result);		render_result_free(re->result);
re->result = NULL;		re->result = NULL;
}		}
else if (re->result) {		else if (re->result) {
SceneRenderLayer *actsrl = BLI_findlink(&re->r.layers, re->r.actlay);		SceneLayer *active_render_layer = BLI_findlink(&re->render_layers, re->active_layer);
RenderLayer *rl;		RenderLayer *rl;
bool have_layer = false;		bool have_layer = false;

for (rl = re->result->layers.first; rl; rl = rl->next)		for (rl = re->result->layers.first; rl; rl = rl->next)
if (STREQ(rl->name, actsrl->name))		if (STREQ(rl->name, active_render_layer->name))
have_layer = true;		have_layer = true;

if (re->result->rectx == re->rectx && re->result->recty == re->recty &&		if (re->result->rectx == re->rectx && re->result->recty == re->recty &&
have_layer)		have_layer)
{		{
/* keep render result, this avoids flickering black tiles		/* keep render result, this avoids flickering black tiles
* when the preview changes */		* when the preview changes */
}		}
▲ Show 20 Lines • Show All 108 Lines • ▼ Show 20 Lines	void RE_ChangeModeFlag(Render *re, int flag, bool clear)
}		}
else {		else {
re->r.mode \|= flag;		re->r.mode \|= flag;
}		}
}		}

/* update some variables that can be animated, and otherwise wouldn't be due to		/* update some variables that can be animated, and otherwise wouldn't be due to
* RenderData getting copied once at the start of animation render */		* RenderData getting copied once at the start of animation render */
void render_update_anim_renderdata(Render re, RenderData rd)		void render_update_anim_renderdata(Render re, RenderData rd, ListBase *render_layers)
{		{
/* filter */		/* filter */
re->r.gauss = rd->gauss;		re->r.gauss = rd->gauss;

/* motion blur */		/* motion blur */
re->r.mblur_samples = rd->mblur_samples;		re->r.mblur_samples = rd->mblur_samples;
re->r.blurfac = rd->blurfac;		re->r.blurfac = rd->blurfac;

/* freestyle */		/* freestyle */
re->r.line_thickness_mode = rd->line_thickness_mode;		re->r.line_thickness_mode = rd->line_thickness_mode;
re->r.unit_line_thickness = rd->unit_line_thickness;		re->r.unit_line_thickness = rd->unit_line_thickness;

/* render layers */		/* render layers */
BLI_freelistN(&re->r.layers);		BLI_freelistN(&re->render_layers);
BLI_duplicatelist(&re->r.layers, &rd->layers);		BLI_duplicatelist(&re->render_layers, render_layers);

/* render views */		/* render views */
BLI_freelistN(&re->r.views);		BLI_freelistN(&re->r.views);
BLI_duplicatelist(&re->r.views, &rd->views);		BLI_duplicatelist(&re->r.views, &rd->views);
}		}

void RE_SetWindow(Render re, const rctf viewplane, float clipsta, float clipend)		void RE_SetWindow(Render re, const rctf viewplane, float clipsta, float clipend)
{		{
▲ Show 20 Lines • Show All 985 Lines • ▼ Show 20 Lines	static void render_scene(Render re, Scene sce, int cfra)

/* exception: scene uses own size (unfinished code) */		/* exception: scene uses own size (unfinished code) */
if (0) {		if (0) {
winx = (sce->r.size * sce->r.xsch) / 100;		winx = (sce->r.size * sce->r.xsch) / 100;
winy = (sce->r.size * sce->r.ysch) / 100;		winy = (sce->r.size * sce->r.ysch) / 100;
}		}

/* initial setup */		/* initial setup */
RE_InitState(resc, re, &sce->r, &sce->view_render, NULL, winx, winy, &re->disprect);		RE_InitState(resc, re, &sce->r, &sce->render_layers, sce->active_layer, &sce->view_render, NULL, winx, winy, &re->disprect);

/* We still want to use 'rendercache' setting from org (main) scene... */		/* We still want to use 'rendercache' setting from org (main) scene... */
resc->r.scemode = (resc->r.scemode & ~R_EXR_CACHE_FILE) \| (re->r.scemode & R_EXR_CACHE_FILE);		resc->r.scemode = (resc->r.scemode & ~R_EXR_CACHE_FILE) \| (re->r.scemode & R_EXR_CACHE_FILE);

/* still unsure entity this... */		/* still unsure entity this... */
resc->main = re->main;		resc->main = re->main;
resc->depsgraph = re->depsgraph;		resc->depsgraph = re->depsgraph;
resc->scene = sce;		resc->scene = sce;
▲ Show 20 Lines • Show All 254 Lines • ▼ Show 20 Lines	static void init_freestyle(Render *re)
re->freestyle_bmain->wm = re->main->wm;		re->freestyle_bmain->wm = re->main->wm;

FRS_init_stroke_renderer(re);		FRS_init_stroke_renderer(re);
}		}

/* invokes Freestyle stroke rendering */		/* invokes Freestyle stroke rendering */
static void add_freestyle(Render *re, int render)		static void add_freestyle(Render *re, int render)
{		{
SceneRenderLayer srl, actsrl;		SceneLayer scene_layer, active_render_layer;
LinkData *link;		LinkData *link;
Render *r;		Render *r;
const bool do_link = (re->r.mode & R_MBLUR) == 0 \|\| re->i.curblur == re->r.mblur_samples;		const bool do_link = (re->r.mode & R_MBLUR) == 0 \|\| re->i.curblur == re->r.mblur_samples;

actsrl = BLI_findlink(&re->r.layers, re->r.actlay);		active_render_layer = BLI_findlink(&re->render_layers, re->active_layer);

FRS_begin_stroke_rendering(re);		FRS_begin_stroke_rendering(re);

for (srl = (SceneRenderLayer *)re->r.layers.first; srl; srl = srl->next) {		for (scene_layer = (SceneLayer *)re->render_layers.first; scene_layer; scene_layer = scene_layer->next) {
if (do_link) {		if (do_link) {
link = (LinkData *)MEM_callocN(sizeof(LinkData), "LinkData to Freestyle render");		link = (LinkData *)MEM_callocN(sizeof(LinkData), "LinkData to Freestyle render");
BLI_addtail(&re->freestyle_renders, link);		BLI_addtail(&re->freestyle_renders, link);
}		}
if ((re->r.scemode & R_SINGLE_LAYER) && srl != actsrl)		if ((re->r.scemode & R_SINGLE_LAYER) && scene_layer != active_render_layer)
continue;		continue;
if (FRS_is_freestyle_enabled(srl)) {		if (FRS_is_freestyle_enabled(scene_layer)) {
r = FRS_do_stroke_rendering(re, srl, render);		r = FRS_do_stroke_rendering(re, scene_layer, render);
if (do_link)		if (do_link)
link->data = (void *)r;		link->data = (void *)r;
}		}
}		}

FRS_end_stroke_rendering(re);		FRS_end_stroke_rendering(re);

/* restore the global R value (invalidated by nested execution of the internal renderer) */		/* restore the global R value (invalidated by nested execution of the internal renderer) */
R = *re;		R = *re;
}		}

/* merges the results of Freestyle stroke rendering into a given render result */		/* merges the results of Freestyle stroke rendering into a given render result */
static void composite_freestyle_renders(Render *re, int sample)		static void composite_freestyle_renders(Render *re, int sample)
{		{
Render *freestyle_render;		Render *freestyle_render;
RenderView *rv;		RenderView *rv;
SceneRenderLayer srl, actsrl;		SceneLayer scene_layer, active_scene_layer;
LinkData *link;		LinkData *link;

actsrl = BLI_findlink(&re->r.layers, re->r.actlay);		active_scene_layer = BLI_findlink(&re->render_layers, re->active_layer);

link = (LinkData *)re->freestyle_renders.first;		link = (LinkData *)re->freestyle_renders.first;

for (rv = re->result->views.first; rv; rv = rv->next) {		for (rv = re->result->views.first; rv; rv = rv->next) {
for (srl = (SceneRenderLayer *)re->r.layers.first; srl; srl = srl->next) {		for (scene_layer = (SceneLayer *)re->render_layers.first; scene_layer; scene_layer = scene_layer->next) {
if ((re->r.scemode & R_SINGLE_LAYER) && srl != actsrl)		if ((re->r.scemode & R_SINGLE_LAYER) && scene_layer != active_scene_layer)
continue;		continue;

if (FRS_is_freestyle_enabled(srl)) {		if (FRS_is_freestyle_enabled(scene_layer)) {
freestyle_render = (Render *)link->data;		freestyle_render = (Render *)link->data;

/* may be NULL in case of empty render layer */		/* may be NULL in case of empty render layer */
if (freestyle_render) {		if (freestyle_render) {
render_result_exr_file_read_sample(freestyle_render, sample);		render_result_exr_file_read_sample(freestyle_render, sample);
FRS_composite_result(re, srl, freestyle_render);		FRS_composite_result(re, scene_layer, freestyle_render);
RE_FreeRenderResult(freestyle_render->result);		RE_FreeRenderResult(freestyle_render->result);
freestyle_render->result = NULL;		freestyle_render->result = NULL;
}		}
}		}
link = link->next;		link = link->next;
}		}
}		}
}		}
▲ Show 20 Lines • Show All 563 Lines • ▼ Show 20 Lines	if (re->result != NULL) {
}		}
}		}
}		}

bool RE_force_single_renderlayer(Scene *scene)		bool RE_force_single_renderlayer(Scene *scene)
{		{
int scemode = check_mode_full_sample(&scene->r, &scene->view_render);		int scemode = check_mode_full_sample(&scene->r, &scene->view_render);
if (scemode & R_SINGLE_LAYER) {		if (scemode & R_SINGLE_LAYER) {
SceneRenderLayer *srl = BLI_findlink(&scene->r.layers, scene->r.actlay);		SceneLayer *scene_layer = BLI_findlink(&scene->render_layers, scene->active_layer);
/* force layer to be enabled */		/* force layer to be enabled */
if (srl->layflag & SCE_LAY_DISABLE) {		if ((scene_layer->flag & SCENE_LAYER_RENDER) == 0) {
srl->layflag &= ~SCE_LAY_DISABLE;		scene_layer->flag \|= SCENE_LAYER_RENDER;
return true;		return true;
}		}
}		}
return false;		return false;
}		}

static bool check_valid_compositing_camera(Scene scene, Object camera_override)		static bool check_valid_compositing_camera(Scene scene, Object camera_override)
{		{
▲ Show 20 Lines • Show All 274 Lines • ▼ Show 20 Lines

void RE_SetEngineByID(Render re, const char engine_id)		void RE_SetEngineByID(Render re, const char engine_id)
{		{
BLI_strncpy(re->view_render.engine_id, engine_id, sizeof(re->view_render.engine_id));		BLI_strncpy(re->view_render.engine_id, engine_id, sizeof(re->view_render.engine_id));
}		}

/* evaluating scene options for general Blender render */		/* evaluating scene options for general Blender render */
static int render_initialize_from_main(Render re, RenderData rd, Main bmain, Scene scene, ViewRender *view_render,		static int render_initialize_from_main(Render re, RenderData rd, Main bmain, Scene scene, ViewRender *view_render,
SceneRenderLayer srl, Object camera_override, unsigned int lay_override,		SceneLayer scene_layer, Object camera_override, unsigned int lay_override,
int anim, int anim_init)		int anim, int anim_init)
{		{
int winx, winy;		int winx, winy;
rcti disprect;		rcti disprect;

/* r.xsch and r.ysch has the actual view window size		/* r.xsch and r.ysch has the actual view window size
* r.border is the clipping rect */		* r.border is the clipping rect */

Show All 22 Lines	static int render_initialize_from_main(Render re, RenderData rd, Main bmain, Scene scene, ViewRender *view_render,
re->lay = lay_override ? lay_override : scene->lay;		re->lay = lay_override ? lay_override : scene->lay;
re->layer_override = lay_override;		re->layer_override = lay_override;
re->i.localview = (re->lay & 0xFF000000) != 0;		re->i.localview = (re->lay & 0xFF000000) != 0;
re->viewname[0] = '\0';		re->viewname[0] = '\0';
RE_SetEngineByID(re, view_render->engine_id);		RE_SetEngineByID(re, view_render->engine_id);

/* not too nice, but it survives anim-border render */		/* not too nice, but it survives anim-border render */
if (anim) {		if (anim) {
render_update_anim_renderdata(re, &scene->r);		render_update_anim_renderdata(re, &scene->r, &scene->render_layers);
re->disprect = disprect;		re->disprect = disprect;
return 1;		return 1;
}		}

/* check all scenes involved */		/* check all scenes involved */
tag_scenes_for_render(re);		tag_scenes_for_render(re);

/*		/*
* Disabled completely for now,		* Disabled completely for now,
* can be later set as render profile option		* can be later set as render profile option
* and default for background render.		* and default for background render.
*/		*/
if (0) {		if (0) {
/* make sure dynamics are up to date */		/* make sure dynamics are up to date */
SceneLayer *scene_layer = BKE_scene_layer_from_scene_get(scene);		scene_layer = BKE_scene_layer_from_scene_get(scene);
update_physics_cache(re, scene, scene_layer, anim_init);		update_physics_cache(re, scene, scene_layer, anim_init);
}		}

if (srl \|\| scene->r.scemode & R_SINGLE_LAYER) {		if (scene_layer \|\| scene->r.scemode & R_SINGLE_LAYER) {
BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);		BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
render_result_single_layer_begin(re);		render_result_single_layer_begin(re);
BLI_rw_mutex_unlock(&re->resultmutex);		BLI_rw_mutex_unlock(&re->resultmutex);
}		}

RE_InitState(re, NULL, &scene->r, &scene->view_render, srl, winx, winy, &disprect);		RE_InitState(re, NULL, &scene->r, &scene->render_layers, scene->active_layer, &scene->view_render, scene_layer, winx, winy, &disprect);
if (!re->ok) /* if an error was printed, abort */		if (!re->ok) /* if an error was printed, abort */
return 0;		return 0;

/* initstate makes new result, have to send changed tags around */		/* initstate makes new result, have to send changed tags around */
ntreeCompositTagRender(re->scene);		ntreeCompositTagRender(re->scene);

validate_render_settings(re);		validate_render_settings(re);

re->display_init(re->dih, re->result);		re->display_init(re->dih, re->result);
re->display_clear(re->dch, re->result);		re->display_clear(re->dch, re->result);

return 1;		return 1;
}		}

void RE_SetReports(Render re, ReportList reports)		void RE_SetReports(Render re, ReportList reports)
{		{
re->reports = reports;		re->reports = reports;
}		}

/* general Blender frame render call */		/* general Blender frame render call */
void RE_BlenderFrame(Render re, Main bmain, Scene scene, SceneRenderLayer srl, Object *camera_override,		void RE_BlenderFrame(Render re, Main bmain, Scene scene, SceneLayer scene_layer, Object *camera_override,
unsigned int lay_override, int frame, const bool write_still)		unsigned int lay_override, int frame, const bool write_still)
{		{
BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_INIT);		BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_INIT);

/* ugly global still... is to prevent preview events and signal subsurfs etc to make full resol */		/* ugly global still... is to prevent preview events and signal subsurfs etc to make full resol */
G.is_rendering = true;		G.is_rendering = true;

scene->r.cfra = frame;		scene->r.cfra = frame;

if (render_initialize_from_main(re, &scene->r, bmain, scene, &scene->view_render, srl,		if (render_initialize_from_main(re, &scene->r, bmain, scene, &scene->view_render, scene_layer,
camera_override, lay_override, 0, 0))		camera_override, lay_override, 0, 0))
{		{
MEM_reset_peak_memory();		MEM_reset_peak_memory();

BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_PRE);		BLI_callback_exec(re->main, (ID *)scene, BLI_CB_EVT_RENDER_PRE);

do_render_all_options(re);		do_render_all_options(re);

▲ Show 20 Lines • Show All 569 Lines • ▼ Show 20 Lines
{		{
Object *camera;		Object *camera;
SceneLayer *scene_layer = BKE_scene_layer_from_scene_get(sce);		SceneLayer *scene_layer = BKE_scene_layer_from_scene_get(sce);
int winx, winy;		int winx, winy;

winx = (sce->r.size * sce->r.xsch) / 100;		winx = (sce->r.size * sce->r.xsch) / 100;
winy = (sce->r.size * sce->r.ysch) / 100;		winy = (sce->r.size * sce->r.ysch) / 100;

RE_InitState(re, NULL, &sce->r, view_render, NULL, winx, winy, NULL);		RE_InitState(re, NULL, &sce->r, &sce->render_layers, sce->active_layer, view_render, NULL, winx, winy, NULL);

re->pool = BKE_image_pool_new();		re->pool = BKE_image_pool_new();

re->main = bmain;		re->main = bmain;
re->scene = sce;		re->scene = sce;
re->scene_color_manage = BKE_scene_check_color_management_enabled(sce);		re->scene_color_manage = BKE_scene_check_color_management_enabled(sce);
re->lay = sce->lay;		re->lay = sce->lay;
re->depsgraph = BKE_scene_get_depsgraph(sce, scene_layer, false);		re->depsgraph = BKE_scene_get_depsgraph(sce, scene_layer, false);
Show All 38 Lines	bool RE_ReadRenderResult(Scene scene, Scene scenode)

if (scenode)		if (scenode)
scene = scenode;		scene = scenode;

/* get render: it can be called from UI with draw callbacks */		/* get render: it can be called from UI with draw callbacks */
re = RE_GetSceneRender(scene);		re = RE_GetSceneRender(scene);
if (re == NULL)		if (re == NULL)
re = RE_NewSceneRender(scene);		re = RE_NewSceneRender(scene);
RE_InitState(re, NULL, &scene->r, &scene->view_render, NULL, winx, winy, &disprect);		RE_InitState(re, NULL, &scene->r, &scene->render_layers, scene->active_layer, &scene->view_render, NULL, winx, winy, &disprect);
re->scene = scene;		re->scene = scene;
re->scene_color_manage = BKE_scene_check_color_management_enabled(scene);		re->scene_color_manage = BKE_scene_check_color_management_enabled(scene);

BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);		BLI_rw_mutex_lock(&re->resultmutex, THREAD_LOCK_WRITE);
success = render_result_exr_file_cache_read(re);		success = render_result_exr_file_cache_read(re);
BLI_rw_mutex_unlock(&re->resultmutex);		BLI_rw_mutex_unlock(&re->resultmutex);

render_result_uncrop(re);		render_result_uncrop(re);
▲ Show 20 Lines • Show All 216 Lines • ▼ Show 20 Lines
RenderPass RE_create_gp_pass(RenderResult rr, const char layername, const char viewname)		RenderPass RE_create_gp_pass(RenderResult rr, const char layername, const char viewname)
{		{
RenderLayer *rl = BLI_findstring(&rr->layers, layername, offsetof(RenderLayer, name));		RenderLayer *rl = BLI_findstring(&rr->layers, layername, offsetof(RenderLayer, name));
/* only create render layer if not exist */		/* only create render layer if not exist */
if (!rl) {		if (!rl) {
rl = MEM_callocN(sizeof(RenderLayer), layername);		rl = MEM_callocN(sizeof(RenderLayer), layername);
BLI_addtail(&rr->layers, rl);		BLI_addtail(&rr->layers, rl);
BLI_strncpy(rl->name, layername, sizeof(rl->name));		BLI_strncpy(rl->name, layername, sizeof(rl->name));
rl->lay = 0;
rl->layflag = SCE_LAY_SOLID;		rl->layflag = SCE_LAY_SOLID;
rl->passflag = SCE_PASS_COMBINED;		rl->passflag = SCE_PASS_COMBINED;
rl->rectx = rr->rectx;		rl->rectx = rr->rectx;
rl->recty = rr->recty;		rl->recty = rr->recty;
}		}

/* clear previous pass if exist or the new image will be over previous one*/		/* clear previous pass if exist or the new image will be over previous one*/
RenderPass *rp = RE_pass_find_by_name(rl, RE_PASSNAME_COMBINED, viewname);		RenderPass *rp = RE_pass_find_by_name(rl, RE_PASSNAME_COMBINED, viewname);
Show All 9 Lines