Merge remote-tracking branch 'origin/blender2.8' into render-layers
authorDalai Felinto <dfelinto@gmail.com>
Mon, 23 Jan 2017 10:17:09 +0000 (11:17 +0100)
committerDalai Felinto <dfelinto@gmail.com>
Mon, 23 Jan 2017 10:17:09 +0000 (11:17 +0100)
1  2 
source/blender/blenkernel/intern/scene.c
source/blender/blenloader/intern/readfile.c
source/blender/blenloader/intern/writefile.c
source/blender/editors/mesh/editmesh_tools.c
source/blender/makesdna/DNA_scene_types.h
source/blender/makesrna/RNA_access.h
source/blender/makesrna/intern/rna_scene.c

Simple merge
index e41be32622eeba47cad745d4addc72772d9ce2a2,1166fb89a0a5c89191e728925af4a1bf925a6a2e..018ce7a98f2f97f329b95545bbaa5d69f6ef4578
@@@ -423,7 -445,7 +448,8 @@@ EnumPropertyItem rna_enum_gpencil_inter
  #include "MEM_guardedalloc.h"
  
  #include "BKE_brush.h"
 +#include "BKE_collection.h"
+ #include "BKE_colortools.h"
  #include "BKE_context.h"
  #include "BKE_global.h"
  #include "BKE_image.h"
@@@ -2141,386 -2185,75 +2190,453 @@@ static int rna_gpu_is_hq_supported_get(
        return GPU_instanced_drawing_support() && GPU_geometry_shader_support();
  }
  
 +static void rna_SceneCollection_name_set(PointerRNA *ptr, const char *value)
 +{
 +      Scene *scene = (Scene *)ptr->id.data;
 +      SceneCollection *sc = (SceneCollection *)ptr->data;
 +      SceneCollection *sc_master = BKE_collection_master(scene);
 +
 +      BLI_strncpy_utf8(sc->name, value, sizeof(sc->name));
 +      BLI_uniquename(&sc_master->scene_collections, sc, DATA_("SceneCollection"), '.', offsetof(SceneCollection, name), sizeof(sc->name));
 +}
 +
 +static void rna_SceneCollection_filter_set(PointerRNA *ptr, const char *value)
 +{
 +      Scene *scene = (Scene *)ptr->id.data;
 +      SceneCollection *sc = (SceneCollection *)ptr->data;
 +      BLI_strncpy_utf8(sc->filter, value, sizeof(sc->filter));
 +
 +      TODO_LAYER_SYNC_FILTER;
 +      (void)scene;
 +}
 +
 +static PointerRNA rna_SceneCollection_objects_get(CollectionPropertyIterator *iter)
 +{
 +      ListBaseIterator *internal = &iter->internal.listbase;
 +
 +      /* we are actually iterating a LinkData list, so override get */
 +      return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, ((LinkData *)internal->link)->data);
 +}
 +
 +static SceneCollection *rna_SceneCollection_new(ID *id, SceneCollection *sc_parent, const char *name)
 +{
 +      Scene *scene = (Scene *)id;
 +      SceneCollection *sc = BKE_collection_add(scene, sc_parent, name);
 +
 +      DAG_id_tag_update(&scene->id, 0);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
 +
 +      return sc;
 +}
 +
 +static void rna_SceneCollection_remove(
 +        ID *id, SceneCollection *sc_parent, ReportList *reports, PointerRNA *sc_ptr)
 +{
 +      Scene *scene = (Scene *)id;
 +      SceneCollection *sc = sc_ptr->data;
 +
 +      const int index = BLI_findindex(&sc_parent->scene_collections, sc);
 +      if (index == -1) {
 +              BKE_reportf(reports, RPT_ERROR, "Collection '%s' is not a sub-collection of '%s'",
 +                          sc->name, sc_parent->name);
 +              return;
 +      }
 +
 +      if (!BKE_collection_remove(scene, sc)) {
 +              BKE_reportf(reports, RPT_ERROR, "Collection '%s' could not be removed from collection '%s'",
 +                          sc->name, sc_parent->name);
 +              return;
 +      }
 +
 +      RNA_POINTER_INVALIDATE(sc_ptr);
 +
 +      DAG_id_tag_update(&scene->id, 0);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
 +}
 +
 +void rna_SceneCollection_object_link(
 +        ID *id, SceneCollection *sc, Main *bmain, ReportList *reports, Object *ob)
 +{
 +      Scene *scene = (Scene *)id;
 +
 +      if (BLI_findptr(&sc->objects, ob, offsetof(LinkData, data))) {
 +              BKE_reportf(reports, RPT_ERROR, "Object '%s' is already in collection '%s'", ob->id.name + 2, sc->name);
 +              return;
 +      }
 +
 +      BKE_collection_object_add(scene, sc, ob);
 +
 +      /* TODO(sergey): Only update relations for the current scene. */
 +      DAG_relations_tag_update(bmain);
 +      DAG_id_tag_update(&ob->id, OB_RECALC_OB | OB_RECALC_DATA | OB_RECALC_TIME);
 +
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER | ND_OB_ACTIVE, scene);
 +}
 +
 +static void rna_SceneCollection_object_unlink(
 +        ID *id, SceneCollection *sc, Main *bmain, ReportList *reports, Object *ob)
 +{
 +      Scene *scene = (Scene *)id;
 +
 +      if (!BLI_findptr(&sc->objects, ob, offsetof(LinkData, data))) {
 +              BKE_reportf(reports, RPT_ERROR, "Object '%s' is not in collection '%s'", ob->id.name + 2, sc->name);
 +              return;
 +      }
 +
 +      BKE_collection_object_remove(bmain, scene, sc, ob, false);
 +
 +      /* needed otherwise the depgraph will contain freed objects which can crash, see [#20958] */
 +      DAG_relations_tag_update(bmain);
 +
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER | ND_OB_ACTIVE, scene);
 +}
 +
 +static void rna_LayerCollection_name_get(PointerRNA *ptr, char *value)
 +{
 +      SceneCollection *sc = ((LayerCollection *)ptr->data)->scene_collection;
 +      strcpy(value, sc->name);
 +}
 +
 +static int rna_LayerCollection_name_length(PointerRNA *ptr)
 +{
 +      SceneCollection *sc = ((LayerCollection *)ptr->data)->scene_collection;
 +      return strnlen(sc->name, sizeof(sc->name));
 +}
 +
 +static void rna_LayerCollection_name_set(PointerRNA *ptr, const char *value)
 +{
 +      Scene *scene = (Scene *)ptr->id.data;
 +      SceneCollection *sc = ((LayerCollection *)ptr->data)->scene_collection;
 +      SceneCollection *sc_master = BKE_collection_master(scene);
 +
 +      BLI_strncpy_utf8(sc->name, value, sizeof(sc->name));
 +      BLI_uniquename(&sc_master->scene_collections, sc, DATA_("SceneCollection"), '.', offsetof(SceneCollection, name), sizeof(sc->name));
 +}
 +
 +static PointerRNA rna_LayerCollection_objects_get(CollectionPropertyIterator *iter)
 +{
 +      ListBaseIterator *internal = &iter->internal.listbase;
 +      ObjectBase *base = ((LinkData *)internal->link)->data;
 +      return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, base->object);
 +}
 +
 +static void rna_LayerCollection_hide_update(bContext *C, PointerRNA *ptr)
 +{
 +      Scene *scene = CTX_data_scene(C);
 +      LayerCollection *lc = ptr->data;
 +      SceneLayer *sl = BKE_scene_layer_find_from_collection(scene, lc);
 +
 +      /* hide and deselect bases that are directly influenced by this LayerCollection */
 +      BKE_scene_layer_base_flag_recalculate(sl);
 +      WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, scene);
 +}
 +
 +static void rna_LayerCollection_hide_select_update(bContext *C, PointerRNA *ptr)
 +{
 +      LayerCollection *lc = ptr->data;
 +
 +      if ((lc->flag & COLLECTION_SELECTABLE) == 0) {
 +              Scene *scene = CTX_data_scene(C);
 +              SceneLayer *sl = BKE_scene_layer_find_from_collection(scene, lc);
 +
 +              /* deselect bases that are directly influenced by this LayerCollection */
 +              BKE_scene_layer_base_flag_recalculate(sl);
 +              WM_event_add_notifier(C, NC_SCENE | ND_OB_SELECT, CTX_data_scene(C));
 +      }
 +}
 +
 +static int rna_LayerCollections_active_collection_index_get(PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      return sl->active_collection;
 +}
 +
 +static void rna_LayerCollections_active_collection_index_set(PointerRNA *ptr, int value)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      int num_collections = BKE_layer_collection_count(sl);
 +      sl->active_collection = min_ff(value, num_collections - 1);
 +}
 +
 +static void rna_LayerCollections_active_collection_index_range(
 +        PointerRNA *ptr, int *min, int *max, int *UNUSED(softmin), int *UNUSED(softmax))
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      *min = 0;
 +      *max = max_ii(0, BKE_layer_collection_count(sl) - 1);
 +}
 +
 +static PointerRNA rna_LayerCollections_active_collection_get(PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      LayerCollection *lc = BKE_layer_collection_active(sl);
 +      return rna_pointer_inherit_refine(ptr, &RNA_LayerCollection, lc);
 +}
 +
 +static void rna_LayerCollections_active_collection_set(PointerRNA *ptr, PointerRNA value)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      LayerCollection *lc = (LayerCollection *)value.data;
 +      const int index = BKE_layer_collection_findindex(sl, lc);
 +      if (index != -1) sl->active_collection = index;
 +}
 +
 +LayerCollection * rna_SceneLayer_collection_link(
 +        ID *id, SceneLayer *sl, Main *bmain, SceneCollection *sc)
 +{
 +      Scene *scene = (Scene *)id;
 +      LayerCollection *lc = BKE_collection_link(sl, sc);
 +
 +      /* TODO(sergey/dfelinto): Only update relations for the current scenelayer. */
 +      DAG_relations_tag_update(bmain);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, scene);
 +
 +      return lc;
 +}
 +
 +static void rna_SceneLayer_collection_unlink(
 +        ID *id, SceneLayer *sl, Main *bmain, ReportList *reports, LayerCollection *lc)
 +{
 +      Scene *scene = (Scene *)id;
 +
 +      if (BLI_findindex(&sl->layer_collections, lc) == -1) {
 +              BKE_reportf(reports, RPT_ERROR, "Layer collection '%s' is not in '%s'", lc->scene_collection->name, sl->name);
 +              return;
 +      }
 +
 +      BKE_collection_unlink(sl, lc);
 +
 +      /* needed otherwise the depgraph will contain freed objects which can crash, see [#20958] */
 +      /* TODO(sergey/dfelinto): Only update relations for the current scenelayer. */
 +      DAG_relations_tag_update(bmain);
 +
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER | ND_OB_ACTIVE, scene);
 +}
 +
 +static PointerRNA rna_LayerObjects_active_object_get(PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      return rna_pointer_inherit_refine(ptr, &RNA_Object, sl->basact ? sl->basact->object : NULL);
 +}
 +
 +static void rna_LayerObjects_active_object_set(PointerRNA *ptr, PointerRNA value)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      if (value.data)
 +              sl->basact = BKE_scene_layer_base_find(sl, (Object *)value.data);
 +      else
 +              sl->basact = NULL;
 +}
 +
 +static void rna_SceneLayer_name_set(PointerRNA *ptr, const char *value)
 +{
 +      Scene *scene = (Scene *)ptr->id.data;
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      char oldname[sizeof(sl->name)];
 +
 +      BLI_strncpy(oldname, sl->name, sizeof(sl->name));
 +
 +      BLI_strncpy_utf8(sl->name, value, sizeof(sl->name));
 +      BLI_uniquename(&scene->render_layers, sl, DATA_("SceneLayer"), '.', offsetof(SceneLayer, name), sizeof(sl->name));
 +
 +      if (scene->nodetree) {
 +              bNode *node;
 +              int index = BLI_findindex(&scene->render_layers, sl);
 +
 +              for (node = scene->nodetree->nodes.first; node; node = node->next) {
 +                      if (node->type == CMP_NODE_R_LAYERS && node->id == NULL) {
 +                              if (node->custom1 == index)
 +                                      BLI_strncpy(node->name, sl->name, NODE_MAXSTR);
 +                      }
 +              }
 +      }
 +}
 +
 +static PointerRNA rna_SceneLayer_objects_get(CollectionPropertyIterator *iter)
 +{
 +      ListBaseIterator *internal = &iter->internal.listbase;
 +
 +      /* we are actually iterating a ObjectBase list, so override get */
 +      ObjectBase *base = (ObjectBase *)internal->link;
 +      return rna_pointer_inherit_refine(&iter->parent, &RNA_Object, base->object);
 +}
 +
 +static int rna_SceneLayer_objects_selected_skip(CollectionPropertyIterator *iter, void *UNUSED(data))
 +{
 +      ListBaseIterator *internal = &iter->internal.listbase;
 +      ObjectBase *base = (ObjectBase *)internal->link;
 +
 +      if ((base->flag & BASE_SELECTED) != 0) {
 +                      return 0;
 +      }
 +
 +      return 1;
 +};
 +
 +static void rna_LayerObjects_selected_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      rna_iterator_listbase_begin(iter, &sl->object_bases, rna_SceneLayer_objects_selected_skip);
 +}
 +
 +static void rna_SceneLayer_engine_set(PointerRNA *ptr, int value)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      RenderEngineType *type = BLI_findlink(&R_engines, value);
 +
 +      if (type)
 +              BKE_scene_layer_engine_set(sl, type->idname);
 +}
 +
 +static EnumPropertyItem *rna_SceneLayer_engine_itemf(
 +        bContext *UNUSED(C), PointerRNA *UNUSED(ptr), PropertyRNA *UNUSED(prop), bool *r_free)
 +{
 +      RenderEngineType *type;
 +      EnumPropertyItem *item = NULL;
 +      EnumPropertyItem tmp = {0, "", 0, "", ""};
 +      int a = 0, totitem = 0;
 +
 +      for (type = R_engines.first; type; type = type->next, a++) {
 +              tmp.value = a;
 +              tmp.identifier = type->idname;
 +              tmp.name = type->name;
 +              RNA_enum_item_add(&item, &totitem, &tmp);
 +      }
 +
 +      RNA_enum_item_end(&item, &totitem);
 +      *r_free = true;
 +
 +      return item;
 +}
 +
 +static int rna_SceneLayer_engine_get(PointerRNA *ptr)
 +{
 +      SceneLayer *sl = (SceneLayer *)ptr->data;
 +      RenderEngineType *type;
 +      int a = 0;
 +
 +      for (type = R_engines.first; type; type = type->next, a++)
 +              if (STREQ(type->idname, sl->engine))
 +                      return a;
 +
 +      return 0;
 +}
 +
 +static void rna_SceneLayer_engine_update(Main *bmain, Scene *UNUSED(unused), PointerRNA *UNUSED(ptr))
 +{
 +      ED_render_engine_changed(bmain);
 +}
 +
 +static int rna_SceneLayer_multiple_engines_get(PointerRNA *UNUSED(ptr))
 +{
 +      return (BLI_listbase_count(&R_engines) > 1);
 +}
 +
 +static SceneLayer *rna_SceneLayer_new(ID *id, Scene *UNUSED(sce), const char *name)
 +{
 +      Scene *scene = (Scene *)id;
 +      SceneLayer *sl = BKE_scene_layer_add(scene, name);
 +
 +      DAG_id_tag_update(&scene->id, 0);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
 +
 +      return sl;
 +}
 +
 +static void rna_SceneLayer_remove(
 +        ID *id, Scene *UNUSED(sce), Main *bmain, ReportList *reports, PointerRNA *sl_ptr)
 +{
 +      Scene *scene = (Scene *)id;
 +      SceneLayer *sl = sl_ptr->data;
 +
 +      if (!BKE_scene_layer_remove(bmain, scene, sl)) {
 +              BKE_reportf(reports, RPT_ERROR, "Render layer '%s' could not be removed from scene '%s'",
 +                          sl->name, scene->id.name + 2);
 +              return;
 +      }
 +
 +      RNA_POINTER_INVALIDATE(sl_ptr);
 +
 +      DAG_id_tag_update(&scene->id, 0);
 +      WM_main_add_notifier(NC_SCENE | ND_LAYER, NULL);
 +}
 +
 +static void rna_ObjectBase_select_update(Main *UNUSED(bmain), Scene *UNUSED(scene), PointerRNA *ptr)
 +{
 +      ObjectBase *base = (ObjectBase *)ptr->data;
 +      short mode = (base->flag & BASE_SELECTED) ? BA_SELECT : BA_DESELECT;
 +      ED_object_base_select(base, mode);
 +}
 +
  #else
  
+ /* Grease Pencil Interpolation tool settings */
+ static void rna_def_gpencil_interpolate(BlenderRNA *brna)
+ {
+       StructRNA *srna;
+       PropertyRNA *prop;
+       
+       srna = RNA_def_struct(brna, "GPencilInterpolateSettings", NULL);
+       RNA_def_struct_sdna(srna, "GP_Interpolate_Settings");
+       RNA_def_struct_path_func(srna, "rna_GPencilInterpolateSettings_path");
+       RNA_def_struct_ui_text(srna, "Grease Pencil Interpolate Settings",
+                              "Settings for Grease Pencil interpolation tools");
+       
+       /* flags */
+       prop = RNA_def_property(srna, "interpolate_all_layers", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ALL_LAYERS);
+       RNA_def_property_ui_text(prop, "Interpolate All Layers", "Interpolate all layers, not only active");
+       RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+       prop = RNA_def_property(srna, "interpolate_selected_only", PROP_BOOLEAN, PROP_NONE);
+       RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_TOOLFLAG_INTERPOLATE_ONLY_SELECTED);
+       RNA_def_property_ui_text(prop, "Interpolate Selected Strokes", "Interpolate only selected strokes in the original frame");
+       RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+       
+       /* interpolation type */
+       prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "type");
+       RNA_def_property_enum_items(prop, rna_enum_gpencil_interpolation_mode_items);
+       RNA_def_property_enum_funcs(prop, NULL, "rna_GPencilInterpolateSettings_type_set", NULL);
+       RNA_def_property_ui_text(prop, "Type",
+                                "Interpolation method to use the next time 'Interpolate Sequence' is run");
+       RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+       
+       /* easing */
+       prop = RNA_def_property(srna, "easing", PROP_ENUM, PROP_NONE);
+       RNA_def_property_enum_sdna(prop, NULL, "easing");
+       RNA_def_property_enum_items(prop, rna_enum_beztriple_interpolation_easing_items);
+       RNA_def_property_ui_text(prop, "Easing", 
+                                "Which ends of the segment between the preceding and following grease pencil frames "
+                                "easing interpolation is applied to");
+       RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+       
+       /* easing options */
+       prop = RNA_def_property(srna, "back", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "back");
+       RNA_def_property_ui_text(prop, "Back", "Amount of overshoot for 'back' easing");
+       RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+       
+       prop = RNA_def_property(srna, "amplitude", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "amplitude");
+       RNA_def_property_range(prop, 0.0f, FLT_MAX); /* only positive values... */
+       RNA_def_property_ui_text(prop, "Amplitude", "Amount to boost elastic bounces for 'elastic' easing");
+       RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+       
+       prop = RNA_def_property(srna, "period", PROP_FLOAT, PROP_NONE);
+       RNA_def_property_float_sdna(prop, NULL, "period");
+       RNA_def_property_ui_text(prop, "Period", "Time between bounces for elastic easing");
+       RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+       
+       /* custom curvemap */
+       prop = RNA_def_property(srna, "interpolation_curve", PROP_POINTER, PROP_NONE);
+       RNA_def_property_pointer_sdna(prop, NULL, "custom_ipo");
+       RNA_def_property_struct_type(prop, "CurveMapping");
+       RNA_def_property_ui_text(prop, "Interpolation Curve", 
+                                "Custom curve to control 'sequence' interpolation between Grease Pencil frames");
+       RNA_def_property_update(prop, NC_SCENE | ND_TOOLSETTINGS, NULL);
+ }
  /* Grease Pencil Drawing Brushes */
  static void rna_def_gpencil_brush(BlenderRNA *brna)
  {