Differential D2842 Diff 9393 source/blender/blenkernel/intern/scene.c

Changeset View

Standalone View

source/blender/blenkernel/intern/scene.c

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
#include "DNA_object_types.h"		#include "DNA_object_types.h"
#include "DNA_rigidbody_types.h"		#include "DNA_rigidbody_types.h"
#include "DNA_scene_types.h"		#include "DNA_scene_types.h"
#include "DNA_screen_types.h"		#include "DNA_screen_types.h"
#include "DNA_sequence_types.h"		#include "DNA_sequence_types.h"
#include "DNA_space_types.h"		#include "DNA_space_types.h"
#include "DNA_view3d_types.h"		#include "DNA_view3d_types.h"
#include "DNA_windowmanager_types.h"		#include "DNA_windowmanager_types.h"
		#include "DNA_workspace_types.h"
#include "DNA_gpencil_types.h"		#include "DNA_gpencil_types.h"

#include "BLI_math.h"		#include "BLI_math.h"
#include "BLI_blenlib.h"		#include "BLI_blenlib.h"
#include "BLI_utildefines.h"		#include "BLI_utildefines.h"
#include "BLI_callbacks.h"		#include "BLI_callbacks.h"
#include "BLI_string.h"		#include "BLI_string.h"
#include "BLI_string_utils.h"		#include "BLI_string_utils.h"
▲ Show 20 Lines • Show All 342 Lines • ▼ Show 20 Lines	void BKE_scene_copy_data(Main bmain, Scene sce_dst, const Scene *sce_src, const int flag)
}		}

if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {		if ((flag & LIB_ID_COPY_NO_PREVIEW) == 0) {
BKE_previewimg_id_copy(&sce_dst->id, &sce_src->id);		BKE_previewimg_id_copy(&sce_dst->id, &sce_src->id);
}		}
else {		else {
sce_dst->preview = NULL;		sce_dst->preview = NULL;
}		}

		sce_dst->view_render = MEM_dupallocN(sce_src->view_render);
}		}

Scene BKE_scene_copy(Main bmain, Scene *sce, int type)		Scene BKE_scene_copy(Main bmain, Scene *sce, int type)
{		{
Scene *sce_copy;		Scene *sce_copy;

/* TODO this should/could most likely be replaced by call to more generic code at some point...		/* TODO this should/could most likely be replaced by call to more generic code at some point...
* But for now, let's keep it well isolated here. */		* But for now, let's keep it well isolated here. */
▲ Show 20 Lines • Show All 274 Lines • ▼ Show 20 Lines	void BKE_scene_free_ex(Scene *sce, const bool do_id_user)
}		}

/* Render engine setting. */		/* Render engine setting. */
if (sce->layer_properties) {		if (sce->layer_properties) {
IDP_FreeProperty(sce->layer_properties);		IDP_FreeProperty(sce->layer_properties);
MEM_freeN(sce->layer_properties);		MEM_freeN(sce->layer_properties);
sce->layer_properties = NULL;		sce->layer_properties = NULL;
}		}

		if (sce->view_render) {
		BKE_viewrender_free(sce->view_render);
		MEM_freeN(sce->view_render);
		}
}		}

void BKE_scene_free(Scene *sce)		void BKE_scene_free(Scene *sce)
{		{
BKE_scene_free_ex(sce, true);		BKE_scene_free_ex(sce, true);
}		}

void BKE_scene_init(Scene *sce)		void BKE_scene_init(Scene *sce)
▲ Show 20 Lines • Show All 192 Lines • ▼ Show 20 Lines	void BKE_scene_init(Scene *sce)
}		}
pset->brush[PE_BRUSH_CUT].strength = 1.0f;		pset->brush[PE_BRUSH_CUT].strength = 1.0f;

sce->r.ffcodecdata.audio_mixrate = 48000;		sce->r.ffcodecdata.audio_mixrate = 48000;
sce->r.ffcodecdata.audio_volume = 1.0f;		sce->r.ffcodecdata.audio_volume = 1.0f;
sce->r.ffcodecdata.audio_bitrate = 192;		sce->r.ffcodecdata.audio_bitrate = 192;
sce->r.ffcodecdata.audio_channels = 2;		sce->r.ffcodecdata.audio_channels = 2;

BLI_strncpy(sce->r.engine, RE_engine_id_BLENDER_EEVEE, sizeof(sce->r.engine));		sce->view_render = BKE_viewrender_new();

sce->audio.distance_model = 2.0f;		sce->audio.distance_model = 2.0f;
sce->audio.doppler_factor = 1.0f;		sce->audio.doppler_factor = 1.0f;
sce->audio.speed_of_sound = 343.3f;		sce->audio.speed_of_sound = 343.3f;
sce->audio.volume = 1.0f;		sce->audio.volume = 1.0f;

BLI_strncpy(sce->r.pic, U.renderdir, sizeof(sce->r.pic));		BLI_strncpy(sce->r.pic, U.renderdir, sizeof(sce->r.pic));

▲ Show 20 Lines • Show All 619 Lines • ▼ Show 20 Lines
#endif		#endif

static bool check_rendered_viewport_visible(Main *bmain)		static bool check_rendered_viewport_visible(Main *bmain)
{		{
wmWindowManager *wm = bmain->wm.first;		wmWindowManager *wm = bmain->wm.first;
wmWindow *window;		wmWindow *window;
for (window = wm->windows.first; window != NULL; window = window->next) {		for (window = wm->windows.first; window != NULL; window = window->next) {
const bScreen *screen = BKE_workspace_active_screen_get(window->workspace_hook);		const bScreen *screen = BKE_workspace_active_screen_get(window->workspace_hook);
		WorkSpace *workspace = BKE_workspace_active_get(window->workspace_hook);
Scene *scene = window->scene;		Scene *scene = window->scene;
		ViewRender *view_render = BKE_viewrender_get(scene, workspace);
ScrArea *area;		ScrArea *area;
RenderEngineType *type = RE_engines_find(scene->r.engine);		RenderEngineType *type = RE_engines_find(view_render->engine_id);
if ((type->draw_engine != NULL) \|\| (type->render_to_view == NULL)) {		if ((type->draw_engine != NULL) \|\| (type->render_to_view == NULL)) {
continue;		continue;
}		}
const bool use_legacy = (type->flag & RE_USE_LEGACY_PIPELINE) != 0;		const bool use_legacy = (type->flag & RE_USE_LEGACY_PIPELINE) != 0;
for (area = screen->areabase.first; area != NULL; area = area->next) {		for (area = screen->areabase.first; area != NULL; area = area->next) {
View3D *v3d = area->spacedata.first;		View3D *v3d = area->spacedata.first;
if (area->spacetype != SPACE_VIEW3D) {		if (area->spacetype != SPACE_VIEW3D) {
continue;		continue;
▲ Show 20 Lines • Show All 273 Lines • ▼ Show 20 Lines
{		{
if (r->mode & R_SIMPLIFY)		if (r->mode & R_SIMPLIFY)
return ((1.0f - r->simplify_aosss) * 10.0f + 1.0f) * error;		return ((1.0f - r->simplify_aosss) * 10.0f + 1.0f) * error;
else		else
return error;		return error;
}		}

/**		/**
* Helper function for the SETLOOPER macro		* Helper function for the SETLOOPER and SETLOOPER_SCENE_LAYER macros
*		*
* It iterates over the bases of the active layer and then the bases		* It iterates over the bases of the active layer and then the bases
* of the active layer of the background (set) scenes recursively.		* of the active layer of the background (set) scenes recursively.
*/		*/
Base _setlooper_base_step(Scene sce_iter, Base base)		Base _setlooper_base_step(Scene sce_iter, SceneLayer scene_layer, Base *base)
{		{
if (base && base->next) {		if (base && base->next) {
/* common case, step to the next */		/* Common case, step to the next. */
return base->next;		return base->next;
}		}
else if (base == NULL) {		else if ((base == NULL) && (scene_layer != NULL)) {
/* first time looping, return the scenes first base */		/* First time looping, return the scenes first base. */
		/* For the first loop we should get the layer from workspace when available. */
/* for the first loop we should get the layer from context */		if (scene_layer->object_bases.first) {
SceneLayer sl = BKE_scene_layer_context_active_PLACEHOLDER((sce_iter));		return (Base *)scene_layer->object_bases.first;
/* TODO For first scene (non-background set), we should pass the render layer as argument.
* In some cases we want it to be the workspace one, in other the scene one. */
TODO_LAYER;

if (sl->object_bases.first) {
return (Base *)sl->object_bases.first;
}		}
/* no base on this scene layer */		/* No base on this scene layer. */
goto next_set;		goto next_set;
}		}
else {		else {
next_set:		next_set:
/* reached the end, get the next base in the set */		/* Reached the end, get the next base in the set. */
while ((sce_iter = (sce_iter)->set)) {		while ((sce_iter = (sce_iter)->set)) {
SceneLayer sl = BKE_scene_layer_from_scene_get((sce_iter));		SceneLayer scene_layer_set = BKE_scene_layer_from_scene_get((sce_iter));
base = (Base *)sl->object_bases.first;		base = (Base *)scene_layer_set->object_bases.first;

if (base) {		if (base) {
return base;		return base;
}		}
}		}
}		}

return NULL;		return NULL;
}		}

bool BKE_scene_use_new_shading_nodes(const Scene *scene)		bool BKE_scene_use_new_shading_nodes(const Scene *scene)
{		{
const RenderEngineType *type = RE_engines_find(scene->r.engine);		return BKE_viewrender_use_new_shading_nodes(scene->view_render);
return (type && type->flag & RE_USE_SHADING_NODES);
}		}

bool BKE_scene_use_shading_nodes_custom(Scene *scene)		bool BKE_scene_use_shading_nodes_custom(Scene *scene)
{		{
RenderEngineType *type = RE_engines_find(scene->r.engine);		return BKE_viewrender_use_shading_nodes_custom(scene->view_render);
return (type && type->flag & RE_USE_SHADING_NODES_CUSTOM);
}		}

bool BKE_scene_use_world_space_shading(Scene *scene)		bool BKE_scene_use_world_space_shading(Scene *scene)
{		{
const RenderEngineType *type = RE_engines_find(scene->r.engine);		RenderEngineType *type = RE_engines_find(scene->view_render->engine_id);
return ((scene->r.mode & R_USE_WS_SHADING) \|\|		return ((scene->r.mode & R_USE_WS_SHADING) \|\|
(type && (type->flag & RE_USE_SHADING_NODES)));		(type && (type->flag & RE_USE_SHADING_NODES)));
}		}

bool BKE_scene_use_spherical_stereo(Scene *scene)		bool BKE_scene_use_spherical_stereo(Scene *scene)
{		{
RenderEngineType *type = RE_engines_find(scene->r.engine);		return BKE_viewrender_use_spherical_stereo(scene->view_render);
return (type && type->flag & RE_USE_SPHERICAL_STEREO);
}		}

bool BKE_scene_uses_blender_internal(const Scene *scene)		bool BKE_scene_uses_blender_internal(const Scene *scene)
{		{
return STREQ(scene->r.engine, RE_engine_id_BLENDER_RENDER);		return BKE_viewrender_uses_blender_internal(scene->view_render);
}		}

bool BKE_scene_uses_blender_game(const Scene *scene)		bool BKE_scene_uses_blender_game(const Scene *scene)
{		{
return STREQ(scene->r.engine, RE_engine_id_BLENDER_GAME);		return BKE_viewrender_uses_blender_game(scene->view_render);
}		}

bool BKE_scene_uses_blender_eevee(const Scene *scene)		bool BKE_scene_uses_blender_eevee(const Scene *scene)
{		{
return STREQ(scene->r.engine, RE_engine_id_BLENDER_EEVEE);		return BKE_viewrender_uses_blender_eevee(scene->view_render);
}		}

void BKE_scene_base_flag_to_objects(SceneLayer *sl)		void BKE_scene_base_flag_to_objects(SceneLayer *sl)
{		{
Base *base = sl->object_bases.first;		Base *base = sl->object_bases.first;

while (base) {		while (base) {
BKE_scene_object_base_flag_sync_from_base(base);		BKE_scene_object_base_flag_sync_from_base(base);
▲ Show 20 Lines • Show All 98 Lines • ▼ Show 20 Lines
int BKE_render_preview_pixel_size(const RenderData *r)		int BKE_render_preview_pixel_size(const RenderData *r)
{		{
if (r->preview_pixel_size == 0) {		if (r->preview_pixel_size == 0) {
return (U.pixelsize > 1.5f) ? 2 : 1;		return (U.pixelsize > 1.5f) ? 2 : 1;
}		}
return r->preview_pixel_size;		return r->preview_pixel_size;
}		}

		/* ***************************************************** */
		/* render engine settings */

		ViewRender BKE_viewrender_get(const Scene scene, const WorkSpace *workspace)
		{
		if (workspace == NULL \|\| BKE_workspace_use_scene_settings_get(workspace)) {
		return scene->view_render;
		}
		return BKE_workspace_view_render_get(workspace);
		}

		/**
		* Allocate a new struct for WorkSpace and Scene to store the viewport
		* related drawing data.
		*/
		ViewRender *BKE_viewrender_new()
		{
		ViewRender *view_render = MEM_callocN(sizeof(ViewRender), __func__);
		BLI_strncpy(view_render->engine_id, RE_engine_id_BLENDER_EEVEE, sizeof(view_render->engine_id));
		return view_render;
		}

		/**
		* Do not free ViewRender itself.
		*/
		void BKE_viewrender_free(ViewRender *UNUSED(view_render))
		{
		/* Do nothing. */
		}

		/**
		* Copy used by libblock copying.
		*/
		void BKE_viewrender_copy(ViewRender to, const ViewRender from)
		{
		to = from;
		/* XXX (dalai) not sure if the following is needed. */
		/* BLI_strncpy(to->engine_id, from->engine_id, sizeof(to->engine_id)); */
		}

		bool BKE_viewrender_use_new_shading_nodes(const ViewRender *view_render)
		{
		RenderEngineType *type = RE_engines_find(view_render->engine_id);
		return (type && type->flag & RE_USE_SHADING_NODES);
		}

		bool BKE_viewrender_use_shading_nodes_custom(const ViewRender *view_render)
		{
		RenderEngineType *type = RE_engines_find(view_render->engine_id);
		return (type && type->flag & RE_USE_SHADING_NODES_CUSTOM);
		}

		bool BKE_viewrender_use_spherical_stereo(const ViewRender *view_render)
		{
		const char *engine_id = view_render->engine_id;
		RenderEngineType *type = RE_engines_find(engine_id);
		return (type && type->flag & RE_USE_SPHERICAL_STEREO);
		}

		bool BKE_viewrender_uses_blender_internal(const ViewRender *view_render)
		{
		const char *engine_id = view_render->engine_id;
		return STREQ(engine_id, RE_engine_id_BLENDER_RENDER);
		}

		bool BKE_viewrender_uses_blender_game(const ViewRender *view_render)
		{
		const char *engine_id = view_render->engine_id;
		return STREQ(engine_id, RE_engine_id_BLENDER_GAME);
		}

		bool BKE_viewrender_uses_blender_eevee(const ViewRender *view_render)
		{
		const char *engine_id = view_render->engine_id;
		return STREQ(engine_id, RE_engine_id_BLENDER_EEVEE);
		}

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

/* Apply the needed correction factor to value, based on unit_type (only length-related are affected currently)		/* Apply the needed correction factor to value, based on unit_type (only length-related are affected currently)
* and unit->scale_length.		* and unit->scale_length.
*/		*/
double BKE_scene_unit_scale(const UnitSettings *unit, const int unit_type, double value)		double BKE_scene_unit_scale(const UnitSettings *unit, const int unit_type, double value)
{		{
if (unit->system == USER_UNIT_NONE) {		if (unit->system == USER_UNIT_NONE) {
/* Never apply scale_length when not using a unit setting! */		/* Never apply scale_length when not using a unit setting! */
return value;		return value;
▲ Show 20 Lines • Show All 303 Lines • Show Last 20 Lines