Differential D2927 Diff 9589 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->active_layer);		RenderLayer *rl = BLI_findlink(&rr->layers, re->active_view_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)
{		{
SceneLayer *scene_layer;		ViewLayer *view_layer;
for (scene_layer = re->render_layers.first; scene_layer; scene_layer = scene_layer->next)		for (view_layer = re->view_layers.first; view_layer; view_layer = view_layer->next)
if (scene_layer->flag & SCENE_LAYER_RENDER) {		if (view_layer->flag & VIEW_LAYER_RENDER) {
if (scene_layer->passflag & SCE_PASS_VECTOR) {		if (view_layer->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)
{		{
SceneLayer *scene_layer;		ViewLayer *view_layer;
for (scene_layer = scene->render_layers.first; scene_layer; scene_layer = scene_layer->next) {		for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
if (scene_layer->flag & SCENE_LAYER_RENDER) {		if (view_layer->flag & VIEW_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->render_layers);		BLI_freelistN(&re->view_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 147 Lines • ▼ Show 20 Lines
{		{
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,
ListBase *render_layers, const int active_layer,		ListBase *render_layers, const int active_layer,
ViewRender view_render, SceneLayer scene_layer,		ViewRender view_render, ViewLayer view_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_freelistN(&re->view_layers);
BLI_duplicatelist(&re->render_layers, render_layers);		BLI_duplicatelist(&re->view_layers, render_layers);
re->active_layer = active_layer;		re->active_view_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 (scene_layer) {		if (view_layer) {
int index = BLI_findindex(render_layers, scene_layer);		int index = BLI_findindex(render_layers, view_layer);
if (index != -1) {		if (index != -1) {
re->active_layer = index;		re->active_view_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) {
SceneLayer *active_render_layer = BLI_findlink(&re->render_layers, re->active_layer);		ViewLayer *active_render_layer = BLI_findlink(&re->view_layers, re->active_view_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, active_render_layer->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 &&
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines	void render_update_anim_renderdata(Render re, RenderData rd, ListBase *render_layers)
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->render_layers);		BLI_freelistN(&re->view_layers);
BLI_duplicatelist(&re->render_layers, render_layers);		BLI_duplicatelist(&re->view_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->render_layers, sce->active_layer, &sce->view_render, NULL, winx, winy, &re->disprect);		RE_InitState(resc, re, &sce->r, &sce->view_layers, sce->active_view_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)
{		{
SceneLayer scene_layer, active_render_layer;		ViewLayer view_layer, active_view_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;

active_render_layer = BLI_findlink(&re->render_layers, re->active_layer);		active_view_layer = BLI_findlink(&re->view_layers, re->active_view_layer);

FRS_begin_stroke_rendering(re);		FRS_begin_stroke_rendering(re);

for (scene_layer = (SceneLayer *)re->render_layers.first; scene_layer; scene_layer = scene_layer->next) {		for (view_layer = (ViewLayer *)re->view_layers.first; view_layer; view_layer = view_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) && scene_layer != active_render_layer)		if ((re->r.scemode & R_SINGLE_LAYER) && view_layer != active_view_layer)
continue;		continue;
if (FRS_is_freestyle_enabled(scene_layer)) {		if (FRS_is_freestyle_enabled(view_layer)) {
r = FRS_do_stroke_rendering(re, scene_layer, render);		r = FRS_do_stroke_rendering(re, view_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;
SceneLayer scene_layer, active_scene_layer;		ViewLayer view_layer, active_view_layer;
LinkData *link;		LinkData *link;

active_scene_layer = BLI_findlink(&re->render_layers, re->active_layer);		active_view_layer = BLI_findlink(&re->view_layers, re->active_view_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 (scene_layer = (SceneLayer *)re->render_layers.first; scene_layer; scene_layer = scene_layer->next) {		for (view_layer = (ViewLayer *)re->view_layers.first; view_layer; view_layer = view_layer->next) {
if ((re->r.scemode & R_SINGLE_LAYER) && scene_layer != active_scene_layer)		if ((re->r.scemode & R_SINGLE_LAYER) && view_layer != active_view_layer)
continue;		continue;

if (FRS_is_freestyle_enabled(scene_layer)) {		if (FRS_is_freestyle_enabled(view_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, scene_layer, freestyle_render);		FRS_composite_result(re, view_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) {
SceneLayer *scene_layer = BLI_findlink(&scene->render_layers, scene->active_layer);		ViewLayer *view_layer = BLI_findlink(&scene->view_layers, scene->active_view_layer);
/* force layer to be enabled */		/* force layer to be enabled */
if ((scene_layer->flag & SCENE_LAYER_RENDER) == 0) {		if ((view_layer->flag & VIEW_LAYER_RENDER) == 0) {
scene_layer->flag \|= SCENE_LAYER_RENDER;		view_layer->flag \|= VIEW_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)
{		{
if (scene->r.scemode & R_DOCOMP && scene->use_nodes) {		if (scene->r.scemode & R_DOCOMP && scene->use_nodes) {
bNode *node = scene->nodetree->nodes.first;		bNode *node = scene->nodetree->nodes.first;

while (node) {		while (node) {
if (node->type == CMP_NODE_R_LAYERS && (node->flag & NODE_MUTED) == 0) {		if (node->type == CMP_NODE_R_LAYERS && (node->flag & NODE_MUTED) == 0) {
Scene sce = node->id ? (Scene )node->id : scene;		Scene sce = node->id ? (Scene )node->id : scene;
if (sce->camera == NULL) {		if (sce->camera == NULL) {
sce->camera = BKE_scene_layer_camera_find(BKE_scene_layer_from_scene_get(sce));		sce->camera = BKE_view_layer_camera_find(BKE_view_layer_from_scene_get(sce));
}		}
if (sce->camera == NULL) {		if (sce->camera == NULL) {
/* all render layers nodes need camera */		/* all render layers nodes need camera */
return false;		return false;
}		}
}		}
node = node->next;		node = node->next;
}		}
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines	static bool check_valid_camera_multiview(Scene scene, Object camera, ReportList *reports)
return true;		return true;
}		}

static int check_valid_camera(Scene scene, Object camera_override, ReportList *reports)		static int check_valid_camera(Scene scene, Object camera_override, ReportList *reports)
{		{
const char *err_msg = "No camera found in scene \"%s\"";		const char *err_msg = "No camera found in scene \"%s\"";

if (camera_override == NULL && scene->camera == NULL)		if (camera_override == NULL && scene->camera == NULL)
scene->camera = BKE_scene_layer_camera_find(BKE_scene_layer_from_scene_get(scene));		scene->camera = BKE_view_layer_camera_find(BKE_view_layer_from_scene_get(scene));

if (!check_valid_camera_multiview(scene, scene->camera, reports))		if (!check_valid_camera_multiview(scene, scene->camera, reports))
return false;		return false;

if (RE_seq_render_active(scene, &scene->r)) {		if (RE_seq_render_active(scene, &scene->r)) {
if (scene->ed) {		if (scene->ed) {
Sequence *seq = scene->ed->seqbase.first;		Sequence *seq = scene->ed->seqbase.first;

while (seq) {		while (seq) {
if ((seq->type == SEQ_TYPE_SCENE) &&		if ((seq->type == SEQ_TYPE_SCENE) &&
((seq->flag & SEQ_SCENE_STRIPS) == 0) &&		((seq->flag & SEQ_SCENE_STRIPS) == 0) &&
(seq->scene != NULL))		(seq->scene != NULL))
{		{
if (!seq->scene_camera) {		if (!seq->scene_camera) {
if (!seq->scene->camera &&		if (!seq->scene->camera &&
!BKE_scene_layer_camera_find(BKE_scene_layer_from_scene_get(seq->scene)))		!BKE_view_layer_camera_find(BKE_view_layer_from_scene_get(seq->scene)))
{		{
/* camera could be unneeded due to composite nodes */		/* camera could be unneeded due to composite nodes */
Object *override = (seq->scene == scene) ? camera_override : NULL;		Object *override = (seq->scene == scene) ? camera_override : NULL;

if (!check_valid_compositing_camera(seq->scene, override)) {		if (!check_valid_compositing_camera(seq->scene, override)) {
BKE_reportf(reports, RPT_ERROR, err_msg, seq->scene->id.name + 2);		BKE_reportf(reports, RPT_ERROR, err_msg, seq->scene->id.name + 2);
return false;		return false;
}		}
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Lines	static void validate_render_settings(Render *re)

if (RE_engine_is_external(re)) {		if (RE_engine_is_external(re)) {
/* not supported yet */		/* not supported yet */
re->r.scemode &= ~(R_FULL_SAMPLE);		re->r.scemode &= ~(R_FULL_SAMPLE);
re->r.mode &= ~(R_FIELDS \| R_MBLUR);		re->r.mode &= ~(R_FIELDS \| R_MBLUR);
}		}
}		}

static void update_physics_cache(Render re, Scene scene, SceneLayer *scene_layer, int UNUSED(anim_init))		static void update_physics_cache(Render re, Scene scene, ViewLayer *view_layer, int UNUSED(anim_init))
{		{
PTCacheBaker baker;		PTCacheBaker baker;

memset(&baker, 0, sizeof(baker));		memset(&baker, 0, sizeof(baker));
baker.main = re->main;		baker.main = re->main;
baker.scene = scene;		baker.scene = scene;
baker.scene_layer = scene_layer;		baker.view_layer = view_layer;
baker.depsgraph = BKE_scene_get_depsgraph(scene, scene_layer, true);		baker.depsgraph = BKE_scene_get_depsgraph(scene, view_layer, true);
baker.bake = 0;		baker.bake = 0;
baker.render = 1;		baker.render = 1;
baker.anim_init = 1;		baker.anim_init = 1;
baker.quick_step = 1;		baker.quick_step = 1;

BKE_ptcache_bake(&baker);		BKE_ptcache_bake(&baker);
}		}

Show All 9 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,
SceneLayer scene_layer, Object camera_override, unsigned int lay_override,		ViewLayer view_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, &scene->render_layers);		render_update_anim_renderdata(re, &scene->r, &scene->view_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 */
scene_layer = BKE_scene_layer_from_scene_get(scene);		view_layer = BKE_view_layer_from_scene_get(scene);
update_physics_cache(re, scene, scene_layer, anim_init);		update_physics_cache(re, scene, view_layer, anim_init);
}		}

if (scene_layer \|\| scene->r.scemode & R_SINGLE_LAYER) {		if (view_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->render_layers, scene->active_layer, &scene->view_render, scene_layer, winx, winy, &disprect);		RE_InitState(re, NULL, &scene->r, &scene->view_layers, scene->active_view_layer, &scene->view_render, view_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, SceneLayer scene_layer, Object *camera_override,		void RE_BlenderFrame(Render re, Main bmain, Scene scene, ViewLayer view_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, scene_layer,		if (render_initialize_from_main(re, &scene->r, bmain, scene, &scene->view_render, view_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 563 Lines • ▼ Show 20 Lines	void RE_BlenderAnim(Render re, Main bmain, Scene scene, Object camera_override,

/* UGLY WARNING */		/* UGLY WARNING */
G.is_rendering = false;		G.is_rendering = false;
}		}

void RE_PreviewRender(Render re, Main bmain, Scene sce, ViewRender view_render)		void RE_PreviewRender(Render re, Main bmain, Scene sce, ViewRender view_render)
{		{
Object *camera;		Object *camera;
SceneLayer *scene_layer = BKE_scene_layer_from_scene_get(sce);		ViewLayer *view_layer = BKE_view_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, &sce->render_layers, sce->active_layer, view_render, NULL, winx, winy, NULL);		RE_InitState(re, NULL, &sce->r, &sce->view_layers, sce->active_view_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, view_layer, false);
re->eval_ctx->scene_layer = scene_layer;		re->eval_ctx->view_layer = view_layer;

camera = RE_GetCamera(re);		camera = RE_GetCamera(re);
RE_SetCamera(re, camera);		RE_SetCamera(re, camera);

do_render_3d(re);		do_render_3d(re);

BKE_image_pool_free(re->pool);		BKE_image_pool_free(re->pool);
re->pool = NULL;		re->pool = NULL;
Show All 29 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->render_layers, scene->active_layer, &scene->view_render, NULL, winx, winy, &disprect);		RE_InitState(re, NULL, &scene->r, &scene->view_layers, scene->active_view_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 241 Lines • Show Last 20 Lines