blender
/
blender
129
398
Fork 572
Code Issues 6.2k Pull Requests 748 Projects 19 Wiki Activity

Implement overridable scene render settings 

This add a new set of (possible) render settings that can be defined at
the scene level and overridable at the scene layer level.

Once we get workspaces we can either add workspace inbetween scene and
scene layer evaluation. Or to replace layer settings, to avoid extra
confusion to users.

An example of this setting is "samples", as implemented now for the clay
engine.
This commit is contained in:
Dalai Felinto 2017-05-05 16:27:31 +02:00
parent 741d848cf8
commit 8d9c484152
Notes: blender-bot 2023-09-08 04:55:43 +02:00 
Referenced by issue #51376, Create overridable scene render settings
22 changed files with 606 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
release/scripts/startup/bl_ui/properties_render.py
View File

@ -584,6 +584,18 @@ class RENDER_PT_bake(RenderButtonsPanel, Panel):
sub.prop(rd, "bake_user_scale", text="User Scale")
class RENDER_PT_clay_layer_settings(RenderButtonsPanel, Panel):
bl_label = "Clay Layer Settings"
COMPAT_ENGINES = {'BLENDER_CLAY'}
def draw(self, context):
layout = self.layout
props = context.scene.layer_properties['BLENDER_CLAY']
col = layout.column()
col.prop(props, "ssao_samples")
class RENDER_PT_clay_collection_settings(RenderButtonsPanel, Panel):
bl_label = "Clay Collection Settings"
COMPAT_ENGINES = {'BLENDER_CLAY'}
@ -619,6 +631,7 @@ classes = (
RENDER_PT_output,
RENDER_PT_encoding,
RENDER_PT_bake,
RENDER_PT_clay_layer_settings,
RENDER_PT_clay_collection_settings,
)

21
release/scripts/startup/bl_ui/properties_render_layer.py
View File

@ -130,11 +130,32 @@ class RENDERLAYER_PT_views(RenderLayerButtonsPanel, Panel):
row.prop(rv, "camera_suffix", text="")
class RENDERLAYER_PT_clay_settings(RenderLayerButtonsPanel, Panel):
bl_label = "Render Settings"
COMPAT_ENGINES = {'BLENDER_CLAY'}
@classmethod
def poll(cls, context):
scene = context.scene
return scene and (scene.render.engine in cls.COMPAT_ENGINES)
def draw(self, context):
layout = self.layout
scene = context.scene
scene_props = scene.layer_properties['BLENDER_CLAY']
layer = bpy.context.render_layer
layer_props = layer.engine_overrides['BLENDER_CLAY']
col = layout.column()
col.template_override_property(layer_props, scene_props, "ssao_samples")
classes = (
RENDERLAYER_UL_renderlayers,
RENDERLAYER_PT_layers,
RENDERLAYER_UL_renderviews,
RENDERLAYER_PT_views,
RENDERLAYER_PT_clay_settings,
)
if __name__ == "__main__": # only for live edit.

20
source/blender/blenkernel/BKE_layer.h
View File

@ -108,16 +108,26 @@ void BKE_layer_sync_object_unlink(const struct Scene *scene, struct SceneCollect
void BKE_collection_override_datablock_add(struct LayerCollection *lc, const char *data_path, struct ID *id);
/* engine settings */
typedef void (*CollectionEngineSettingsCB)(struct RenderEngine *engine, struct IDProperty *props);
struct IDProperty *BKE_layer_collection_engine_get(struct LayerCollection *lc, const int type, const char *engine_name);
struct IDProperty *BKE_object_collection_engine_get(struct Object *ob, const int type, const char *engine_name);
struct IDProperty *BKE_scene_collection_engine_get(struct Scene *scene, const int type, const char *engine_name);
void BKE_layer_collection_engine_settings_callback_register(struct Main *bmain, const char *engine_name, CollectionEngineSettingsCB func);
typedef void (*EngineSettingsCB)(struct RenderEngine *engine, struct IDProperty *props);
struct IDProperty *BKE_layer_collection_engine_evaluated_get(struct Object *ob, const int type, const char *engine_name);
struct IDProperty *BKE_layer_collection_engine_collection_get(struct LayerCollection *lc, const int type, const char *engine_name);
struct IDProperty *BKE_layer_collection_engine_scene_get(struct Scene *scene, const int type, const char *engine_name);
void BKE_layer_collection_engine_settings_callback_register(struct Main *bmain, const char *engine_name, EngineSettingsCB func);
void BKE_layer_collection_engine_settings_callback_free(void);
void BKE_layer_collection_engine_settings_create(struct IDProperty *root);
void BKE_layer_collection_engine_settings_validate_scene(struct Scene *scene);
void BKE_layer_collection_engine_settings_validate_collection(struct LayerCollection *lc);
struct IDProperty *BKE_scene_layer_engine_evaluated_get(struct SceneLayer *sl, const int type, const char *engine_name);
struct IDProperty *BKE_scene_layer_engine_layer_get(struct SceneLayer *sl, const int type, const char *engine_name);
struct IDProperty *BKE_scene_layer_engine_scene_get(struct Scene *scene, const int type, const char *engine_name);
void BKE_scene_layer_engine_settings_callback_register(struct Main *bmain, const char *engine_name, EngineSettingsCB func);
void BKE_scene_layer_engine_settings_callback_free(void);
void BKE_scene_layer_engine_settings_validate_scene(struct Scene *scene);
void BKE_scene_layer_engine_settings_validate_layer(struct SceneLayer *sl);
void BKE_scene_layer_engine_settings_create(struct IDProperty *root);
void BKE_collection_engine_property_add_float(struct IDProperty *props, const char *name, float value);
void BKE_collection_engine_property_add_int(struct IDProperty *props, const char *name, int value);
void BKE_collection_engine_property_add_bool(struct IDProperty *props, const char *name, bool value);

324
source/blender/blenkernel/intern/layer.c
View File

@ -52,13 +52,14 @@
#define DEBUG_PRINT if (G.debug & G_DEBUG_DEPSGRAPH) printf
/* prototype */
struct CollectionEngineSettingsCB_Type;
struct EngineSettingsCB_Type;
static void layer_collection_free(SceneLayer *sl, LayerCollection *lc);
static LayerCollection *layer_collection_add(SceneLayer *sl, LayerCollection *parent, SceneCollection *sc);
static LayerCollection *find_layer_collection_by_scene_collection(LayerCollection *lc, const SceneCollection *sc);
static IDProperty *collection_engine_settings_create(struct CollectionEngineSettingsCB_Type *ces_type, const bool populate);
static IDProperty *collection_engine_settings_create(struct EngineSettingsCB_Type *ces_type, const bool populate);
static IDProperty *collection_engine_get(IDProperty *root, const int type, const char *engine_name);
static void collection_engine_settings_init(IDProperty *root, const bool populate);
static void layer_engine_settings_init(IDProperty *root, const bool populate);
static void object_bases_Iterator_next(Iterator *iter, const int flag);
/* RenderLayer */
@ -95,9 +96,13 @@ SceneLayer *BKE_scene_layer_add(Scene *scene, const char *name)
name = DATA_("Render Layer");
}
IDPropertyTemplate val = {0};
SceneLayer *sl = MEM_callocN(sizeof(SceneLayer), "Scene Layer");
sl->flag |= SCENE_LAYER_RENDER;
sl->properties = IDP_New(IDP_GROUP, &val, ROOT_PROP);
layer_engine_settings_init(sl->properties, false);
BLI_addtail(&scene->render_layers, sl);
/* unique name */
@ -160,6 +165,16 @@ void BKE_scene_layer_free(SceneLayer *sl)
layer_collection_free(NULL, lc);
}
BLI_freelistN(&sl->layer_collections);
if (sl->properties) {
IDP_FreeProperty(sl->properties);
MEM_freeN(sl->properties);
}
if (sl->properties_evaluated) {
IDP_FreeProperty(sl->properties_evaluated);
MEM_freeN(sl->properties_evaluated);
}
}
/**
@ -957,83 +972,140 @@ void BKE_collection_override_datablock_add(LayerCollection *UNUSED(lc), const ch
/* ---------------------------------------------------------------------- */
/* Engine Settings */
ListBase R_engines_settings_callbacks = {NULL, NULL};
ListBase R_layer_collection_engines_settings_callbacks = {NULL, NULL};
ListBase R_scene_layer_engines_settings_callbacks = {NULL, NULL};
typedef struct CollectionEngineSettingsCB_Type {
struct CollectionEngineSettingsCB_Type *next, *prev;
typedef struct EngineSettingsCB_Type {
struct EngineSettingsCB_Type *next, *prev;
char name[MAX_NAME]; /* engine name */
CollectionEngineSettingsCB callback;
EngineSettingsCB callback;
} CollectionEngineSettingsCB_Type;
} EngineSettingsCB_Type;
static void create_engine_settings_scene(Scene *scene, CollectionEngineSettingsCB_Type *ces_type)
static void create_engine_settings_scene(IDProperty *root, EngineSettingsCB_Type *es_type)
{
if (collection_engine_get(scene->collection_properties, COLLECTION_MODE_NONE, ces_type->name)) {
if (collection_engine_get(root, COLLECTION_MODE_NONE, es_type->name)) {
return;
}
IDProperty *props = collection_engine_settings_create(ces_type, true);
IDP_AddToGroup(scene->collection_properties, props);
IDProperty *props = collection_engine_settings_create(es_type, true);
IDP_AddToGroup(root, props);
}
static void create_engine_settings_layer_collection(LayerCollection *lc, CollectionEngineSettingsCB_Type *ces_type)
static void create_layer_collection_engine_settings_scene(Scene *scene, EngineSettingsCB_Type *es_type)
{
if (BKE_layer_collection_engine_get(lc, COLLECTION_MODE_NONE, ces_type->name)) {
create_engine_settings_scene(scene->collection_properties, es_type);
}
static void create_scene_layer_engine_settings_scene(Scene *scene, EngineSettingsCB_Type *es_type)
{
create_engine_settings_scene(scene->layer_properties, es_type);
}
static void create_layer_collection_engine_settings_collection(LayerCollection *lc, EngineSettingsCB_Type *es_type)
{
if (BKE_layer_collection_engine_collection_get(lc, COLLECTION_MODE_NONE, es_type->name)) {
return;
}
IDProperty *props = collection_engine_settings_create(ces_type, false);
IDProperty *props = collection_engine_settings_create(es_type, false);
IDP_AddToGroup(lc->properties, props);
for (LayerCollection *lcn = lc->layer_collections.first; lcn; lcn = lcn->next) {
create_engine_settings_layer_collection(lcn, ces_type);
create_layer_collection_engine_settings_collection(lcn, es_type);
}
}
static void create_engines_settings_scene(Scene *scene, CollectionEngineSettingsCB_Type *ces_type)
static void create_layer_collection_engines_settings_scene(Scene *scene, EngineSettingsCB_Type *es_type)
{
/* populate the scene with the new settings */
create_engine_settings_scene(scene, ces_type);
/* Populate the scene with the new settings. */
create_layer_collection_engine_settings_scene(scene, es_type);
for (SceneLayer *sl = scene->render_layers.first; sl; sl = sl->next) {
for (LayerCollection *lc = sl->layer_collections.first; lc; lc = lc->next) {
create_engine_settings_layer_collection(lc, ces_type);
create_layer_collection_engine_settings_collection(lc, es_type);
}
}
}
void BKE_layer_collection_engine_settings_callback_register(
Main *bmain, const char *engine_name, CollectionEngineSettingsCB func)
static void create_scene_layer_engines_settings_scene(Scene *scene, EngineSettingsCB_Type *es_type)
{
CollectionEngineSettingsCB_Type *ces_type;
/* Populate the scene with the new settings. */
create_scene_layer_engine_settings_scene(scene, es_type);
}
/* cleanup in case it existed */
ces_type = BLI_findstring(&R_engines_settings_callbacks, engine_name,
offsetof(CollectionEngineSettingsCB_Type, name));
if (ces_type) {
BLI_remlink(&R_engines_settings_callbacks, ces_type);
MEM_freeN(ces_type);
static void create_scene_layer_engines_settings_layer(SceneLayer *sl, EngineSettingsCB_Type *es_type)
{
if (BKE_scene_layer_engine_layer_get(sl, COLLECTION_MODE_NONE, es_type->name)) {
return;
}
ces_type = MEM_callocN(sizeof(CollectionEngineSettingsCB_Type), "collection_engine_type");
BLI_strncpy_utf8(ces_type->name, engine_name, sizeof(ces_type->name));
ces_type->callback = func;
BLI_addtail(&R_engines_settings_callbacks, ces_type);
IDProperty *props = collection_engine_settings_create(es_type, false);
IDP_AddToGroup(sl->properties, props);
}
static EngineSettingsCB_Type *engine_settings_callback_register(const char *engine_name, EngineSettingsCB func, ListBase *lb)
{
EngineSettingsCB_Type *es_type;
/* Cleanup in case it existed. */
es_type = BLI_findstring(lb, engine_name, offsetof(EngineSettingsCB_Type, name));
if (es_type) {
BLI_remlink(lb, es_type);
MEM_freeN(es_type);
}
es_type = MEM_callocN(sizeof(EngineSettingsCB_Type), __func__);
BLI_strncpy_utf8(es_type->name, engine_name, sizeof(es_type->name));
es_type->callback = func;
BLI_addtail(lb, es_type);
return es_type;
}
void BKE_layer_collection_engine_settings_callback_register(
Main *bmain, const char *engine_name, EngineSettingsCB func)
{
EngineSettingsCB_Type *es_type =
engine_settings_callback_register(engine_name, func, &R_layer_collection_engines_settings_callbacks);
if (bmain) {
/* populate all of the collections of the scene with those settings */
/* Populate all of the collections of the scene with those settings. */
for (Scene *scene = bmain->scene.first; scene; scene = scene->id.next) {
create_engines_settings_scene(scene, ces_type);
create_layer_collection_engines_settings_scene(scene, es_type);
}
}
}
void BKE_scene_layer_engine_settings_callback_register(
Main *bmain, const char *engine_name, EngineSettingsCB func)
{
EngineSettingsCB_Type *es_type =
engine_settings_callback_register(engine_name, func, &R_scene_layer_engines_settings_callbacks);
if (bmain) {
/* Populate all of the collections of the scene with those settings. */
for (Scene *scene = bmain->scene.first; scene; scene = scene->id.next) {
create_scene_layer_engines_settings_scene(scene, es_type);
for (SceneLayer *sl = scene->render_layers.first; sl; sl = sl->next) {
create_scene_layer_engines_settings_layer(sl, es_type);
}
}
}
}
void BKE_layer_collection_engine_settings_callback_free(void)
{
BLI_freelistN(&R_engines_settings_callbacks);
BLI_freelistN(&R_layer_collection_engines_settings_callbacks);
}
void BKE_scene_layer_engine_settings_callback_free(void)
{
BLI_freelistN(&R_scene_layer_engines_settings_callbacks);
}
/**
@ -1041,17 +1113,17 @@ void BKE_layer_collection_engine_settings_callback_free(void)
*
* \param populate whether we want to pre-fill the collection with the default properties
*/
static IDProperty *collection_engine_settings_create(CollectionEngineSettingsCB_Type *ces_type, const bool populate)
static IDProperty *collection_engine_settings_create(EngineSettingsCB_Type *es_type, const bool populate)
{
IDProperty *props;
IDPropertyTemplate val = {0};
props = IDP_New(IDP_GROUP, &val, ces_type->name);
props = IDP_New(IDP_GROUP, &val, es_type->name);
props->subtype = IDP_GROUP_SUB_ENGINE_RENDER;
/* properties */
if (populate) {
ces_type->callback(NULL, props);
es_type->callback(NULL, props);
}
return props;
@ -1121,11 +1193,20 @@ static void layer_collection_create_mode_settings_paint_vertex(IDProperty *root,
IDP_AddToGroup(root, props);
}
static void collection_create_render_settings(IDProperty *root, const bool populate)
static void layer_collection_create_render_settings(IDProperty *root, const bool populate)
{
CollectionEngineSettingsCB_Type *ces_type;
for (ces_type = R_engines_settings_callbacks.first; ces_type; ces_type = ces_type->next) {
IDProperty *props = collection_engine_settings_create(ces_type, populate);
EngineSettingsCB_Type *es_type;
for (es_type = R_layer_collection_engines_settings_callbacks.first; es_type; es_type = es_type->next) {
IDProperty *props = collection_engine_settings_create(es_type, populate);
IDP_AddToGroup(root, props);
}
}
static void scene_layer_create_render_settings(IDProperty *root, const bool populate)
{
EngineSettingsCB_Type *es_type;
for (es_type = R_scene_layer_engines_settings_callbacks.first; es_type; es_type = es_type->next) {
IDProperty *props = collection_engine_settings_create(es_type, populate);
IDP_AddToGroup(root, props);
}
}
@ -1140,6 +1221,12 @@ static void collection_create_mode_settings(IDProperty *root, const bool populat
layer_collection_create_mode_settings_paint_vertex(root, populate);
}
static void layer_create_mode_settings(IDProperty *root, const bool populate)
{
TODO_LAYER; /* XXX like collection_create_mode_settings */
UNUSED_VARS(root, populate);
}
static int idproperty_group_subtype(const int mode_type)
{
int idgroup_type;
@ -1193,26 +1280,50 @@ static IDProperty *collection_engine_get(
/**
* Return collection engine settings from Object for specified engine of mode
*/
IDProperty *BKE_object_collection_engine_get(Object *ob, const int type, const char *engine_name)
IDProperty *BKE_layer_collection_engine_evaluated_get(Object *ob, const int type, const char *engine_name)
{
return collection_engine_get(ob->base_collection_properties, type, engine_name);
}
/**
* Return layer collection engine settings for specified engine
*/
IDProperty *BKE_layer_collection_engine_get(LayerCollection *lc, const int type, const char *engine_name)
IDProperty *BKE_layer_collection_engine_collection_get(LayerCollection *lc, const int type, const char *engine_name)
{
return collection_engine_get(lc->properties, type, engine_name);
}
/**
* Return scene engine settings for specified engine
* Return layer collection engine settings for specified engine in the scene
*/
IDProperty *BKE_scene_collection_engine_get(Scene *scene, const int type, const char *engine_name)
IDProperty *BKE_layer_collection_engine_scene_get(Scene *scene, const int type, const char *engine_name)
{
return collection_engine_get(scene->collection_properties, type, engine_name);
}
/**
* Return scene layer engine settings for specified engine in the scene
*/
IDProperty *BKE_scene_layer_engine_scene_get(Scene *scene, const int type, const char *engine_name)
{
return collection_engine_get(scene->layer_properties, type, engine_name);
}
/**
* Return scene layer engine settings for specified engine
*/
IDProperty *BKE_scene_layer_engine_layer_get(SceneLayer *sl, const int type, const char *engine_name)
{
return collection_engine_get(sl->properties, type, engine_name);
}
/**
* Return scene layer evaluated engine settings for specified engine
*/
IDProperty *BKE_scene_layer_engine_evaluated_get(SceneLayer *sl, const int type, const char *engine_name)
{
return collection_engine_get(sl->properties_evaluated, type, engine_name);
}
/* ---------------------------------------------------------------------- */
/* Engine Settings Properties */
@ -1279,14 +1390,24 @@ void BKE_collection_engine_property_value_set_bool(IDProperty *props, const char
static void collection_engine_settings_init(IDProperty *root, const bool populate)
{
/* render engines */
collection_create_render_settings(root, populate);
layer_collection_create_render_settings(root, populate);
/* mode engines */
collection_create_mode_settings(root, populate);
}
/* get all the default settings defined in scene and merge them here */
static void layer_engine_settings_init(IDProperty *root, const bool populate)
{
/* render engines */
scene_layer_create_render_settings(root, populate);
/* mode engines */
layer_create_mode_settings(root, populate);
}
/**
* Initialize the render setings
* Initialize the layer collection render setings
* It's used mainly for scenes
*/
void BKE_layer_collection_engine_settings_create(IDProperty *root)
@ -1294,34 +1415,60 @@ void BKE_layer_collection_engine_settings_create(IDProperty *root)
collection_engine_settings_init(root, true);
}
/**
* Initialize the render setings
* It's used mainly for scenes
*/
void BKE_scene_layer_engine_settings_create(IDProperty *root)
{
layer_engine_settings_init(root, true);
}
/**
* Reference of IDProperty group scene collection settings
* Used when reading blendfiles, to see if there is any missing settings.
*/
static struct {
IDProperty *scene;
struct {
IDProperty *collection_properties;
IDProperty *render_settings;
} scene;
IDProperty *scene_layer;
IDProperty *layer_collection;
} root_reference = {
.scene = NULL,
.scene = {NULL, NULL},
.scene_layer = NULL,
.layer_collection = NULL,
};
/**
* Free the reference scene collection settings IDProperty group.
*/
static void layer_collection_engine_settings_validate_init(void)
static void engine_settings_validate_init(void)
{
IDPropertyTemplate val = {0};
if (root_reference.scene == NULL) {
root_reference.scene = IDP_New(IDP_GROUP, &val, ROOT_PROP);
collection_engine_settings_init(root_reference.scene, true);
/* LayerCollection engine settings. */
if (root_reference.scene.collection_properties == NULL) {
root_reference.scene.collection_properties = IDP_New(IDP_GROUP, &val, ROOT_PROP);
collection_engine_settings_init(root_reference.scene.collection_properties, true);
}
if (root_reference.layer_collection == NULL) {
root_reference.layer_collection = IDP_New(IDP_GROUP, &val, ROOT_PROP);
collection_engine_settings_init(root_reference.layer_collection, false);
}
/* Render engine setting. */
if (root_reference.scene.render_settings == NULL) {
root_reference.scene.render_settings = IDP_New(IDP_GROUP, &val, ROOT_PROP);
layer_engine_settings_init(root_reference.scene.render_settings, true);
}
if (root_reference.scene_layer == NULL) {
root_reference.scene_layer = IDP_New(IDP_GROUP, &val, ROOT_PROP);
layer_engine_settings_init(root_reference.scene_layer, false);
}
}
/**
@ -1329,16 +1476,22 @@ static void layer_collection_engine_settings_validate_init(void)
*/
static void layer_collection_engine_settings_validate_free(void)
{
if (root_reference.scene != NULL) {
IDP_FreeProperty(root_reference.scene);
MEM_freeN(root_reference.scene);
root_reference.scene = NULL;
}
IDProperty *idprops[] = {
root_reference.scene.render_settings,
root_reference.scene.collection_properties,
root_reference.scene_layer,
root_reference.layer_collection,
NULL,
};
if (root_reference.layer_collection != NULL) {
IDP_FreeProperty(root_reference.layer_collection);
MEM_freeN(root_reference.layer_collection);
root_reference.layer_collection = NULL;
IDProperty **idprop = &idprops[0];
while (*idprop) {
if (*idprop) {
IDP_FreeProperty(*idprop);
MEM_freeN(*idprop);
*idprop = NULL;
idprop++;
}
}
}
@ -1347,8 +1500,8 @@ static void layer_collection_engine_settings_validate_free(void)
*/
void BKE_layer_collection_engine_settings_validate_scene(Scene *scene)
{
if (root_reference.scene == NULL) {
layer_collection_engine_settings_validate_init();
if (root_reference.scene.collection_properties == NULL) {
engine_settings_validate_init();
}
if (scene->collection_properties == NULL) {
@ -1357,7 +1510,7 @@ void BKE_layer_collection_engine_settings_validate_scene(Scene *scene)
BKE_layer_collection_engine_settings_create(scene->collection_properties);
}
else {
IDP_MergeGroup(scene->collection_properties, root_reference.scene, false);
IDP_MergeGroup(scene->collection_properties, root_reference.scene.collection_properties, false);
}
}
@ -1367,13 +1520,44 @@ void BKE_layer_collection_engine_settings_validate_scene(Scene *scene)
void BKE_layer_collection_engine_settings_validate_collection(LayerCollection *lc)
{
if (root_reference.layer_collection == NULL) {
layer_collection_engine_settings_validate_init();
engine_settings_validate_init();
}
BLI_assert(lc->properties != NULL);
IDP_MergeGroup(lc->properties, root_reference.layer_collection, false);
}
/**
* Make sure Scene has all required collection settings.
*/
void BKE_scene_layer_engine_settings_validate_scene(Scene *scene)
{
if (root_reference.scene.render_settings == NULL) {
engine_settings_validate_init();
}
if (scene->layer_properties == NULL) {
IDPropertyTemplate val = {0};
scene->layer_properties = IDP_New(IDP_GROUP, &val, ROOT_PROP);
BKE_scene_layer_engine_settings_create(scene->layer_properties);
}
else {
IDP_MergeGroup(scene->layer_properties, root_reference.scene.render_settings, false);
}
}
/**
* Make sure Scene has all required collection settings.
*/
void BKE_scene_layer_engine_settings_validate_layer(SceneLayer *sl)
{
if (root_reference.scene_layer == NULL) {
engine_settings_validate_init();
}
IDP_MergeGroup(sl->properties, root_reference.scene_layer, false);
}
/* ---------------------------------------------------------------------- */
/* Iterators */
@ -1525,6 +1709,10 @@ void BKE_layer_eval_layer_collection_pre(struct EvaluationContext *UNUSED(eval_c
idproperty_reset(&base->collection_properties, scene->collection_properties);
}
/* Sync properties from scene to scene layer. */
idproperty_reset(&scene_layer->properties_evaluated, scene->layer_properties);
IDP_MergeGroup(scene_layer->properties_evaluated, scene_layer->properties, true);
/* TODO(sergey): Is it always required? */
scene_layer->flag |= SCENE_LAYER_ENGINE_DIRTY;
}

26
source/blender/blenkernel/intern/scene.c
View File

@ -317,6 +317,8 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
BLI_duplicatelist(&scen->render_layers, &sce->render_layers);
SceneLayer *new_sl = scen->render_layers.first;
for (SceneLayer *sl = sce->render_layers.first; sl; sl = sl->next) {
new_sl->properties = IDP_New(IDP_GROUP, (const IDPropertyTemplate *){0}, ROOT_PROP);
new_sl->properties_evaluated = NULL;
/* we start fresh with no overrides and no visibility flags set
* instead of syncing both trees we simply unlink and relink the scene collection */
@ -324,6 +326,7 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
BLI_listbase_clear(&new_sl->object_bases);
layer_collections_recreate(new_sl, &sl->layer_collections, mcn, mc);
if (sl->basact) {
Object *active_ob = sl->basact->object;
for (Base *base = new_sl->object_bases.first; base; base = base->next) {
@ -336,8 +339,8 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
new_sl = new_sl->next;
}
IDPropertyTemplate val = {0};
scen->collection_properties = IDP_New(IDP_GROUP, &val, ROOT_PROP);
scen->collection_properties = IDP_New(IDP_GROUP, (const IDPropertyTemplate *){0}, ROOT_PROP);
scen->layer_properties = IDP_New(IDP_GROUP, (const IDPropertyTemplate *){0}, ROOT_PROP);
}
/* copy color management settings */
@ -455,6 +458,9 @@ Scene *BKE_scene_copy(Main *bmain, Scene *sce, int type)
if (sce->collection_properties) {
IDP_MergeGroup(scen->collection_properties, sce->collection_properties, true);
}
if (sce->layer_properties) {
IDP_MergeGroup(scen->layer_properties, sce->layer_properties, true);
}
}
return scen;
@ -586,12 +592,19 @@ void BKE_scene_free(Scene *sce)
MEM_freeN(sce->collection);
sce->collection = NULL;
/* Runtime Engine Data */
/* LayerCollection engine settings. */
if (sce->collection_properties) {
IDP_FreeProperty(sce->collection_properties);
MEM_freeN(sce->collection_properties);
sce->collection_properties = NULL;
}
/* Render engine setting. */
if (sce->layer_properties) {
IDP_FreeProperty(sce->layer_properties);
MEM_freeN(sce->layer_properties);
sce->layer_properties = NULL;
}
}
void BKE_scene_init(Scene *sce)
@ -946,10 +959,13 @@ void BKE_scene_init(Scene *sce)
sce->collection = MEM_callocN(sizeof(SceneCollection), "Master Collection");
BLI_strncpy(sce->collection->name, "Master Collection", sizeof(sce->collection->name));
IDPropertyTemplate val = {0};
sce->collection_properties = IDP_New(IDP_GROUP, &val, ROOT_PROP);
/* Engine settings */
sce->collection_properties = IDP_New(IDP_GROUP, (const IDPropertyTemplate *){0}, ROOT_PROP);
BKE_layer_collection_engine_settings_create(sce->collection_properties);
sce->layer_properties = IDP_New(IDP_GROUP, (const IDPropertyTemplate *){0}, ROOT_PROP);
BKE_scene_layer_engine_settings_create(sce->layer_properties);
BKE_scene_layer_add(sce, "Render Layer");
}

14
source/blender/blenloader/intern/readfile.c
View File

@ -6310,11 +6310,25 @@ static void direct_link_scene(FileData *fd, Scene *sce)
link_list(fd, &sl->object_bases);
sl->basact = newdataadr(fd, sl->basact);
direct_link_layer_collections(fd, &sl->layer_collections);
if (sl->properties != NULL) {
sl->properties = newdataadr(fd, sl->properties);
BLI_assert(sl->properties != NULL);
IDP_DirectLinkGroup_OrFree(&sl->properties, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
BKE_scene_layer_engine_settings_validate_layer(sl);
}
sl->properties_evaluated = NULL;
}
sce->collection_properties = newdataadr(fd, sce->collection_properties);
IDP_DirectLinkGroup_OrFree(&sce->collection_properties, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
sce->layer_properties = newdataadr(fd, sce->layer_properties);
IDP_DirectLinkGroup_OrFree(&sce->layer_properties, (fd->flags & FD_FLAGS_SWITCH_ENDIAN), fd);
BKE_layer_collection_engine_settings_validate_scene(sce);
BKE_scene_layer_engine_settings_validate_scene(sce);
}
/* ************ READ WM ***************** */

10
source/blender/blenloader/intern/versioning_280.c
View File

@ -254,4 +254,14 @@ void blo_do_versions_280(FileData *fd, Library *UNUSED(lib), Main *main)
}
}
}
if (!DNA_struct_elem_find(fd->filesdna, "SceneLayer", "IDProperty", "properties")) {
for (Scene *scene = main->scene.first; scene; scene = scene->id.next) {
for (SceneLayer *sl = scene->render_layers.first; sl; sl = sl->next) {
IDPropertyTemplate val = {0};
sl->properties = IDP_New(IDP_GROUP, &val, ROOT_PROP);
BKE_scene_layer_engine_settings_create(sl->properties);
}
}
}
}

7
source/blender/blenloader/intern/writefile.c
View File

@ -2775,9 +2775,16 @@ static void write_scene(WriteData *wd, Scene *sce)
for (SceneLayer *sl = sce->render_layers.first; sl; sl = sl->next) {
writestruct(wd, DATA, SceneLayer, 1, sl);
writelist(wd, DATA, Base, &sl->object_bases);
if (sl->properties) {
IDP_WriteProperty(sl->properties, wd);
}
write_layer_collections(wd, &sl->layer_collections);
}
if (sce->layer_properties) {
IDP_WriteProperty(sce->layer_properties, wd);
}
if (sce->collection_properties) {
IDP_WriteProperty(sce->collection_properties, wd);
}

2
source/blender/draw/engines/basic/basic_engine.c
View File

@ -248,7 +248,7 @@ DrawEngineType draw_engine_basic_type = {
RenderEngineType DRW_engine_viewport_basic_type = {
NULL, NULL,
BASIC_ENGINE, N_("Basic"), RE_INTERNAL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&draw_engine_basic_type,
{NULL, NULL, NULL}
};

25
source/blender/draw/engines/clay/clay_engine.c
View File

@ -344,7 +344,11 @@ static void CLAY_engine_init(void *vedata)
/* SSAO setup */
{
int ssao_samples = 32; /* XXX get from render settings */
const DRWContextState *draw_ctx = DRW_context_state_get();
SceneLayer *scene_layer = draw_ctx->sl;
IDProperty *props = BKE_scene_layer_engine_evaluated_get(scene_layer, COLLECTION_MODE_NONE, RE_engine_id_BLENDER_CLAY);
int ssao_samples = BKE_collection_engine_property_value_get_int(props, "ssao_samples");
float invproj[4][4];
float dfdyfacs[2];
const bool is_persp = DRW_viewport_is_persp_get();
@ -505,7 +509,7 @@ static int mat_in_ubo(CLAY_Storage *storage, float matcap_rot, float matcap_hue,
static DRWShadingGroup *CLAY_object_shgrp_get(CLAY_Data *vedata, Object *ob, CLAY_StorageList *stl, CLAY_PassList *psl)
{
DRWShadingGroup **shgrps = stl->storage->shgrps;
IDProperty *props = BKE_object_collection_engine_get(ob, COLLECTION_MODE_NONE, RE_engine_id_BLENDER_CLAY);
IDProperty *props = BKE_layer_collection_engine_evaluated_get(ob, COLLECTION_MODE_NONE, RE_engine_id_BLENDER_CLAY);
/* Default Settings */
float matcap_rot = BKE_collection_engine_property_value_get_float(props, "matcap_rotation");
@ -574,7 +578,7 @@ static void CLAY_cache_populate(void *vedata, Object *ob)
struct Batch *geom = DRW_cache_object_surface_get(ob);
if (geom) {
IDProperty *ces_mode_ob = BKE_object_collection_engine_get(ob, COLLECTION_MODE_OBJECT, "");
IDProperty *ces_mode_ob = BKE_layer_collection_engine_evaluated_get(ob, COLLECTION_MODE_OBJECT, "");
bool do_cull = BKE_collection_engine_property_value_get_bool(ces_mode_ob, "show_backface_culling");
/* Depth Prepass */
@ -614,7 +618,7 @@ static void CLAY_draw_scene(void *vedata)
DRW_draw_pass(psl->clay_pass);
}
static void CLAY_collection_settings_create(RenderEngine *UNUSED(engine), IDProperty *props)
static void CLAY_layer_collection_settings_create(RenderEngine *UNUSED(engine), IDProperty *props)
{
BLI_assert(props &&
props->type == IDP_GROUP &&
@ -632,6 +636,15 @@ static void CLAY_collection_settings_create(RenderEngine *UNUSED(engine), IDProp
BKE_collection_engine_property_add_float(props, "ssao_factor_edge", 1.0f);
}
static void CLAY_scene_layer_settings_create(RenderEngine *UNUSED(engine), IDProperty *props)
{
BLI_assert(props &&
props->type == IDP_GROUP &&
props->subtype == IDP_GROUP_SUB_ENGINE_RENDER);
BKE_collection_engine_property_add_int(props, "ssao_samples", 32);
}
static void CLAY_engine_free(void)
{
DRW_SHADER_FREE_SAFE(e_data.clay_sh);
@ -658,7 +671,9 @@ DrawEngineType draw_engine_clay_type = {
RenderEngineType DRW_engine_viewport_clay_type = {
NULL, NULL,
CLAY_ENGINE, N_("Clay"), RE_INTERNAL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, &CLAY_collection_settings_create,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&CLAY_layer_collection_settings_create,
&CLAY_scene_layer_settings_create,
&draw_engine_clay_type,
{NULL, NULL, NULL}
};

17
source/blender/draw/engines/eevee/eevee_engine.c
View File

@ -555,7 +555,7 @@ static void EEVEE_cache_populate(void *vedata, Object *ob)
struct Batch *geom = DRW_cache_object_surface_get(ob);
if (geom) {
IDProperty *ces_mode_ob = BKE_object_collection_engine_get(ob, COLLECTION_MODE_OBJECT, "");
IDProperty *ces_mode_ob = BKE_layer_collection_engine_evaluated_get(ob, COLLECTION_MODE_OBJECT, "");
const bool do_cull = BKE_collection_engine_property_value_get_bool(ces_mode_ob, "show_backface_culling");
/* Depth Prepass */
@ -717,12 +717,22 @@ static void EEVEE_engine_free(void)
DRW_TEXTURE_FREE_SAFE(e_data.jitter);
}
static void EEVEE_collection_settings_create(RenderEngine *UNUSED(engine), IDProperty *props)
static void EEVEE_layer_collection_settings_create(RenderEngine *UNUSED(engine), IDProperty *props)
{
BLI_assert(props &&
props->type == IDP_GROUP &&
props->subtype == IDP_GROUP_SUB_ENGINE_RENDER);
// BKE_collection_engine_property_add_int(props, "high_quality_sphere_lamps", false);
UNUSED_VARS_NDEBUG(props);
}
static void EEVEE_scene_layer_settings_create(RenderEngine *UNUSED(engine), IDProperty *props)
{
BLI_assert(props &&
props->type == IDP_GROUP &&
props->subtype == IDP_GROUP_SUB_ENGINE_RENDER);
UNUSED_VARS_NDEBUG(props);
}
static const DrawEngineDataSize EEVEE_data_size = DRW_VIEWPORT_DATA_SIZE(EEVEE_Data);
@ -743,7 +753,8 @@ DrawEngineType draw_engine_eevee_type = {
RenderEngineType DRW_engine_viewport_eevee_type = {
NULL, NULL,
EEVEE_ENGINE, N_("Eevee"), RE_INTERNAL | RE_USE_SHADING_NODES,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, &EEVEE_collection_settings_create,
NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&EEVEE_layer_collection_settings_create, &EEVEE_scene_layer_settings_create,
&draw_engine_eevee_type,
{NULL, NULL, NULL}
};

2
source/blender/draw/engines/external/external_engine.c vendored
View File

@ -224,7 +224,7 @@ DrawEngineType draw_engine_external_type = {
RenderEngineType DRW_engine_viewport_external_type = {
NULL, NULL,
EXTERNAL_ENGINE, N_("External"), RE_INTERNAL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&draw_engine_external_type,
{NULL, NULL, NULL}
};

2
source/blender/draw/intern/draw_manager.c
View File

@ -1607,7 +1607,7 @@ bool DRW_is_object_renderable(Object *ob)
if (ob->type == OB_MESH) {
if (ob == obedit) {
IDProperty *props = BKE_object_collection_engine_get(ob, COLLECTION_MODE_EDIT, "");
IDProperty *props = BKE_layer_collection_engine_evaluated_get(ob, COLLECTION_MODE_EDIT, "");
bool do_occlude_wire = BKE_collection_engine_property_value_get_bool(props, "show_occlude_wire");
if (do_occlude_wire)

2
source/blender/draw/modes/edit_mesh_mode.c
View File

@ -400,7 +400,7 @@ static void EDIT_MESH_cache_populate(void *vedata, Object *ob)
if (ob->type == OB_MESH) {
if (ob == obedit) {
IDProperty *ces_mode_ed = BKE_object_collection_engine_get(ob, COLLECTION_MODE_EDIT, "");
IDProperty *ces_mode_ed = BKE_layer_collection_engine_evaluated_get(ob, COLLECTION_MODE_EDIT, "");
bool do_occlude_wire = BKE_collection_engine_property_value_get_bool(ces_mode_ed, "show_occlude_wire");
/* Updating uniform */
backwire_opacity = BKE_collection_engine_property_value_get_float(ces_mode_ed, "backwire_opacity");

2
source/blender/draw/modes/object_mode.c
View File

@ -1182,7 +1182,7 @@ static void OBJECT_cache_populate(void *vedata, Object *ob)
SceneLayer *sl = draw_ctx->sl;
int theme_id = TH_UNDEFINED;
//CollectionEngineSettings *ces_mode_ob = BKE_object_collection_engine_get(ob, COLLECTION_MODE_OBJECT, "");
//CollectionEngineSettings *ces_mode_ob = BKE_layer_collection_engine_evaluated_get(ob, COLLECTION_MODE_OBJECT, "");
//bool do_wire = BKE_collection_engine_property_value_get_bool(ces_mode_ob, "show_wire");
bool do_outlines = ((ob->base_flag & BASE_SELECTED) != 0);

2
source/blender/draw/modes/paint_vertex_mode.c
View File

@ -144,7 +144,7 @@ static void PAINT_VERTEX_cache_populate(void *vedata, Object *ob)
SceneLayer *sl = draw_ctx->sl;
if (ob->type == OB_MESH && ob == sl->basact->object) {
IDProperty *ces_mode_pw = BKE_object_collection_engine_get(ob, COLLECTION_MODE_PAINT_VERTEX, "");
IDProperty *ces_mode_pw = BKE_layer_collection_engine_evaluated_get(ob, COLLECTION_MODE_PAINT_VERTEX, "");
bool use_wire = BKE_collection_engine_property_value_get_bool(ces_mode_pw, "use_wire");
char flag = ((Mesh *)ob->data)->editflag;
struct Batch *geom;

2
source/blender/draw/modes/paint_weight_mode.c
View File

@ -168,7 +168,7 @@ static void PAINT_WEIGHT_cache_populate(void *vedata, Object *ob)
SceneLayer *sl = draw_ctx->sl;
if (ob->type == OB_MESH && ob == sl->basact->object) {
IDProperty *ces_mode_pw = BKE_object_collection_engine_get(ob, COLLECTION_MODE_PAINT_WEIGHT, "");
IDProperty *ces_mode_pw = BKE_layer_collection_engine_evaluated_get(ob, COLLECTION_MODE_PAINT_WEIGHT, "");
bool use_wire = BKE_collection_engine_property_value_get_bool(ces_mode_pw, "use_wire");
char flag = ((Mesh *)ob->data)->editflag;
struct Batch *geom;

2
source/blender/makesdna/DNA_layer_types.h
View File

@ -76,6 +76,8 @@ typedef struct SceneLayer {
ListBase object_bases; /* ObjectBase */
struct Base *basact;
ListBase layer_collections; /* LayerCollection */
struct IDProperty *properties; /* overrides */
struct IDProperty *properties_evaluated;
} SceneLayer;
typedef struct SceneCollection {

2
source/blender/makesdna/DNA_scene_types.h
View File

@ -1753,6 +1753,8 @@ typedef struct Scene {
int pad4;
IDProperty *collection_properties; /* settings to be overriden by layer collections */
IDProperty *layer_properties; /* settings to be override by workspaces */
int pad5[2];
} Scene;

252
source/blender/makesrna/intern/rna_scene.c
View File

@ -1932,6 +1932,31 @@ static void rna_GameSettings_exit_key_set(PointerRNA *ptr, int value)
gm->exitkey = value;
}
static StructRNA *rna_SceneLayerSettings_refine(PointerRNA *ptr)
{
IDProperty *props = (IDProperty *)ptr->data;
BLI_assert(props && props->type == IDP_GROUP);
switch (props->subtype) {
case IDP_GROUP_SUB_ENGINE_RENDER:
#ifdef WITH_CLAY_ENGINE
if (STREQ(props->name, RE_engine_id_BLENDER_CLAY)) {
return &RNA_SceneLayerEngineSettingsClay;
}
#endif
break;
case IDP_GROUP_SUB_MODE_OBJECT:
case IDP_GROUP_SUB_MODE_EDIT:
case IDP_GROUP_SUB_MODE_PAINT_WEIGHT:
case IDP_GROUP_SUB_MODE_PAINT_VERTEX:
default:
BLI_assert(!"Mode not fully implemented");
break;
}
return &RNA_SceneLayerSettings;
}
static StructRNA *rna_LayerCollectionSettings_refine(PointerRNA *ptr)
{
IDProperty *props = (IDProperty *)ptr->data;
@ -2505,6 +2530,10 @@ static void rna_LayerEngineSettings_##_ENGINE_##_##_NAME_##_set(PointerRNA *ptr,
/* clay engine */
#ifdef WITH_CLAY_ENGINE
/* SceneLayer settings. */
RNA_LAYER_ENGINE_CLAY_GET_SET_INT(ssao_samples)
/* LayerCollection settings. */
RNA_LAYER_ENGINE_CLAY_GET_SET_INT(matcap_icon)
RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(matcap_rotation)
RNA_LAYER_ENGINE_CLAY_GET_SET_FLOAT(matcap_hue)
@ -2538,6 +2567,13 @@ RNA_LAYER_MODE_PAINT_VERTEX_GET_SET_BOOL(use_wire)
#undef RNA_LAYER_ENGINE_GET_SET
static void rna_SceneLayerEngineSettings_update(bContext *C, PointerRNA *UNUSED(ptr))
{
Scene *scene = CTX_data_scene(C);
/* TODO(sergey): Use proper flag for tagging here. */
DAG_id_tag_update(&scene->id, 0);
}
static void rna_LayerCollectionEngineSettings_update(bContext *C, PointerRNA *UNUSED(ptr))
{
Scene *scene = CTX_data_scene(C);
@ -2561,6 +2597,79 @@ static void rna_LayerCollectionEngineSettings_wire_update(bContext *C, PointerRN
/***********************************/
static void engine_settings_use(IDProperty *root, IDProperty *props, PointerRNA *props_ptr, const char *identifier)
{
PropertyRNA *prop = RNA_struct_find_property(props_ptr, identifier);
switch (RNA_property_type(prop)) {
case PROP_FLOAT:
{
float value = BKE_collection_engine_property_value_get_float(props, identifier);
BKE_collection_engine_property_add_float(root, identifier, value);
break;
}
case PROP_ENUM:
{
int value = BKE_collection_engine_property_value_get_int(props, identifier);
BKE_collection_engine_property_add_int(root, identifier, value);
break;
}
case PROP_INT:
{
int value = BKE_collection_engine_property_value_get_int(props, identifier);
BKE_collection_engine_property_add_int(root, identifier, value);
break;
}
case PROP_BOOLEAN:
{
int value = BKE_collection_engine_property_value_get_int(props, identifier);
BKE_collection_engine_property_add_bool(root, identifier, value);
break;
}
case PROP_STRING:
case PROP_POINTER:
case PROP_COLLECTION:
default:
break;
}
}
static void rna_SceneLayerSettings_name_get(PointerRNA *ptr, char *value)
{
IDProperty *props = (IDProperty *)ptr->data;
strcpy(value, props->name);
}
static int rna_SceneLayerSettings_name_length(PointerRNA *ptr)
{
IDProperty *props = (IDProperty *)ptr->data;
return strnlen(props->name, sizeof(props->name));
}
static void rna_SceneLayerSettings_use(ID *id, IDProperty *props, const char *identifier)
{
Scene *scene = (Scene *)id;
PointerRNA scene_props_ptr;
IDProperty *scene_props;
scene_props = BKE_scene_layer_engine_scene_get(scene, COLLECTION_MODE_NONE, props->name);
RNA_pointer_create(id, &RNA_SceneLayerSettings, scene_props, &scene_props_ptr);
engine_settings_use(props, scene_props, &scene_props_ptr, identifier);
/* TODO(sergey): Use proper flag for tagging here. */
DAG_id_tag_update(id, 0);
}
static void rna_SceneLayerSettings_unuse(ID *id, IDProperty *props, const char *identifier)
{
IDProperty *prop_to_remove = IDP_GetPropertyFromGroup(props, identifier);
IDP_FreeFromGroup(props, prop_to_remove);
/* TODO(sergey): Use proper flag for tagging here. */
DAG_id_tag_update(id, 0);
}
static void rna_LayerCollectionSettings_name_get(PointerRNA *ptr, char *value)
{
IDProperty *props = (IDProperty *)ptr->data;
@ -2577,44 +2686,11 @@ static void rna_LayerCollectionSettings_use(ID *id, IDProperty *props, const cha
{
Scene *scene = (Scene *)id;
PointerRNA scene_props_ptr;
PropertyRNA *prop;
IDProperty *scene_props;
scene_props = BKE_scene_collection_engine_get(scene, COLLECTION_MODE_NONE, props->name);
scene_props = BKE_layer_collection_engine_scene_get(scene, COLLECTION_MODE_NONE, props->name);
RNA_pointer_create(id, &RNA_LayerCollectionSettings, scene_props, &scene_props_ptr);
prop = RNA_struct_find_property(&scene_props_ptr, identifier);
switch (RNA_property_type(prop)) {
case PROP_FLOAT:
{
float value = BKE_collection_engine_property_value_get_float(scene_props, identifier);
BKE_collection_engine_property_add_float(props, identifier, value);
break;
}
case PROP_ENUM:
{
int value = BKE_collection_engine_property_value_get_int(scene_props, identifier);
BKE_collection_engine_property_add_int(props, identifier, value);
break;
}
case PROP_INT:
{
int value = BKE_collection_engine_property_value_get_int(scene_props, identifier);
BKE_collection_engine_property_add_int(props, identifier, value);
break;
}
case PROP_BOOLEAN:
{
int value = BKE_collection_engine_property_value_get_int(scene_props, identifier);
BKE_collection_engine_property_add_bool(props, identifier, value);
break;
}
case PROP_STRING:
case PROP_POINTER:
case PROP_COLLECTION:
default:
break;
}
engine_settings_use(props, scene_props, &scene_props_ptr, identifier);
/* TODO(sergey): Use proper flag for tagging here. */
DAG_id_tag_update(id, 0);
@ -6003,6 +6079,31 @@ static void rna_def_layer_collection_override(BlenderRNA *brna)
RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, NULL);
}
#ifdef WITH_CLAY_ENGINE
static void rna_def_scene_layer_engine_settings_clay(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, "SceneLayerEngineSettingsClay", "SceneLayerSettings");
RNA_def_struct_ui_text(srna, "Clay Scene Layer Settings", "Clay Engine settings");
RNA_define_verify_sdna(0); /* not in sdna */
/* see RNA_LAYER_ENGINE_GET_SET macro */
prop = RNA_def_property(srna, "ssao_samples", PROP_INT, PROP_NONE);
RNA_def_property_int_funcs(prop, "rna_LayerEngineSettings_Clay_ssao_samples_get",
"rna_LayerEngineSettings_Clay_ssao_samples_set", NULL);
RNA_def_property_ui_text(prop, "Samples", "Number of samples");
RNA_def_property_range(prop, 1, 500);
RNA_def_property_flag(prop, PROP_CONTEXT_UPDATE);
RNA_def_property_update(prop, NC_SCENE | ND_LAYER_CONTENT, "rna_SceneLayerEngineSettings_update");
RNA_define_verify_sdna(1); /* not in sdna */
}
#endif /* WITH_CLAY_ENGINE */
#ifdef WITH_CLAY_ENGINE
static void rna_def_layer_collection_engine_settings_clay(BlenderRNA *brna)
{
@ -6243,6 +6344,53 @@ static void rna_def_layer_collection_mode_settings_paint_vertex(BlenderRNA *brna
RNA_define_verify_sdna(1); /* not in sdna */
}
static void rna_def_scene_layer_settings(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
FunctionRNA *func;
PropertyRNA *parm;
srna = RNA_def_struct(brna, "SceneLayerSettings", NULL);
RNA_def_struct_sdna(srna, "IDProperty");
RNA_def_struct_ui_text(srna, "Scene Layer Settings",
"Engine specific settings that can be overriden by SceneLayer");
RNA_def_struct_refine_func(srna, "rna_SceneLayerSettings_refine");
RNA_define_verify_sdna(0);
prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
RNA_def_property_string_funcs(prop, "rna_SceneLayerSettings_name_get", "rna_SceneLayerSettings_name_length", NULL);
RNA_def_property_ui_text(prop, "Name", "Engine Name");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_struct_name_property(srna, prop);
func = RNA_def_function(srna, "use", "rna_SceneLayerSettings_use");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Initialize this property to use");
parm = RNA_def_string(func, "identifier", NULL, 0, "Property Name", "Name of the property to set");
RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
func = RNA_def_function(srna, "unuse", "rna_SceneLayerSettings_unuse");
RNA_def_function_flag(func, FUNC_USE_SELF_ID);
RNA_def_function_ui_description(func, "Remove the property");
parm = RNA_def_string(func, "identifier", NULL, 0, "Property Name", "Name of the property to unset");
RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
#ifdef WITH_CLAY_ENGINE
rna_def_scene_layer_engine_settings_clay(brna);
#endif
#if 0
rna_def_scene_layer_mode_settings_object(brna);
rna_def_scene_layer_mode_settings_edit(brna);
rna_def_scene_layer_mode_settings_paint_weight(brna);
rna_def_scene_layer_mode_settings_paint_vertex(brna);
#endif
RNA_define_verify_sdna(1);
}
static void rna_def_layer_collection_settings(BlenderRNA *brna)
{
StructRNA *srna;
@ -6484,6 +6632,12 @@ static void rna_def_scene_layer(BlenderRNA *brna)
RNA_def_property_ui_text(prop, "Enabled", "Disable or enable the render layer");
RNA_def_property_update(prop, NC_SCENE | ND_LAYER, NULL);
/* Override settings */
prop = RNA_def_property(srna, "engine_overrides", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "properties->data.group", NULL);
RNA_def_property_struct_type(prop, "SceneLayerSettings");
RNA_def_property_ui_text(prop, "Layer Settings", "Override of engine specific render settings");
/* engine */
prop = RNA_def_property(srna, "engine", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, engine_items);
@ -7304,27 +7458,6 @@ static void rna_def_scene_quicktime_settings(BlenderRNA *brna)
}
#endif
#ifdef WITH_CLAY_ENGINE
static void UNUSED_FUNCTION(rna_def_scene_engine_settings_clay)(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
srna = RNA_def_struct(brna, "SceneEngineSettingsClay", "SceneEngineSettings");
RNA_def_struct_ui_text(srna, "Clay Scene Settings", "Clay Engine settings");
RNA_define_verify_sdna(0); /* not in sdna */
/* Clay settings */
prop = RNA_def_property(srna, "ssao_samples", PROP_INT, PROP_NONE);
RNA_def_property_ui_text(prop, "Samples", "Number of samples");
RNA_def_property_range(prop, 1, 500);
RNA_def_property_update(prop, NC_SPACE | ND_SPACE_VIEW3D, NULL);
RNA_define_verify_sdna(1); /* not in sdna */
}
#endif /* WITH_CLAY_ENGINE */
static void rna_def_scene_render_data(BlenderRNA *brna)
{
StructRNA *srna;
@ -8833,6 +8966,12 @@ void RNA_def_scene(BlenderRNA *brna)
RNA_def_property_ui_text(prop, "Render Data", "");
/* Render Engine Data */
prop = RNA_def_property(srna, "layer_properties", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "layer_properties->data.group", NULL);
RNA_def_property_struct_type(prop, "SceneLayerSettings");
RNA_def_property_ui_text(prop, "Layer Settings",
"Engine specific render settings to be overridden by layers");
prop = RNA_def_property(srna, "collection_properties", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "collection_properties->data.group", NULL);
RNA_def_property_struct_type(prop, "LayerCollectionSettings");
@ -8989,6 +9128,7 @@ void RNA_def_scene(BlenderRNA *brna)
rna_def_object_base(brna);
RNA_define_animate_sdna(true);
/* *** Animated *** */
rna_def_scene_layer_settings(brna);
rna_def_layer_collection_settings(brna);
rna_def_scene_render_data(brna);
rna_def_scene_render_layer(brna);

1
source/blender/render/extern/include/RE_engine.h vendored
View File

@ -105,6 +105,7 @@ typedef struct RenderEngineType {
void (*update_render_passes)(struct RenderEngine *engine, struct Scene *scene, struct SceneRenderLayer *srl);
void (*collection_settings_create)(struct RenderEngine *engine, struct IDProperty *props);
void (*render_settings_create)(struct RenderEngine *engine, struct IDProperty *props);
struct DrawEngineType *draw_engine;

9
source/blender/render/intern/source/external_engine.c
View File

@ -74,7 +74,7 @@
static RenderEngineType internal_render_type = {
NULL, NULL,
"BLENDER_RENDER", N_("Blender Render"), RE_INTERNAL | RE_USE_LEGACY_PIPELINE,
NULL, NULL, NULL, NULL, NULL, NULL, render_internal_update_passes, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, render_internal_update_passes, NULL, NULL, NULL,
{NULL, NULL, NULL}
};
@ -83,7 +83,7 @@ static RenderEngineType internal_render_type = {
static RenderEngineType internal_game_type = {
NULL, NULL,
"BLENDER_GAME", N_("Blender Game"), RE_INTERNAL | RE_GAME | RE_USE_LEGACY_PIPELINE,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
{NULL, NULL, NULL}
};
@ -107,6 +107,7 @@ void RE_engines_exit(void)
DRW_engines_free();
BKE_layer_collection_engine_settings_callback_free();
BKE_scene_layer_engine_settings_callback_free();
for (type = R_engines.first; type; type = next) {
next = type->next;
@ -131,6 +132,10 @@ void RE_engines_register(Main *bmain, RenderEngineType *render_type)
BKE_layer_collection_engine_settings_callback_register(
bmain, render_type->idname, render_type->collection_settings_create);
}
if (render_type->render_settings_create) {
BKE_scene_layer_engine_settings_callback_register(
bmain, render_type->idname, render_type->render_settings_create);
}
BLI_addtail(&R_engines, render_type);
}