From 0b49fdd0ee0de93665cc688454fb3ccbd7a619ce Mon Sep 17 00:00:00 2001
From: Bastien Montagne <bastien@blender.org>
Date: Tue, 18 Aug 2020 11:36:34 +0200
Subject: Fix/cleanup Constraint poll function in liboverride cases.

Some constraint-specific operators, like set/clear inverse matrix of
childof constraint, are also valid on original, linked/overridden
constraints.

Similar change to what was done to modifiers poll function a few days
ago.

Reported by Josephbburg (@Josephbburg) over IRC, thanks.
---
 source/blender/editors/object/object_constraint.c | 41 +++++++++++++++--------
 1 file changed, 27 insertions(+), 14 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/object/object_constraint.c b/source/blender/editors/object/object_constraint.c
index bcb1b8afbdd..70404af6433 100644
--- a/source/blender/editors/object/object_constraint.c
+++ b/source/blender/editors/object/object_constraint.c
@@ -663,10 +663,13 @@ static const EnumPropertyItem constraint_owner_items[] = {
     {0, NULL, 0, NULL, NULL},
 };
 
-static bool edit_constraint_poll_generic(bContext *C, StructRNA *rna_type)
+static bool edit_constraint_poll_generic(bContext *C,
+                                         StructRNA *rna_type,
+                                         const bool is_liboverride_allowed)
 {
   PointerRNA ptr = CTX_data_pointer_get_type(C, "constraint", rna_type);
   Object *ob = (ptr.owner_id) ? (Object *)ptr.owner_id : ED_object_active_context(C);
+  bConstraint *con = ptr.data;
 
   if (!ob) {
     CTX_wm_operator_poll_msg_set(C, "Context missing active object");
@@ -678,9 +681,11 @@ static bool edit_constraint_poll_generic(bContext *C, StructRNA *rna_type)
     return false;
   }
 
-  if (ID_IS_OVERRIDE_LIBRARY(ob) && ptr.data != NULL) {
-    CTX_wm_operator_poll_msg_set(C, "Cannot edit constraints coming from library override");
-    return (((bConstraint *)ptr.data)->flag & CONSTRAINT_OVERRIDE_LIBRARY_LOCAL) != 0;
+  if (ID_IS_OVERRIDE_LIBRARY(ob) && !is_liboverride_allowed) {
+    if ((con == NULL) || (con->flag & CONSTRAINT_OVERRIDE_LIBRARY_LOCAL) != 0) {
+      CTX_wm_operator_poll_msg_set(C, "Cannot edit constraints coming from library override");
+      return false;
+    }
   }
 
   return true;
@@ -688,7 +693,14 @@ static bool edit_constraint_poll_generic(bContext *C, StructRNA *rna_type)
 
 static bool edit_constraint_poll(bContext *C)
 {
-  return edit_constraint_poll_generic(C, &RNA_Constraint);
+  return edit_constraint_poll_generic(C, &RNA_Constraint, false);
+}
+
+/* Used by operators performing actions allowed also on constraints from the overridden linked
+ * object (not only from added 'local' ones). */
+static bool edit_constraint_liboverride_allowed_poll(bContext *C)
+{
+  return edit_constraint_poll_generic(C, &RNA_Constraint, true);
 }
 
 static void edit_constraint_properties(wmOperatorType *ot)
@@ -864,7 +876,7 @@ void CONSTRAINT_OT_stretchto_reset(wmOperatorType *ot)
   /* callbacks */
   ot->invoke = stretchto_reset_invoke;
   ot->exec = stretchto_reset_exec;
-  ot->poll = edit_constraint_poll;
+  ot->poll = edit_constraint_liboverride_allowed_poll;
 
   /* flags */
   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
@@ -919,7 +931,7 @@ void CONSTRAINT_OT_limitdistance_reset(wmOperatorType *ot)
   /* callbacks */
   ot->invoke = limitdistance_reset_invoke;
   ot->exec = limitdistance_reset_exec;
-  ot->poll = edit_constraint_poll;
+  ot->poll = edit_constraint_liboverride_allowed_poll;
 
   /* flags */
   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
@@ -997,7 +1009,7 @@ void CONSTRAINT_OT_childof_set_inverse(wmOperatorType *ot)
   /* callbacks */
   ot->invoke = childof_set_inverse_invoke;
   ot->exec = childof_set_inverse_exec;
-  ot->poll = edit_constraint_poll;
+  ot->poll = edit_constraint_liboverride_allowed_poll;
 
   /* flags */
   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
@@ -1046,7 +1058,7 @@ void CONSTRAINT_OT_childof_clear_inverse(wmOperatorType *ot)
   /* callbacks */
   ot->invoke = childof_clear_inverse_invoke;
   ot->exec = childof_clear_inverse_exec;
-  ot->poll = edit_constraint_poll;
+  ot->poll = edit_constraint_liboverride_allowed_poll;
 
   /* flags */
   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
@@ -1693,8 +1705,8 @@ void POSE_OT_constraints_clear(wmOperatorType *ot)
 
   /* callbacks */
   ot->exec = pose_constraints_clear_exec;
-  ot->poll =
-      ED_operator_posemode_exclusive;  // XXX - do we want to ensure there are selected bones too?
+  ot->poll = ED_operator_posemode_exclusive;  // XXX - do we want to ensure there are selected
+                                              // bones too?
 }
 
 static int object_constraints_clear_exec(bContext *C, wmOperator *UNUSED(op))
@@ -1942,7 +1954,8 @@ static bool get_new_constraint_target(
 
           /* perform some special operations on the target */
           if (only_curve) {
-            /* Curve-Path option must be enabled for follow-path constraints to be able to work */
+            /* Curve-Path option must be enabled for follow-path constraints to be able to work
+             */
             Curve *cu = (Curve *)ob->data;
             cu->flag |= CU_PATH;
           }
@@ -2214,8 +2227,8 @@ void OBJECT_OT_constraint_add_with_targets(wmOperatorType *ot)
   /* identifiers */
   ot->name = "Add Constraint (with Targets)";
   ot->description =
-      "Add a constraint to the active object, with target (where applicable) set to the selected "
-      "Objects/Bones";
+      "Add a constraint to the active object, with target (where applicable) set to the "
+      "selected Objects/Bones";
   ot->idname = "OBJECT_OT_constraint_add_with_targets";
 
   /* api callbacks */
-- 
cgit v1.2.3


From db4e08dfdc9c90680e4722e02a3c6f35d51f124f Mon Sep 17 00:00:00 2001
From: Pablo Dobarro <pablodp606@gmail.com>
Date: Mon, 17 Aug 2020 22:18:26 +0200
Subject: Sculpt: Expose the functions to create and init a
 SculptClothSimulation

This will be used for new features like supporting cloth deformation in
other brushes and tools outside of the cloth brush code.
No functional changes.

Reviewed By: sergey

Differential Revision: https://developer.blender.org/D8602
---
 source/blender/editors/sculpt_paint/sculpt_cloth.c | 218 +++++++++++----------
 .../blender/editors/sculpt_paint/sculpt_intern.h   |  24 +++
 2 files changed, 137 insertions(+), 105 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/sculpt_paint/sculpt_cloth.c b/source/blender/editors/sculpt_paint/sculpt_cloth.c
index 4070822a0a8..bdc7d7520ea 100644
--- a/source/blender/editors/sculpt_paint/sculpt_cloth.c
+++ b/source/blender/editors/sculpt_paint/sculpt_cloth.c
@@ -505,49 +505,6 @@ static ListBase *cloth_brush_collider_cache_create(Depsgraph *depsgraph)
   return cache;
 }
 
-static SculptClothSimulation *cloth_brush_simulation_create(SculptSession *ss,
-                                                            Brush *brush,
-                                                            const float cloth_mass,
-                                                            const float cloth_damping,
-                                                            const bool use_collisions)
-{
-  const int totverts = SCULPT_vertex_count_get(ss);
-  SculptClothSimulation *cloth_sim;
-
-  cloth_sim = MEM_callocN(sizeof(SculptClothSimulation), "cloth constraints");
-
-  cloth_sim->length_constraints = MEM_callocN(sizeof(SculptClothLengthConstraint) *
-                                                  CLOTH_LENGTH_CONSTRAINTS_BLOCK,
-                                              "cloth length constraints");
-  cloth_sim->capacity_length_constraints = CLOTH_LENGTH_CONSTRAINTS_BLOCK;
-
-  cloth_sim->acceleration = MEM_calloc_arrayN(
-      totverts, sizeof(float[3]), "cloth sim acceleration");
-  cloth_sim->pos = MEM_calloc_arrayN(totverts, sizeof(float[3]), "cloth sim pos");
-  cloth_sim->prev_pos = MEM_calloc_arrayN(totverts, sizeof(float[3]), "cloth sim prev pos");
-  cloth_sim->last_iteration_pos = MEM_calloc_arrayN(
-      totverts, sizeof(float[3]), "cloth sim last iteration pos");
-  cloth_sim->init_pos = MEM_calloc_arrayN(totverts, sizeof(float[3]), "cloth sim init pos");
-  cloth_sim->length_constraint_tweak = MEM_calloc_arrayN(
-      totverts, sizeof(float), "cloth sim length tweak");
-
-  /* Brush can be NULL for tools that need the solver but don't rely on constraint to deformation
-   * positions. */
-  if (brush && SCULPT_is_cloth_deform_brush(brush)) {
-    cloth_sim->deformation_pos = MEM_calloc_arrayN(
-        totverts, sizeof(float[3]), "cloth sim deformation positions");
-  }
-
-  cloth_sim->mass = cloth_mass;
-  cloth_sim->damping = cloth_damping;
-
-  if (use_collisions) {
-    cloth_sim->collider_list = cloth_brush_collider_cache_create(ss->depsgraph);
-  }
-
-  return cloth_sim;
-}
-
 typedef struct ClothBrushCollision {
   CollisionModifierData *col_data;
   struct IsectRayPrecalc isect_precalc;
@@ -699,43 +656,6 @@ static void do_cloth_brush_solve_simulation_task_cb_ex(
   BKE_pbvh_vertex_iter_end;
 }
 
-static void cloth_brush_build_nodes_constraints(
-    Sculpt *sd,
-    Object *ob,
-    PBVHNode **nodes,
-    int totnode,
-    SculptClothSimulation *cloth_sim,
-    /* Cannot be const, because it is assigned to a non-const variable.
-     * NOLINTNEXTLINE: readability-non-const-parameter. */
-    float initial_location[3],
-    const float radius)
-{
-  Brush *brush = BKE_paint_brush(&sd->paint);
-
-  /* TODO: Multi-threaded needs to be disabled for this task until implementing the optimization of
-   * storing the constraints per node. */
-  /* Currently all constrains are added to the same global array which can't be accessed from
-   * different threads. */
-  TaskParallelSettings settings;
-  BKE_pbvh_parallel_range_settings(&settings, false, totnode);
-
-  cloth_sim->created_length_constraints = BLI_edgeset_new("created length constraints");
-
-  SculptThreadedTaskData build_constraints_data = {
-      .sd = sd,
-      .ob = ob,
-      .brush = brush,
-      .nodes = nodes,
-      .cloth_sim = cloth_sim,
-      .cloth_sim_initial_location = initial_location,
-      .cloth_sim_radius = radius,
-  };
-  BLI_task_parallel_range(
-      0, totnode, &build_constraints_data, do_cloth_brush_build_constraints_task_cb_ex, &settings);
-
-  BLI_edgeset_free(cloth_sim->created_length_constraints);
-}
-
 static void cloth_brush_satisfy_constraints(SculptSession *ss,
                                             Brush *brush,
                                             SculptClothSimulation *cloth_sim)
@@ -897,6 +817,107 @@ static void cloth_brush_apply_brush_foces(Sculpt *sd, Object *ob, PBVHNode **nod
 }
 
 /* Public functions. */
+SculptClothSimulation *SCULPT_cloth_brush_simulation_create(SculptSession *ss,
+                                                            Brush *brush,
+                                                            const float cloth_mass,
+                                                            const float cloth_damping,
+                                                            const bool use_collisions)
+{
+  const int totverts = SCULPT_vertex_count_get(ss);
+  SculptClothSimulation *cloth_sim;
+
+  cloth_sim = MEM_callocN(sizeof(SculptClothSimulation), "cloth constraints");
+
+  cloth_sim->length_constraints = MEM_callocN(sizeof(SculptClothLengthConstraint) *
+                                                  CLOTH_LENGTH_CONSTRAINTS_BLOCK,
+                                              "cloth length constraints");
+  cloth_sim->capacity_length_constraints = CLOTH_LENGTH_CONSTRAINTS_BLOCK;
+
+  cloth_sim->acceleration = MEM_calloc_arrayN(
+      totverts, sizeof(float[3]), "cloth sim acceleration");
+  cloth_sim->pos = MEM_calloc_arrayN(totverts, sizeof(float[3]), "cloth sim pos");
+  cloth_sim->prev_pos = MEM_calloc_arrayN(totverts, sizeof(float[3]), "cloth sim prev pos");
+  cloth_sim->last_iteration_pos = MEM_calloc_arrayN(
+      totverts, sizeof(float[3]), "cloth sim last iteration pos");
+  cloth_sim->init_pos = MEM_calloc_arrayN(totverts, sizeof(float[3]), "cloth sim init pos");
+  cloth_sim->length_constraint_tweak = MEM_calloc_arrayN(
+      totverts, sizeof(float), "cloth sim length tweak");
+
+  /* Brush can be NULL for tools that need the solver but don't rely on constraint to deformation
+   * positions. */
+  if (brush && SCULPT_is_cloth_deform_brush(brush)) {
+    cloth_sim->deformation_pos = MEM_calloc_arrayN(
+        totverts, sizeof(float[3]), "cloth sim deformation positions");
+  }
+
+  cloth_sim->mass = cloth_mass;
+  cloth_sim->damping = cloth_damping;
+
+  if (use_collisions) {
+    cloth_sim->collider_list = cloth_brush_collider_cache_create(ss->depsgraph);
+  }
+
+  return cloth_sim;
+}
+
+void SCULPT_cloth_brush_build_nodes_constraints(
+    Sculpt *sd,
+    Object *ob,
+    PBVHNode **nodes,
+    int totnode,
+    SculptClothSimulation *cloth_sim,
+    /* Cannot be const, because it is assigned to a non-const variable.
+     * NOLINTNEXTLINE: readability-non-const-parameter. */
+    float initial_location[3],
+    const float radius)
+{
+  Brush *brush = BKE_paint_brush(&sd->paint);
+
+  /* TODO: Multi-threaded needs to be disabled for this task until implementing the optimization of
+   * storing the constraints per node. */
+  /* Currently all constrains are added to the same global array which can't be accessed from
+   * different threads. */
+  TaskParallelSettings settings;
+  BKE_pbvh_parallel_range_settings(&settings, false, totnode);
+
+  cloth_sim->created_length_constraints = BLI_edgeset_new("created length constraints");
+
+  SculptThreadedTaskData build_constraints_data = {
+      .sd = sd,
+      .ob = ob,
+      .brush = brush,
+      .nodes = nodes,
+      .cloth_sim = cloth_sim,
+      .cloth_sim_initial_location = initial_location,
+      .cloth_sim_radius = radius,
+  };
+  BLI_task_parallel_range(
+      0, totnode, &build_constraints_data, do_cloth_brush_build_constraints_task_cb_ex, &settings);
+
+  BLI_edgeset_free(cloth_sim->created_length_constraints);
+}
+
+void SCULPT_cloth_brush_simulation_init(SculptSession *ss, SculptClothSimulation *cloth_sim)
+{
+  const int totverts = SCULPT_vertex_count_get(ss);
+  const bool has_deformation_pos = cloth_sim->deformation_pos != NULL;
+  for (int i = 0; i < totverts; i++) {
+    copy_v3_v3(cloth_sim->last_iteration_pos[i], SCULPT_vertex_co_get(ss, i));
+    copy_v3_v3(cloth_sim->init_pos[i], SCULPT_vertex_co_get(ss, i));
+    copy_v3_v3(cloth_sim->prev_pos[i], SCULPT_vertex_co_get(ss, i));
+    if (has_deformation_pos) {
+      copy_v3_v3(cloth_sim->deformation_pos[i], SCULPT_vertex_co_get(ss, i));
+    }
+  }
+}
+
+void SCULPT_cloth_brush_store_simulation_state(SculptSession *ss, SculptClothSimulation *cloth_sim)
+{
+  const int totverts = SCULPT_vertex_count_get(ss);
+  for (int i = 0; i < totverts; i++) {
+    copy_v3_v3(cloth_sim->pos[i], SCULPT_vertex_co_get(ss, i));
+  }
+}
 
 /* Main Brush Function. */
 void SCULPT_do_cloth_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
@@ -914,27 +935,19 @@ void SCULPT_do_cloth_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
 
     /* The simulation structure only needs to be created on the first symmetry pass. */
     if (SCULPT_stroke_is_first_brush_step(ss->cache) || !ss->cache->cloth_sim) {
-      const bool is_cloth_deform_brush = SCULPT_is_cloth_deform_brush(brush);
-      ss->cache->cloth_sim = cloth_brush_simulation_create(
+      ss->cache->cloth_sim = SCULPT_cloth_brush_simulation_create(
           ss,
           brush,
           brush->cloth_mass,
           brush->cloth_damping,
           (brush->flag2 & BRUSH_CLOTH_USE_COLLISION));
-      for (int i = 0; i < totverts; i++) {
-        copy_v3_v3(ss->cache->cloth_sim->last_iteration_pos[i], SCULPT_vertex_co_get(ss, i));
-        copy_v3_v3(ss->cache->cloth_sim->init_pos[i], SCULPT_vertex_co_get(ss, i));
-        copy_v3_v3(ss->cache->cloth_sim->prev_pos[i], SCULPT_vertex_co_get(ss, i));
-        if (is_cloth_deform_brush) {
-          copy_v3_v3(ss->cache->cloth_sim->deformation_pos[i], SCULPT_vertex_co_get(ss, i));
-        }
-      }
+      SCULPT_cloth_brush_simulation_init(ss, ss->cache->cloth_sim);
     }
 
     /* Build the constraints. */
     const float radius = ss->cache->initial_radius;
     const float limit = radius + (radius * brush->cloth_sim_limit);
-    cloth_brush_build_nodes_constraints(
+    SCULPT_cloth_brush_build_nodes_constraints(
         sd, ob, nodes, totnode, ss->cache->cloth_sim, ss->cache->location, limit);
 
     return;
@@ -1192,26 +1205,21 @@ static int sculpt_cloth_filter_invoke(bContext *C, wmOperator *op, const wmEvent
   const float cloth_mass = RNA_float_get(op->ptr, "cloth_mass");
   const float cloth_damping = RNA_float_get(op->ptr, "cloth_damping");
   const bool use_collisions = RNA_boolean_get(op->ptr, "use_collisions");
-  ss->filter_cache->cloth_sim = cloth_brush_simulation_create(
+  ss->filter_cache->cloth_sim = SCULPT_cloth_brush_simulation_create(
       ss, NULL, cloth_mass, cloth_damping, use_collisions);
 
   copy_v3_v3(ss->filter_cache->cloth_sim_pinch_point, SCULPT_active_vertex_co_get(ss));
 
-  const int totverts = SCULPT_vertex_count_get(ss);
-  for (int i = 0; i < totverts; i++) {
-    copy_v3_v3(ss->filter_cache->cloth_sim->last_iteration_pos[i], SCULPT_vertex_co_get(ss, i));
-    copy_v3_v3(ss->filter_cache->cloth_sim->prev_pos[i], SCULPT_vertex_co_get(ss, i));
-    copy_v3_v3(ss->filter_cache->cloth_sim->init_pos[i], SCULPT_vertex_co_get(ss, i));
-  }
+  SCULPT_cloth_brush_simulation_init(ss, ss->filter_cache->cloth_sim);
 
   float origin[3] = {0.0f, 0.0f, 0.0f};
-  cloth_brush_build_nodes_constraints(sd,
-                                      ob,
-                                      ss->filter_cache->nodes,
-                                      ss->filter_cache->totnode,
-                                      ss->filter_cache->cloth_sim,
-                                      origin,
-                                      FLT_MAX);
+  SCULPT_cloth_brush_build_nodes_constraints(sd,
+                                             ob,
+                                             ss->filter_cache->nodes,
+                                             ss->filter_cache->totnode,
+                                             ss->filter_cache->cloth_sim,
+                                             origin,
+                                             FLT_MAX);
 
   const bool use_face_sets = RNA_boolean_get(op->ptr, "use_face_sets");
   if (use_face_sets) {
diff --git a/source/blender/editors/sculpt_paint/sculpt_intern.h b/source/blender/editors/sculpt_paint/sculpt_intern.h
index ee0eaeb28f3..4ac7c79e839 100644
--- a/source/blender/editors/sculpt_paint/sculpt_intern.h
+++ b/source/blender/editors/sculpt_paint/sculpt_intern.h
@@ -352,6 +352,30 @@ void SCULPT_do_cloth_brush(struct Sculpt *sd,
                            int totnode);
 void SCULPT_cloth_simulation_free(struct SculptClothSimulation *cloth_sim);
 
+struct SculptClothSimulation *SCULPT_cloth_brush_simulation_create(struct SculptSession *ss,
+                                                                   struct Brush *brush,
+                                                                   const float cloth_mass,
+                                                                   const float cloth_damping,
+                                                                   const bool use_collisions);
+void SCULPT_cloth_brush_simulation_init(struct SculptSession *ss,
+                                        struct SculptClothSimulation *cloth_sim);
+void SCULPT_cloth_brush_store_simulation_state(struct SculptSession *ss,
+                                               struct SculptClothSimulation *cloth_sim);
+
+void SCULPT_cloth_brush_do_simulation_step(struct Sculpt *sd,
+                                           struct Object *ob,
+                                           struct SculptClothSimulation *cloth_sim,
+                                           struct PBVHNode **nodes,
+                                           int totnode);
+
+void SCULPT_cloth_brush_build_nodes_constraints(struct Sculpt *sd,
+                                                struct Object *ob,
+                                                struct PBVHNode **nodes,
+                                                int totnode,
+                                                struct SculptClothSimulation *cloth_sim,
+                                                float initial_location[3],
+                                                const float radius);
+
 void SCULPT_cloth_simulation_limits_draw(const uint gpuattr,
                                          const struct Brush *brush,
                                          const float location[3],
-- 
cgit v1.2.3


From ca7414c4cb4c85a337dbe3effb76b9a5b1ad7d83 Mon Sep 17 00:00:00 2001
From: Pablo Dobarro <pablodp606@gmail.com>
Date: Tue, 18 Aug 2020 12:19:39 +0200
Subject: Fix Mask Slice deleting the Face Sets

This was a TODO in the code. Previously the Face Set datalayer was
deleted and recreated with a constant ID of 0. Now the datalayer is
preserved and set to the SculptSession after slicing the mask and a new
ID is calculated for the new faces that the slicing operation produced,
so they can be easily isolated for further tweaking.

Reviewed By: sergey

Differential Revision: https://developer.blender.org/D8583
---
 source/blender/editors/include/ED_sculpt.h         |  4 +++
 .../blender/editors/mesh/editmesh_mask_extract.c   | 16 +++++------
 .../blender/editors/sculpt_paint/sculpt_face_set.c | 31 ++++++++++++++++++++++
 3 files changed, 41 insertions(+), 10 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/include/ED_sculpt.h b/source/blender/editors/include/ED_sculpt.h
index c3abde479f1..bfc46534b99 100644
--- a/source/blender/editors/include/ED_sculpt.h
+++ b/source/blender/editors/include/ED_sculpt.h
@@ -53,6 +53,10 @@ void ED_sculpt_undosys_type(struct UndoType *ut);
 void ED_sculpt_undo_geometry_begin(struct Object *ob, const char *name);
 void ED_sculpt_undo_geometry_end(struct Object *ob);
 
+/* Face sets. */
+int ED_sculpt_face_sets_find_next_available_id(struct Mesh *mesh);
+void ED_sculpt_face_sets_initialize_none_to_id(struct Mesh *mesh, const int new_id);
+
 /* Undo for changes happening on a base mesh for multires sculpting.
  * if there is no multires sculpt active regular undo is used. */
 void ED_sculpt_undo_push_multires_mesh_begin(struct bContext *C, const char *str);
diff --git a/source/blender/editors/mesh/editmesh_mask_extract.c b/source/blender/editors/mesh/editmesh_mask_extract.c
index 8eeba5007e1..34fcee779de 100644
--- a/source/blender/editors/mesh/editmesh_mask_extract.c
+++ b/source/blender/editors/mesh/editmesh_mask_extract.c
@@ -354,10 +354,6 @@ static int paint_mask_slice_exec(bContext *C, wmOperator *op)
 
   if (ob->mode == OB_MODE_SCULPT) {
     ED_sculpt_undo_geometry_begin(ob, "mask slice");
-    /* TODO: The ideal functionality would be to preserve the current face sets and add a new one
-     * for the new triangles, but this data-layer needs to be rebuild in order to make sculpt mode
-     * not crash when modifying the geometry. */
-    CustomData_free_layers(&mesh->pdata, CD_SCULPT_FACE_SETS, mesh->totpoly);
   }
 
   BMesh *bm;
@@ -429,14 +425,14 @@ static int paint_mask_slice_exec(bContext *C, wmOperator *op)
   BKE_mesh_calc_normals(ob->data);
 
   if (ob->mode == OB_MODE_SCULPT) {
-    ED_sculpt_undo_geometry_end(ob);
     SculptSession *ss = ob->sculpt;
-    /* Rebuild a new valid Face Set layer for the object. */
-    ss->face_sets = CustomData_add_layer(
-        &mesh->pdata, CD_SCULPT_FACE_SETS, CD_CALLOC, NULL, mesh->totpoly);
-    for (int i = 0; i < mesh->totpoly; i++) {
-      ss->face_sets[i] = 1;
+    ss->face_sets = CustomData_get_layer(&((Mesh *)ob->data)->pdata, CD_SCULPT_FACE_SETS);
+    if (ss->face_sets) {
+      /* Assign a new Face Set ID to the new faces created by the slice operation. */
+      const int next_face_set_id = ED_sculpt_face_sets_find_next_available_id(ob->data);
+      ED_sculpt_face_sets_initialize_none_to_id(ob->data, next_face_set_id);
     }
+    ED_sculpt_undo_geometry_end(ob);
   }
 
   BKE_mesh_batch_cache_dirty_tag(ob->data, BKE_MESH_BATCH_DIRTY_ALL);
diff --git a/source/blender/editors/sculpt_paint/sculpt_face_set.c b/source/blender/editors/sculpt_paint/sculpt_face_set.c
index 2afa3556dd9..cd0720bbe1c 100644
--- a/source/blender/editors/sculpt_paint/sculpt_face_set.c
+++ b/source/blender/editors/sculpt_paint/sculpt_face_set.c
@@ -71,6 +71,37 @@
 #include <math.h>
 #include <stdlib.h>
 
+/* Utils. */
+int ED_sculpt_face_sets_find_next_available_id(struct Mesh *mesh)
+{
+  int *face_sets = CustomData_get_layer(&mesh->pdata, CD_SCULPT_FACE_SETS);
+  if (!face_sets) {
+    return SCULPT_FACE_SET_NONE;
+  }
+
+  int next_face_set_id = 0;
+  for (int i = 0; i < mesh->totpoly; i++) {
+    next_face_set_id = max_ii(next_face_set_id, abs(face_sets[i]));
+  }
+  next_face_set_id++;
+
+  return next_face_set_id;
+}
+
+void ED_sculpt_face_sets_initialize_none_to_id(struct Mesh *mesh, const int new_id)
+{
+  int *face_sets = CustomData_get_layer(&mesh->pdata, CD_SCULPT_FACE_SETS);
+  if (!face_sets) {
+    return;
+  }
+
+  for (int i = 0; i < mesh->totpoly; i++) {
+    if (face_sets[i] == SCULPT_FACE_SET_NONE) {
+      face_sets[i] = new_id;
+    }
+  }
+}
+
 /* Draw Face Sets Brush. */
 
 static void do_draw_face_sets_brush_task_cb_ex(void *__restrict userdata,
-- 
cgit v1.2.3


From 6a6cb83eb306d2b774ad2f029dc7beadc43bf28b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= <foucault.clem@gmail.com>
Date: Tue, 18 Aug 2020 12:26:10 +0200
Subject: Fix T79568 EEVEE: Film transparent not working

Since world shader use the same standard output and are considered opaque,
we need to set alpha as holdout.
---
 .../blender/gpu/shaders/material/gpu_shader_material_output_world.glsl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'source')

diff --git a/source/blender/gpu/shaders/material/gpu_shader_material_output_world.glsl b/source/blender/gpu/shaders/material/gpu_shader_material_output_world.glsl
index 27ca96501ae..5eb853a4c1a 100644
--- a/source/blender/gpu/shaders/material/gpu_shader_material_output_world.glsl
+++ b/source/blender/gpu/shaders/material/gpu_shader_material_output_world.glsl
@@ -6,7 +6,8 @@ void node_output_world(Closure surface, Closure volume, out Closure result)
   float alpha = renderPassEnvironment ? 1.0 : backgroundAlpha;
   result = CLOSURE_DEFAULT;
   result.radiance = surface.radiance * alpha;
-  result.transmittance = vec3(1.0 - alpha);
+  result.transmittance = vec3(0.0);
+  result.holdout = (1.0 - alpha);
 #else
   result = volume;
 #endif /* VOLUMETRICS */
-- 
cgit v1.2.3


From 762daacbc7aed37c5984f02c4d4b29436e2cf005 Mon Sep 17 00:00:00 2001
From: Pablo Dobarro <pablodp606@gmail.com>
Date: Sat, 15 Aug 2020 17:03:58 +0200
Subject: Fix Face Set Visibility operator using wrong active Face Set

The Face Set visibility operator was using the last active Face Set
updated by the paint cursor, so when the paint cursor is not used (when
using a filter or a transform tool), the active Face Set was not updating
and it was hidding the wrong Face Set based on the last cursor position
with a brush tool active. Now the Face Set Visitility operator has an
invoke callback wich forces a active vertex and face set update
regardless of the active tool, so it should always work correctly.

Reviewed By: sergey

Differential Revision: https://developer.blender.org/D8580
---
 .../blender/editors/sculpt_paint/sculpt_face_set.c   | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

(limited to 'source')

diff --git a/source/blender/editors/sculpt_paint/sculpt_face_set.c b/source/blender/editors/sculpt_paint/sculpt_face_set.c
index cd0720bbe1c..b9265380a35 100644
--- a/source/blender/editors/sculpt_paint/sculpt_face_set.c
+++ b/source/blender/editors/sculpt_paint/sculpt_face_set.c
@@ -932,6 +932,25 @@ static int sculpt_face_sets_change_visibility_exec(bContext *C, wmOperator *op)
   return OPERATOR_FINISHED;
 }
 
+static int sculpt_face_sets_change_visibility_invoke(bContext *C,
+                                                     wmOperator *op,
+                                                     const wmEvent *event)
+{
+  Object *ob = CTX_data_active_object(C);
+  SculptSession *ss = ob->sculpt;
+
+  /* Update the active vertex and Face Set using the cursor position to avoid relying on the paint
+   * cursor updates. */
+  SculptCursorGeometryInfo sgi;
+  float mouse[2];
+  mouse[0] = event->mval[0];
+  mouse[1] = event->mval[1];
+  SCULPT_vertex_random_access_ensure(ss);
+  SCULPT_cursor_geometry_info_update(C, &sgi, mouse, false);
+
+  return sculpt_face_sets_change_visibility_exec(C, op);
+}
+
 void SCULPT_OT_face_sets_change_visibility(wmOperatorType *ot)
 {
   /* Identifiers. */
@@ -941,6 +960,7 @@ void SCULPT_OT_face_sets_change_visibility(wmOperatorType *ot)
 
   /* Api callbacks. */
   ot->exec = sculpt_face_sets_change_visibility_exec;
+  ot->invoke = sculpt_face_sets_change_visibility_invoke;
   ot->poll = SCULPT_mode_poll;
 
   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
-- 
cgit v1.2.3


From e3eb53a5b3f82d293f61d20da2258f07dbdde001 Mon Sep 17 00:00:00 2001
From: Pablo Dobarro <pablodp606>
Date: Tue, 18 Aug 2020 12:35:28 +0200
Subject: Cleanup: Remove unused code in the Paint Cursor

This code was left here after the refactor, it was doing nothing and it
was causing an assert.

Reviewed By: sergey

Differential Revision: https://developer.blender.org/D8579
---
 source/blender/editors/sculpt_paint/paint_cursor.c | 3 ---
 source/tools                                       | 2 +-
 2 files changed, 1 insertion(+), 4 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/sculpt_paint/paint_cursor.c b/source/blender/editors/sculpt_paint/paint_cursor.c
index d4379262666..63b4516b1cc 100644
--- a/source/blender/editors/sculpt_paint/paint_cursor.c
+++ b/source/blender/editors/sculpt_paint/paint_cursor.c
@@ -1762,9 +1762,6 @@ static void paint_cursor_cursor_draw_3d_view_brush_cursor_active(PaintCursorCont
 
   GPU_matrix_pop();
 
-  /* This Cloth brush cursor overlay always works in cursor space. */
-  paint_cursor_drawing_setup_cursor_space(pcontext);
-
   GPU_matrix_pop_projection();
   wmWindowViewport(pcontext->win);
 }
diff --git a/source/tools b/source/tools
index 6a252de776d..44ae9d181c7 160000
--- a/source/tools
+++ b/source/tools
@@ -1 +1 @@
-Subproject commit 6a252de776d0b9dca3167c30a7621a4f1e9bc911
+Subproject commit 44ae9d181c734c14ae22feb0d33ad39a626f8ce7
-- 
cgit v1.2.3


From 5aecc4b57bb54464e8cc8bcf239d42c1d78322f0 Mon Sep 17 00:00:00 2001
From: Pablo Dobarro <pablodp606@gmail.com>
Date: Mon, 17 Aug 2020 18:28:39 +0200
Subject: Fix Cloth Brush Grab deform types not working with spacing

Even the Cloth Brush grab works like a regular grab brush, it makes
sense to support spacing just in this brush in order to prevent creating
more brush steps that update the simulation. This way, it is possible to
create grab brushes that update the simulation constantly while grabbing
(using the dots stroke mode) or brushes that only update the simulation
when the cursor moves (using spacing).

Reviewed By: sergey

Differential Revision: https://developer.blender.org/D8568
---
 source/blender/editors/sculpt_paint/paint_stroke.c | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

(limited to 'source')

diff --git a/source/blender/editors/sculpt_paint/paint_stroke.c b/source/blender/editors/sculpt_paint/paint_stroke.c
index 90b0f017bd6..071042e6728 100644
--- a/source/blender/editors/sculpt_paint/paint_stroke.c
+++ b/source/blender/editors/sculpt_paint/paint_stroke.c
@@ -997,7 +997,19 @@ static void stroke_done(bContext *C, wmOperator *op)
 /* Returns zero if the stroke dots should not be spaced, non-zero otherwise */
 bool paint_space_stroke_enabled(Brush *br, ePaintMode mode)
 {
-  return (br->flag & BRUSH_SPACE) && paint_supports_dynamic_size(br, mode);
+  if ((br->flag & BRUSH_SPACE) == 0) {
+    return false;
+  }
+
+  if (br->sculpt_tool == SCULPT_TOOL_CLOTH) {
+    /* The Cloth Brush is a special case for stroke spacing. Even if it has grab modes which do
+     * not support dynamic size, stroke spacing needs to be enabled so it is possible to control
+     * whether the simulation runs constantly or only when the brush moves when using the cloth
+     * grab brushes. */
+    return true;
+  }
+
+  return paint_supports_dynamic_size(br, mode);
 }
 
 static bool sculpt_is_grab_tool(Brush *br)
-- 
cgit v1.2.3


From e371378c8b52273eab4c834b544c6c9af4f71f02 Mon Sep 17 00:00:00 2001
From: Pablo Dobarro <pablodp606@gmail.com>
Date: Wed, 12 Aug 2020 23:38:36 +0200
Subject: Cleanup: rename bdata to boundary

Reviewed By: sergey

Differential Revision: https://developer.blender.org/D8556
---
 source/blender/editors/sculpt_paint/sculpt.c       |   4 +-
 .../blender/editors/sculpt_paint/sculpt_boundary.c | 317 +++++++++++----------
 .../blender/editors/sculpt_paint/sculpt_intern.h   |   4 +-
 3 files changed, 168 insertions(+), 157 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c
index 2fdf04a8b46..03d079ba0e1 100644
--- a/source/blender/editors/sculpt_paint/sculpt.c
+++ b/source/blender/editors/sculpt_paint/sculpt.c
@@ -6371,8 +6371,8 @@ void SCULPT_cache_free(StrokeCache *cache)
   }
 
   for (int i = 0; i < PAINT_SYMM_AREAS; i++) {
-    if (cache->bdata[i]) {
-      SCULPT_boundary_data_free(cache->bdata[i]);
+    if (cache->boundaries[i]) {
+      SCULPT_boundary_data_free(cache->boundaries[i]);
     }
   }
 
diff --git a/source/blender/editors/sculpt_paint/sculpt_boundary.c b/source/blender/editors/sculpt_paint/sculpt_boundary.c
index f65c64d6d78..a188d6a678c 100644
--- a/source/blender/editors/sculpt_paint/sculpt_boundary.c
+++ b/source/blender/editors/sculpt_paint/sculpt_boundary.c
@@ -130,38 +130,39 @@ static int sculpt_boundary_get_closest_boundary_vertex(SculptSession *ss,
  * deformations usually need in the boundary. */
 static int BOUNDARY_INDICES_BLOCK_SIZE = 300;
 
-static void sculpt_boundary_index_add(SculptBoundary *bdata,
+static void sculpt_boundary_index_add(SculptBoundary *boundary,
                                       const int new_index,
                                       const float distance,
                                       GSet *included_vertices)
 {
 
-  bdata->vertices[bdata->num_vertices] = new_index;
-  if (bdata->distance) {
-    bdata->distance[new_index] = distance;
+  boundary->vertices[boundary->num_vertices] = new_index;
+  if (boundary->distance) {
+    boundary->distance[new_index] = distance;
   }
   if (included_vertices) {
     BLI_gset_add(included_vertices, POINTER_FROM_INT(new_index));
   }
-  bdata->num_vertices++;
-  if (bdata->num_vertices >= bdata->vertices_capacity) {
-    bdata->vertices_capacity += BOUNDARY_INDICES_BLOCK_SIZE;
-    bdata->vertices = MEM_reallocN_id(
-        bdata->vertices, bdata->vertices_capacity * sizeof(int), "boundary indices");
+  boundary->num_vertices++;
+  if (boundary->num_vertices >= boundary->vertices_capacity) {
+    boundary->vertices_capacity += BOUNDARY_INDICES_BLOCK_SIZE;
+    boundary->vertices = MEM_reallocN_id(
+        boundary->vertices, boundary->vertices_capacity * sizeof(int), "boundary indices");
   }
 };
 
-static void sculpt_boundary_preview_edge_add(SculptBoundary *bdata, const int v1, const int v2)
+static void sculpt_boundary_preview_edge_add(SculptBoundary *boundary, const int v1, const int v2)
 {
 
-  bdata->edges[bdata->num_edges].v1 = v1;
-  bdata->edges[bdata->num_edges].v2 = v2;
-  bdata->num_edges++;
+  boundary->edges[boundary->num_edges].v1 = v1;
+  boundary->edges[boundary->num_edges].v2 = v2;
+  boundary->num_edges++;
 
-  if (bdata->num_edges >= bdata->edges_capacity) {
-    bdata->edges_capacity += BOUNDARY_INDICES_BLOCK_SIZE;
-    bdata->edges = MEM_reallocN_id(
-        bdata->edges, bdata->edges_capacity * sizeof(SculptBoundaryPreviewEdge), "boundary edges");
+  if (boundary->num_edges >= boundary->edges_capacity) {
+    boundary->edges_capacity += BOUNDARY_INDICES_BLOCK_SIZE;
+    boundary->edges = MEM_reallocN_id(boundary->edges,
+                                      boundary->edges_capacity * sizeof(SculptBoundaryPreviewEdge),
+                                      "boundary edges");
   }
 };
 
@@ -203,7 +204,7 @@ static bool sculpt_boundary_is_vertex_in_editable_boundary(SculptSession *ss,
  */
 
 typedef struct BoundaryFloodFillData {
-  SculptBoundary *bdata;
+  SculptBoundary *boundary;
   GSet *included_vertices;
   EdgeSet *preview_edges;
 
@@ -215,15 +216,16 @@ static bool boundary_floodfill_cb(
     SculptSession *ss, int from_v, int to_v, bool is_duplicate, void *userdata)
 {
   BoundaryFloodFillData *data = userdata;
-  SculptBoundary *bdata = data->bdata;
+  SculptBoundary *boundary = data->boundary;
   if (SCULPT_vertex_is_boundary(ss, to_v)) {
     const float edge_len = len_v3v3(SCULPT_vertex_co_get(ss, from_v),
                                     SCULPT_vertex_co_get(ss, to_v));
-    const float distance_boundary_to_dst = bdata->distance ? bdata->distance[from_v] + edge_len :
-                                                             0.0f;
-    sculpt_boundary_index_add(bdata, to_v, distance_boundary_to_dst, data->included_vertices);
+    const float distance_boundary_to_dst = boundary->distance ?
+                                               boundary->distance[from_v] + edge_len :
+                                               0.0f;
+    sculpt_boundary_index_add(boundary, to_v, distance_boundary_to_dst, data->included_vertices);
     if (!is_duplicate) {
-      sculpt_boundary_preview_edge_add(bdata, from_v, to_v);
+      sculpt_boundary_preview_edge_add(boundary, from_v, to_v);
     }
     return sculpt_boundary_is_vertex_in_editable_boundary(ss, to_v);
   }
@@ -231,31 +233,32 @@ static bool boundary_floodfill_cb(
 }
 
 static void sculpt_boundary_indices_init(SculptSession *ss,
-                                         SculptBoundary *bdata,
+                                         SculptBoundary *boundary,
                                          const bool init_boundary_distances,
                                          const int initial_boundary_index)
 {
 
   const int totvert = SCULPT_vertex_count_get(ss);
-  bdata->vertices = MEM_malloc_arrayN(
+  boundary->vertices = MEM_malloc_arrayN(
       BOUNDARY_INDICES_BLOCK_SIZE, sizeof(int), "boundary indices");
   if (init_boundary_distances) {
-    bdata->distance = MEM_calloc_arrayN(totvert, sizeof(float), "boundary distances");
+    boundary->distance = MEM_calloc_arrayN(totvert, sizeof(float), "boundary distances");
   }
-  bdata->edges = MEM_malloc_arrayN(
+  boundary->edges = MEM_malloc_arrayN(
       BOUNDARY_INDICES_BLOCK_SIZE, sizeof(SculptBoundaryPreviewEdge), "boundary edges");
 
   GSet *included_vertices = BLI_gset_int_new_ex("included vertices", BOUNDARY_INDICES_BLOCK_SIZE);
   SculptFloodFill flood;
   SCULPT_floodfill_init(ss, &flood);
 
-  bdata->initial_vertex = initial_boundary_index;
-  copy_v3_v3(bdata->initial_vertex_position, SCULPT_vertex_co_get(ss, bdata->initial_vertex));
-  sculpt_boundary_index_add(bdata, initial_boundary_index, 0.0f, included_vertices);
+  boundary->initial_vertex = initial_boundary_index;
+  copy_v3_v3(boundary->initial_vertex_position,
+             SCULPT_vertex_co_get(ss, boundary->initial_vertex));
+  sculpt_boundary_index_add(boundary, initial_boundary_index, 0.0f, included_vertices);
   SCULPT_floodfill_add_initial(&flood, initial_boundary_index);
 
   BoundaryFloodFillData fdata = {
-      .bdata = bdata,
+      .boundary = boundary,
       .included_vertices = included_vertices,
       .last_visited_vertex = BOUNDARY_VERTEX_NONE,
 
@@ -271,8 +274,8 @@ static void sculpt_boundary_indices_init(SculptSession *ss,
     SCULPT_VERTEX_NEIGHBORS_ITER_BEGIN (ss, fdata.last_visited_vertex, ni) {
       if (BLI_gset_haskey(included_vertices, POINTER_FROM_INT(ni.index)) &&
           sculpt_boundary_is_vertex_in_editable_boundary(ss, ni.index)) {
-        sculpt_boundary_preview_edge_add(bdata, fdata.last_visited_vertex, ni.index);
-        bdata->forms_loop = true;
+        sculpt_boundary_preview_edge_add(boundary, fdata.last_visited_vertex, ni.index);
+        boundary->forms_loop = true;
       }
     }
     SCULPT_VERTEX_NEIGHBORS_ITER_END(ni);
@@ -288,7 +291,7 @@ static void sculpt_boundary_indices_init(SculptSession *ss,
  * the closest one.
  */
 static void sculpt_boundary_edit_data_init(SculptSession *ss,
-                                           SculptBoundary *bdata,
+                                           SculptBoundary *boundary,
                                            const int initial_vertex,
                                            const float radius)
 {
@@ -296,12 +299,12 @@ static void sculpt_boundary_edit_data_init(SculptSession *ss,
 
   const bool has_duplicates = BKE_pbvh_type(ss->pbvh) == PBVH_GRIDS;
 
-  bdata->edit_info = MEM_malloc_arrayN(
+  boundary->edit_info = MEM_malloc_arrayN(
       totvert, sizeof(SculptBoundaryEditInfo), "Boundary edit info");
 
   for (int i = 0; i < totvert; i++) {
-    bdata->edit_info[i].original_vertex = BOUNDARY_VERTEX_NONE;
-    bdata->edit_info[i].num_propagation_steps = BOUNDARY_STEPS_NONE;
+    boundary->edit_info[i].original_vertex = BOUNDARY_VERTEX_NONE;
+    boundary->edit_info[i].num_propagation_steps = BOUNDARY_STEPS_NONE;
   }
 
   GSQueue *current_iteration = BLI_gsqueue_new(sizeof(int));
@@ -310,23 +313,23 @@ static void sculpt_boundary_edit_data_init(SculptSession *ss,
   /* Initialized the first iteration with the vertices already in the boundary. This is propagation
    * step 0. */
   BLI_bitmap *visited_vertices = BLI_BITMAP_NEW(SCULPT_vertex_count_get(ss), "visited_vertices");
-  for (int i = 0; i < bdata->num_vertices; i++) {
-    bdata->edit_info[bdata->vertices[i]].original_vertex = bdata->vertices[i];
-    bdata->edit_info[bdata->vertices[i]].num_propagation_steps = 0;
+  for (int i = 0; i < boundary->num_vertices; i++) {
+    boundary->edit_info[boundary->vertices[i]].original_vertex = boundary->vertices[i];
+    boundary->edit_info[boundary->vertices[i]].num_propagation_steps = 0;
 
     /* This ensures that all duplicate vertices in the boundary have the same original_vertex
      * index, so the deformation for them will be the same. */
     if (has_duplicates) {
       SculptVertexNeighborIter ni_duplis;
-      SCULPT_VERTEX_DUPLICATES_AND_NEIGHBORS_ITER_BEGIN (ss, bdata->vertices[i], ni_duplis) {
+      SCULPT_VERTEX_DUPLICATES_AND_NEIGHBORS_ITER_BEGIN (ss, boundary->vertices[i], ni_duplis) {
         if (ni_duplis.is_duplicate) {
-          bdata->edit_info[ni_duplis.index].original_vertex = bdata->vertices[i];
+          boundary->edit_info[ni_duplis.index].original_vertex = boundary->vertices[i];
         }
       }
       SCULPT_VERTEX_NEIGHBORS_ITER_END(ni_duplis);
     }
 
-    BLI_gsqueue_push(current_iteration, &bdata->vertices[i]);
+    BLI_gsqueue_push(current_iteration, &boundary->vertices[i]);
   }
 
   int num_propagation_steps = 0;
@@ -336,7 +339,7 @@ static void sculpt_boundary_edit_data_init(SculptSession *ss,
     /* This steps is further away from the boundary than the brush radius, so stop adding more
      * steps. */
     if (accum_distance > radius) {
-      bdata->max_propagation_steps = num_propagation_steps;
+      boundary->max_propagation_steps = num_propagation_steps;
       break;
     }
 
@@ -346,19 +349,20 @@ static void sculpt_boundary_edit_data_init(SculptSession *ss,
 
       SculptVertexNeighborIter ni;
       SCULPT_VERTEX_DUPLICATES_AND_NEIGHBORS_ITER_BEGIN (ss, from_v, ni) {
-        if (bdata->edit_info[ni.index].num_propagation_steps == BOUNDARY_STEPS_NONE) {
-          bdata->edit_info[ni.index].original_vertex = bdata->edit_info[from_v].original_vertex;
+        if (boundary->edit_info[ni.index].num_propagation_steps == BOUNDARY_STEPS_NONE) {
+          boundary->edit_info[ni.index].original_vertex =
+              boundary->edit_info[from_v].original_vertex;
 
           BLI_BITMAP_ENABLE(visited_vertices, ni.index);
 
           if (ni.is_duplicate) {
             /* Grids duplicates handling. */
-            bdata->edit_info[ni.index].num_propagation_steps =
-                bdata->edit_info[from_v].num_propagation_steps;
+            boundary->edit_info[ni.index].num_propagation_steps =
+                boundary->edit_info[from_v].num_propagation_steps;
           }
           else {
-            bdata->edit_info[ni.index].num_propagation_steps =
-                bdata->edit_info[from_v].num_propagation_steps + 1;
+            boundary->edit_info[ni.index].num_propagation_steps =
+                boundary->edit_info[from_v].num_propagation_steps + 1;
 
             BLI_gsqueue_push(next_iteration, &ni.index);
 
@@ -370,10 +374,10 @@ static void sculpt_boundary_edit_data_init(SculptSession *ss,
               SculptVertexNeighborIter ni_duplis;
               SCULPT_VERTEX_DUPLICATES_AND_NEIGHBORS_ITER_BEGIN (ss, ni.index, ni_duplis) {
                 if (ni_duplis.is_duplicate) {
-                  bdata->edit_info[ni_duplis.index].original_vertex =
-                      bdata->edit_info[from_v].original_vertex;
-                  bdata->edit_info[ni_duplis.index].num_propagation_steps =
-                      bdata->edit_info[from_v].num_propagation_steps + 1;
+                  boundary->edit_info[ni_duplis.index].original_vertex =
+                      boundary->edit_info[from_v].original_vertex;
+                  boundary->edit_info[ni_duplis.index].num_propagation_steps =
+                      boundary->edit_info[from_v].num_propagation_steps + 1;
                 }
               }
               SCULPT_VERTEX_NEIGHBORS_ITER_END(ni_duplis);
@@ -381,9 +385,9 @@ static void sculpt_boundary_edit_data_init(SculptSession *ss,
 
             /* Check the distance using the vertex that was propagated from the initial vertex that
              * was used to initialize the boundary. */
-            if (bdata->edit_info[from_v].original_vertex == initial_vertex) {
-              bdata->pivot_vertex = ni.index;
-              copy_v3_v3(bdata->initial_pivot_position, SCULPT_vertex_co_get(ss, ni.index));
+            if (boundary->edit_info[from_v].original_vertex == initial_vertex) {
+              boundary->pivot_vertex = ni.index;
+              copy_v3_v3(boundary->initial_pivot_position, SCULPT_vertex_co_get(ss, ni.index));
               accum_distance += len_v3v3(SCULPT_vertex_co_get(ss, from_v),
                                          SCULPT_vertex_co_get(ss, ni.index));
             }
@@ -419,7 +423,7 @@ static void sculpt_boundary_edit_data_init(SculptSession *ss,
  * on the brush curve and its propagation steps. The falloff goes from the boundary into the mesh.
  */
 static void sculpt_boundary_falloff_factor_init(SculptSession *ss,
-                                                SculptBoundary *bdata,
+                                                SculptBoundary *boundary,
                                                 Brush *brush,
                                                 const float radius)
 {
@@ -427,24 +431,24 @@ static void sculpt_boundary_falloff_factor_init(SculptSession *ss,
   BKE_curvemapping_init(brush->curve);
 
   for (int i = 0; i < totvert; i++) {
-    if (bdata->edit_info[i].num_propagation_steps != -1) {
-      bdata->edit_info[i].strength_factor = BKE_brush_curve_strength(
-          brush, bdata->edit_info[i].num_propagation_steps, bdata->max_propagation_steps);
+    if (boundary->edit_info[i].num_propagation_steps != -1) {
+      boundary->edit_info[i].strength_factor = BKE_brush_curve_strength(
+          brush, boundary->edit_info[i].num_propagation_steps, boundary->max_propagation_steps);
     }
 
-    if (bdata->edit_info[i].original_vertex == bdata->initial_vertex) {
+    if (boundary->edit_info[i].original_vertex == boundary->initial_vertex) {
       /* All vertices that are propagated from the original vertex won't be affected by the
        * boundary falloff, so there is no need to calculate anything else. */
       continue;
     }
 
-    if (!bdata->distance) {
+    if (!boundary->distance) {
       /* There are falloff modes that do not require to modify the previously calculated falloff
        * based on boundary distances. */
       continue;
     }
 
-    const float boundary_distance = bdata->distance[bdata->edit_info[i].original_vertex];
+    const float boundary_distance = boundary->distance[boundary->edit_info[i].original_vertex];
     float falloff_distance = 0.0f;
     float direction = 1.0f;
 
@@ -471,8 +475,8 @@ static void sculpt_boundary_falloff_factor_init(SculptSession *ss,
         BLI_assert(false);
     }
 
-    bdata->edit_info[i].strength_factor *= direction * BKE_brush_curve_strength(
-                                                           brush, falloff_distance, radius);
+    boundary->edit_info[i].strength_factor *= direction * BKE_brush_curve_strength(
+                                                              brush, falloff_distance, radius);
   }
 }
 
@@ -501,116 +505,118 @@ SculptBoundary *SCULPT_boundary_data_init(Object *object,
     return NULL;
   }
 
-  SculptBoundary *bdata = MEM_callocN(sizeof(SculptBoundary), "Boundary edit data");
+  SculptBoundary *boundary = MEM_callocN(sizeof(SculptBoundary), "Boundary edit data");
 
   const bool init_boundary_distances = brush->boundary_falloff_type !=
                                        BRUSH_BOUNDARY_FALLOFF_CONSTANT;
-  sculpt_boundary_indices_init(ss, bdata, init_boundary_distances, boundary_initial_vertex);
+  sculpt_boundary_indices_init(ss, boundary, init_boundary_distances, boundary_initial_vertex);
 
   const float boundary_radius = radius * (1.0f + brush->boundary_offset);
-  sculpt_boundary_edit_data_init(ss, bdata, boundary_initial_vertex, boundary_radius);
+  sculpt_boundary_edit_data_init(ss, boundary, boundary_initial_vertex, boundary_radius);
 
-  return bdata;
+  return boundary;
 }
 
-void SCULPT_boundary_data_free(SculptBoundary *bdata)
+void SCULPT_boundary_data_free(SculptBoundary *boundary)
 {
-  MEM_SAFE_FREE(bdata->vertices);
-  MEM_SAFE_FREE(bdata->distance);
-  MEM_SAFE_FREE(bdata->edit_info);
-  MEM_SAFE_FREE(bdata->bend.pivot_positions);
-  MEM_SAFE_FREE(bdata->bend.pivot_rotation_axis);
-  MEM_SAFE_FREE(bdata->slide.directions);
-  MEM_SAFE_FREE(bdata);
+  MEM_SAFE_FREE(boundary->vertices);
+  MEM_SAFE_FREE(boundary->distance);
+  MEM_SAFE_FREE(boundary->edit_info);
+  MEM_SAFE_FREE(boundary->bend.pivot_positions);
+  MEM_SAFE_FREE(boundary->bend.pivot_rotation_axis);
+  MEM_SAFE_FREE(boundary->slide.directions);
+  MEM_SAFE_FREE(boundary);
 }
 
 /* These functions initialize the required vectors for the desired deformation using the
  * SculptBoundaryEditInfo. They calculate the data using the vertices that have the
  * max_propagation_steps value and them this data is copied to the rest of the vertices using the
  * original vertex index. */
-static void sculpt_boundary_bend_data_init(SculptSession *ss, SculptBoundary *bdata)
+static void sculpt_boundary_bend_data_init(SculptSession *ss, SculptBoundary *boundary)
 {
   const int totvert = SCULPT_vertex_count_get(ss);
-  bdata->bend.pivot_rotation_axis = MEM_calloc_arrayN(
+  boundary->bend.pivot_rotation_axis = MEM_calloc_arrayN(
       totvert, 3 * sizeof(float), "pivot rotation axis");
-  bdata->bend.pivot_positions = MEM_calloc_arrayN(totvert, 3 * sizeof(float), "pivot positions");
+  boundary->bend.pivot_positions = MEM_calloc_arrayN(
+      totvert, 3 * sizeof(float), "pivot positions");
 
   for (int i = 0; i < totvert; i++) {
-    if (bdata->edit_info[i].num_propagation_steps == bdata->max_propagation_steps) {
+    if (boundary->edit_info[i].num_propagation_steps == boundary->max_propagation_steps) {
       float dir[3];
       float normal[3];
       SCULPT_vertex_normal_get(ss, i, normal);
       sub_v3_v3v3(dir,
-                  SCULPT_vertex_co_get(ss, bdata->edit_info[i].original_vertex),
+                  SCULPT_vertex_co_get(ss, boundary->edit_info[i].original_vertex),
                   SCULPT_vertex_co_get(ss, i));
       cross_v3_v3v3(
-          bdata->bend.pivot_rotation_axis[bdata->edit_info[i].original_vertex], dir, normal);
-      normalize_v3(bdata->bend.pivot_rotation_axis[bdata->edit_info[i].original_vertex]);
-      copy_v3_v3(bdata->bend.pivot_positions[bdata->edit_info[i].original_vertex],
+          boundary->bend.pivot_rotation_axis[boundary->edit_info[i].original_vertex], dir, normal);
+      normalize_v3(boundary->bend.pivot_rotation_axis[boundary->edit_info[i].original_vertex]);
+      copy_v3_v3(boundary->bend.pivot_positions[boundary->edit_info[i].original_vertex],
                  SCULPT_vertex_co_get(ss, i));
     }
   }
 
   for (int i = 0; i < totvert; i++) {
-    if (bdata->edit_info[i].num_propagation_steps != BOUNDARY_STEPS_NONE) {
-      copy_v3_v3(bdata->bend.pivot_positions[i],
-                 bdata->bend.pivot_positions[bdata->edit_info[i].original_vertex]);
-      copy_v3_v3(bdata->bend.pivot_rotation_axis[i],
-                 bdata->bend.pivot_rotation_axis[bdata->edit_info[i].original_vertex]);
+    if (boundary->edit_info[i].num_propagation_steps != BOUNDARY_STEPS_NONE) {
+      copy_v3_v3(boundary->bend.pivot_positions[i],
+                 boundary->bend.pivot_positions[boundary->edit_info[i].original_vertex]);
+      copy_v3_v3(boundary->bend.pivot_rotation_axis[i],
+                 boundary->bend.pivot_rotation_axis[boundary->edit_info[i].original_vertex]);
     }
   }
 }
 
-static void sculpt_boundary_slide_data_init(SculptSession *ss, SculptBoundary *bdata)
+static void sculpt_boundary_slide_data_init(SculptSession *ss, SculptBoundary *boundary)
 {
   const int totvert = SCULPT_vertex_count_get(ss);
-  bdata->slide.directions = MEM_calloc_arrayN(totvert, 3 * sizeof(float), "slide directions");
+  boundary->slide.directions = MEM_calloc_arrayN(totvert, 3 * sizeof(float), "slide directions");
 
   for (int i = 0; i < totvert; i++) {
-    if (bdata->edit_info[i].num_propagation_steps == bdata->max_propagation_steps) {
-      sub_v3_v3v3(bdata->slide.directions[bdata->edit_info[i].original_vertex],
-                  SCULPT_vertex_co_get(ss, bdata->edit_info[i].original_vertex),
+    if (boundary->edit_info[i].num_propagation_steps == boundary->max_propagation_steps) {
+      sub_v3_v3v3(boundary->slide.directions[boundary->edit_info[i].original_vertex],
+                  SCULPT_vertex_co_get(ss, boundary->edit_info[i].original_vertex),
                   SCULPT_vertex_co_get(ss, i));
-      normalize_v3(bdata->slide.directions[bdata->edit_info[i].original_vertex]);
+      normalize_v3(boundary->slide.directions[boundary->edit_info[i].original_vertex]);
     }
   }
 
   for (int i = 0; i < totvert; i++) {
-    if (bdata->edit_info[i].num_propagation_steps != BOUNDARY_STEPS_NONE) {
-      copy_v3_v3(bdata->slide.directions[i],
-                 bdata->slide.directions[bdata->edit_info[i].original_vertex]);
+    if (boundary->edit_info[i].num_propagation_steps != BOUNDARY_STEPS_NONE) {
+      copy_v3_v3(boundary->slide.directions[i],
+                 boundary->slide.directions[boundary->edit_info[i].original_vertex]);
     }
   }
 }
 
-static void sculpt_boundary_twist_data_init(SculptSession *ss, SculptBoundary *bdata)
+static void sculpt_boundary_twist_data_init(SculptSession *ss, SculptBoundary *boundary)
 {
-  zero_v3(bdata->twist.pivot_position);
-  float(*poly_verts)[3] = MEM_malloc_arrayN(bdata->num_vertices, sizeof(float) * 3, "poly verts");
-  for (int i = 0; i < bdata->num_vertices; i++) {
-    add_v3_v3(bdata->twist.pivot_position, SCULPT_vertex_co_get(ss, bdata->vertices[i]));
-    copy_v3_v3(poly_verts[i], SCULPT_vertex_co_get(ss, bdata->vertices[i]));
+  zero_v3(boundary->twist.pivot_position);
+  float(*poly_verts)[3] = MEM_malloc_arrayN(
+      boundary->num_vertices, sizeof(float) * 3, "poly verts");
+  for (int i = 0; i < boundary->num_vertices; i++) {
+    add_v3_v3(boundary->twist.pivot_position, SCULPT_vertex_co_get(ss, boundary->vertices[i]));
+    copy_v3_v3(poly_verts[i], SCULPT_vertex_co_get(ss, boundary->vertices[i]));
   }
-  mul_v3_fl(bdata->twist.pivot_position, 1.0f / bdata->num_vertices);
-  if (bdata->forms_loop) {
-    normal_poly_v3(bdata->twist.rotation_axis, poly_verts, bdata->num_vertices);
+  mul_v3_fl(boundary->twist.pivot_position, 1.0f / boundary->num_vertices);
+  if (boundary->forms_loop) {
+    normal_poly_v3(boundary->twist.rotation_axis, poly_verts, boundary->num_vertices);
   }
   else {
-    sub_v3_v3v3(bdata->twist.rotation_axis,
-                SCULPT_vertex_co_get(ss, bdata->pivot_vertex),
-                SCULPT_vertex_co_get(ss, bdata->initial_vertex));
-    normalize_v3(bdata->twist.rotation_axis);
+    sub_v3_v3v3(boundary->twist.rotation_axis,
+                SCULPT_vertex_co_get(ss, boundary->pivot_vertex),
+                SCULPT_vertex_co_get(ss, boundary->initial_vertex));
+    normalize_v3(boundary->twist.rotation_axis);
   }
   MEM_freeN(poly_verts);
 }
 
 static float sculpt_boundary_displacement_from_grab_delta_get(SculptSession *ss,
-                                                              SculptBoundary *bdata)
+                                                              SculptBoundary *boundary)
 {
   float plane[4];
   float pos[3];
   float normal[3];
-  sub_v3_v3v3(normal, ss->cache->initial_location, bdata->initial_pivot_position);
+  sub_v3_v3v3(normal, ss->cache->initial_location, boundary->initial_pivot_position);
   normalize_v3(normal);
   plane_from_point_normal_v3(plane, ss->cache->initial_location, normal);
   add_v3_v3v3(pos, ss->cache->initial_location, ss->cache->grab_delta_symmetry);
@@ -625,7 +631,7 @@ static void do_boundary_brush_bend_task_cb_ex(void *__restrict userdata,
   SculptThreadedTaskData *data = userdata;
   SculptSession *ss = data->ob->sculpt;
   const int symm_area = ss->cache->mirror_symmetry_pass;
-  SculptBoundary *bdata = ss->cache->bdata[symm_area];
+  SculptBoundary *boundary = ss->cache->boundaries[symm_area];
   const ePaintSymmetryFlags symm = data->sd->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
 
   const float strength = ss->cache->bstrength;
@@ -634,7 +640,7 @@ static void do_boundary_brush_bend_task_cb_ex(void *__restrict userdata,
   SculptOrigVertData orig_data;
   SCULPT_orig_vert_data_init(&orig_data, data->ob, data->nodes[n]);
 
-  const float disp = strength * sculpt_boundary_displacement_from_grab_delta_get(ss, bdata);
+  const float disp = strength * sculpt_boundary_displacement_from_grab_delta_get(ss, boundary);
   float angle_factor = disp / ss->cache->radius;
   /* Angle Snapping when inverting the brush. */
   if (ss->cache->invert) {
@@ -645,17 +651,18 @@ static void do_boundary_brush_bend_task_cb_ex(void *__restrict userdata,
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
 
-    if (bdata->edit_info[vd.index].num_propagation_steps != -1) {
+    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
       SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(orig_data.co, bdata->initial_vertex_position, symm)) {
+      if (SCULPT_check_vertex_pivot_symmetry(
+              orig_data.co, boundary->initial_vertex_position, symm)) {
         const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
         float t_orig_co[3];
-        sub_v3_v3v3(t_orig_co, orig_data.co, bdata->bend.pivot_positions[vd.index]);
+        sub_v3_v3v3(t_orig_co, orig_data.co, boundary->bend.pivot_positions[vd.index]);
         rotate_v3_v3v3fl(vd.co,
                          t_orig_co,
-                         bdata->bend.pivot_rotation_axis[vd.index],
-                         angle * bdata->edit_info[vd.index].strength_factor * mask);
-        add_v3_v3(vd.co, bdata->bend.pivot_positions[vd.index]);
+                         boundary->bend.pivot_rotation_axis[vd.index],
+                         angle * boundary->edit_info[vd.index].strength_factor * mask);
+        add_v3_v3(vd.co, boundary->bend.pivot_positions[vd.index]);
       }
     }
 
@@ -673,7 +680,7 @@ static void do_boundary_brush_slide_task_cb_ex(void *__restrict userdata,
   SculptThreadedTaskData *data = userdata;
   SculptSession *ss = data->ob->sculpt;
   const int symm_area = ss->cache->mirror_symmetry_pass;
-  SculptBoundary *bdata = ss->cache->bdata[symm_area];
+  SculptBoundary *boundary = ss->cache->boundaries[symm_area];
   const ePaintSymmetryFlags symm = data->sd->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
 
   const float strength = ss->cache->bstrength;
@@ -682,19 +689,20 @@ static void do_boundary_brush_slide_task_cb_ex(void *__restrict userdata,
   SculptOrigVertData orig_data;
   SCULPT_orig_vert_data_init(&orig_data, data->ob, data->nodes[n]);
 
-  const float disp = sculpt_boundary_displacement_from_grab_delta_get(ss, bdata);
+  const float disp = sculpt_boundary_displacement_from_grab_delta_get(ss, boundary);
 
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
 
-    if (bdata->edit_info[vd.index].num_propagation_steps != -1) {
+    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
       SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(orig_data.co, bdata->initial_vertex_position, symm)) {
+      if (SCULPT_check_vertex_pivot_symmetry(
+              orig_data.co, boundary->initial_vertex_position, symm)) {
         const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
         madd_v3_v3v3fl(vd.co,
                        orig_data.co,
-                       bdata->slide.directions[vd.index],
-                       bdata->edit_info[vd.index].strength_factor * disp * mask * strength);
+                       boundary->slide.directions[vd.index],
+                       boundary->edit_info[vd.index].strength_factor * disp * mask * strength);
       }
     }
 
@@ -712,7 +720,7 @@ static void do_boundary_brush_inflate_task_cb_ex(void *__restrict userdata,
   SculptThreadedTaskData *data = userdata;
   SculptSession *ss = data->ob->sculpt;
   const int symm_area = ss->cache->mirror_symmetry_pass;
-  SculptBoundary *bdata = ss->cache->bdata[symm_area];
+  SculptBoundary *boundary = ss->cache->boundaries[symm_area];
   const ePaintSymmetryFlags symm = data->sd->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
 
   const float strength = ss->cache->bstrength;
@@ -721,21 +729,22 @@ static void do_boundary_brush_inflate_task_cb_ex(void *__restrict userdata,
   SculptOrigVertData orig_data;
   SCULPT_orig_vert_data_init(&orig_data, data->ob, data->nodes[n]);
 
-  const float disp = sculpt_boundary_displacement_from_grab_delta_get(ss, bdata);
+  const float disp = sculpt_boundary_displacement_from_grab_delta_get(ss, boundary);
 
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
 
-    if (bdata->edit_info[vd.index].num_propagation_steps != -1) {
+    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
       SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(orig_data.co, bdata->initial_vertex_position, symm)) {
+      if (SCULPT_check_vertex_pivot_symmetry(
+              orig_data.co, boundary->initial_vertex_position, symm)) {
         const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
         float normal[3];
         normal_short_to_float_v3(normal, orig_data.no);
         madd_v3_v3v3fl(vd.co,
                        orig_data.co,
                        normal,
-                       bdata->edit_info[vd.index].strength_factor * disp * mask * strength);
+                       boundary->edit_info[vd.index].strength_factor * disp * mask * strength);
       }
     }
 
@@ -753,7 +762,7 @@ static void do_boundary_brush_grab_task_cb_ex(void *__restrict userdata,
   SculptThreadedTaskData *data = userdata;
   SculptSession *ss = data->ob->sculpt;
   const int symm_area = ss->cache->mirror_symmetry_pass;
-  SculptBoundary *bdata = ss->cache->bdata[symm_area];
+  SculptBoundary *boundary = ss->cache->boundaries[symm_area];
   const ePaintSymmetryFlags symm = data->sd->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
 
   const float strength = ss->cache->bstrength;
@@ -765,14 +774,15 @@ static void do_boundary_brush_grab_task_cb_ex(void *__restrict userdata,
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
 
-    if (bdata->edit_info[vd.index].num_propagation_steps != -1) {
+    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
       SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(orig_data.co, bdata->initial_vertex_position, symm)) {
+      if (SCULPT_check_vertex_pivot_symmetry(
+              orig_data.co, boundary->initial_vertex_position, symm)) {
         const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
         madd_v3_v3v3fl(vd.co,
                        orig_data.co,
                        ss->cache->grab_delta_symmetry,
-                       bdata->edit_info[vd.index].strength_factor * mask * strength);
+                       boundary->edit_info[vd.index].strength_factor * mask * strength);
       }
     }
 
@@ -790,7 +800,7 @@ static void do_boundary_brush_twist_task_cb_ex(void *__restrict userdata,
   SculptThreadedTaskData *data = userdata;
   SculptSession *ss = data->ob->sculpt;
   const int symm_area = ss->cache->mirror_symmetry_pass;
-  SculptBoundary *bdata = ss->cache->bdata[symm_area];
+  SculptBoundary *boundary = ss->cache->boundaries[symm_area];
   const ePaintSymmetryFlags symm = data->sd->paint.symmetry_flags & PAINT_SYMM_AXIS_ALL;
 
   const float strength = ss->cache->bstrength;
@@ -799,7 +809,7 @@ static void do_boundary_brush_twist_task_cb_ex(void *__restrict userdata,
   SculptOrigVertData orig_data;
   SCULPT_orig_vert_data_init(&orig_data, data->ob, data->nodes[n]);
 
-  const float disp = strength * sculpt_boundary_displacement_from_grab_delta_get(ss, bdata);
+  const float disp = strength * sculpt_boundary_displacement_from_grab_delta_get(ss, boundary);
   float angle_factor = disp / ss->cache->radius;
   /* Angle Snapping when inverting the brush. */
   if (ss->cache->invert) {
@@ -810,17 +820,18 @@ static void do_boundary_brush_twist_task_cb_ex(void *__restrict userdata,
   BKE_pbvh_vertex_iter_begin(ss->pbvh, data->nodes[n], vd, PBVH_ITER_UNIQUE)
   {
 
-    if (bdata->edit_info[vd.index].num_propagation_steps != -1) {
+    if (boundary->edit_info[vd.index].num_propagation_steps != -1) {
       SCULPT_orig_vert_data_update(&orig_data, &vd);
-      if (SCULPT_check_vertex_pivot_symmetry(orig_data.co, bdata->initial_vertex_position, symm)) {
+      if (SCULPT_check_vertex_pivot_symmetry(
+              orig_data.co, boundary->initial_vertex_position, symm)) {
         const float mask = vd.mask ? 1.0f - *vd.mask : 1.0f;
         float t_orig_co[3];
-        sub_v3_v3v3(t_orig_co, orig_data.co, bdata->twist.pivot_position);
+        sub_v3_v3v3(t_orig_co, orig_data.co, boundary->twist.pivot_position);
         rotate_v3_v3v3fl(vd.co,
                          t_orig_co,
-                         bdata->twist.rotation_axis,
-                         angle * mask * bdata->edit_info[vd.index].strength_factor);
-        add_v3_v3(vd.co, bdata->twist.pivot_position);
+                         boundary->twist.rotation_axis,
+                         angle * mask * boundary->edit_info[vd.index].strength_factor);
+        add_v3_v3(vd.co, boundary->twist.pivot_position);
       }
     }
 
@@ -851,20 +862,20 @@ void SCULPT_do_boundary_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totn
           sd, ob, location, ss->cache->radius_squared, false);
     }
 
-    ss->cache->bdata[symm_area] = SCULPT_boundary_data_init(
+    ss->cache->boundaries[symm_area] = SCULPT_boundary_data_init(
         ob, brush, initial_vertex, ss->cache->initial_radius);
 
-    if (ss->cache->bdata[symm_area]) {
+    if (ss->cache->boundaries[symm_area]) {
 
       switch (brush->boundary_deform_type) {
         case BRUSH_BOUNDARY_DEFORM_BEND:
-          sculpt_boundary_bend_data_init(ss, ss->cache->bdata[symm_area]);
+          sculpt_boundary_bend_data_init(ss, ss->cache->boundaries[symm_area]);
           break;
         case BRUSH_BOUNDARY_DEFORM_EXPAND:
-          sculpt_boundary_slide_data_init(ss, ss->cache->bdata[symm_area]);
+          sculpt_boundary_slide_data_init(ss, ss->cache->boundaries[symm_area]);
           break;
         case BRUSH_BOUNDARY_DEFORM_TWIST:
-          sculpt_boundary_twist_data_init(ss, ss->cache->bdata[symm_area]);
+          sculpt_boundary_twist_data_init(ss, ss->cache->boundaries[symm_area]);
           break;
         case BRUSH_BOUNDARY_DEFORM_INFLATE:
         case BRUSH_BOUNDARY_DEFORM_GRAB:
@@ -873,12 +884,12 @@ void SCULPT_do_boundary_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totn
       }
 
       sculpt_boundary_falloff_factor_init(
-          ss, ss->cache->bdata[symm_area], brush, ss->cache->initial_radius);
+          ss, ss->cache->boundaries[symm_area], brush, ss->cache->initial_radius);
     }
   }
 
   /* No active boundary under the cursor. */
-  if (!ss->cache->bdata[symm_area]) {
+  if (!ss->cache->boundaries[symm_area]) {
     return;
   }
 
diff --git a/source/blender/editors/sculpt_paint/sculpt_intern.h b/source/blender/editors/sculpt_paint/sculpt_intern.h
index 4ac7c79e839..f233a9085e2 100644
--- a/source/blender/editors/sculpt_paint/sculpt_intern.h
+++ b/source/blender/editors/sculpt_paint/sculpt_intern.h
@@ -425,7 +425,7 @@ struct SculptBoundary *SCULPT_boundary_data_init(Object *object,
                                                  Brush *brush,
                                                  const int initial_vertex,
                                                  const float radius);
-void SCULPT_boundary_data_free(struct SculptBoundary *bdata);
+void SCULPT_boundary_data_free(struct SculptBoundary *boundary);
 void SCULPT_do_boundary_brush(struct Sculpt *sd,
                               struct Object *ob,
                               struct PBVHNode **nodes,
@@ -904,7 +904,7 @@ typedef struct StrokeCache {
   float true_initial_normal[3];
 
   /* Boundary brush */
-  struct SculptBoundary *bdata[PAINT_SYMM_AREAS];
+  struct SculptBoundary *boundaries[PAINT_SYMM_AREAS];
 
   /* Surface Smooth Brush */
   /* Stores the displacement produced by the laplacian step of HC smooth. */
-- 
cgit v1.2.3


From fc5eab357009f10fe68bb19a5d48f3ff7ab8825a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sybren=20A=2E=20St=C3=BCvel?= <sybren@blender.org>
Date: Tue, 18 Aug 2020 12:58:48 +0200
Subject: Mesh: merge `mesh_create_eval_final_{view,render}` functions

Functions `mesh_create_eval_final_view()` and
`mesh_create_eval_final_render()` were doing the exact same thing,
except for a hack introduced in d3eb9dddd6b4 (2012-10-08, Better fix for
T32846: dupligroup messes up particle instancing on rendering) that
appears to be no longer necessary. Besides that, these functions had
confusing names. Their functionality changed over time, and whether to
do for-render or for-viewport evaluation is now actually determined by
the depsgraph evaluation mode. This means that the `..._render` function
could evaluate a mesh with viewport settings, and vice versa.

The functions are now merged into `mesh_create_eval_final()`, and the
hack has been removed. The `OB_NO_PSYS_UPDATE` flag has been removed
entirely (instead of keeping it around as deprecated flag), because it
was always only temporarily set on objects during mesh evaluation and
thus not saved to the blend file.

No expected functional changes as far as users are concerned.
---
 source/blender/blenkernel/BKE_mesh_runtime.h       |  7 +------
 source/blender/blenkernel/intern/DerivedMesh.c     | 22 +---------------------
 source/blender/blenkernel/intern/mesh_convert.c    | 10 +---------
 source/blender/editors/object/object_modifier.c    |  2 +-
 .../editors/sculpt_paint/paint_image_proj.c        |  2 +-
 source/blender/makesdna/DNA_object_types.h         |  2 --
 .../blender/modifiers/intern/MOD_particlesystem.c  |  2 +-
 source/blender/python/bmesh/bmesh_py_types.c       |  2 +-
 .../blender/python/mathutils/mathutils_bvhtree.c   |  2 +-
 9 files changed, 8 insertions(+), 43 deletions(-)

(limited to 'source')

diff --git a/source/blender/blenkernel/BKE_mesh_runtime.h b/source/blender/blenkernel/BKE_mesh_runtime.h
index adb7c357049..267be4f44fd 100644
--- a/source/blender/blenkernel/BKE_mesh_runtime.h
+++ b/source/blender/blenkernel/BKE_mesh_runtime.h
@@ -71,7 +71,7 @@ struct Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph,
                                   struct Object *ob,
                                   const struct CustomData_MeshMasks *dataMask);
 
-struct Mesh *mesh_create_eval_final_render(struct Depsgraph *depsgraph,
+struct Mesh *mesh_create_eval_final(struct Depsgraph *depsgraph,
                                            struct Scene *scene,
                                            struct Object *ob,
                                            const struct CustomData_MeshMasks *dataMask);
@@ -82,11 +82,6 @@ struct Mesh *mesh_create_eval_final_index_render(struct Depsgraph *depsgraph,
                                                  const struct CustomData_MeshMasks *dataMask,
                                                  int index);
 
-struct Mesh *mesh_create_eval_final_view(struct Depsgraph *depsgraph,
-                                         struct Scene *scene,
-                                         struct Object *ob,
-                                         const struct CustomData_MeshMasks *dataMask);
-
 struct Mesh *mesh_create_eval_no_deform(struct Depsgraph *depsgraph,
                                         struct Scene *scene,
                                         struct Object *ob,
diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index 0dc85dfaa18..248e7958723 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -1991,7 +1991,7 @@ Mesh *mesh_get_eval_deform(struct Depsgraph *depsgraph,
   return ob->runtime.mesh_deform_eval;
 }
 
-Mesh *mesh_create_eval_final_render(Depsgraph *depsgraph,
+Mesh *mesh_create_eval_final(Depsgraph *depsgraph,
                                     Scene *scene,
                                     Object *ob,
                                     const CustomData_MeshMasks *dataMask)
@@ -2016,26 +2016,6 @@ Mesh *mesh_create_eval_final_index_render(Depsgraph *depsgraph,
   return final;
 }
 
-Mesh *mesh_create_eval_final_view(Depsgraph *depsgraph,
-                                  Scene *scene,
-                                  Object *ob,
-                                  const CustomData_MeshMasks *dataMask)
-{
-  Mesh *final;
-
-  /* XXX hack
-   * psys modifier updates particle state when called during dupli-list generation,
-   * which can lead to wrong transforms. This disables particle system modifier execution.
-   */
-  ob->transflag |= OB_NO_PSYS_UPDATE;
-
-  mesh_calc_modifiers(depsgraph, scene, ob, 1, false, dataMask, -1, false, false, NULL, &final);
-
-  ob->transflag &= ~OB_NO_PSYS_UPDATE;
-
-  return final;
-}
-
 Mesh *mesh_create_eval_no_deform(Depsgraph *depsgraph,
                                  Scene *scene,
                                  Object *ob,
diff --git a/source/blender/blenkernel/intern/mesh_convert.c b/source/blender/blenkernel/intern/mesh_convert.c
index 76a6d23bc8f..9426d09885e 100644
--- a/source/blender/blenkernel/intern/mesh_convert.c
+++ b/source/blender/blenkernel/intern/mesh_convert.c
@@ -1111,15 +1111,7 @@ static Mesh *mesh_new_from_mesh_object_with_layers(Depsgraph *depsgraph, Object
 
   Scene *scene = DEG_get_evaluated_scene(depsgraph);
   CustomData_MeshMasks mask = CD_MASK_MESH;
-  Mesh *result;
-
-  if (DEG_get_mode(depsgraph) == DAG_EVAL_RENDER) {
-    result = mesh_create_eval_final_render(depsgraph, scene, &object_for_eval, &mask);
-  }
-  else {
-    result = mesh_create_eval_final_view(depsgraph, scene, &object_for_eval, &mask);
-  }
-
+  Mesh *result = mesh_create_eval_final(depsgraph, scene, &object_for_eval, &mask);
   return result;
 }
 
diff --git a/source/blender/editors/object/object_modifier.c b/source/blender/editors/object/object_modifier.c
index ceb6553bdf6..14882ab8ffc 100644
--- a/source/blender/editors/object/object_modifier.c
+++ b/source/blender/editors/object/object_modifier.c
@@ -107,7 +107,7 @@ static void object_force_modifier_update_for_bind(Depsgraph *depsgraph, Object *
   Object *ob_eval = DEG_get_evaluated_object(depsgraph, ob);
   BKE_object_eval_reset(ob_eval);
   if (ob->type == OB_MESH) {
-    Mesh *me_eval = mesh_create_eval_final_view(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
+    Mesh *me_eval = mesh_create_eval_final(depsgraph, scene_eval, ob_eval, &CD_MASK_BAREMESH);
     BKE_mesh_eval_delete(me_eval);
   }
   else if (ob->type == OB_LATTICE) {
diff --git a/source/blender/editors/sculpt_paint/paint_image_proj.c b/source/blender/editors/sculpt_paint/paint_image_proj.c
index db7de01bee5..1b340f532c2 100644
--- a/source/blender/editors/sculpt_paint/paint_image_proj.c
+++ b/source/blender/editors/sculpt_paint/paint_image_proj.c
@@ -4037,7 +4037,7 @@ static bool proj_paint_state_mesh_eval_init(const bContext *C, ProjPaintState *p
   /* Workaround for subsurf selection, try the display mesh first */
   if (ps->source == PROJ_SRC_IMAGE_CAM) {
     /* using render mesh, assume only camera was rendered from */
-    ps->me_eval = mesh_create_eval_final_render(depsgraph, scene_eval, ob_eval, &cddata_masks);
+    ps->me_eval = mesh_create_eval_final(depsgraph, scene_eval, ob_eval, &cddata_masks);
     ps->me_eval_free = true;
   }
   else {
diff --git a/source/blender/makesdna/DNA_object_types.h b/source/blender/makesdna/DNA_object_types.h
index 6568281a8d4..62c072831b4 100644
--- a/source/blender/makesdna/DNA_object_types.h
+++ b/source/blender/makesdna/DNA_object_types.h
@@ -537,8 +537,6 @@ enum {
   OB_TRANSFLAG_UNUSED_12 = 1 << 12, /* cleared */
   /* runtime constraints disable */
   OB_NO_CONSTRAINTS = 1 << 13,
-  /* hack to work around particle issue */
-  OB_NO_PSYS_UPDATE = 1 << 14,
 
   OB_DUPLI = OB_DUPLIVERTS | OB_DUPLICOLLECTION | OB_DUPLIFACES | OB_DUPLIPARTS,
 };
diff --git a/source/blender/modifiers/intern/MOD_particlesystem.c b/source/blender/modifiers/intern/MOD_particlesystem.c
index ea0c63da1b0..4ef1b19dc64 100644
--- a/source/blender/modifiers/intern/MOD_particlesystem.c
+++ b/source/blender/modifiers/intern/MOD_particlesystem.c
@@ -219,7 +219,7 @@ static void deformVerts(ModifierData *md,
   psmd->totdmedge = psmd->mesh_final->totedge;
   psmd->totdmface = psmd->mesh_final->totface;
 
-  if (!(ctx->object->transflag & OB_NO_PSYS_UPDATE)) {
+  {
     struct Scene *scene = DEG_get_evaluated_scene(ctx->depsgraph);
     psmd->flag &= ~eParticleSystemFlag_psys_updated;
     particle_system_update(
diff --git a/source/blender/python/bmesh/bmesh_py_types.c b/source/blender/python/bmesh/bmesh_py_types.c
index e39b5faf3c4..04bceb17c20 100644
--- a/source/blender/python/bmesh/bmesh_py_types.c
+++ b/source/blender/python/bmesh/bmesh_py_types.c
@@ -1134,7 +1134,7 @@ static PyObject *bpy_bmesh_from_object(BPy_BMesh *self, PyObject *args, PyObject
         return NULL;
       }
 
-      me_eval = mesh_create_eval_final_render(depsgraph, scene_eval, ob_eval, &data_masks);
+      me_eval = mesh_create_eval_final(depsgraph, scene_eval, ob_eval, &data_masks);
     }
     else {
       if (use_cage) {
diff --git a/source/blender/python/mathutils/mathutils_bvhtree.c b/source/blender/python/mathutils/mathutils_bvhtree.c
index 9d76f07e4fb..16ea05771d0 100644
--- a/source/blender/python/mathutils/mathutils_bvhtree.c
+++ b/source/blender/python/mathutils/mathutils_bvhtree.c
@@ -1053,7 +1053,7 @@ static Mesh *bvh_get_mesh(const char *funcname,
       }
 
       *r_free_mesh = true;
-      return mesh_create_eval_final_render(depsgraph, scene, ob, &data_masks);
+      return mesh_create_eval_final(depsgraph, scene, ob, &data_masks);
     }
     if (ob_eval != NULL) {
       if (use_cage) {
-- 
cgit v1.2.3


From df495e758d0fabc74e8ca5bbf9dc4d71af3ac63c Mon Sep 17 00:00:00 2001
From: Jacques Lucke <jacques@blender.org>
Date: Tue, 18 Aug 2020 13:04:28 +0200
Subject: Cleanup: use Span instead of separate pointer and length

Reviewers: sergey

Differential Revision: https://developer.blender.org/D8605
---
 .../depsgraph/intern/builder/pipeline_from_ids.cc  | 45 ++++++++++------------
 .../depsgraph/intern/builder/pipeline_from_ids.h   |  5 +--
 source/blender/depsgraph/intern/depsgraph_build.cc |  3 +-
 3 files changed, 25 insertions(+), 28 deletions(-)

(limited to 'source')

diff --git a/source/blender/depsgraph/intern/builder/pipeline_from_ids.cc b/source/blender/depsgraph/intern/builder/pipeline_from_ids.cc
index e44f554f197..c42bccaadec 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_from_ids.cc
+++ b/source/blender/depsgraph/intern/builder/pipeline_from_ids.cc
@@ -32,11 +32,9 @@ namespace {
 
 class DepsgraphFromIDsFilter {
  public:
-  DepsgraphFromIDsFilter(ID **ids, const int num_ids)
+  DepsgraphFromIDsFilter(Span<ID *> ids)
   {
-    for (int i = 0; i < num_ids; ++i) {
-      ids_.add(ids[i]);
-    }
+    ids_.add_multiple(ids);
   }
 
   bool contains(ID *id)
@@ -50,9 +48,11 @@ class DepsgraphFromIDsFilter {
 
 class DepsgraphFromIDsNodeBuilder : public DepsgraphNodeBuilder {
  public:
-  DepsgraphFromIDsNodeBuilder(
-      Main *bmain, Depsgraph *graph, DepsgraphBuilderCache *cache, ID **ids, const int num_ids)
-      : DepsgraphNodeBuilder(bmain, graph, cache), filter_(ids, num_ids)
+  DepsgraphFromIDsNodeBuilder(Main *bmain,
+                              Depsgraph *graph,
+                              DepsgraphBuilderCache *cache,
+                              Span<ID *> ids)
+      : DepsgraphNodeBuilder(bmain, graph, cache), filter_(ids)
   {
   }
 
@@ -81,9 +81,11 @@ class DepsgraphFromIDsNodeBuilder : public DepsgraphNodeBuilder {
 
 class DepsgraphFromIDsRelationBuilder : public DepsgraphRelationBuilder {
  public:
-  DepsgraphFromIDsRelationBuilder(
-      Main *bmain, Depsgraph *graph, DepsgraphBuilderCache *cache, ID **ids, const int num_ids)
-      : DepsgraphRelationBuilder(bmain, graph, cache), filter_(ids, num_ids)
+  DepsgraphFromIDsRelationBuilder(Main *bmain,
+                                  Depsgraph *graph,
+                                  DepsgraphBuilderCache *cache,
+                                  Span<ID *> ids)
+      : DepsgraphRelationBuilder(bmain, graph, cache), filter_(ids)
   {
   }
 
@@ -112,41 +114,36 @@ class DepsgraphFromIDsRelationBuilder : public DepsgraphRelationBuilder {
 
 }  // namespace
 
-FromIDsBuilderPipeline::FromIDsBuilderPipeline(::Depsgraph *graph,
-                                               Main *bmain,
-                                               Scene *scene,
-                                               ViewLayer *view_layer,
-                                               ID **ids,
-                                               const int num_ids)
-    : AbstractBuilderPipeline(graph, bmain, scene, view_layer), ids_(ids), num_ids_(num_ids)
+FromIDsBuilderPipeline::FromIDsBuilderPipeline(
+    ::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer, Span<ID *> ids)
+    : AbstractBuilderPipeline(graph, bmain, scene, view_layer), ids_(ids)
 {
 }
 
 unique_ptr<DepsgraphNodeBuilder> FromIDsBuilderPipeline::construct_node_builder()
 {
-  return std::make_unique<DepsgraphFromIDsNodeBuilder>(
-      bmain_, deg_graph_, &builder_cache_, ids_, num_ids_);
+  return std::make_unique<DepsgraphFromIDsNodeBuilder>(bmain_, deg_graph_, &builder_cache_, ids_);
 }
 
 unique_ptr<DepsgraphRelationBuilder> FromIDsBuilderPipeline::construct_relation_builder()
 {
   return std::make_unique<DepsgraphFromIDsRelationBuilder>(
-      bmain_, deg_graph_, &builder_cache_, ids_, num_ids_);
+      bmain_, deg_graph_, &builder_cache_, ids_);
 }
 
 void FromIDsBuilderPipeline::build_nodes(DepsgraphNodeBuilder &node_builder)
 {
   node_builder.build_view_layer(scene_, view_layer_, DEG_ID_LINKED_DIRECTLY);
-  for (int i = 0; i < num_ids_; ++i) {
-    node_builder.build_id(ids_[i]);
+  for (ID *id : ids_) {
+    node_builder.build_id(id);
   }
 }
 
 void FromIDsBuilderPipeline::build_relations(DepsgraphRelationBuilder &relation_builder)
 {
   relation_builder.build_view_layer(scene_, view_layer_, DEG_ID_LINKED_DIRECTLY);
-  for (int i = 0; i < num_ids_; ++i) {
-    relation_builder.build_id(ids_[i]);
+  for (ID *id : ids_) {
+    relation_builder.build_id(id);
   }
 }
 
diff --git a/source/blender/depsgraph/intern/builder/pipeline_from_ids.h b/source/blender/depsgraph/intern/builder/pipeline_from_ids.h
index 4a507f2c728..a52a9f6f252 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_from_ids.h
+++ b/source/blender/depsgraph/intern/builder/pipeline_from_ids.h
@@ -44,7 +44,7 @@ namespace deg {
 class FromIDsBuilderPipeline : public AbstractBuilderPipeline {
  public:
   FromIDsBuilderPipeline(
-      ::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer, ID **ids, int num_ids);
+      ::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer, Span<ID *> ids);
 
  protected:
   virtual unique_ptr<DepsgraphNodeBuilder> construct_node_builder() override;
@@ -54,8 +54,7 @@ class FromIDsBuilderPipeline : public AbstractBuilderPipeline {
   virtual void build_relations(DepsgraphRelationBuilder &relation_builder) override;
 
  private:
-  ID **ids_;
-  const int num_ids_;
+  Span<ID *> ids_;
 };
 
 }  // namespace deg
diff --git a/source/blender/depsgraph/intern/depsgraph_build.cc b/source/blender/depsgraph/intern/depsgraph_build.cc
index 230c59bd651..dc49534eb2d 100644
--- a/source/blender/depsgraph/intern/depsgraph_build.cc
+++ b/source/blender/depsgraph/intern/depsgraph_build.cc
@@ -251,7 +251,8 @@ void DEG_graph_build_from_ids(Depsgraph *graph,
                               ID **ids,
                               const int num_ids)
 {
-  deg::FromIDsBuilderPipeline builder(graph, bmain, scene, view_layer, ids, num_ids);
+  deg::FromIDsBuilderPipeline builder(
+      graph, bmain, scene, view_layer, blender::Span(ids, num_ids));
   builder.build();
 }
 
-- 
cgit v1.2.3


From 976f0113e008b4ff2d96760b0e83d5466dda8c54 Mon Sep 17 00:00:00 2001
From: Pablo Dobarro <pablodp606@gmail.com>
Date: Fri, 14 Aug 2020 00:23:54 +0200
Subject: Multires: Base Mesh Sculpting

This adds an option to the Multires modifier to sculpt directly on the
base mesh while previewing the displacement of a higher subdivisions
level. What this does it considering Multires as a regular modifier
without exposing the grid displacement to sculpt mode.

This allows to see the propagation happening in real time, which enables
to use complex tools like Cloth or Pose in much higher resolutions and
without surface noise and artifacts.

Reviewed By: sergey, Severin

Differential Revision: https://developer.blender.org/D8555
---
 source/blender/blenkernel/intern/DerivedMesh.c |  3 +--
 source/blender/blenkernel/intern/paint.c       |  7 +++++--
 source/blender/makesdna/DNA_modifier_types.h   |  1 +
 source/blender/makesrna/intern/rna_modifier.c  |  8 ++++++++
 source/blender/modifiers/intern/MOD_multires.c | 10 +++++++++-
 5 files changed, 24 insertions(+), 5 deletions(-)

(limited to 'source')

diff --git a/source/blender/blenkernel/intern/DerivedMesh.c b/source/blender/blenkernel/intern/DerivedMesh.c
index 248e7958723..4f587abd9f0 100644
--- a/source/blender/blenkernel/intern/DerivedMesh.c
+++ b/source/blender/blenkernel/intern/DerivedMesh.c
@@ -909,8 +909,7 @@ static void mesh_calc_modifiers(struct Depsgraph *depsgraph,
   const int required_mode = use_render ? eModifierMode_Render : eModifierMode_Realtime;
 
   /* Sculpt can skip certain modifiers. */
-  MultiresModifierData *mmd = get_multires_modifier(scene, ob, 0);
-  const bool has_multires = (mmd && mmd->sculptlvl != 0);
+  const bool has_multires = BKE_sculpt_multires_active(scene, ob) != NULL;
   bool multires_applied = false;
   const bool sculpt_mode = ob->mode & OB_MODE_SCULPT && ob->sculpt && !use_render;
   const bool sculpt_dyntopo = (sculpt_mode && ob->sculpt->bm) && !use_render;
diff --git a/source/blender/blenkernel/intern/paint.c b/source/blender/blenkernel/intern/paint.c
index 19d5c34ad73..f6e744096bb 100644
--- a/source/blender/blenkernel/intern/paint.c
+++ b/source/blender/blenkernel/intern/paint.c
@@ -1421,7 +1421,7 @@ MultiresModifierData *BKE_sculpt_multires_active(Scene *scene, Object *ob)
         continue;
       }
 
-      if (mmd->sculptlvl > 0) {
+      if (mmd->sculptlvl > 0 && !(mmd->flags & eMultiresModifierFlag_UseSculptBaseMesh)) {
         return mmd;
       }
 
@@ -1458,7 +1458,10 @@ static bool sculpt_modifiers_active(Scene *scene, Sculpt *sd, Object *ob)
       continue;
     }
     if (md->type == eModifierType_Multires && (ob->mode & OB_MODE_SCULPT)) {
-      continue;
+      MultiresModifierData *mmd = (MultiresModifierData *)md;
+      if (!(mmd->flags & eMultiresModifierFlag_UseSculptBaseMesh)) {
+        continue;
+      }
     }
     if (md->type == eModifierType_ShapeKey) {
       continue;
diff --git a/source/blender/makesdna/DNA_modifier_types.h b/source/blender/makesdna/DNA_modifier_types.h
index fc50261eb03..b92c9f42a73 100644
--- a/source/blender/makesdna/DNA_modifier_types.h
+++ b/source/blender/makesdna/DNA_modifier_types.h
@@ -1033,6 +1033,7 @@ typedef enum {
   eMultiresModifierFlag_PlainUv_DEPRECATED = (1 << 1),
   eMultiresModifierFlag_UseCrease = (1 << 2),
   eMultiresModifierFlag_UseCustomNormals = (1 << 3),
+  eMultiresModifierFlag_UseSculptBaseMesh = (1 << 4),
 } MultiresModifierFlag;
 
 /* DEPRECATED, only used for versioning. */
diff --git a/source/blender/makesrna/intern/rna_modifier.c b/source/blender/makesrna/intern/rna_modifier.c
index f95899262d3..65c6706a3b1 100644
--- a/source/blender/makesrna/intern/rna_modifier.c
+++ b/source/blender/makesrna/intern/rna_modifier.c
@@ -2076,6 +2076,14 @@ static void rna_def_modifier_multires(BlenderRNA *brna)
       prop, "Use Custom Normals", "Interpolates existing custom normals to resulting mesh");
   RNA_def_property_update(prop, 0, "rna_Modifier_update");
 
+  prop = RNA_def_property(srna, "use_sculpt_base_mesh", PROP_BOOLEAN, PROP_NONE);
+  RNA_def_property_boolean_sdna(prop, NULL, "flags", eMultiresModifierFlag_UseSculptBaseMesh);
+  RNA_def_property_ui_text(prop,
+                           "Sculpt Base Mesh",
+                           "Make Sculpt Mode tools deform the base mesh while previewing the "
+                           "displacement of higher subdivision levels");
+  RNA_def_property_update(prop, 0, "rna_Modifier_update");
+
   RNA_define_lib_overridable(false);
 }
 
diff --git a/source/blender/modifiers/intern/MOD_multires.c b/source/blender/modifiers/intern/MOD_multires.c
index 7853bc4acac..9ced297bb48 100644
--- a/source/blender/modifiers/intern/MOD_multires.c
+++ b/source/blender/modifiers/intern/MOD_multires.c
@@ -238,7 +238,9 @@ static Mesh *modifyMesh(ModifierData *md, const ModifierEvalContext *ctx, Mesh *
   /* Needed when rendering or baking will in sculpt mode. */
   const bool for_render = (ctx->flag & MOD_APPLY_RENDER) != 0;
 
-  if ((ctx->object->mode & OB_MODE_SCULPT) && !for_orco && !for_render) {
+  const bool sculpt_base_mesh = mmd->flags & eMultiresModifierFlag_UseSculptBaseMesh;
+
+  if ((ctx->object->mode & OB_MODE_SCULPT) && !for_orco && !for_render && !sculpt_base_mesh) {
     /* NOTE: CCG takes ownership over Subdiv. */
     result = multires_as_ccg(mmd, ctx, mesh, subdiv);
     result->runtime.subdiv_ccg_tot_level = mmd->totlvl;
@@ -341,6 +343,12 @@ static void panel_draw(const bContext *C, Panel *panel)
   uiItemR(col, &ptr, "sculpt_levels", 0, IFACE_("Sculpt"), ICON_NONE);
   uiItemR(col, &ptr, "render_levels", 0, IFACE_("Render"), ICON_NONE);
 
+  const bool is_sculpt_mode = CTX_data_active_object(C)->mode & OB_MODE_SCULPT;
+  uiBlock *block = uiLayoutGetBlock(panel->layout);
+  UI_block_lock_set(block, !is_sculpt_mode, IFACE_("Sculpt Base Mesh"));
+  uiItemR(col, &ptr, "use_sculpt_base_mesh", 0, IFACE_("Sculpt Base Mesh"), ICON_NONE);
+  UI_block_lock_clear(block);
+
   uiItemR(layout, &ptr, "show_only_control_edges", 0, NULL, ICON_NONE);
 
   modifier_panel_end(layout, &ptr);
-- 
cgit v1.2.3


From 4814836120e50cce4a23e037a9bbb6a1e53de890 Mon Sep 17 00:00:00 2001
From: Pablo Dobarro <pablodp606@gmail.com>
Date: Tue, 18 Aug 2020 13:27:58 +0200
Subject: Sculpt: Option to limit the forces axis in the Cloth Filter

This uses the same concept of the Mesh Filter but for applying the cloth
filter forces, so now it can be limited to a specific axis.

Reviewed By: sergey

Differential Revision: https://developer.blender.org/D8567
---
 source/blender/editors/sculpt_paint/sculpt_cloth.c | 30 ++++++++++++++++++++++
 .../blender/editors/sculpt_paint/sculpt_intern.h   |  1 +
 2 files changed, 31 insertions(+)

(limited to 'source')

diff --git a/source/blender/editors/sculpt_paint/sculpt_cloth.c b/source/blender/editors/sculpt_paint/sculpt_cloth.c
index bdc7d7520ea..080124d2445 100644
--- a/source/blender/editors/sculpt_paint/sculpt_cloth.c
+++ b/source/blender/editors/sculpt_paint/sculpt_cloth.c
@@ -1060,6 +1060,19 @@ static EnumPropertyItem prop_cloth_filter_type[] = {
     {0, NULL, 0, NULL, NULL},
 };
 
+typedef enum eClothFilterForceAxis {
+  CLOTH_FILTER_FORCE_X = 1 << 0,
+  CLOTH_FILTER_FORCE_Y = 1 << 1,
+  CLOTH_FILTER_FORCE_Z = 1 << 2,
+} eClothFilterForceAxis;
+
+static EnumPropertyItem prop_cloth_filter_force_axis_items[] = {
+    {CLOTH_FILTER_FORCE_X, "X", 0, "X", "Apply force in the X axis"},
+    {CLOTH_FILTER_FORCE_Y, "Y", 0, "Y", "Apply force in the Y axis"},
+    {CLOTH_FILTER_FORCE_Z, "Z", 0, "Z", "Apply force in the Z axis"},
+    {0, NULL, 0, NULL, NULL},
+};
+
 static void cloth_filter_apply_forces_task_cb(void *__restrict userdata,
                                               const int i,
                                               const TaskParallelTLS *__restrict UNUSED(tls))
@@ -1114,6 +1127,12 @@ static void cloth_filter_apply_forces_task_cb(void *__restrict userdata,
         break;
     }
 
+    for (int axis = 0; axis < 3; axis++) {
+      if (!ss->filter_cache->enabled_force_axis[axis]) {
+        force[axis] = 0.0f;
+      }
+    }
+
     add_v3_v3(force, sculpt_gravity);
 
     cloth_brush_apply_force_to_vertex(ss, cloth_sim, force, vd.index);
@@ -1229,6 +1248,11 @@ static int sculpt_cloth_filter_invoke(bContext *C, wmOperator *op, const wmEvent
     ss->filter_cache->active_face_set = SCULPT_FACE_SET_NONE;
   }
 
+  const int force_axis = RNA_enum_get(op->ptr, "force_axis");
+  ss->filter_cache->enabled_force_axis[0] = force_axis & CLOTH_FILTER_FORCE_X;
+  ss->filter_cache->enabled_force_axis[1] = force_axis & CLOTH_FILTER_FORCE_Y;
+  ss->filter_cache->enabled_force_axis[2] = force_axis & CLOTH_FILTER_FORCE_Z;
+
   WM_event_add_modal_handler(C, op);
   return OPERATOR_RUNNING_MODAL;
 }
@@ -1256,6 +1280,12 @@ void SCULPT_OT_cloth_filter(struct wmOperatorType *ot)
                "Operation that is going to be applied to the mesh");
   RNA_def_float(
       ot->srna, "strength", 1.0f, -10.0f, 10.0f, "Strength", "Filter Strength", -10.0f, 10.0f);
+  RNA_def_enum_flag(ot->srna,
+                    "force_axis",
+                    prop_cloth_filter_force_axis_items,
+                    CLOTH_FILTER_FORCE_X | CLOTH_FILTER_FORCE_Y | CLOTH_FILTER_FORCE_Z,
+                    "Force axis",
+                    "Apply the force in the selected axis");
   RNA_def_float(ot->srna,
                 "cloth_mass",
                 1.0f,
diff --git a/source/blender/editors/sculpt_paint/sculpt_intern.h b/source/blender/editors/sculpt_paint/sculpt_intern.h
index f233a9085e2..14928ba933a 100644
--- a/source/blender/editors/sculpt_paint/sculpt_intern.h
+++ b/source/blender/editors/sculpt_paint/sculpt_intern.h
@@ -946,6 +946,7 @@ typedef struct StrokeCache {
 
 typedef struct FilterCache {
   bool enabled_axis[3];
+  bool enabled_force_axis[3];
   int random_seed;
 
   /* Used for alternating between filter operations in filters that need to apply different ones to
-- 
cgit v1.2.3


From fe1827df821cdba2d66b03c0f3366e8df3c2fe76 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= <foucault.clem@gmail.com>
Date: Tue, 18 Aug 2020 13:52:20 +0200
Subject: Fix T79782 GPU: Crash cause by shadow batch reference

After drawing, the batch could be reset and draw again using other
parameters.

Avoid having to track references by setting the batch pointer to NULL after
drawing.
---
 source/blender/gpu/opengl/gl_drawlist.cc | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'source')

diff --git a/source/blender/gpu/opengl/gl_drawlist.cc b/source/blender/gpu/opengl/gl_drawlist.cc
index 575b2c989e4..b02681af892 100644
--- a/source/blender/gpu/opengl/gl_drawlist.cc
+++ b/source/blender/gpu/opengl/gl_drawlist.cc
@@ -235,6 +235,8 @@ void GLDrawList::submit(void)
   }
   /* Do not submit this buffer again. */
   command_len_ = 0;
+  /* Avoid keeping reference to the batch. */
+  batch_ = NULL;
 }
 
 /** \} */
-- 
cgit v1.2.3


From 41235eed1dad40abf7a34750beedff1176e0c6e5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= <foucault.clem@gmail.com>
Date: Tue, 18 Aug 2020 13:53:00 +0200
Subject: GPU: Avoid invalid GL API usage

Drawing with 0 sized buffer is prohibited.
---
 source/blender/gpu/opengl/gl_batch.cc    | 2 ++
 source/blender/gpu/opengl/gl_drawlist.cc | 5 +++++
 2 files changed, 7 insertions(+)

(limited to 'source')

diff --git a/source/blender/gpu/opengl/gl_batch.cc b/source/blender/gpu/opengl/gl_batch.cc
index 00e1a61f7cf..38448e8a0b8 100644
--- a/source/blender/gpu/opengl/gl_batch.cc
+++ b/source/blender/gpu/opengl/gl_batch.cc
@@ -325,6 +325,8 @@ void GLBatch::draw(int v_first, int v_count, int i_first, int i_count)
 {
   this->bind(i_first);
 
+  BLI_assert(v_count > 0 && i_count > 0);
+
   GLenum gl_type = convert_prim_type_to_gl(prim_type);
 
   if (elem) {
diff --git a/source/blender/gpu/opengl/gl_drawlist.cc b/source/blender/gpu/opengl/gl_drawlist.cc
index b02681af892..16ea924d8dc 100644
--- a/source/blender/gpu/opengl/gl_drawlist.cc
+++ b/source/blender/gpu/opengl/gl_drawlist.cc
@@ -151,6 +151,11 @@ void GLDrawList::append(GPUBatch *batch, int i_first, int i_count)
     v_count_ = batch->elem ? batch->elem->index_len : batch->verts[0]->vertex_len;
   }
 
+  if (v_count_ == 0) {
+    /* Nothing to draw. */
+    return;
+  }
+
   if (MDI_INDEXED) {
     GLDrawCommandIndexed *cmd = reinterpret_cast<GLDrawCommandIndexed *>(data_ + command_offset_);
     cmd->v_first = v_first_;
-- 
cgit v1.2.3


From aba46371a1cb293bf96cf0e343a39d9954e02511 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= <foucault.clem@gmail.com>
Date: Tue, 18 Aug 2020 14:01:14 +0200
Subject: GPUTexture: Extend CUBE_MAP_ARRAY_ARB proxy workaround to all Apple
 gpus

Related to T79716
---
 source/blender/gpu/intern/gpu_texture.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source')

diff --git a/source/blender/gpu/intern/gpu_texture.c b/source/blender/gpu/intern/gpu_texture.c
index 5bbfd04c114..53feaa3ed76 100644
--- a/source/blender/gpu/intern/gpu_texture.c
+++ b/source/blender/gpu/intern/gpu_texture.c
@@ -678,7 +678,7 @@ static bool gpu_texture_check_capacity(
     GPUTexture *tex, GLenum proxy, GLenum internalformat, GLenum data_format, GLenum data_type)
 {
   if (proxy == GL_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB &&
-      GPU_type_matches(GPU_DEVICE_ATI, GPU_OS_MAC, GPU_DRIVER_ANY)) {
+      GPU_type_matches(GPU_DEVICE_ANY, GPU_OS_MAC, GPU_DRIVER_ANY)) {
     /* Special fix for T79703. */
     /* Depth has already been checked. */
     return tex->w <= GPU_max_cube_map_size();
-- 
cgit v1.2.3


From 20a8edaa725ddbae16179d2f7cea88c097c61615 Mon Sep 17 00:00:00 2001
From: Dalai Felinto <dalai@blender.org>
Date: Mon, 17 Aug 2020 19:50:35 +0200
Subject: No experimental feature (but debug ones) to work for blender
 beta/release

Final releases (including beta) should strictly show features that are
finalized to prevent loss of data, old API clanging around, and the
overall quality of the product (Blender) presented.

Note that rendering should never be affected by user preferences, so
this is only changing things in the UI level.

Development note: This is reset experimental UI on file load.
Also note: to hide RNA (needed for hair and particles) will be done as a
separate patch.

Differential Revision: https://developer.blender.org/D8606
---
 source/blender/blenkernel/BKE_blender_version.h      |  3 +++
 source/blender/blenkernel/intern/blender.c           |  6 ++++++
 source/blender/blenloader/BLO_readfile.h             |  3 +++
 .../blender/blenloader/intern/versioning_userdef.c   | 20 ++++++++++++++++++++
 source/blender/editors/interface/interface.c         |  4 ++++
 5 files changed, 36 insertions(+)

(limited to 'source')

diff --git a/source/blender/blenkernel/BKE_blender_version.h b/source/blender/blenkernel/BKE_blender_version.h
index 3df09d08814..c340e1f1ff7 100644
--- a/source/blender/blenkernel/BKE_blender_version.h
+++ b/source/blender/blenkernel/BKE_blender_version.h
@@ -50,6 +50,9 @@ extern "C" {
 /** User readable version string. */
 const char *BKE_blender_version_string(void);
 
+/* Returns true when version cycle is alpha, otherwise (beta, rc) returns false. */
+bool BKE_blender_version_is_alpha(void);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/source/blender/blenkernel/intern/blender.c b/source/blender/blenkernel/intern/blender.c
index e8aa13a8beb..af502d30145 100644
--- a/source/blender/blenkernel/intern/blender.c
+++ b/source/blender/blenkernel/intern/blender.c
@@ -135,6 +135,12 @@ const char *BKE_blender_version_string(void)
   return blender_version_string;
 }
 
+bool BKE_blender_version_is_alpha(void)
+{
+  static bool is_alpha = STREQ(STRINGIFY(BLENDER_VERSION_CYCLE), "alpha");
+  return is_alpha;
+}
+
 void BKE_blender_globals_init(void)
 {
   blender_version_init();
diff --git a/source/blender/blenloader/BLO_readfile.h b/source/blender/blenloader/BLO_readfile.h
index 97c77ed2e19..580c833d8dc 100644
--- a/source/blender/blenloader/BLO_readfile.h
+++ b/source/blender/blenloader/BLO_readfile.h
@@ -186,6 +186,9 @@ void BLO_update_defaults_workspace(struct WorkSpace *workspace, const char *app_
 /* Version patch user preferences. */
 void BLO_version_defaults_userpref_blend(struct Main *mainvar, struct UserDef *userdef);
 
+/* Disable unwanted experimental feature settings on startup. */
+void BLO_sanitize_experimental_features_userpref_blend(struct UserDef *userdef);
+
 struct BlendThumbnail *BLO_thumbnail_from_file(const char *filepath);
 
 /* datafiles (generated theme) */
diff --git a/source/blender/blenloader/intern/versioning_userdef.c b/source/blender/blenloader/intern/versioning_userdef.c
index 50e3b375166..ec631eb64f3 100644
--- a/source/blender/blenloader/intern/versioning_userdef.c
+++ b/source/blender/blenloader/intern/versioning_userdef.c
@@ -38,6 +38,7 @@
 #include "DNA_windowmanager_types.h"
 
 #include "BKE_addon.h"
+#include "BKE_blender_version.h"
 #include "BKE_colorband.h"
 #include "BKE_idprop.h"
 #include "BKE_keyconfig.h"
@@ -784,4 +785,23 @@ void BLO_version_defaults_userpref_blend(Main *bmain, UserDef *userdef)
 #undef USER_VERSION_ATLEAST
 }
 
+void BLO_sanitize_experimental_features_userpref_blend(UserDef *userdef)
+{
+  /* User preference experimental settings are only supported in alpha builds.
+   * This prevents users corrupting data and relying on API that may change.
+   *
+   * If user preferences are saved this will be stored in disk as expected.
+   * This only starts to take effect when there is a release branch (on beta).
+   *
+   * At that time master already has its version bumped so its user preferences
+   * are not touched by these settings. */
+
+  if (BKE_blender_version_is_alpha()) {
+    return;
+  }
+  userdef->experimental.use_new_particle_system = false;
+  userdef->experimental.use_new_hair_type = false;
+  userdef->experimental.use_sculpt_vertex_colors = false;
+}
+
 #undef USER_LMOUSESELECT
diff --git a/source/blender/editors/interface/interface.c b/source/blender/editors/interface/interface.c
index 286cb1571bd..d19c677efb4 100644
--- a/source/blender/editors/interface/interface.c
+++ b/source/blender/editors/interface/interface.c
@@ -44,6 +44,8 @@
 
 #include "BLI_utildefines.h"
 
+#include "BLO_readfile.h"
+
 #include "BKE_animsys.h"
 #include "BKE_context.h"
 #include "BKE_idprop.h"
@@ -6818,6 +6820,8 @@ void UI_init_userdef(Main *bmain)
   /* fix saved themes */
   init_userdef_do_versions(bmain);
   uiStyleInit();
+
+  BLO_sanitize_experimental_features_userpref_blend(&U);
 }
 
 void UI_reinit_font(void)
-- 
cgit v1.2.3


From c526a34fc2fe0d51a81837bd49dbc0b78c8b5224 Mon Sep 17 00:00:00 2001
From: Sergey Sharybin <sergey@blender.org>
Date: Tue, 18 Aug 2020 14:37:53 +0200
Subject: Cleanup: Fix strict compiler warning

---
 source/blender/blenkernel/intern/paint.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'source')

diff --git a/source/blender/blenkernel/intern/paint.c b/source/blender/blenkernel/intern/paint.c
index f6e744096bb..e3c209b60e6 100644
--- a/source/blender/blenkernel/intern/paint.c
+++ b/source/blender/blenkernel/intern/paint.c
@@ -1437,10 +1437,9 @@ static bool sculpt_modifiers_active(Scene *scene, Sculpt *sd, Object *ob)
 {
   ModifierData *md;
   Mesh *me = (Mesh *)ob->data;
-  MultiresModifierData *mmd = BKE_sculpt_multires_active(scene, ob);
   VirtualModifierData virtualModifierData;
 
-  if (mmd || ob->sculpt->bm) {
+  if (ob->sculpt->bm || BKE_sculpt_multires_active(scene, ob)) {
     return false;
   }
 
-- 
cgit v1.2.3


From 83e3d25bcae37df0139bb93b85d7ae5bf3da553b Mon Sep 17 00:00:00 2001
From: Dalai Felinto <dalai@blender.org>
Date: Mon, 17 Aug 2020 09:47:10 +0200
Subject: Remove (ifdef) RNA for simulation, point cloud and particles

For 2.90 release this should not be exposed in the RNA API.

In master this needs to be ON by default, that's all.

Differential Revision: https://developer.blender.org/D8589
---
 source/blender/editors/space_buttons/CMakeLists.txt    |  5 +++++
 source/blender/editors/space_buttons/buttons_context.c |  8 ++++++++
 source/blender/makesrna/intern/CMakeLists.txt          | 13 ++++++++++---
 source/blender/makesrna/intern/makesrna.c              |  6 ++++++
 source/blender/makesrna/intern/rna_ID.c                | 18 ++++++++++++++++++
 source/blender/makesrna/intern/rna_internal.h          |  6 ++++++
 source/blender/makesrna/intern/rna_main.c              | 12 ++++++++++++
 source/blender/makesrna/intern/rna_main_api.c          | 18 ++++++++++++++++++
 source/blender/makesrna/intern/rna_modifier.c          |  8 ++++++++
 source/blender/makesrna/intern/rna_object.c            |  8 ++++++++
 source/blender/makesrna/intern/rna_space.c             |  4 ++++
 11 files changed, 103 insertions(+), 3 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/space_buttons/CMakeLists.txt b/source/blender/editors/space_buttons/CMakeLists.txt
index 25ff6bbd098..75d91174470 100644
--- a/source/blender/editors/space_buttons/CMakeLists.txt
+++ b/source/blender/editors/space_buttons/CMakeLists.txt
@@ -54,4 +54,9 @@ if(WITH_FREESTYLE)
   add_definitions(-DWITH_FREESTYLE)
 endif()
 
+if(WITH_EXPERIMENTAL_FEATURES)
+  add_definitions(-DWITH_PARTICLE_NODES)
+  add_definitions(-DWITH_HAIR_NODES)
+endif()
+
 blender_add_lib(bf_editor_space_buttons "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
diff --git a/source/blender/editors/space_buttons/buttons_context.c b/source/blender/editors/space_buttons/buttons_context.c
index 16256f6c97e..044fadb9a50 100644
--- a/source/blender/editors/space_buttons/buttons_context.c
+++ b/source/blender/editors/space_buttons/buttons_context.c
@@ -249,12 +249,16 @@ static int buttons_context_path_data(ButsContextPath *path, int type)
   if (RNA_struct_is_a(ptr->type, &RNA_GreasePencil) && (type == -1 || type == OB_GPENCIL)) {
     return 1;
   }
+#ifdef WITH_HAIR_NODES
   if (RNA_struct_is_a(ptr->type, &RNA_Hair) && (type == -1 || type == OB_HAIR)) {
     return 1;
   }
+#endif
+#ifdef WITH_PARTICLE_NODES
   if (RNA_struct_is_a(ptr->type, &RNA_PointCloud) && (type == -1 || type == OB_POINTCLOUD)) {
     return 1;
   }
+#endif
   if (RNA_struct_is_a(ptr->type, &RNA_Volume) && (type == -1 || type == OB_VOLUME)) {
     return 1;
   }
@@ -871,14 +875,18 @@ int buttons_context(const bContext *C, const char *member, bContextDataResult *r
     set_pointer_type(path, result, &RNA_LightProbe);
     return 1;
   }
+#ifdef WITH_HAIR_NODES
   if (CTX_data_equals(member, "hair")) {
     set_pointer_type(path, result, &RNA_Hair);
     return 1;
   }
+#endif
+#ifdef WITH_PARTICLE_NODES
   if (CTX_data_equals(member, "pointcloud")) {
     set_pointer_type(path, result, &RNA_PointCloud);
     return 1;
   }
+#endif
   if (CTX_data_equals(member, "volume")) {
     set_pointer_type(path, result, &RNA_Volume);
     return 1;
diff --git a/source/blender/makesrna/intern/CMakeLists.txt b/source/blender/makesrna/intern/CMakeLists.txt
index 0b43a5a6653..1896813bdb3 100644
--- a/source/blender/makesrna/intern/CMakeLists.txt
+++ b/source/blender/makesrna/intern/CMakeLists.txt
@@ -47,7 +47,6 @@ set(DEFSRC
   rna_fluid.c
   rna_gpencil.c
   rna_gpencil_modifier.c
-  rna_hair.c
   rna_image.c
   rna_key.c
   rna_lattice.c
@@ -69,7 +68,6 @@ set(DEFSRC
   rna_packedfile.c
   rna_palette.c
   rna_particle.c
-  rna_pointcloud.c
   rna_pose.c
   rna_render.c
   rna_rigidbody.c
@@ -79,7 +77,6 @@ set(DEFSRC
   rna_sculpt_paint.c
   rna_sequencer.c
   rna_shader_fx.c
-  rna_simulation.c
   rna_sound.c
   rna_space.c
   rna_speaker.c
@@ -99,6 +96,16 @@ set(DEFSRC
   rna_xr.c
 )
 
+if(WITH_EXPERIMENTAL_FEATURES)
+  add_definitions(-DWITH_PARTICLE_NODES)
+  add_definitions(-DWITH_HAIR_NODES)
+  list(APPEND DEFSRC
+    rna_pointcloud.c
+    rna_simulation.c
+    rna_hair.c
+  )
+endif()
+
 set(APISRC
   rna_action_api.c
   rna_animation_api.c
diff --git a/source/blender/makesrna/intern/makesrna.c b/source/blender/makesrna/intern/makesrna.c
index b7f0fb87536..b49a6885675 100644
--- a/source/blender/makesrna/intern/makesrna.c
+++ b/source/blender/makesrna/intern/makesrna.c
@@ -4285,7 +4285,9 @@ static RNAProcessItem PROCESS_ITEMS[] = {
     {"rna_dynamicpaint.c", NULL, RNA_def_dynamic_paint},
     {"rna_fcurve.c", "rna_fcurve_api.c", RNA_def_fcurve},
     {"rna_gpencil.c", NULL, RNA_def_gpencil},
+#ifdef WITH_HAIR_NODES
     {"rna_hair.c", NULL, RNA_def_hair},
+#endif
     {"rna_image.c", "rna_image_api.c", RNA_def_image},
     {"rna_key.c", NULL, RNA_def_key},
     {"rna_light.c", NULL, RNA_def_light},
@@ -4308,7 +4310,9 @@ static RNAProcessItem PROCESS_ITEMS[] = {
     {"rna_packedfile.c", NULL, RNA_def_packedfile},
     {"rna_palette.c", NULL, RNA_def_palette},
     {"rna_particle.c", NULL, RNA_def_particle},
+#ifdef WITH_PARTICLE_NODES
     {"rna_pointcloud.c", NULL, RNA_def_pointcloud},
+#endif
     {"rna_pose.c", "rna_pose_api.c", RNA_def_pose},
     {"rna_curveprofile.c", NULL, RNA_def_profile},
     {"rna_lightprobe.c", NULL, RNA_def_lightprobe},
@@ -4318,7 +4322,9 @@ static RNAProcessItem PROCESS_ITEMS[] = {
     {"rna_screen.c", NULL, RNA_def_screen},
     {"rna_sculpt_paint.c", NULL, RNA_def_sculpt_paint},
     {"rna_sequencer.c", "rna_sequencer_api.c", RNA_def_sequencer},
+#ifdef WITH_PARTICLE_NODES
     {"rna_simulation.c", NULL, RNA_def_simulation},
+#endif
     {"rna_space.c", "rna_space_api.c", RNA_def_space},
     {"rna_speaker.c", NULL, RNA_def_speaker},
     {"rna_test.c", NULL, RNA_def_test},
diff --git a/source/blender/makesrna/intern/rna_ID.c b/source/blender/makesrna/intern/rna_ID.c
index e9ca0d577ce..f1c125fcbb9 100644
--- a/source/blender/makesrna/intern/rna_ID.c
+++ b/source/blender/makesrna/intern/rna_ID.c
@@ -251,9 +251,11 @@ short RNA_type_to_ID_code(const StructRNA *type)
   if (base_type == &RNA_FreestyleLineStyle) {
     return ID_LS;
   }
+#  ifdef WITH_HAIR_NODES
   if (base_type == &RNA_Hair) {
     return ID_HA;
   }
+#  endif
   if (base_type == &RNA_Lattice) {
     return ID_LT;
   }
@@ -287,9 +289,11 @@ short RNA_type_to_ID_code(const StructRNA *type)
   if (base_type == &RNA_PaintCurve) {
     return ID_PC;
   }
+#  ifdef WITH_PARTICLE_NODES
   if (base_type == &RNA_PointCloud) {
     return ID_PT;
   }
+#  endif
   if (base_type == &RNA_LightProbe) {
     return ID_LP;
   }
@@ -299,9 +303,11 @@ short RNA_type_to_ID_code(const StructRNA *type)
   if (base_type == &RNA_Screen) {
     return ID_SCR;
   }
+#  ifdef WITH_PARTICLE_NODES
   if (base_type == &RNA_Simulation) {
     return ID_SIM;
   }
+#  endif
   if (base_type == &RNA_Sound) {
     return ID_SO;
   }
@@ -355,7 +361,11 @@ StructRNA *ID_code_to_RNA_type(short idcode)
     case ID_GR:
       return &RNA_Collection;
     case ID_HA:
+#  ifdef WITH_HAIR_NODES
       return &RNA_Hair;
+#  else
+      return &RNA_ID;
+#  endif
     case ID_IM:
       return &RNA_Image;
     case ID_KE:
@@ -389,7 +399,11 @@ StructRNA *ID_code_to_RNA_type(short idcode)
     case ID_PC:
       return &RNA_PaintCurve;
     case ID_PT:
+#  ifdef WITH_PARTICLE_NODES
       return &RNA_PointCloud;
+#  else
+      return &RNA_ID;
+#  endif
     case ID_LP:
       return &RNA_LightProbe;
     case ID_SCE:
@@ -397,7 +411,11 @@ StructRNA *ID_code_to_RNA_type(short idcode)
     case ID_SCR:
       return &RNA_Screen;
     case ID_SIM:
+#  ifdef WITH_PARTICLE_NODES
       return &RNA_Simulation;
+#  else
+      return &RNA_ID;
+#  endif
     case ID_SO:
       return &RNA_Sound;
     case ID_SPK:
diff --git a/source/blender/makesrna/intern/rna_internal.h b/source/blender/makesrna/intern/rna_internal.h
index 8045279eef2..6254e40a410 100644
--- a/source/blender/makesrna/intern/rna_internal.h
+++ b/source/blender/makesrna/intern/rna_internal.h
@@ -455,10 +455,16 @@ void RNA_def_main_cachefiles(BlenderRNA *brna, PropertyRNA *cprop);
 void RNA_def_main_paintcurves(BlenderRNA *brna, PropertyRNA *cprop);
 void RNA_def_main_workspaces(BlenderRNA *brna, PropertyRNA *cprop);
 void RNA_def_main_lightprobes(BlenderRNA *brna, PropertyRNA *cprop);
+#ifdef WITH_PARTICLE_NODES
 void RNA_def_main_hairs(BlenderRNA *brna, PropertyRNA *cprop);
+#endif
+#ifdef WITH_HAIR_NODES
 void RNA_def_main_pointclouds(BlenderRNA *brna, PropertyRNA *cprop);
+#endif
 void RNA_def_main_volumes(BlenderRNA *brna, PropertyRNA *cprop);
+#ifdef WITH_PARTICLE_NODES
 void RNA_def_main_simulations(BlenderRNA *brna, PropertyRNA *cprop);
+#endif
 
 /* ID Properties */
 
diff --git a/source/blender/makesrna/intern/rna_main.c b/source/blender/makesrna/intern/rna_main.c
index 97702b06b6f..d83fca69278 100644
--- a/source/blender/makesrna/intern/rna_main.c
+++ b/source/blender/makesrna/intern/rna_main.c
@@ -109,7 +109,9 @@ RNA_MAIN_LISTBASE_FUNCS_DEF(collections)
 RNA_MAIN_LISTBASE_FUNCS_DEF(curves)
 RNA_MAIN_LISTBASE_FUNCS_DEF(fonts)
 RNA_MAIN_LISTBASE_FUNCS_DEF(gpencils)
+#  ifdef WITH_HAIR_NODES
 RNA_MAIN_LISTBASE_FUNCS_DEF(hairs)
+#  endif
 RNA_MAIN_LISTBASE_FUNCS_DEF(images)
 RNA_MAIN_LISTBASE_FUNCS_DEF(lattices)
 RNA_MAIN_LISTBASE_FUNCS_DEF(libraries)
@@ -126,11 +128,15 @@ RNA_MAIN_LISTBASE_FUNCS_DEF(objects)
 RNA_MAIN_LISTBASE_FUNCS_DEF(paintcurves)
 RNA_MAIN_LISTBASE_FUNCS_DEF(palettes)
 RNA_MAIN_LISTBASE_FUNCS_DEF(particles)
+#  ifdef WITH_PARTICLE_NODES
 RNA_MAIN_LISTBASE_FUNCS_DEF(pointclouds)
+#  endif
 RNA_MAIN_LISTBASE_FUNCS_DEF(scenes)
 RNA_MAIN_LISTBASE_FUNCS_DEF(screens)
 RNA_MAIN_LISTBASE_FUNCS_DEF(shapekeys)
+#  ifdef WITH_PARTICLE_NODES
 RNA_MAIN_LISTBASE_FUNCS_DEF(simulations)
+#  endif
 RNA_MAIN_LISTBASE_FUNCS_DEF(sounds)
 RNA_MAIN_LISTBASE_FUNCS_DEF(speakers)
 RNA_MAIN_LISTBASE_FUNCS_DEF(texts)
@@ -384,25 +390,31 @@ void RNA_def_main(BlenderRNA *brna)
        "LightProbes",
        "LightProbe data-blocks",
        RNA_def_main_lightprobes},
+#  ifdef WITH_HAIR_NODES
       {"hairs", "Hair", "rna_Main_hairs_begin", "Hairs", "Hair data-blocks", RNA_def_main_hairs},
+#  endif
+#  ifdef WITH_PARTICLE_NODES
       {"pointclouds",
        "PointCloud",
        "rna_Main_pointclouds_begin",
        "Point Clouds",
        "Point cloud data-blocks",
        RNA_def_main_pointclouds},
+#  endif
       {"volumes",
        "Volume",
        "rna_Main_volumes_begin",
        "Volumes",
        "Volume data-blocks",
        RNA_def_main_volumes},
+#  ifdef WITH_PARTICLE_NODES
       {"simulations",
        "Simulation",
        "rna_Main_simulations_begin",
        "Simulations",
        "Simulation data-blocks",
        RNA_def_main_simulations},
+#  endif
       {NULL, NULL, NULL, NULL, NULL, NULL},
   };
 
diff --git a/source/blender/makesrna/intern/rna_main_api.c b/source/blender/makesrna/intern/rna_main_api.c
index 990a5412093..7c941ddb524 100644
--- a/source/blender/makesrna/intern/rna_main_api.c
+++ b/source/blender/makesrna/intern/rna_main_api.c
@@ -708,6 +708,7 @@ static bGPdata *rna_Main_gpencils_new(Main *bmain, const char *name)
   return gpd;
 }
 
+#  ifdef WITH_HAIR_NODES
 static Hair *rna_Main_hairs_new(Main *bmain, const char *name)
 {
   char safe_name[MAX_ID_NAME - 2];
@@ -717,7 +718,9 @@ static Hair *rna_Main_hairs_new(Main *bmain, const char *name)
   id_us_min(&hair->id);
   return hair;
 }
+#  endif
 
+#  ifdef WITH_PARTICLE_NODES
 static PointCloud *rna_Main_pointclouds_new(Main *bmain, const char *name)
 {
   char safe_name[MAX_ID_NAME - 2];
@@ -727,6 +730,7 @@ static PointCloud *rna_Main_pointclouds_new(Main *bmain, const char *name)
   id_us_min(&pointcloud->id);
   return pointcloud;
 }
+#  endif
 
 static Volume *rna_Main_volumes_new(Main *bmain, const char *name)
 {
@@ -738,6 +742,7 @@ static Volume *rna_Main_volumes_new(Main *bmain, const char *name)
   return volume;
 }
 
+#  ifdef WITH_PARTICLE_NODES
 static Simulation *rna_Main_simulations_new(Main *bmain, const char *name)
 {
   char safe_name[MAX_ID_NAME - 2];
@@ -747,6 +752,7 @@ static Simulation *rna_Main_simulations_new(Main *bmain, const char *name)
   id_us_min(&simulation->id);
   return simulation;
 }
+#  endif
 
 /* tag functions, all the same */
 #  define RNA_MAIN_ID_TAG_FUNCS_DEF(_func_name, _listbase_name, _id_type) \
@@ -790,10 +796,16 @@ RNA_MAIN_ID_TAG_FUNCS_DEF(cachefiles, cachefiles, ID_CF)
 RNA_MAIN_ID_TAG_FUNCS_DEF(paintcurves, paintcurves, ID_PC)
 RNA_MAIN_ID_TAG_FUNCS_DEF(workspaces, workspaces, ID_WS)
 RNA_MAIN_ID_TAG_FUNCS_DEF(lightprobes, lightprobes, ID_LP)
+#  ifdef WITH_HAIR_NODES
 RNA_MAIN_ID_TAG_FUNCS_DEF(hairs, hairs, ID_HA)
+#  endif
+#  ifdef WITH_PARTICLE_NODES
 RNA_MAIN_ID_TAG_FUNCS_DEF(pointclouds, pointclouds, ID_PT)
+#  endif
 RNA_MAIN_ID_TAG_FUNCS_DEF(volumes, volumes, ID_VO)
+#  ifdef WITH_PARTICLE_NODES
 RNA_MAIN_ID_TAG_FUNCS_DEF(simulations, simulations, ID_SIM)
+#  endif
 
 #  undef RNA_MAIN_ID_TAG_FUNCS_DEF
 
@@ -2194,6 +2206,7 @@ void RNA_def_main_lightprobes(BlenderRNA *brna, PropertyRNA *cprop)
   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 }
 
+#  ifdef WITH_HAIR_NODES
 void RNA_def_main_hairs(BlenderRNA *brna, PropertyRNA *cprop)
 {
   StructRNA *srna;
@@ -2237,7 +2250,9 @@ void RNA_def_main_hairs(BlenderRNA *brna, PropertyRNA *cprop)
   parm = RNA_def_boolean(func, "value", 0, "Value", "");
   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 }
+#  endif
 
+#  ifdef WITH_PARTICLE_NODES
 void RNA_def_main_pointclouds(BlenderRNA *brna, PropertyRNA *cprop)
 {
   StructRNA *srna;
@@ -2284,6 +2299,7 @@ void RNA_def_main_pointclouds(BlenderRNA *brna, PropertyRNA *cprop)
   parm = RNA_def_boolean(func, "value", 0, "Value", "");
   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 }
+#  endif
 
 void RNA_def_main_volumes(BlenderRNA *brna, PropertyRNA *cprop)
 {
@@ -2329,6 +2345,7 @@ void RNA_def_main_volumes(BlenderRNA *brna, PropertyRNA *cprop)
   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 }
 
+#  ifdef WITH_PARTICLE_NODES
 void RNA_def_main_simulations(BlenderRNA *brna, PropertyRNA *cprop)
 {
   StructRNA *srna;
@@ -2368,5 +2385,6 @@ void RNA_def_main_simulations(BlenderRNA *brna, PropertyRNA *cprop)
   parm = RNA_def_boolean(func, "value", 0, "Value", "");
   RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
 }
+#  endif
 
 #endif
diff --git a/source/blender/makesrna/intern/rna_modifier.c b/source/blender/makesrna/intern/rna_modifier.c
index 86f05c350f3..bd507d7b1fc 100644
--- a/source/blender/makesrna/intern/rna_modifier.c
+++ b/source/blender/makesrna/intern/rna_modifier.c
@@ -723,7 +723,9 @@ static StructRNA *rna_Modifier_refine(struct PointerRNA *ptr)
     case eModifierType_WeightedNormal:
       return &RNA_WeightedNormalModifier;
     case eModifierType_Simulation:
+#  ifdef WITH_PARTICLE_NODES
       return &RNA_SimulationModifier;
+#  endif
     /* Default */
     case eModifierType_Fluidsim: /* deprecated */
     case eModifierType_None:
@@ -1630,6 +1632,7 @@ static void rna_ParticleInstanceModifier_particle_system_set(PointerRNA *ptr,
   CLAMP_MIN(psmd->psys, 1);
 }
 
+#  ifdef WITH_PARTICLE_NODES
 static void rna_SimulationModifier_simulation_update(Main *bmain, Scene *scene, PointerRNA *ptr)
 {
   SimulationModifierData *smd = ptr->data;
@@ -1672,6 +1675,7 @@ static void rna_SimulationModifier_data_path_set(PointerRNA *ptr, const char *va
     smd->data_path = NULL;
   }
 }
+#  endif
 
 /**
  * Special set callback that just changes the first bit of the expansion flag.
@@ -6898,6 +6902,7 @@ static void rna_def_modifier_weightednormal(BlenderRNA *brna)
   RNA_define_lib_overridable(false);
 }
 
+#  ifdef WITH_PARTICLE_NODES
 static void rna_def_modifier_simulation(BlenderRNA *brna)
 {
   StructRNA *srna;
@@ -6926,6 +6931,7 @@ static void rna_def_modifier_simulation(BlenderRNA *brna)
 
   RNA_define_lib_overridable(false);
 }
+#  endif
 
 void RNA_def_modifier(BlenderRNA *brna)
 {
@@ -7055,7 +7061,9 @@ void RNA_def_modifier(BlenderRNA *brna)
   rna_def_modifier_meshseqcache(brna);
   rna_def_modifier_surfacedeform(brna);
   rna_def_modifier_weightednormal(brna);
+#  ifdef WITH_PARTICLE_NODES
   rna_def_modifier_simulation(brna);
+#  endif
 }
 
 #endif
diff --git a/source/blender/makesrna/intern/rna_object.c b/source/blender/makesrna/intern/rna_object.c
index 84b83bee089..347ac6fd5a7 100644
--- a/source/blender/makesrna/intern/rna_object.c
+++ b/source/blender/makesrna/intern/rna_object.c
@@ -564,9 +564,17 @@ static StructRNA *rna_Object_data_typef(PointerRNA *ptr)
     case OB_GPENCIL:
       return &RNA_GreasePencil;
     case OB_HAIR:
+#  ifdef WITH_HAIR_NODES
       return &RNA_Hair;
+#  else
+      return &RNA_ID;
+#  endif
     case OB_POINTCLOUD:
+#  ifdef WITH_PARTICLE_NODES
       return &RNA_PointCloud;
+#  else
+      return &RNA_ID;
+#  endif
     case OB_VOLUME:
       return &RNA_Volume;
     default:
diff --git a/source/blender/makesrna/intern/rna_space.c b/source/blender/makesrna/intern/rna_space.c
index 494fcec4c31..5765dac881e 100644
--- a/source/blender/makesrna/intern/rna_space.c
+++ b/source/blender/makesrna/intern/rna_space.c
@@ -2181,6 +2181,7 @@ static void rna_SpaceNodeEditor_node_tree_update(const bContext *C, PointerRNA *
   ED_node_tree_update(C);
 }
 
+#  ifdef WITH_PARTICLE_NODES
 static PointerRNA rna_SpaceNodeEditor_simulation_get(PointerRNA *ptr)
 {
   SpaceNode *snode = (SpaceNode *)ptr->data;
@@ -2212,6 +2213,7 @@ static void rna_SpaceNodeEditor_simulation_set(PointerRNA *ptr,
   }
   snode->id = &sim->id;
 }
+#  endif
 
 static int rna_SpaceNodeEditor_tree_type_get(PointerRNA *ptr)
 {
@@ -6266,6 +6268,7 @@ static void rna_def_space_node(BlenderRNA *brna)
   RNA_def_property_ui_text(
       prop, "ID From", "Data-block from which the edited data-block is linked");
 
+#  ifdef WITH_PARTICLE_NODES
   prop = RNA_def_property(srna, "simulation", PROP_POINTER, PROP_NONE);
   RNA_def_property_flag(prop, PROP_EDITABLE);
   RNA_def_property_struct_type(prop, "Simulation");
@@ -6276,6 +6279,7 @@ static void rna_def_space_node(BlenderRNA *brna)
                                  NULL,
                                  NULL);
   RNA_def_property_update(prop, NC_SPACE | ND_SPACE_NODE, NULL);
+#  endif
 
   prop = RNA_def_property(srna, "path", PROP_COLLECTION, PROP_NONE);
   RNA_def_property_collection_sdna(prop, NULL, "treepath", NULL);
-- 
cgit v1.2.3


From 017941057f8a36925de4d3d7ce6fd16338846bf1 Mon Sep 17 00:00:00 2001
From: Antonio Vazquez <blendergit@gmail.com>
Date: Tue, 18 Aug 2020 13:40:21 +0200
Subject: Fix T79800: Split vertex size for grease pencil

Differential Revision: https://developer.blender.org/D8607
---
 source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl | 2 +-
 source/blender/draw/intern/draw_common.c                           | 1 +
 source/blender/draw/intern/draw_common.h                           | 3 +--
 source/blender/draw/intern/shaders/common_globals_lib.glsl         | 3 +--
 4 files changed, 4 insertions(+), 5 deletions(-)

(limited to 'source')

diff --git a/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl b/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
index 5818d8eca52..a6161d36a07 100644
--- a/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
+++ b/source/blender/draw/engines/overlay/shaders/edit_gpencil_vert.glsl
@@ -73,7 +73,7 @@ void main()
   }
 
 #ifdef USE_POINTS
-  gl_PointSize = sizeVertex * 2.0;
+  gl_PointSize = sizeVertexGpencil * 2.0;
 
   if (is_point_dimmed) {
     finalColor.rgb = clamp(colorUnselect.rgb + vec3(0.3), 0.0, 1.0);
diff --git a/source/blender/draw/intern/draw_common.c b/source/blender/draw/intern/draw_common.c
index f0d73d5bb84..aac9af088de 100644
--- a/source/blender/draw/intern/draw_common.c
+++ b/source/blender/draw/intern/draw_common.c
@@ -187,6 +187,7 @@ void DRW_globals_update(void)
   /* M_SQRT2 to be at least the same size of the old square */
   gb->sizeVertex = U.pixelsize *
                    (max_ff(1.0f, UI_GetThemeValuef(TH_VERTEX_SIZE) * (float)M_SQRT2 / 2.0f));
+  gb->sizeVertexGpencil = U.pixelsize * UI_GetThemeValuef(TH_GP_VERTEX_SIZE);
   gb->sizeFaceDot = U.pixelsize * UI_GetThemeValuef(TH_FACEDOT_SIZE);
   gb->sizeEdge = U.pixelsize * (1.0f / 2.0f); /* TODO Theme */
   gb->sizeEdgeFix = U.pixelsize * (0.5f + 2.0f * (2.0f * (gb->sizeEdge * (float)M_SQRT1_2)));
diff --git a/source/blender/draw/intern/draw_common.h b/source/blender/draw/intern/draw_common.h
index 6060dce47ac..d6402127e5e 100644
--- a/source/blender/draw/intern/draw_common.h
+++ b/source/blender/draw/intern/draw_common.h
@@ -150,8 +150,7 @@ typedef struct GlobalsUboStorage {
   float sizeObjectCenter, sizeLightCenter, sizeLightCircle, sizeLightCircleShadow;
   float sizeVertex, sizeEdge, sizeEdgeFix, sizeFaceDot;
   float sizeChecker;
-
-  float pad_globalsBlock;
+  float sizeVertexGpencil;
 } GlobalsUboStorage;
 /* Keep in sync with globalsBlock in shaders */
 BLI_STATIC_ASSERT_ALIGN(GlobalsUboStorage, 16)
diff --git a/source/blender/draw/intern/shaders/common_globals_lib.glsl b/source/blender/draw/intern/shaders/common_globals_lib.glsl
index 40a527a6ba4..bd1b1fb6f3a 100644
--- a/source/blender/draw/intern/shaders/common_globals_lib.glsl
+++ b/source/blender/draw/intern/shaders/common_globals_lib.glsl
@@ -117,8 +117,7 @@ layout(std140) uniform globalsBlock
   float sizeEdgeFix;
   float sizeFaceDot;
   float sizeChecker;
-
-  float pad_globalsBlock;
+  float sizeVertexGpencil;
 };
 
 #define sizeViewportInv (sizeViewport.zw)
-- 
cgit v1.2.3


From 89a374cd9640ddaec12d6216ddb910592fe42950 Mon Sep 17 00:00:00 2001
From: Pablo Dobarro <pablodp606@gmail.com>
Date: Mon, 17 Aug 2020 18:47:00 +0200
Subject: Sculpt: Sculpt Filter Orientation Options

Previously, the XYZ deform axis of the Mesh Filter were limited to
object space (which is the default for sculpt mode). Now it is possible
to limit the XYZ displacement in Local, Global or View space.

Reviewed By: sergey

Differential Revision: https://developer.blender.org/D8582
---
 source/blender/editors/sculpt_paint/sculpt_cloth.c |  2 +-
 .../editors/sculpt_paint/sculpt_filter_color.c     |  2 +-
 .../editors/sculpt_paint/sculpt_filter_mesh.c      | 78 +++++++++++++++++++++-
 .../blender/editors/sculpt_paint/sculpt_intern.h   | 19 +++++-
 .../editors/sculpt_paint/sculpt_transform.c        |  2 +-
 5 files changed, 97 insertions(+), 6 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/sculpt_paint/sculpt_cloth.c b/source/blender/editors/sculpt_paint/sculpt_cloth.c
index 080124d2445..acfa04022cb 100644
--- a/source/blender/editors/sculpt_paint/sculpt_cloth.c
+++ b/source/blender/editors/sculpt_paint/sculpt_cloth.c
@@ -1219,7 +1219,7 @@ static int sculpt_cloth_filter_invoke(bContext *C, wmOperator *op, const wmEvent
   BKE_sculpt_update_object_for_edit(depsgraph, ob, true, true, false);
 
   SCULPT_undo_push_begin("Cloth filter");
-  SCULPT_filter_cache_init(ob, sd, SCULPT_UNDO_COORDS);
+  SCULPT_filter_cache_init(C, ob, sd, SCULPT_UNDO_COORDS);
 
   const float cloth_mass = RNA_float_get(op->ptr, "cloth_mass");
   const float cloth_damping = RNA_float_get(op->ptr, "cloth_damping");
diff --git a/source/blender/editors/sculpt_paint/sculpt_filter_color.c b/source/blender/editors/sculpt_paint/sculpt_filter_color.c
index 576536cac03..c5acf736f3e 100644
--- a/source/blender/editors/sculpt_paint/sculpt_filter_color.c
+++ b/source/blender/editors/sculpt_paint/sculpt_filter_color.c
@@ -289,7 +289,7 @@ static int sculpt_color_filter_invoke(bContext *C, wmOperator *op, const wmEvent
     return OPERATOR_CANCELLED;
   }
 
-  SCULPT_filter_cache_init(ob, sd, SCULPT_UNDO_COLOR);
+  SCULPT_filter_cache_init(C, ob, sd, SCULPT_UNDO_COLOR);
 
   WM_event_add_modal_handler(C, op);
   return OPERATOR_RUNNING_MODAL;
diff --git a/source/blender/editors/sculpt_paint/sculpt_filter_mesh.c b/source/blender/editors/sculpt_paint/sculpt_filter_mesh.c
index f9ae91fce7f..0da4297450f 100644
--- a/source/blender/editors/sculpt_paint/sculpt_filter_mesh.c
+++ b/source/blender/editors/sculpt_paint/sculpt_filter_mesh.c
@@ -50,6 +50,7 @@
 #include "ED_object.h"
 #include "ED_screen.h"
 #include "ED_sculpt.h"
+#include "ED_view3d.h"
 #include "paint_intern.h"
 #include "sculpt_intern.h"
 
@@ -63,6 +64,39 @@
 #include <math.h>
 #include <stdlib.h>
 
+/* Filter orientation utils. */
+void SCULPT_filter_to_orientation_space(float r_v[3], struct FilterCache *filter_cache)
+{
+  switch (filter_cache->orientation) {
+    case SCULPT_FILTER_ORIENTATION_LOCAL:
+      /* Do nothing, Sculpt Mode already works in object space. */
+      break;
+    case SCULPT_FILTER_ORIENTATION_WORLD:
+      mul_mat3_m4_v3(filter_cache->obmat, r_v);
+      break;
+    case SCULPT_FILTER_ORIENTATION_VIEW:
+      mul_mat3_m4_v3(filter_cache->obmat, r_v);
+      mul_mat3_m4_v3(filter_cache->viewmat, r_v);
+      break;
+  }
+}
+
+void SCULPT_filter_to_object_space(float r_v[3], struct FilterCache *filter_cache)
+{
+  switch (filter_cache->orientation) {
+    case SCULPT_FILTER_ORIENTATION_LOCAL:
+      /* Do nothing, Sculpt Mode already works in object space. */
+      break;
+    case SCULPT_FILTER_ORIENTATION_WORLD:
+      mul_mat3_m4_v3(filter_cache->obmat_inv, r_v);
+      break;
+    case SCULPT_FILTER_ORIENTATION_VIEW:
+      mul_mat3_m4_v3(filter_cache->viewmat_inv, r_v);
+      mul_mat3_m4_v3(filter_cache->obmat_inv, r_v);
+      break;
+  }
+}
+
 static void filter_cache_init_task_cb(void *__restrict userdata,
                                       const int i,
                                       const TaskParallelTLS *__restrict UNUSED(tls))
@@ -73,7 +107,7 @@ static void filter_cache_init_task_cb(void *__restrict userdata,
   SCULPT_undo_push_node(data->ob, node, data->filter_undo_type);
 }
 
-void SCULPT_filter_cache_init(Object *ob, Sculpt *sd, const int undo_type)
+void SCULPT_filter_cache_init(bContext *C, Object *ob, Sculpt *sd, const int undo_type)
 {
   SculptSession *ss = ob->sculpt;
   PBVH *pbvh = ob->sculpt->pbvh;
@@ -117,6 +151,16 @@ void SCULPT_filter_cache_init(Object *ob, Sculpt *sd, const int undo_type)
   BKE_pbvh_parallel_range_settings(&settings, true, ss->filter_cache->totnode);
   BLI_task_parallel_range(
       0, ss->filter_cache->totnode, &data, filter_cache_init_task_cb, &settings);
+
+  /* Setup orientation matrices. */
+  copy_m4_m4(ss->filter_cache->obmat, ob->obmat);
+  invert_m4_m4(ss->filter_cache->obmat_inv, ob->obmat);
+
+  Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
+  ViewContext vc;
+  ED_view3d_viewcontext_init(C, &vc, depsgraph);
+  copy_m4_m4(ss->filter_cache->viewmat, vc.rv3d->viewmat);
+  copy_m4_m4(ss->filter_cache->viewmat_inv, vc.rv3d->viewinv);
 }
 
 void SCULPT_filter_cache_free(SculptSession *ss)
@@ -182,6 +226,25 @@ static EnumPropertyItem prop_mesh_filter_deform_axis_items[] = {
     {0, NULL, 0, NULL, NULL},
 };
 
+static EnumPropertyItem prop_mesh_filter_orientation_items[] = {
+    {SCULPT_FILTER_ORIENTATION_LOCAL,
+     "LOCAL",
+     0,
+     "Local",
+     "Use the local axis to limit the displacement"},
+    {SCULPT_FILTER_ORIENTATION_WORLD,
+     "WORLD",
+     0,
+     "World",
+     "Use the global axis to limit the displacement"},
+    {SCULPT_FILTER_ORIENTATION_VIEW,
+     "VIEW",
+     0,
+     "View",
+     "Use the view axis to limit the displacement"},
+    {0, NULL, 0, NULL, NULL},
+};
+
 static bool sculpt_mesh_filter_needs_pmap(int filter_type, bool use_face_sets)
 {
   return use_face_sets || ELEM(filter_type,
@@ -372,11 +435,13 @@ static void mesh_filter_task_cb(void *__restrict userdata,
       }
     }
 
+    SCULPT_filter_to_orientation_space(disp, ss->filter_cache);
     for (int it = 0; it < 3; it++) {
       if (!ss->filter_cache->enabled_axis[it]) {
         disp[it] = 0.0f;
       }
     }
+    SCULPT_filter_to_object_space(disp, ss->filter_cache);
 
     if (ELEM(filter_type, MESH_FILTER_SURFACE_SMOOTH, MESH_FILTER_SHARPEN)) {
       madd_v3_v3v3fl(final_pos, vd.co, disp, clamp_f(fade, 0.0f, 1.0f));
@@ -584,7 +649,7 @@ static int sculpt_mesh_filter_invoke(bContext *C, wmOperator *op, const wmEvent
     SCULPT_boundary_info_ensure(ob);
   }
 
-  SCULPT_filter_cache_init(ob, sd, SCULPT_UNDO_COORDS);
+  SCULPT_filter_cache_init(C, ob, sd, SCULPT_UNDO_COORDS);
 
   if (use_face_sets) {
     ss->filter_cache->active_face_set = SCULPT_active_face_set_get(ss);
@@ -620,6 +685,9 @@ static int sculpt_mesh_filter_invoke(bContext *C, wmOperator *op, const wmEvent
   ss->filter_cache->enabled_axis[1] = deform_axis & MESH_FILTER_DEFORM_Y;
   ss->filter_cache->enabled_axis[2] = deform_axis & MESH_FILTER_DEFORM_Z;
 
+  SculptFilterOrientation orientation = RNA_enum_get(op->ptr, "orientation");
+  ss->filter_cache->orientation = orientation;
+
   WM_event_add_modal_handler(C, op);
   return OPERATOR_RUNNING_MODAL;
 }
@@ -653,6 +721,12 @@ void SCULPT_OT_mesh_filter(struct wmOperatorType *ot)
                     MESH_FILTER_DEFORM_X | MESH_FILTER_DEFORM_Y | MESH_FILTER_DEFORM_Z,
                     "Deform axis",
                     "Apply the deformation in the selected axis");
+  RNA_def_enum(ot->srna,
+               "orientation",
+               prop_mesh_filter_orientation_items,
+               SCULPT_FILTER_ORIENTATION_LOCAL,
+               "Orientation",
+               "Orientation of the axis to limit the filter displacement");
   ot->prop = RNA_def_boolean(ot->srna,
                              "use_face_sets",
                              false,
diff --git a/source/blender/editors/sculpt_paint/sculpt_intern.h b/source/blender/editors/sculpt_paint/sculpt_intern.h
index 14928ba933a..65006031bb3 100644
--- a/source/blender/editors/sculpt_paint/sculpt_intern.h
+++ b/source/blender/editors/sculpt_paint/sculpt_intern.h
@@ -337,7 +337,7 @@ float *SCULPT_boundary_automasking_init(Object *ob,
                                         float *automask_factor);
 
 /* Filters. */
-void SCULPT_filter_cache_init(Object *ob, Sculpt *sd, const int undo_type);
+void SCULPT_filter_cache_init(struct bContext *C, Object *ob, Sculpt *sd, const int undo_type);
 void SCULPT_filter_cache_free(SculptSession *ss);
 
 void SCULPT_mask_filter_smooth_apply(
@@ -944,6 +944,16 @@ typedef struct StrokeCache {
 
 } StrokeCache;
 
+/* Sculpt Filters */
+typedef enum SculptFilterOrientation {
+  SCULPT_FILTER_ORIENTATION_LOCAL = 0,
+  SCULPT_FILTER_ORIENTATION_WORLD = 1,
+  SCULPT_FILTER_ORIENTATION_VIEW = 2,
+} SculptFilterOrientation;
+
+void SCULPT_filter_to_orientation_space(float r_v[3], struct FilterCache *filter_cache);
+void SCULPT_filter_to_object_space(float r_v[3], struct FilterCache *filter_cache);
+
 typedef struct FilterCache {
   bool enabled_axis[3];
   bool enabled_force_axis[3];
@@ -965,6 +975,13 @@ typedef struct FilterCache {
   float *sharpen_factor;
   float (*sharpen_detail_directions)[3];
 
+  /* Filter orientaiton. */
+  SculptFilterOrientation orientation;
+  float obmat[4][4];
+  float obmat_inv[4][4];
+  float viewmat[4][4];
+  float viewmat_inv[4][4];
+
   /* unmasked nodes */
   PBVHNode **nodes;
   int totnode;
diff --git a/source/blender/editors/sculpt_paint/sculpt_transform.c b/source/blender/editors/sculpt_paint/sculpt_transform.c
index 4c54a0465b9..bdada4d2565 100644
--- a/source/blender/editors/sculpt_paint/sculpt_transform.c
+++ b/source/blender/editors/sculpt_paint/sculpt_transform.c
@@ -76,7 +76,7 @@ void ED_sculpt_init_transform(struct bContext *C)
   ss->pivot_rot[3] = 1.0f;
 
   SCULPT_vertex_random_access_ensure(ss);
-  SCULPT_filter_cache_init(ob, sd, SCULPT_UNDO_COORDS);
+  SCULPT_filter_cache_init(C, ob, sd, SCULPT_UNDO_COORDS);
 }
 
 static void sculpt_transform_task_cb(void *__restrict userdata,
-- 
cgit v1.2.3


From 63998d352256f2ab747e9e072cb77ea1df39d297 Mon Sep 17 00:00:00 2001
From: Jacques Lucke <jacques@blender.org>
Date: Tue, 18 Aug 2020 15:32:25 +0200
Subject: Cleanup: remove unused TimeSourceNode->offset

---
 source/blender/depsgraph/intern/node/deg_node_time.h | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'source')

diff --git a/source/blender/depsgraph/intern/node/deg_node_time.h b/source/blender/depsgraph/intern/node/deg_node_time.h
index 364c214b014..172a3873301 100644
--- a/source/blender/depsgraph/intern/node/deg_node_time.h
+++ b/source/blender/depsgraph/intern/node/deg_node_time.h
@@ -33,9 +33,6 @@ struct TimeSourceNode : public Node {
   /* New "current time". */
   float cfra;
 
-  /* time-offset relative to the "official" time source that this one has. */
-  float offset;
-
   // TODO: evaluate() operation needed
 
   virtual void tag_update(Depsgraph *graph, eUpdateSource source) override;
-- 
cgit v1.2.3


From 2e908156d0c744e526e165b386c61a0a4d0e8ed0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= <foucault.clem@gmail.com>
Date: Tue, 18 Aug 2020 14:43:18 +0200
Subject: Fix T77564: VSE (and compositor background) lost stereoscopy preview

Issue introduced on fe045b2b77dc6d7f0b552619fe824b496d34db6c.

Since the stereoscopy compositing (anaglyph, ...) is only done for
viewports the VSE preview and compositor need to use viewports.

Reviewed by: dfelinto

Differential Revision: https://developer.blender.org/D8472
---
 source/blender/editors/space_node/node_draw.c           |  7 +++++++
 source/blender/editors/space_sequencer/sequencer_draw.c | 12 +++++++++++-
 source/blender/gpu/GPU_framebuffer.h                    |  1 +
 source/blender/gpu/intern/gpu_framebuffer.cc            | 12 ++++++++++++
 source/blender/windowmanager/intern/wm_draw.c           |  4 +++-
 5 files changed, 34 insertions(+), 2 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/space_node/node_draw.c b/source/blender/editors/space_node/node_draw.c
index 9d048bf7c3c..df1a24eb71a 100644
--- a/source/blender/editors/space_node/node_draw.c
+++ b/source/blender/editors/space_node/node_draw.c
@@ -52,6 +52,7 @@
 #include "GPU_immediate_util.h"
 #include "GPU_matrix.h"
 #include "GPU_state.h"
+#include "GPU_viewport.h"
 
 #include "WM_api.h"
 #include "WM_types.h"
@@ -1755,6 +1756,12 @@ void drawnodespace(const bContext *C, ARegion *region)
   SpaceNode *snode = CTX_wm_space_node(C);
   View2D *v2d = &region->v2d;
 
+  /* Setup offscreen buffers. */
+  GPUViewport *viewport = WM_draw_region_get_viewport(region);
+
+  GPUFrameBuffer *framebuffer_overlay = GPU_viewport_framebuffer_overlay_get(viewport);
+  GPU_framebuffer_bind_no_srgb(framebuffer_overlay);
+
   UI_ThemeClearColor(TH_BACK);
   GPU_clear(GPU_COLOR_BIT);
 
diff --git a/source/blender/editors/space_sequencer/sequencer_draw.c b/source/blender/editors/space_sequencer/sequencer_draw.c
index 0f4690c11d5..b784104e9ce 100644
--- a/source/blender/editors/space_sequencer/sequencer_draw.c
+++ b/source/blender/editors/space_sequencer/sequencer_draw.c
@@ -56,6 +56,7 @@
 #include "GPU_matrix.h"
 #include "GPU_state.h"
 #include "GPU_vertex_buffer.h"
+#include "GPU_viewport.h"
 
 #include "ED_anim_api.h"
 #include "ED_gpencil.h"
@@ -1537,7 +1538,7 @@ static void sequencer_preview_clear(void)
   float col[3];
 
   UI_GetThemeColor3fv(TH_SEQ_PREVIEW, col);
-  GPU_clear_color(col[0], col[1], col[2], 0.0);
+  GPU_clear_color(col[0], col[1], col[2], 1.0f);
   GPU_clear(GPU_COLOR_BIT);
 }
 
@@ -1780,6 +1781,12 @@ void sequencer_draw_preview(const bContext *C,
     return;
   }
 
+  /* Setup offscreen buffers. */
+  GPUViewport *viewport = WM_draw_region_get_viewport(region);
+
+  GPUFrameBuffer *framebuffer_overlay = GPU_viewport_framebuffer_overlay_get(viewport);
+  GPU_framebuffer_bind_no_srgb(framebuffer_overlay);
+
   /* Setup view. */
   sequencer_display_size(scene, viewrect);
   UI_view2d_totRect_set(v2d, viewrect[0] + 0.5f, viewrect[1] + 0.5f);
@@ -1798,6 +1805,9 @@ void sequencer_draw_preview(const bContext *C,
   ibuf = sequencer_ibuf_get(
       bmain, depsgraph, scene, sseq, cfra, frame_ofs, names[sseq->multiview_eye]);
 
+  /* sequencer_ibuf_get can call GPU_framebuffer_bind. So disable srgb framebuffer again. */
+  GPU_framebuffer_bind_no_srgb(framebuffer_overlay);
+
   if (ibuf) {
     scope = sequencer_get_scope(scene, sseq, ibuf, draw_backdrop);
 
diff --git a/source/blender/gpu/GPU_framebuffer.h b/source/blender/gpu/GPU_framebuffer.h
index 9dc07fefd4e..7103317e4d6 100644
--- a/source/blender/gpu/GPU_framebuffer.h
+++ b/source/blender/gpu/GPU_framebuffer.h
@@ -61,6 +61,7 @@ typedef struct GPUOffScreen GPUOffScreen;
 GPUFrameBuffer *GPU_framebuffer_create(void);
 void GPU_framebuffer_free(GPUFrameBuffer *fb);
 void GPU_framebuffer_bind(GPUFrameBuffer *fb);
+void GPU_framebuffer_bind_no_srgb(GPUFrameBuffer *fb);
 void GPU_framebuffer_restore(void);
 
 bool GPU_framebuffer_bound(GPUFrameBuffer *fb);
diff --git a/source/blender/gpu/intern/gpu_framebuffer.cc b/source/blender/gpu/intern/gpu_framebuffer.cc
index 5f3089b2ffb..627f417e0c3 100644
--- a/source/blender/gpu/intern/gpu_framebuffer.cc
+++ b/source/blender/gpu/intern/gpu_framebuffer.cc
@@ -555,6 +555,18 @@ void GPU_framebuffer_bind(GPUFrameBuffer *fb)
   glViewport(0, 0, fb->width, fb->height);
 }
 
+/* Workaround for binding a srgb framebuffer without doing the srgb transform. */
+void GPU_framebuffer_bind_no_srgb(GPUFrameBuffer *fb)
+{
+  GPU_framebuffer_bind(fb);
+
+  glDisable(GL_FRAMEBUFFER_SRGB);
+
+  GPUTexture *first_target = fb->attachments[GPU_FB_COLOR_ATTACHMENT0].tex;
+  const bool is_srgb_target = (first_target && (GPU_texture_format(first_target) == GPU_SRGB8_A8));
+  GPU_shader_set_framebuffer_srgb_target(!is_srgb_target);
+}
+
 void GPU_framebuffer_restore(void)
 {
   if (GPU_framebuffer_active_get() != NULL) {
diff --git a/source/blender/windowmanager/intern/wm_draw.c b/source/blender/windowmanager/intern/wm_draw.c
index b8cb5432a49..bfc155dce16 100644
--- a/source/blender/windowmanager/intern/wm_draw.c
+++ b/source/blender/windowmanager/intern/wm_draw.c
@@ -307,7 +307,9 @@ static void wm_region_test_xr_do_draw(const wmWindowManager *wm,
 
 static bool wm_region_use_viewport_by_type(short space_type, short region_type)
 {
-  return (ELEM(space_type, SPACE_VIEW3D, SPACE_IMAGE) && region_type == RGN_TYPE_WINDOW);
+  return (ELEM(space_type, SPACE_VIEW3D, SPACE_IMAGE, SPACE_NODE) &&
+          region_type == RGN_TYPE_WINDOW) ||
+         ((space_type == SPACE_SEQ) && region_type == RGN_TYPE_PREVIEW);
 }
 
 bool WM_region_use_viewport(ScrArea *area, ARegion *region)
-- 
cgit v1.2.3


From 2922f9b83d499f13cf77283677103e4efde0b5cf Mon Sep 17 00:00:00 2001
From: Jacques Lucke <jacques@blender.org>
Date: Tue, 18 Aug 2020 15:40:15 +0200
Subject: Cleanup: remove TimeSourceNode->cfra which is never read

---
 source/blender/depsgraph/intern/depsgraph_eval.cc    | 4 ----
 source/blender/depsgraph/intern/node/deg_node_time.h | 3 ---
 2 files changed, 7 deletions(-)

(limited to 'source')

diff --git a/source/blender/depsgraph/intern/depsgraph_eval.cc b/source/blender/depsgraph/intern/depsgraph_eval.cc
index 8a641f23a42..a11594a019c 100644
--- a/source/blender/depsgraph/intern/depsgraph_eval.cc
+++ b/source/blender/depsgraph/intern/depsgraph_eval.cc
@@ -53,8 +53,6 @@ void DEG_evaluate_on_refresh(Main *bmain, Depsgraph *graph)
   deg::Depsgraph *deg_graph = reinterpret_cast<deg::Depsgraph *>(graph);
   deg_graph->ctime = BKE_scene_frame_get(deg_graph->scene);
   /* Update time on primary timesource. */
-  deg::TimeSourceNode *tsrc = deg_graph->find_time_source();
-  tsrc->cfra = deg_graph->ctime;
   /* Update time in scene. */
   if (deg_graph->scene_cow) {
     BKE_scene_frame_set(deg_graph->scene_cow, deg_graph->ctime);
@@ -70,8 +68,6 @@ void DEG_evaluate_on_framechange(Main *bmain, Depsgraph *graph, float ctime)
   deg::Depsgraph *deg_graph = reinterpret_cast<deg::Depsgraph *>(graph);
   deg_graph->ctime = ctime;
   /* Update time on primary timesource. */
-  deg::TimeSourceNode *tsrc = deg_graph->find_time_source();
-  tsrc->cfra = ctime;
   deg_graph->need_update_time = true;
   deg::deg_graph_flush_updates(bmain, deg_graph);
   /* Update time in scene. */
diff --git a/source/blender/depsgraph/intern/node/deg_node_time.h b/source/blender/depsgraph/intern/node/deg_node_time.h
index 172a3873301..fe17684abb0 100644
--- a/source/blender/depsgraph/intern/node/deg_node_time.h
+++ b/source/blender/depsgraph/intern/node/deg_node_time.h
@@ -30,9 +30,6 @@ namespace deg {
 
 /* Time Source Node. */
 struct TimeSourceNode : public Node {
-  /* New "current time". */
-  float cfra;
-
   // TODO: evaluate() operation needed
 
   virtual void tag_update(Depsgraph *graph, eUpdateSource source) override;
-- 
cgit v1.2.3


From f653a4f34997adbb856db0aad49ffe72111603e4 Mon Sep 17 00:00:00 2001
From: Jacques Lucke <jacques@blender.org>
Date: Tue, 18 Aug 2020 15:41:26 +0200
Subject: Cleanup: remove outdated comments

---
 source/blender/depsgraph/intern/depsgraph_eval.cc | 2 --
 1 file changed, 2 deletions(-)

(limited to 'source')

diff --git a/source/blender/depsgraph/intern/depsgraph_eval.cc b/source/blender/depsgraph/intern/depsgraph_eval.cc
index a11594a019c..b4c93fb12af 100644
--- a/source/blender/depsgraph/intern/depsgraph_eval.cc
+++ b/source/blender/depsgraph/intern/depsgraph_eval.cc
@@ -52,7 +52,6 @@ void DEG_evaluate_on_refresh(Main *bmain, Depsgraph *graph)
 {
   deg::Depsgraph *deg_graph = reinterpret_cast<deg::Depsgraph *>(graph);
   deg_graph->ctime = BKE_scene_frame_get(deg_graph->scene);
-  /* Update time on primary timesource. */
   /* Update time in scene. */
   if (deg_graph->scene_cow) {
     BKE_scene_frame_set(deg_graph->scene_cow, deg_graph->ctime);
@@ -67,7 +66,6 @@ void DEG_evaluate_on_framechange(Main *bmain, Depsgraph *graph, float ctime)
 {
   deg::Depsgraph *deg_graph = reinterpret_cast<deg::Depsgraph *>(graph);
   deg_graph->ctime = ctime;
-  /* Update time on primary timesource. */
   deg_graph->need_update_time = true;
   deg::deg_graph_flush_updates(bmain, deg_graph);
   /* Update time in scene. */
-- 
cgit v1.2.3


From d9f7cbb8af07b27d3825453a036557a0e0dab37b Mon Sep 17 00:00:00 2001
From: Jacques Lucke <jacques@blender.org>
Date: Tue, 18 Aug 2020 15:45:58 +0200
Subject: Cleanup: remove bmain argument from
 BKE_scene_graph_update_for_newframe

Reviewers: sergey

Differential Revision: https://developer.blender.org/D8613
---
 source/blender/blenkernel/BKE_scene.h                          |  2 +-
 source/blender/blenkernel/intern/pointcache.c                  |  5 ++---
 source/blender/blenkernel/intern/scene.c                       |  3 ++-
 source/blender/blenkernel/intern/sequencer.c                   |  4 ++--
 source/blender/depsgraph/DEG_depsgraph_query.h                 |  3 +++
 source/blender/depsgraph/intern/depsgraph_query.cc             |  6 ++++++
 source/blender/editors/animation/anim_motion_paths.c           | 10 +++++-----
 source/blender/editors/gpencil/gpencil_edit.c                  |  5 ++---
 source/blender/editors/gpencil/gpencil_mesh.c                  |  4 ++--
 source/blender/editors/render/render_opengl.c                  |  8 +++-----
 source/blender/editors/screen/screen_edit.c                    |  2 +-
 source/blender/editors/sound/sound_ops.c                       |  5 ++---
 .../freestyle/intern/blender_interface/FRS_freestyle.cpp       |  2 +-
 source/blender/gpencil_modifiers/intern/MOD_gpencilarmature.c  |  9 ++++++---
 source/blender/gpencil_modifiers/intern/MOD_gpencilhook.c      |  9 ++++++---
 source/blender/gpencil_modifiers/intern/MOD_gpencillattice.c   |  9 ++++++---
 source/blender/gpencil_modifiers/intern/MOD_gpencilmirror.c    |  9 ++++++---
 source/blender/gpencil_modifiers/intern/MOD_gpenciltint.c      |  9 ++++++---
 source/blender/io/alembic/exporter/abc_export_capi.cc          |  4 ++--
 source/blender/io/usd/intern/usd_capi.cc                       |  4 ++--
 source/blender/makesrna/intern/rna_scene_api.c                 |  2 +-
 source/blender/render/intern/source/external_engine.c          |  4 ++--
 source/blender/windowmanager/intern/wm_operators.c             |  8 +++-----
 23 files changed, 72 insertions(+), 54 deletions(-)

(limited to 'source')

diff --git a/source/blender/blenkernel/BKE_scene.h b/source/blender/blenkernel/BKE_scene.h
index 8cd86593873..e3bd57e75e3 100644
--- a/source/blender/blenkernel/BKE_scene.h
+++ b/source/blender/blenkernel/BKE_scene.h
@@ -145,7 +145,7 @@ void BKE_scene_update_tag_audio_volume(struct Depsgraph *, struct Scene *scene);
 void BKE_scene_graph_update_tagged(struct Depsgraph *depsgraph, struct Main *bmain);
 void BKE_scene_graph_evaluated_ensure(struct Depsgraph *depsgraph, struct Main *bmain);
 
-void BKE_scene_graph_update_for_newframe(struct Depsgraph *depsgraph, struct Main *bmain);
+void BKE_scene_graph_update_for_newframe(struct Depsgraph *depsgraph);
 
 void BKE_scene_view_layer_graph_evaluated_ensure(struct Main *bmain,
                                                  struct Scene *scene,
diff --git a/source/blender/blenkernel/intern/pointcache.c b/source/blender/blenkernel/intern/pointcache.c
index 64e642462af..8c5915d3768 100644
--- a/source/blender/blenkernel/intern/pointcache.c
+++ b/source/blender/blenkernel/intern/pointcache.c
@@ -4025,7 +4025,6 @@ static void ptcache_dt_to_str(char *str, double dtime)
 /* if bake is not given run simulations to current frame */
 void BKE_ptcache_bake(PTCacheBaker *baker)
 {
-  Main *bmain = baker->bmain;
   Scene *scene = baker->scene;
   ViewLayer *view_layer = baker->view_layer;
   struct Depsgraph *depsgraph = baker->depsgraph;
@@ -4156,7 +4155,7 @@ void BKE_ptcache_bake(PTCacheBaker *baker)
   stime = ptime = PIL_check_seconds_timer();
 
   for (int fr = CFRA; fr <= endframe; fr += baker->quick_step, CFRA = fr) {
-    BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
 
     if (baker->update_progress) {
       float progress = ((float)(CFRA - startframe) / (float)(endframe - startframe));
@@ -4255,7 +4254,7 @@ void BKE_ptcache_bake(PTCacheBaker *baker)
   CFRA = cfrao;
 
   if (bake) { /* already on cfra unless baking */
-    BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
   }
 
   /* TODO: call redraw all windows somehow */
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index 7e25e8c96ae..f95ee27ed58 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -1541,10 +1541,11 @@ void BKE_scene_graph_evaluated_ensure(Depsgraph *depsgraph, Main *bmain)
 }
 
 /* applies changes right away, does all sets too */
-void BKE_scene_graph_update_for_newframe(Depsgraph *depsgraph, Main *bmain)
+void BKE_scene_graph_update_for_newframe(Depsgraph *depsgraph)
 {
   Scene *scene = DEG_get_input_scene(depsgraph);
   ViewLayer *view_layer = DEG_get_input_view_layer(depsgraph);
+  Main *bmain = DEG_get_bmain(depsgraph);
 
   /* Keep this first. */
   BKE_callback_exec_id(bmain, &scene->id, BKE_CB_EVT_FRAME_CHANGE_PRE);
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index a2a45ae56b3..b4da0c5bd33 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -3593,7 +3593,7 @@ static ImBuf *seq_render_scene_strip(const SeqRenderData *context,
 
     /* opengl offscreen render */
     depsgraph = BKE_scene_get_depsgraph(context->bmain, scene, view_layer, true);
-    BKE_scene_graph_update_for_newframe(depsgraph, context->bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
     ibuf = sequencer_view3d_fn(
         /* set for OpenGL render (NULL when scrubbing) */
         depsgraph,
@@ -3695,7 +3695,7 @@ finally:
   scene->r.subframe = orig_data.subframe;
 
   if (is_frame_update && (depsgraph != NULL)) {
-    BKE_scene_graph_update_for_newframe(depsgraph, context->bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
   }
 
 #ifdef DURIAN_CAMERA_SWITCH
diff --git a/source/blender/depsgraph/DEG_depsgraph_query.h b/source/blender/depsgraph/DEG_depsgraph_query.h
index e0166a13d69..7eb5f1ccec1 100644
--- a/source/blender/depsgraph/DEG_depsgraph_query.h
+++ b/source/blender/depsgraph/DEG_depsgraph_query.h
@@ -55,6 +55,9 @@ struct Scene *DEG_get_input_scene(const Depsgraph *graph);
 /* Get view layer that depsgraph was built for. */
 struct ViewLayer *DEG_get_input_view_layer(const Depsgraph *graph);
 
+/* Get bmain that depsgraph was built for. */
+struct Main *DEG_get_bmain(const Depsgraph *graph);
+
 /* Get evaluation mode that depsgraph was built for. */
 eEvaluationMode DEG_get_mode(const Depsgraph *graph);
 
diff --git a/source/blender/depsgraph/intern/depsgraph_query.cc b/source/blender/depsgraph/intern/depsgraph_query.cc
index 0b6014c18f1..fc9ed9a6ab9 100644
--- a/source/blender/depsgraph/intern/depsgraph_query.cc
+++ b/source/blender/depsgraph/intern/depsgraph_query.cc
@@ -61,6 +61,12 @@ struct ViewLayer *DEG_get_input_view_layer(const Depsgraph *graph)
   return deg_graph->view_layer;
 }
 
+struct Main *DEG_get_bmain(const Depsgraph *graph)
+{
+  const deg::Depsgraph *deg_graph = reinterpret_cast<const deg::Depsgraph *>(graph);
+  return deg_graph->bmain;
+}
+
 eEvaluationMode DEG_get_mode(const Depsgraph *graph)
 {
   const deg::Depsgraph *deg_graph = reinterpret_cast<const deg::Depsgraph *>(graph);
diff --git a/source/blender/editors/animation/anim_motion_paths.c b/source/blender/editors/animation/anim_motion_paths.c
index 4c10c66dfa6..eb3bdf43a3c 100644
--- a/source/blender/editors/animation/anim_motion_paths.c
+++ b/source/blender/editors/animation/anim_motion_paths.c
@@ -69,9 +69,9 @@ typedef struct MPathTarget {
 /* ........ */
 
 /* update scene for current frame */
-static void motionpaths_calc_update_scene(Main *bmain, struct Depsgraph *depsgraph)
+static void motionpaths_calc_update_scene(struct Depsgraph *depsgraph)
 {
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 }
 
 Depsgraph *animviz_depsgraph_build(Main *bmain,
@@ -95,7 +95,7 @@ Depsgraph *animviz_depsgraph_build(Main *bmain,
   MEM_freeN(ids);
 
   /* Update once so we can access pointers of evaluated animation data. */
-  motionpaths_calc_update_scene(bmain, depsgraph);
+  motionpaths_calc_update_scene(depsgraph);
   return depsgraph;
 }
 
@@ -471,7 +471,7 @@ void animviz_calc_motionpaths(Depsgraph *depsgraph,
     }
     else {
       /* Update relevant data for new frame. */
-      motionpaths_calc_update_scene(bmain, depsgraph);
+      motionpaths_calc_update_scene(depsgraph);
     }
 
     /* perform baking for targets */
@@ -484,7 +484,7 @@ void animviz_calc_motionpaths(Depsgraph *depsgraph,
    * We always have to restore the current frame though. */
   CFRA = cfra;
   if (range != ANIMVIZ_CALC_RANGE_CURRENT_FRAME && restore) {
-    motionpaths_calc_update_scene(bmain, depsgraph);
+    motionpaths_calc_update_scene(depsgraph);
   }
 
   if (is_active_depsgraph) {
diff --git a/source/blender/editors/gpencil/gpencil_edit.c b/source/blender/editors/gpencil/gpencil_edit.c
index 99e98df3397..1bbba6c4b8a 100644
--- a/source/blender/editors/gpencil/gpencil_edit.c
+++ b/source/blender/editors/gpencil/gpencil_edit.c
@@ -3645,7 +3645,6 @@ static int gpencil_strokes_reproject_exec(bContext *C, wmOperator *op)
 {
   bGPdata *gpd = ED_gpencil_data_get_active(C);
   Scene *scene = CTX_data_scene(C);
-  Main *bmain = CTX_data_main(C);
   Depsgraph *depsgraph = CTX_data_ensure_evaluated_depsgraph(C);
   ARegion *region = CTX_wm_region(C);
   int oldframe = (int)DEG_get_ctime(depsgraph);
@@ -3669,7 +3668,7 @@ static int gpencil_strokes_reproject_exec(bContext *C, wmOperator *op)
       if ((mode == GP_REPROJECT_SURFACE) && (cfra_prv != gpf_->framenum)) {
         cfra_prv = gpf_->framenum;
         CFRA = gpf_->framenum;
-        BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+        BKE_scene_graph_update_for_newframe(depsgraph);
       }
 
       ED_gpencil_stroke_reproject(depsgraph, &gsc, sctx, gpl, gpf_, gps, mode, keep_original);
@@ -3679,7 +3678,7 @@ static int gpencil_strokes_reproject_exec(bContext *C, wmOperator *op)
 
   /* return frame state and DB to original state */
   CFRA = oldframe;
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 
   if (sctx != NULL) {
     ED_transform_snap_object_context_destroy(sctx);
diff --git a/source/blender/editors/gpencil/gpencil_mesh.c b/source/blender/editors/gpencil/gpencil_mesh.c
index a6088e31ff8..f4e40c2670f 100644
--- a/source/blender/editors/gpencil/gpencil_mesh.c
+++ b/source/blender/editors/gpencil/gpencil_mesh.c
@@ -246,7 +246,7 @@ static int gpencil_bake_mesh_animation_exec(bContext *C, wmOperator *op)
 
     /* Move scene to new frame. */
     CFRA = i;
-    BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
 
     /* Loop all objects in the list. */
     LISTBASE_FOREACH (GpBakeOb *, elem, &list) {
@@ -287,7 +287,7 @@ static int gpencil_bake_mesh_animation_exec(bContext *C, wmOperator *op)
 
   /* Return scene frame state and DB to original state. */
   CFRA = oldframe;
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 
   /* Remove unused materials. */
   int actcol = ob_gpencil->actcol;
diff --git a/source/blender/editors/render/render_opengl.c b/source/blender/editors/render/render_opengl.c
index f75dd428968..52a7b92217b 100644
--- a/source/blender/editors/render/render_opengl.c
+++ b/source/blender/editors/render/render_opengl.c
@@ -879,7 +879,6 @@ static bool screen_opengl_render_init(bContext *C, wmOperator *op)
 
 static void screen_opengl_render_end(bContext *C, OGLRender *oglrender)
 {
-  Main *bmain = CTX_data_main(C);
   Scene *scene = oglrender->scene;
   int i;
 
@@ -929,7 +928,7 @@ static void screen_opengl_render_end(bContext *C, OGLRender *oglrender)
   if (oglrender->timer) { /* exec will not have a timer */
     Depsgraph *depsgraph = oglrender->depsgraph;
     scene->r.cfra = oglrender->cfrao;
-    BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
 
     WM_event_remove_timer(oglrender->wm, oglrender->win, oglrender->timer);
   }
@@ -1119,7 +1118,6 @@ static bool schedule_write_result(OGLRender *oglrender, RenderResult *rr)
 
 static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op)
 {
-  Main *bmain = CTX_data_main(C);
   OGLRender *oglrender = op->customdata;
   Scene *scene = oglrender->scene;
   Depsgraph *depsgraph = oglrender->depsgraph;
@@ -1134,7 +1132,7 @@ static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op)
     CFRA++;
   }
   while (CFRA < oglrender->nfra) {
-    BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
     CFRA++;
   }
 
@@ -1161,7 +1159,7 @@ static bool screen_opengl_render_anim_step(bContext *C, wmOperator *op)
 
   WM_cursor_time(oglrender->win, scene->r.cfra);
 
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 
   if (view_context) {
     if (oglrender->rv3d->persp == RV3D_CAMOB && oglrender->v3d->camera &&
diff --git a/source/blender/editors/screen/screen_edit.c b/source/blender/editors/screen/screen_edit.c
index 06e800433b1..dbf84cad80b 100644
--- a/source/blender/editors/screen/screen_edit.c
+++ b/source/blender/editors/screen/screen_edit.c
@@ -1594,7 +1594,7 @@ void ED_update_for_newframe(Main *bmain, Depsgraph *depsgraph)
   ED_clip_update_frame(bmain, scene->r.cfra);
 
   /* this function applies the changes too */
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 }
 
 /*
diff --git a/source/blender/editors/sound/sound_ops.c b/source/blender/editors/sound/sound_ops.c
index 050dca07c34..e8eddc014db 100644
--- a/source/blender/editors/sound/sound_ops.c
+++ b/source/blender/editors/sound/sound_ops.c
@@ -306,7 +306,6 @@ static void SOUND_OT_update_animation_flags(wmOperatorType *ot)
 
 static int sound_bake_animation_exec(bContext *C, wmOperator *UNUSED(op))
 {
-  Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
   /* NOTE: We will be forcefully evaluating dependency graph at every frame, so no need to ensure
    * current scene state is evaluated as it will be lost anyway. */
@@ -318,11 +317,11 @@ static int sound_bake_animation_exec(bContext *C, wmOperator *UNUSED(op))
 
   for (cfra = (scene->r.sfra > 0) ? (scene->r.sfra - 1) : 0; cfra <= scene->r.efra + 1; cfra++) {
     scene->r.cfra = cfra;
-    BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
   }
 
   scene->r.cfra = oldfra;
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 
   return OPERATOR_FINISHED;
 }
diff --git a/source/blender/freestyle/intern/blender_interface/FRS_freestyle.cpp b/source/blender/freestyle/intern/blender_interface/FRS_freestyle.cpp
index 388c2f35774..2446bfc13dc 100644
--- a/source/blender/freestyle/intern/blender_interface/FRS_freestyle.cpp
+++ b/source/blender/freestyle/intern/blender_interface/FRS_freestyle.cpp
@@ -655,7 +655,7 @@ void FRS_do_stroke_rendering(Render *re, ViewLayer *view_layer)
   ViewLayer *scene_view_layer = (ViewLayer *)BLI_findstring(
       &re->scene->view_layers, view_layer->name, offsetof(ViewLayer, name));
   Depsgraph *depsgraph = DEG_graph_new(re->main, re->scene, scene_view_layer, DAG_EVAL_RENDER);
-  BKE_scene_graph_update_for_newframe(depsgraph, re->main);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 
   // prepare Freestyle:
   //   - load mesh
diff --git a/source/blender/gpencil_modifiers/intern/MOD_gpencilarmature.c b/source/blender/gpencil_modifiers/intern/MOD_gpencilarmature.c
index 60c3877b89a..41365da1153 100644
--- a/source/blender/gpencil_modifiers/intern/MOD_gpencilarmature.c
+++ b/source/blender/gpencil_modifiers/intern/MOD_gpencilarmature.c
@@ -128,7 +128,10 @@ static void deformStroke(GpencilModifierData *md,
   BKE_gpencil_stroke_geometry_update(gps);
 }
 
-static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData *md, Object *ob)
+static void bakeModifier(Main *UNUSED(bmain),
+                         Depsgraph *depsgraph,
+                         GpencilModifierData *md,
+                         Object *ob)
 {
   Scene *scene = DEG_get_evaluated_scene(depsgraph);
   Object *object_eval = DEG_get_evaluated_object(depsgraph, ob);
@@ -147,7 +150,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
        * NOTE: this assumes that we don't want armature animation on non-keyframed frames
        */
       CFRA = gpf->framenum;
-      BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+      BKE_scene_graph_update_for_newframe(depsgraph);
 
       /* compute armature effects on this frame */
       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
@@ -158,7 +161,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
 
   /* return frame state and DB to original state */
   CFRA = oldframe;
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 }
 
 static bool isDisabled(GpencilModifierData *md, int UNUSED(userRenderParams))
diff --git a/source/blender/gpencil_modifiers/intern/MOD_gpencilhook.c b/source/blender/gpencil_modifiers/intern/MOD_gpencilhook.c
index 30ac18c64ae..1608d7a2d4c 100644
--- a/source/blender/gpencil_modifiers/intern/MOD_gpencilhook.c
+++ b/source/blender/gpencil_modifiers/intern/MOD_gpencilhook.c
@@ -280,7 +280,10 @@ static void deformStroke(GpencilModifierData *md,
 /* FIXME: Ideally we be doing this on a copy of the main depsgraph
  * (i.e. one where we don't have to worry about restoring state)
  */
-static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData *md, Object *ob)
+static void bakeModifier(Main *UNUSED(bmain),
+                         Depsgraph *depsgraph,
+                         GpencilModifierData *md,
+                         Object *ob)
 {
   HookGpencilModifierData *mmd = (HookGpencilModifierData *)md;
   Scene *scene = DEG_get_evaluated_scene(depsgraph);
@@ -297,7 +300,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
        * NOTE: this assumes that we don't want hook animation on non-keyframed frames
        */
       CFRA = gpf->framenum;
-      BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+      BKE_scene_graph_update_for_newframe(depsgraph);
 
       /* compute hook effects on this frame */
       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
@@ -308,7 +311,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
 
   /* return frame state and DB to original state */
   CFRA = oldframe;
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 }
 
 static void freeData(GpencilModifierData *md)
diff --git a/source/blender/gpencil_modifiers/intern/MOD_gpencillattice.c b/source/blender/gpencil_modifiers/intern/MOD_gpencillattice.c
index 0f5fc4d5cf6..2d2f39f0189 100644
--- a/source/blender/gpencil_modifiers/intern/MOD_gpencillattice.c
+++ b/source/blender/gpencil_modifiers/intern/MOD_gpencillattice.c
@@ -126,7 +126,10 @@ static void deformStroke(GpencilModifierData *md,
 /* FIXME: Ideally we be doing this on a copy of the main depsgraph
  * (i.e. one where we don't have to worry about restoring state)
  */
-static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData *md, Object *ob)
+static void bakeModifier(Main *UNUSED(bmain),
+                         Depsgraph *depsgraph,
+                         GpencilModifierData *md,
+                         Object *ob)
 {
   LatticeGpencilModifierData *mmd = (LatticeGpencilModifierData *)md;
   Scene *scene = DEG_get_evaluated_scene(depsgraph);
@@ -144,7 +147,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
        * NOTE: this assumes that we don't want lattice animation on non-keyframed frames
        */
       CFRA = gpf->framenum;
-      BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+      BKE_scene_graph_update_for_newframe(depsgraph);
 
       /* recalculate lattice data */
       BKE_gpencil_lattice_init(ob);
@@ -165,7 +168,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
 
   /* return frame state and DB to original state */
   CFRA = oldframe;
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 }
 
 static void freeData(GpencilModifierData *md)
diff --git a/source/blender/gpencil_modifiers/intern/MOD_gpencilmirror.c b/source/blender/gpencil_modifiers/intern/MOD_gpencilmirror.c
index c99ca64325c..3554cf2e4eb 100644
--- a/source/blender/gpencil_modifiers/intern/MOD_gpencilmirror.c
+++ b/source/blender/gpencil_modifiers/intern/MOD_gpencilmirror.c
@@ -174,7 +174,10 @@ static void generateStrokes(GpencilModifierData *md, Depsgraph *depsgraph, Objec
   }
 }
 
-static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData *md, Object *ob)
+static void bakeModifier(Main *UNUSED(bmain),
+                         Depsgraph *depsgraph,
+                         GpencilModifierData *md,
+                         Object *ob)
 {
   Scene *scene = DEG_get_evaluated_scene(depsgraph);
   bGPdata *gpd = ob->data;
@@ -184,7 +187,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
     LISTBASE_FOREACH (bGPDframe *, gpf, &gpl->frames) {
       /* apply mirror effects on this frame */
       CFRA = gpf->framenum;
-      BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+      BKE_scene_graph_update_for_newframe(depsgraph);
 
       /* compute mirror effects on this frame */
       generate_geometry(md, ob, gpl, gpf);
@@ -193,7 +196,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
 
   /* return frame state and DB to original state */
   CFRA = oldframe;
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 }
 
 static bool isDisabled(GpencilModifierData *UNUSED(md), int UNUSED(userRenderParams))
diff --git a/source/blender/gpencil_modifiers/intern/MOD_gpenciltint.c b/source/blender/gpencil_modifiers/intern/MOD_gpenciltint.c
index 9d10fcbe49b..9e86ea6ecdc 100644
--- a/source/blender/gpencil_modifiers/intern/MOD_gpenciltint.c
+++ b/source/blender/gpencil_modifiers/intern/MOD_gpenciltint.c
@@ -259,7 +259,10 @@ static void deformStroke(GpencilModifierData *md,
 /* FIXME: Ideally we be doing this on a copy of the main depsgraph
  * (i.e. one where we don't have to worry about restoring state)
  */
-static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData *md, Object *ob)
+static void bakeModifier(Main *UNUSED(bmain),
+                         Depsgraph *depsgraph,
+                         GpencilModifierData *md,
+                         Object *ob)
 {
   TintGpencilModifierData *mmd = (TintGpencilModifierData *)md;
   Scene *scene = DEG_get_evaluated_scene(depsgraph);
@@ -276,7 +279,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
        * NOTE: this assumes that we don't want animation on non-keyframed frames
        */
       CFRA = gpf->framenum;
-      BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+      BKE_scene_graph_update_for_newframe(depsgraph);
 
       /* compute effects on this frame */
       LISTBASE_FOREACH (bGPDstroke *, gps, &gpf->strokes) {
@@ -287,7 +290,7 @@ static void bakeModifier(Main *bmain, Depsgraph *depsgraph, GpencilModifierData
 
   /* return frame state and DB to original state */
   CFRA = oldframe;
-  BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+  BKE_scene_graph_update_for_newframe(depsgraph);
 }
 
 static void freeData(GpencilModifierData *md)
diff --git a/source/blender/io/alembic/exporter/abc_export_capi.cc b/source/blender/io/alembic/exporter/abc_export_capi.cc
index c4966a965eb..eeb13d31bd4 100644
--- a/source/blender/io/alembic/exporter/abc_export_capi.cc
+++ b/source/blender/io/alembic/exporter/abc_export_capi.cc
@@ -156,7 +156,7 @@ static void export_startjob(void *customdata,
       // Update the scene for the next frame to render.
       scene->r.cfra = static_cast<int>(frame);
       scene->r.subframe = frame - scene->r.cfra;
-      BKE_scene_graph_update_for_newframe(data->depsgraph, data->bmain);
+      BKE_scene_graph_update_for_newframe(data->depsgraph);
 
       CLOG_INFO(&LOG, 2, "Exporting frame %.2f", frame);
       ExportSubset export_subset = abc_archive->export_subset_for_frame(frame);
@@ -177,7 +177,7 @@ static void export_startjob(void *customdata,
   // Finish up by going back to the keyframe that was current before we started.
   if (CFRA != orig_frame) {
     CFRA = orig_frame;
-    BKE_scene_graph_update_for_newframe(data->depsgraph, data->bmain);
+    BKE_scene_graph_update_for_newframe(data->depsgraph);
   }
 
   data->export_ok = !data->was_canceled;
diff --git a/source/blender/io/usd/intern/usd_capi.cc b/source/blender/io/usd/intern/usd_capi.cc
index a7c5ff1a305..1c23535e248 100644
--- a/source/blender/io/usd/intern/usd_capi.cc
+++ b/source/blender/io/usd/intern/usd_capi.cc
@@ -127,7 +127,7 @@ static void export_startjob(void *customdata,
       // Update the scene for the next frame to render.
       scene->r.cfra = static_cast<int>(frame);
       scene->r.subframe = frame - scene->r.cfra;
-      BKE_scene_graph_update_for_newframe(data->depsgraph, data->bmain);
+      BKE_scene_graph_update_for_newframe(data->depsgraph);
 
       iter.set_export_frame(frame);
       iter.iterate_and_write();
@@ -147,7 +147,7 @@ static void export_startjob(void *customdata,
   // Finish up by going back to the keyframe that was current before we started.
   if (CFRA != orig_frame) {
     CFRA = orig_frame;
-    BKE_scene_graph_update_for_newframe(data->depsgraph, data->bmain);
+    BKE_scene_graph_update_for_newframe(data->depsgraph);
   }
 
   data->export_ok = true;
diff --git a/source/blender/makesrna/intern/rna_scene_api.c b/source/blender/makesrna/intern/rna_scene_api.c
index 06c73fbb19c..d258677c606 100644
--- a/source/blender/makesrna/intern/rna_scene_api.c
+++ b/source/blender/makesrna/intern/rna_scene_api.c
@@ -73,7 +73,7 @@ static void rna_Scene_frame_set(Scene *scene, Main *bmain, int frame, float subf
   for (ViewLayer *view_layer = scene->view_layers.first; view_layer != NULL;
        view_layer = view_layer->next) {
     Depsgraph *depsgraph = BKE_scene_get_depsgraph(bmain, scene, view_layer, true);
-    BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
   }
 
 #  ifdef WITH_PYTHON
diff --git a/source/blender/render/intern/source/external_engine.c b/source/blender/render/intern/source/external_engine.c
index 0527766d865..e3bf3bdc743 100644
--- a/source/blender/render/intern/source/external_engine.c
+++ b/source/blender/render/intern/source/external_engine.c
@@ -615,7 +615,7 @@ static void engine_depsgraph_init(RenderEngine *engine, ViewLayer *view_layer)
     DEG_ids_clear_recalc(bmain, depsgraph);
   }
   else {
-    BKE_scene_graph_update_for_newframe(engine->depsgraph, bmain);
+    BKE_scene_graph_update_for_newframe(engine->depsgraph);
   }
 }
 
@@ -637,7 +637,7 @@ void RE_engine_frame_set(RenderEngine *engine, int frame, float subframe)
 
   CLAMP(cfra, MINAFRAME, MAXFRAME);
   BKE_scene_frame_set(re->scene, cfra);
-  BKE_scene_graph_update_for_newframe(engine->depsgraph, re->main);
+  BKE_scene_graph_update_for_newframe(engine->depsgraph);
 
   BKE_scene_camera_switch_update(re->scene);
 }
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index 1964813fff9..8e6b139ca7d 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -3151,7 +3151,6 @@ static const EnumPropertyItem redraw_timer_type_items[] = {
 };
 
 static void redraw_timer_step(bContext *C,
-                              Main *bmain,
                               Scene *scene,
                               struct Depsgraph *depsgraph,
                               wmWindow *win,
@@ -3202,7 +3201,7 @@ static void redraw_timer_step(bContext *C,
   }
   else if (type == eRTAnimationStep) {
     scene->r.cfra += (cfra == scene->r.cfra) ? 1 : -1;
-    BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+    BKE_scene_graph_update_for_newframe(depsgraph);
   }
   else if (type == eRTAnimationPlay) {
     /* play anim, return on same frame as started with */
@@ -3215,7 +3214,7 @@ static void redraw_timer_step(bContext *C,
         scene->r.cfra = scene->r.sfra;
       }
 
-      BKE_scene_graph_update_for_newframe(depsgraph, bmain);
+      BKE_scene_graph_update_for_newframe(depsgraph);
       redraw_timer_window_swap(C);
     }
   }
@@ -3231,7 +3230,6 @@ static void redraw_timer_step(bContext *C,
 
 static int redraw_timer_exec(bContext *C, wmOperator *op)
 {
-  Main *bmain = CTX_data_main(C);
   Scene *scene = CTX_data_scene(C);
   wmWindow *win = CTX_wm_window(C);
   ScrArea *area = CTX_wm_area(C);
@@ -3256,7 +3254,7 @@ static int redraw_timer_exec(bContext *C, wmOperator *op)
   wm_window_make_drawable(wm, win);
 
   for (a = 0; a < iter; a++) {
-    redraw_timer_step(C, bmain, scene, depsgraph, win, area, region, type, cfra);
+    redraw_timer_step(C, scene, depsgraph, win, area, region, type, cfra);
     iter_steps += 1;
 
     if (time_limit != 0.0) {
-- 
cgit v1.2.3


From 47c6f41b8926befcf1ffe8b0dcccb90922c4b9be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Cl=C3=A9ment=20Foucault?= <foucault.clem@gmail.com>
Date: Tue, 18 Aug 2020 15:49:48 +0200
Subject: Fix T77564: VSE (and compositor background) lost stereoscopy preview

Issue introduced on fe045b2b77dc6d7f0b552619fe824b496d34db6c.

Since the stereoscopy compositing (anaglyph, ...) is only done for
viewports the VSE preview and compositor need to use viewports.

Reviewed by: dfelinto

Differential Revision: https://developer.blender.org/D8472
---
 source/blender/editors/space_node/node_draw.c           | 13 +++++++++++--
 source/blender/editors/space_sequencer/sequencer_draw.c | 14 +++++++++++++-
 source/blender/gpu/GPU_framebuffer.h                    |  1 +
 source/blender/gpu/intern/gpu_framebuffer.c             | 12 ++++++++++++
 source/blender/windowmanager/intern/wm_draw.c           |  4 +++-
 5 files changed, 40 insertions(+), 4 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/space_node/node_draw.c b/source/blender/editors/space_node/node_draw.c
index 22b549cbd5d..884f551bad1 100644
--- a/source/blender/editors/space_node/node_draw.c
+++ b/source/blender/editors/space_node/node_draw.c
@@ -47,11 +47,13 @@
 
 #include "BIF_glutil.h"
 
+#include "GPU_batch_presets.h"
 #include "GPU_framebuffer.h"
 #include "GPU_immediate.h"
 #include "GPU_immediate_util.h"
 #include "GPU_matrix.h"
 #include "GPU_state.h"
+#include "GPU_viewport.h"
 
 #include "WM_api.h"
 #include "WM_types.h"
@@ -1771,11 +1773,18 @@ void drawnodespace(const bContext *C, ARegion *region)
   SpaceNode *snode = CTX_wm_space_node(C);
   View2D *v2d = &region->v2d;
 
+  UI_view2d_view_ortho(v2d);
+
+  /* Setup offscreen buffers. */
+  GPUViewport *viewport = WM_draw_region_get_viewport(region);
+
+  GPUFrameBuffer *framebuffer_overlay = GPU_viewport_framebuffer_overlay_get(viewport);
+  GPU_framebuffer_bind_no_srgb(framebuffer_overlay);
+  GPU_batch_presets_reset();
+
   UI_ThemeClearColor(TH_BACK);
   GPU_clear(GPU_COLOR_BIT);
 
-  UI_view2d_view_ortho(v2d);
-
   /* XXX snode->cursor set in coordspace for placing new nodes, used for drawing noodles too */
   UI_view2d_region_to_view(&region->v2d,
                            win->eventstate->x - region->winrct.xmin,
diff --git a/source/blender/editors/space_sequencer/sequencer_draw.c b/source/blender/editors/space_sequencer/sequencer_draw.c
index 995e980aba0..edbe830683f 100644
--- a/source/blender/editors/space_sequencer/sequencer_draw.c
+++ b/source/blender/editors/space_sequencer/sequencer_draw.c
@@ -50,12 +50,14 @@
 #include "IMB_colormanagement.h"
 #include "IMB_imbuf.h"
 
+#include "GPU_batch_presets.h"
 #include "GPU_framebuffer.h"
 #include "GPU_immediate.h"
 #include "GPU_immediate_util.h"
 #include "GPU_matrix.h"
 #include "GPU_state.h"
 #include "GPU_vertex_buffer.h"
+#include "GPU_viewport.h"
 
 #include "ED_anim_api.h"
 #include "ED_gpencil.h"
@@ -1537,7 +1539,7 @@ static void sequencer_preview_clear(void)
   float col[3];
 
   UI_GetThemeColor3fv(TH_SEQ_PREVIEW, col);
-  GPU_clear_color(col[0], col[1], col[2], 0.0);
+  GPU_clear_color(col[0], col[1], col[2], 1.0);
   GPU_clear(GPU_COLOR_BIT);
 }
 
@@ -1775,6 +1777,13 @@ void sequencer_draw_preview(const bContext *C,
     return;
   }
 
+  /* Setup offscreen buffers. */
+  GPUViewport *viewport = WM_draw_region_get_viewport(region);
+
+  GPUFrameBuffer *framebuffer_overlay = GPU_viewport_framebuffer_overlay_get(viewport);
+  GPU_framebuffer_bind_no_srgb(framebuffer_overlay);
+  GPU_batch_presets_reset();
+
   if (sseq->render_size == SEQ_PROXY_RENDER_SIZE_NONE) {
     sequencer_preview_clear();
     return;
@@ -1798,6 +1807,9 @@ void sequencer_draw_preview(const bContext *C,
   ibuf = sequencer_ibuf_get(
       bmain, depsgraph, scene, sseq, cfra, frame_ofs, names[sseq->multiview_eye]);
 
+  /* sequencer_ibuf_get can call GPU_framebuffer_bind. So disable srgb framebuffer again. */
+  GPU_framebuffer_bind_no_srgb(framebuffer_overlay);
+
   if (ibuf) {
     scope = sequencer_get_scope(scene, sseq, ibuf, draw_backdrop);
 
diff --git a/source/blender/gpu/GPU_framebuffer.h b/source/blender/gpu/GPU_framebuffer.h
index 4958d1eaac8..ee99f1f68c8 100644
--- a/source/blender/gpu/GPU_framebuffer.h
+++ b/source/blender/gpu/GPU_framebuffer.h
@@ -61,6 +61,7 @@ typedef struct GPUOffScreen GPUOffScreen;
 GPUFrameBuffer *GPU_framebuffer_create(void);
 void GPU_framebuffer_free(GPUFrameBuffer *fb);
 void GPU_framebuffer_bind(GPUFrameBuffer *fb);
+void GPU_framebuffer_bind_no_srgb(GPUFrameBuffer *fb);
 void GPU_framebuffer_restore(void);
 
 bool GPU_framebuffer_bound(GPUFrameBuffer *fb);
diff --git a/source/blender/gpu/intern/gpu_framebuffer.c b/source/blender/gpu/intern/gpu_framebuffer.c
index 77abb786117..838450e6528 100644
--- a/source/blender/gpu/intern/gpu_framebuffer.c
+++ b/source/blender/gpu/intern/gpu_framebuffer.c
@@ -544,6 +544,18 @@ void GPU_framebuffer_bind(GPUFrameBuffer *fb)
   glViewport(0, 0, fb->width, fb->height);
 }
 
+/* Workaround for binding a srgb framebuffer without doing the srgb transform. */
+void GPU_framebuffer_bind_no_srgb(GPUFrameBuffer *fb)
+{
+  GPU_framebuffer_bind(fb);
+
+  glDisable(GL_FRAMEBUFFER_SRGB);
+
+  GPUTexture *first_target = fb->attachments[GPU_FB_COLOR_ATTACHMENT0].tex;
+  const bool is_srgb_target = (first_target && (GPU_texture_format(first_target) == GPU_SRGB8_A8));
+  GPU_shader_set_framebuffer_srgb_target(!is_srgb_target);
+}
+
 void GPU_framebuffer_restore(void)
 {
   if (GPU_framebuffer_active_get() != NULL) {
diff --git a/source/blender/windowmanager/intern/wm_draw.c b/source/blender/windowmanager/intern/wm_draw.c
index fdbc7a7d136..622e8359541 100644
--- a/source/blender/windowmanager/intern/wm_draw.c
+++ b/source/blender/windowmanager/intern/wm_draw.c
@@ -308,7 +308,9 @@ static void wm_region_test_xr_do_draw(const wmWindowManager *wm,
 
 static bool wm_region_use_viewport_by_type(short space_type, short region_type)
 {
-  return (ELEM(space_type, SPACE_VIEW3D, SPACE_IMAGE) && region_type == RGN_TYPE_WINDOW);
+  return (ELEM(space_type, SPACE_VIEW3D, SPACE_IMAGE, SPACE_NODE) &&
+          region_type == RGN_TYPE_WINDOW) ||
+         ((space_type == SPACE_SEQ) && region_type == RGN_TYPE_PREVIEW);
 }
 
 bool WM_region_use_viewport(ScrArea *area, ARegion *region)
-- 
cgit v1.2.3


From 6a4f5e6a8c3990330fe8839e39e0094ba5410ba4 Mon Sep 17 00:00:00 2001
From: Jacques Lucke <jacques@blender.org>
Date: Tue, 18 Aug 2020 15:51:32 +0200
Subject: Depsgraph: simplify build API

Reviewers: sergey, sybren

Differential Revision: https://developer.blender.org/D8611
---
 source/blender/blenkernel/intern/scene.c           |  8 ++---
 source/blender/blenkernel/intern/seqprefetch.c     |  2 +-
 .../tests/blendfile_loading_base_test.cc           |  2 +-
 source/blender/depsgraph/DEG_depsgraph_build.h     | 35 ++++---------------
 .../blender/depsgraph/intern/builder/pipeline.cc   | 11 +++---
 source/blender/depsgraph/intern/builder/pipeline.h |  2 +-
 .../intern/builder/pipeline_all_objects.cc         |  7 ++--
 .../intern/builder/pipeline_all_objects.h          |  2 +-
 .../intern/builder/pipeline_compositor.cc          |  5 ++-
 .../depsgraph/intern/builder/pipeline_compositor.h |  3 +-
 .../depsgraph/intern/builder/pipeline_from_ids.cc  |  5 ++-
 .../depsgraph/intern/builder/pipeline_from_ids.h   |  3 +-
 .../depsgraph/intern/builder/pipeline_render.cc    |  6 +---
 .../depsgraph/intern/builder/pipeline_render.h     |  2 +-
 .../intern/builder/pipeline_view_layer.cc          |  7 ++--
 .../depsgraph/intern/builder/pipeline_view_layer.h |  2 +-
 source/blender/depsgraph/intern/depsgraph_build.cc | 40 +++++++---------------
 source/blender/depsgraph/intern/depsgraph_debug.cc |  2 +-
 .../blender/draw/engines/eevee/eevee_lightcache.c  |  2 +-
 .../blender/editors/animation/anim_motion_paths.c  |  2 +-
 source/blender/editors/object/object_bake_api.c    |  2 +-
 source/blender/editors/scene/scene_edit.c          |  2 +-
 source/blender/editors/space_node/node_edit.c      |  3 +-
 .../editors/transform/transform_convert_object.c   |  2 +-
 .../blender_interface/BlenderStrokeRenderer.cpp    |  3 +-
 .../blender/io/alembic/exporter/abc_export_capi.cc | 11 +++---
 .../intern/abstract_hierarchy_iterator_test.cc     |  3 +-
 source/blender/io/usd/intern/usd_capi.cc           |  5 ++-
 .../blender/render/intern/source/external_engine.c |  2 +-
 source/blender/render/intern/source/pipeline.c     |  2 +-
 .../blender/windowmanager/intern/wm_event_system.c |  2 +-
 31 files changed, 62 insertions(+), 123 deletions(-)

(limited to 'source')

diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index f95ee27ed58..631c5ed330d 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -1485,7 +1485,7 @@ static void scene_graph_update_tagged(Depsgraph *depsgraph, Main *bmain, bool on
 
   for (int pass = 0; pass < 2; pass++) {
     /* (Re-)build dependency graph if needed. */
-    DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
+    DEG_graph_relations_update(depsgraph);
     /* Uncomment this to check if graph was properly tagged for update. */
     // DEG_debug_graph_relations_validate(depsgraph, bmain, scene);
     /* Flush editing data if needed. */
@@ -1512,7 +1512,7 @@ static void scene_graph_update_tagged(Depsgraph *depsgraph, Main *bmain, bool on
        * be tagged for an update anyway.
        *
        * If there are no relations changed by the callback this call will do nothing. */
-      DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
+      DEG_graph_relations_update(depsgraph);
     }
     /* Inform editors about possible changes. */
     DEG_ids_check_recalc(bmain, depsgraph, scene, view_layer, false);
@@ -1556,7 +1556,7 @@ void BKE_scene_graph_update_for_newframe(Depsgraph *depsgraph)
      */
     BKE_image_editors_update_frame(bmain, scene->r.cfra);
     BKE_sound_set_cfra(scene->r.cfra);
-    DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
+    DEG_graph_relations_update(depsgraph);
     /* Update all objects: drivers, matrices, displists, etc. flags set
      * by depgraph or manual, no layer check here, gets correct flushed.
      *
@@ -1579,7 +1579,7 @@ void BKE_scene_graph_update_for_newframe(Depsgraph *depsgraph)
 
       /* NOTE: Similar to this case in scene_graph_update_tagged(). Need to ensure that
        * DEG_ids_clear_recalc() doesn't access freed memory of possibly removed ID. */
-      DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
+      DEG_graph_relations_update(depsgraph);
     }
 
     /* Inform editors about possible changes. */
diff --git a/source/blender/blenkernel/intern/seqprefetch.c b/source/blender/blenkernel/intern/seqprefetch.c
index 795086fffa4..c442b7ca780 100644
--- a/source/blender/blenkernel/intern/seqprefetch.c
+++ b/source/blender/blenkernel/intern/seqprefetch.c
@@ -220,7 +220,7 @@ static void seq_prefetch_init_depsgraph(PrefetchJob *pfjob)
   DEG_debug_name_set(pfjob->depsgraph, "SEQUENCER PREFETCH");
 
   /* Make sure there is a correct evaluated scene pointer. */
-  DEG_graph_build_for_render_pipeline(pfjob->depsgraph, bmain, scene, view_layer);
+  DEG_graph_build_for_render_pipeline(pfjob->depsgraph);
 
   /* Update immediately so we have proper evaluated scene. */
   seq_prefetch_update_depsgraph(pfjob);
diff --git a/source/blender/blenloader/tests/blendfile_loading_base_test.cc b/source/blender/blenloader/tests/blendfile_loading_base_test.cc
index d74bab4b31c..c743e6bcd3f 100644
--- a/source/blender/blenloader/tests/blendfile_loading_base_test.cc
+++ b/source/blender/blenloader/tests/blendfile_loading_base_test.cc
@@ -148,7 +148,7 @@ void BlendfileLoadingBaseTest::depsgraph_create(eEvaluationMode depsgraph_evalua
 {
   depsgraph = DEG_graph_new(
       bfile->main, bfile->curscene, bfile->cur_view_layer, depsgraph_evaluation_mode);
-  DEG_graph_build_from_view_layer(depsgraph, bfile->main, bfile->curscene, bfile->cur_view_layer);
+  DEG_graph_build_from_view_layer(depsgraph);
   BKE_scene_graph_update_tagged(depsgraph, bfile->main);
 }
 
diff --git a/source/blender/depsgraph/DEG_depsgraph_build.h b/source/blender/depsgraph/DEG_depsgraph_build.h
index dd52c97e03f..2147a584765 100644
--- a/source/blender/depsgraph/DEG_depsgraph_build.h
+++ b/source/blender/depsgraph/DEG_depsgraph_build.h
@@ -51,50 +51,29 @@ extern "C" {
 /* Graph Building -------------------------------- */
 
 /* Build depsgraph for the given scene, and dump results in given graph container. */
-void DEG_graph_build_from_view_layer(struct Depsgraph *graph,
-                                     struct Main *bmain,
-                                     struct Scene *scene,
-                                     struct ViewLayer *view_layer);
+void DEG_graph_build_from_view_layer(struct Depsgraph *graph);
 
 /* Build depsgraph for all objects (so also invisible ones) in the given view layer. */
-void DEG_graph_build_for_all_objects(struct Depsgraph *graph,
-                                     struct Main *bmain,
-                                     struct Scene *scene,
-                                     struct ViewLayer *view_layer);
+void DEG_graph_build_for_all_objects(struct Depsgraph *graph);
 
 /* Special version of builder which produces dependency graph suitable for the render pipeline.
  * It will contain sequencer and compositor (if needed) and all their dependencies. */
-void DEG_graph_build_for_render_pipeline(struct Depsgraph *graph,
-                                         struct Main *bmain,
-                                         struct Scene *scene,
-                                         struct ViewLayer *view_layer);
+void DEG_graph_build_for_render_pipeline(struct Depsgraph *graph);
 
 /* Builds minimal dependency graph for compositor preview.
  *
  * Note that compositor editor might have pinned node tree, which is different from scene's node
  * tree.
  */
-void DEG_graph_build_for_compositor_preview(struct Depsgraph *graph,
-                                            struct Main *bmain,
-                                            struct Scene *scene,
-                                            struct ViewLayer *view_layer,
-                                            struct bNodeTree *nodetree);
-
-void DEG_graph_build_from_ids(struct Depsgraph *graph,
-                              struct Main *bmain,
-                              struct Scene *scene,
-                              struct ViewLayer *view_layer,
-                              struct ID **ids,
-                              const int num_ids);
+void DEG_graph_build_for_compositor_preview(struct Depsgraph *graph, struct bNodeTree *nodetree);
+
+void DEG_graph_build_from_ids(struct Depsgraph *graph, struct ID **ids, const int num_ids);
 
 /* Tag relations from the given graph for update. */
 void DEG_graph_tag_relations_update(struct Depsgraph *graph);
 
 /* Create or update relations in the specified graph. */
-void DEG_graph_relations_update(struct Depsgraph *graph,
-                                struct Main *bmain,
-                                struct Scene *scene,
-                                struct ViewLayer *view_layer);
+void DEG_graph_relations_update(struct Depsgraph *graph);
 
 /* Tag all relations in the database for update.*/
 void DEG_relations_tag_update(struct Main *bmain);
diff --git a/source/blender/depsgraph/intern/builder/pipeline.cc b/source/blender/depsgraph/intern/builder/pipeline.cc
index d6893ba11d8..b13077e4792 100644
--- a/source/blender/depsgraph/intern/builder/pipeline.cc
+++ b/source/blender/depsgraph/intern/builder/pipeline.cc
@@ -33,14 +33,11 @@
 namespace blender {
 namespace deg {
 
-AbstractBuilderPipeline::AbstractBuilderPipeline(::Depsgraph *graph,
-                                                 Main *bmain,
-                                                 Scene *scene,
-                                                 ViewLayer *view_layer)
+AbstractBuilderPipeline::AbstractBuilderPipeline(::Depsgraph *graph)
     : deg_graph_(reinterpret_cast<Depsgraph *>(graph)),
-      bmain_(bmain),
-      scene_(scene),
-      view_layer_(view_layer),
+      bmain_(deg_graph_->bmain),
+      scene_(deg_graph_->scene),
+      view_layer_(deg_graph_->view_layer),
       builder_cache_()
 {
 }
diff --git a/source/blender/depsgraph/intern/builder/pipeline.h b/source/blender/depsgraph/intern/builder/pipeline.h
index 2c9c78bb2cb..d98d834932c 100644
--- a/source/blender/depsgraph/intern/builder/pipeline.h
+++ b/source/blender/depsgraph/intern/builder/pipeline.h
@@ -49,7 +49,7 @@ class DepsgraphRelationBuilder;
  */
 class AbstractBuilderPipeline {
  public:
-  AbstractBuilderPipeline(::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer);
+  AbstractBuilderPipeline(::Depsgraph *graph);
   virtual ~AbstractBuilderPipeline();
 
   void build();
diff --git a/source/blender/depsgraph/intern/builder/pipeline_all_objects.cc b/source/blender/depsgraph/intern/builder/pipeline_all_objects.cc
index c926ff7541a..81d239239be 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_all_objects.cc
+++ b/source/blender/depsgraph/intern/builder/pipeline_all_objects.cc
@@ -58,11 +58,8 @@ class AllObjectsRelationBuilder : public DepsgraphRelationBuilder {
 
 }  // namespace
 
-AllObjectsBuilderPipeline::AllObjectsBuilderPipeline(::Depsgraph *graph,
-                                                     Main *bmain,
-                                                     Scene *scene,
-                                                     ViewLayer *view_layer)
-    : ViewLayerBuilderPipeline(graph, bmain, scene, view_layer)
+AllObjectsBuilderPipeline::AllObjectsBuilderPipeline(::Depsgraph *graph)
+    : ViewLayerBuilderPipeline(graph)
 {
 }
 
diff --git a/source/blender/depsgraph/intern/builder/pipeline_all_objects.h b/source/blender/depsgraph/intern/builder/pipeline_all_objects.h
index 94f00ae840b..11ca2314331 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_all_objects.h
+++ b/source/blender/depsgraph/intern/builder/pipeline_all_objects.h
@@ -33,7 +33,7 @@ namespace deg {
  * (and their dependencies). */
 class AllObjectsBuilderPipeline : public ViewLayerBuilderPipeline {
  public:
-  AllObjectsBuilderPipeline(::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer);
+  AllObjectsBuilderPipeline(::Depsgraph *graph);
 
  protected:
   virtual unique_ptr<DepsgraphNodeBuilder> construct_node_builder() override;
diff --git a/source/blender/depsgraph/intern/builder/pipeline_compositor.cc b/source/blender/depsgraph/intern/builder/pipeline_compositor.cc
index 3e56f17fc7e..2b9922851c1 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_compositor.cc
+++ b/source/blender/depsgraph/intern/builder/pipeline_compositor.cc
@@ -26,9 +26,8 @@
 namespace blender {
 namespace deg {
 
-CompositorBuilderPipeline::CompositorBuilderPipeline(
-    ::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer, bNodeTree *nodetree)
-    : AbstractBuilderPipeline(graph, bmain, scene, view_layer), nodetree_(nodetree)
+CompositorBuilderPipeline::CompositorBuilderPipeline(::Depsgraph *graph, bNodeTree *nodetree)
+    : AbstractBuilderPipeline(graph), nodetree_(nodetree)
 {
   deg_graph_->is_render_pipeline_depsgraph = true;
 }
diff --git a/source/blender/depsgraph/intern/builder/pipeline_compositor.h b/source/blender/depsgraph/intern/builder/pipeline_compositor.h
index 892ece7c2a4..46f1e3694d3 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_compositor.h
+++ b/source/blender/depsgraph/intern/builder/pipeline_compositor.h
@@ -32,8 +32,7 @@ namespace deg {
 
 class CompositorBuilderPipeline : public AbstractBuilderPipeline {
  public:
-  CompositorBuilderPipeline(
-      ::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer, bNodeTree *nodetree);
+  CompositorBuilderPipeline(::Depsgraph *graph, bNodeTree *nodetree);
 
  protected:
   virtual void build_nodes(DepsgraphNodeBuilder &node_builder) override;
diff --git a/source/blender/depsgraph/intern/builder/pipeline_from_ids.cc b/source/blender/depsgraph/intern/builder/pipeline_from_ids.cc
index c42bccaadec..87cfeb46693 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_from_ids.cc
+++ b/source/blender/depsgraph/intern/builder/pipeline_from_ids.cc
@@ -114,9 +114,8 @@ class DepsgraphFromIDsRelationBuilder : public DepsgraphRelationBuilder {
 
 }  // namespace
 
-FromIDsBuilderPipeline::FromIDsBuilderPipeline(
-    ::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer, Span<ID *> ids)
-    : AbstractBuilderPipeline(graph, bmain, scene, view_layer), ids_(ids)
+FromIDsBuilderPipeline::FromIDsBuilderPipeline(::Depsgraph *graph, Span<ID *> ids)
+    : AbstractBuilderPipeline(graph), ids_(ids)
 {
 }
 
diff --git a/source/blender/depsgraph/intern/builder/pipeline_from_ids.h b/source/blender/depsgraph/intern/builder/pipeline_from_ids.h
index a52a9f6f252..79fcfc52446 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_from_ids.h
+++ b/source/blender/depsgraph/intern/builder/pipeline_from_ids.h
@@ -43,8 +43,7 @@ namespace deg {
 
 class FromIDsBuilderPipeline : public AbstractBuilderPipeline {
  public:
-  FromIDsBuilderPipeline(
-      ::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer, Span<ID *> ids);
+  FromIDsBuilderPipeline(::Depsgraph *graph, Span<ID *> ids);
 
  protected:
   virtual unique_ptr<DepsgraphNodeBuilder> construct_node_builder() override;
diff --git a/source/blender/depsgraph/intern/builder/pipeline_render.cc b/source/blender/depsgraph/intern/builder/pipeline_render.cc
index 50a37d0d3e4..3b065f7f1bc 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_render.cc
+++ b/source/blender/depsgraph/intern/builder/pipeline_render.cc
@@ -26,11 +26,7 @@
 namespace blender {
 namespace deg {
 
-RenderBuilderPipeline::RenderBuilderPipeline(::Depsgraph *graph,
-                                             Main *bmain,
-                                             Scene *scene,
-                                             ViewLayer *view_layer)
-    : AbstractBuilderPipeline(graph, bmain, scene, view_layer)
+RenderBuilderPipeline::RenderBuilderPipeline(::Depsgraph *graph) : AbstractBuilderPipeline(graph)
 {
   deg_graph_->is_render_pipeline_depsgraph = true;
 }
diff --git a/source/blender/depsgraph/intern/builder/pipeline_render.h b/source/blender/depsgraph/intern/builder/pipeline_render.h
index df7f9e0de68..91a4be137b6 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_render.h
+++ b/source/blender/depsgraph/intern/builder/pipeline_render.h
@@ -30,7 +30,7 @@ namespace deg {
 
 class RenderBuilderPipeline : public AbstractBuilderPipeline {
  public:
-  RenderBuilderPipeline(::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer);
+  RenderBuilderPipeline(::Depsgraph *graph);
 
  protected:
   virtual void build_nodes(DepsgraphNodeBuilder &node_builder) override;
diff --git a/source/blender/depsgraph/intern/builder/pipeline_view_layer.cc b/source/blender/depsgraph/intern/builder/pipeline_view_layer.cc
index 3223f17f349..f1852a40a10 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_view_layer.cc
+++ b/source/blender/depsgraph/intern/builder/pipeline_view_layer.cc
@@ -26,11 +26,8 @@
 namespace blender {
 namespace deg {
 
-ViewLayerBuilderPipeline::ViewLayerBuilderPipeline(::Depsgraph *graph,
-                                                   Main *bmain,
-                                                   Scene *scene,
-                                                   ViewLayer *view_layer)
-    : AbstractBuilderPipeline(graph, bmain, scene, view_layer)
+ViewLayerBuilderPipeline::ViewLayerBuilderPipeline(::Depsgraph *graph)
+    : AbstractBuilderPipeline(graph)
 {
 }
 
diff --git a/source/blender/depsgraph/intern/builder/pipeline_view_layer.h b/source/blender/depsgraph/intern/builder/pipeline_view_layer.h
index fbd7b98acad..aa85dd7a47b 100644
--- a/source/blender/depsgraph/intern/builder/pipeline_view_layer.h
+++ b/source/blender/depsgraph/intern/builder/pipeline_view_layer.h
@@ -30,7 +30,7 @@ namespace deg {
 
 class ViewLayerBuilderPipeline : public AbstractBuilderPipeline {
  public:
-  ViewLayerBuilderPipeline(::Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer);
+  ViewLayerBuilderPipeline(::Depsgraph *graph);
 
  protected:
   virtual void build_nodes(DepsgraphNodeBuilder &node_builder) override;
diff --git a/source/blender/depsgraph/intern/depsgraph_build.cc b/source/blender/depsgraph/intern/depsgraph_build.cc
index dc49534eb2d..96c17ae4dc5 100644
--- a/source/blender/depsgraph/intern/depsgraph_build.cc
+++ b/source/blender/depsgraph/intern/depsgraph_build.cc
@@ -210,49 +210,33 @@ struct Depsgraph *DEG_get_graph_from_handle(struct DepsNodeHandle *node_handle)
 /* Graph Building API's */
 
 /* Build depsgraph for the given scene layer, and dump results in given graph container. */
-void DEG_graph_build_from_view_layer(Depsgraph *graph,
-                                     Main *bmain,
-                                     Scene *scene,
-                                     ViewLayer *view_layer)
+void DEG_graph_build_from_view_layer(Depsgraph *graph)
 {
-  deg::ViewLayerBuilderPipeline builder(graph, bmain, scene, view_layer);
+  deg::ViewLayerBuilderPipeline builder(graph);
   builder.build();
 }
 
-void DEG_graph_build_for_all_objects(struct Depsgraph *graph,
-                                     struct Main *bmain,
-                                     struct Scene *scene,
-                                     struct ViewLayer *view_layer)
+void DEG_graph_build_for_all_objects(struct Depsgraph *graph)
 {
-  deg::AllObjectsBuilderPipeline builder(graph, bmain, scene, view_layer);
+  deg::AllObjectsBuilderPipeline builder(graph);
   builder.build();
 }
 
-void DEG_graph_build_for_render_pipeline(Depsgraph *graph,
-                                         Main *bmain,
-                                         Scene *scene,
-                                         ViewLayer *view_layer)
+void DEG_graph_build_for_render_pipeline(Depsgraph *graph)
 {
-  deg::RenderBuilderPipeline builder(graph, bmain, scene, view_layer);
+  deg::RenderBuilderPipeline builder(graph);
   builder.build();
 }
 
-void DEG_graph_build_for_compositor_preview(
-    Depsgraph *graph, Main *bmain, Scene *scene, struct ViewLayer *view_layer, bNodeTree *nodetree)
+void DEG_graph_build_for_compositor_preview(Depsgraph *graph, bNodeTree *nodetree)
 {
-  deg::CompositorBuilderPipeline builder(graph, bmain, scene, view_layer, nodetree);
+  deg::CompositorBuilderPipeline builder(graph, nodetree);
   builder.build();
 }
 
-void DEG_graph_build_from_ids(Depsgraph *graph,
-                              Main *bmain,
-                              Scene *scene,
-                              ViewLayer *view_layer,
-                              ID **ids,
-                              const int num_ids)
+void DEG_graph_build_from_ids(Depsgraph *graph, ID **ids, const int num_ids)
 {
-  deg::FromIDsBuilderPipeline builder(
-      graph, bmain, scene, view_layer, blender::Span(ids, num_ids));
+  deg::FromIDsBuilderPipeline builder(graph, blender::Span(ids, num_ids));
   builder.build();
 }
 
@@ -275,14 +259,14 @@ void DEG_graph_tag_relations_update(Depsgraph *graph)
 }
 
 /* Create or update relations in the specified graph. */
-void DEG_graph_relations_update(Depsgraph *graph, Main *bmain, Scene *scene, ViewLayer *view_layer)
+void DEG_graph_relations_update(Depsgraph *graph)
 {
   deg::Depsgraph *deg_graph = (deg::Depsgraph *)graph;
   if (!deg_graph->need_update) {
     /* Graph is up to date, nothing to do. */
     return;
   }
-  DEG_graph_build_from_view_layer(graph, bmain, scene, view_layer);
+  DEG_graph_build_from_view_layer(graph);
 }
 
 /* Tag all relations for update. */
diff --git a/source/blender/depsgraph/intern/depsgraph_debug.cc b/source/blender/depsgraph/intern/depsgraph_debug.cc
index 0763738ff59..c5e306f3148 100644
--- a/source/blender/depsgraph/intern/depsgraph_debug.cc
+++ b/source/blender/depsgraph/intern/depsgraph_debug.cc
@@ -93,7 +93,7 @@ bool DEG_debug_graph_relations_validate(Depsgraph *graph,
 {
   Depsgraph *temp_depsgraph = DEG_graph_new(bmain, scene, view_layer, DEG_get_mode(graph));
   bool valid = true;
-  DEG_graph_build_from_view_layer(temp_depsgraph, bmain, scene, view_layer);
+  DEG_graph_build_from_view_layer(temp_depsgraph);
   if (!DEG_debug_compare(temp_depsgraph, graph)) {
     fprintf(stderr, "ERROR! Depsgraph wasn't tagged for update when it should have!\n");
     BLI_assert(!"This should not happen!");
diff --git a/source/blender/draw/engines/eevee/eevee_lightcache.c b/source/blender/draw/engines/eevee/eevee_lightcache.c
index 6d2577d5b78..b5364a71378 100644
--- a/source/blender/draw/engines/eevee/eevee_lightcache.c
+++ b/source/blender/draw/engines/eevee/eevee_lightcache.c
@@ -1302,7 +1302,7 @@ void EEVEE_lightbake_job(void *custom_data, short *stop, short *do_update, float
   EEVEE_LightBake *lbake = (EEVEE_LightBake *)custom_data;
   Depsgraph *depsgraph = lbake->depsgraph;
 
-  DEG_graph_relations_update(depsgraph, lbake->bmain, lbake->scene, lbake->view_layer_input);
+  DEG_graph_relations_update(depsgraph);
   DEG_evaluate_on_framechange(lbake->bmain, depsgraph, lbake->frame);
 
   lbake->view_layer = DEG_get_evaluated_view_layer(depsgraph);
diff --git a/source/blender/editors/animation/anim_motion_paths.c b/source/blender/editors/animation/anim_motion_paths.c
index eb3bdf43a3c..2a37302872a 100644
--- a/source/blender/editors/animation/anim_motion_paths.c
+++ b/source/blender/editors/animation/anim_motion_paths.c
@@ -91,7 +91,7 @@ Depsgraph *animviz_depsgraph_build(Main *bmain,
   }
 
   /* Build graph from all requested IDs. */
-  DEG_graph_build_from_ids(depsgraph, bmain, scene, view_layer, ids, num_ids);
+  DEG_graph_build_from_ids(depsgraph, ids, num_ids);
   MEM_freeN(ids);
 
   /* Update once so we can access pointers of evaluated animation data. */
diff --git a/source/blender/editors/object/object_bake_api.c b/source/blender/editors/object/object_bake_api.c
index eb8b976320f..4d55aff1d1f 100644
--- a/source/blender/editors/object/object_bake_api.c
+++ b/source/blender/editors/object/object_bake_api.c
@@ -745,7 +745,7 @@ static int bake(Render *re,
   /* We build a depsgraph for the baking,
    * so we don't need to change the original data to adjust visibility and modifiers. */
   Depsgraph *depsgraph = DEG_graph_new(bmain, scene, view_layer, DAG_EVAL_RENDER);
-  DEG_graph_build_from_view_layer(depsgraph, bmain, scene, view_layer);
+  DEG_graph_build_from_view_layer(depsgraph);
 
   int op_result = OPERATOR_CANCELLED;
   bool ok = false;
diff --git a/source/blender/editors/scene/scene_edit.c b/source/blender/editors/scene/scene_edit.c
index fa63a890de7..d599c1cbcf0 100644
--- a/source/blender/editors/scene/scene_edit.c
+++ b/source/blender/editors/scene/scene_edit.c
@@ -119,7 +119,7 @@ void ED_scene_change_update(Main *bmain, Scene *scene, ViewLayer *layer)
   Depsgraph *depsgraph = BKE_scene_get_depsgraph(bmain, scene, layer, true);
 
   BKE_scene_set_background(bmain, scene);
-  DEG_graph_relations_update(depsgraph, bmain, scene, layer);
+  DEG_graph_relations_update(depsgraph);
   DEG_on_visible_update(bmain, false);
 
   ED_render_engine_changed(bmain, false);
diff --git a/source/blender/editors/space_node/node_edit.c b/source/blender/editors/space_node/node_edit.c
index c88b6a1b297..5f5f6467c8a 100644
--- a/source/blender/editors/space_node/node_edit.c
+++ b/source/blender/editors/space_node/node_edit.c
@@ -207,8 +207,7 @@ static void compo_initjob(void *cjv)
   ViewLayer *view_layer = cj->view_layer;
 
   cj->compositor_depsgraph = DEG_graph_new(bmain, scene, view_layer, DAG_EVAL_RENDER);
-  DEG_graph_build_for_compositor_preview(
-      cj->compositor_depsgraph, bmain, scene, view_layer, cj->ntree);
+  DEG_graph_build_for_compositor_preview(cj->compositor_depsgraph, cj->ntree);
 
   /* NOTE: Don't update animation to preserve unkeyed changes, this means can not use
    * evaluate_on_framechange. */
diff --git a/source/blender/editors/transform/transform_convert_object.c b/source/blender/editors/transform/transform_convert_object.c
index 2e92b4e5c09..61af4ebbe46 100644
--- a/source/blender/editors/transform/transform_convert_object.c
+++ b/source/blender/editors/transform/transform_convert_object.c
@@ -357,7 +357,7 @@ static void set_trans_object_base_flags(TransInfo *t)
   /* Makes sure base flags and object flags are identical. */
   BKE_scene_base_flag_to_objects(t->view_layer);
   /* Make sure depsgraph is here. */
-  DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
+  DEG_graph_relations_update(depsgraph);
   /* Clear all flags we need. It will be used to detect dependencies. */
   trans_object_base_deps_flag_prepare(view_layer);
   /* Traverse all bases and set all possible flags. */
diff --git a/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp b/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp
index 68b5b4baeca..4b2fd7b6735 100644
--- a/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp
+++ b/source/blender/freestyle/intern/blender_interface/BlenderStrokeRenderer.cpp
@@ -869,8 +869,7 @@ Render *BlenderStrokeRenderer::RenderScene(Render * /*re*/, bool render)
 #endif
 
   Render *freestyle_render = RE_NewSceneRender(freestyle_scene);
-  ViewLayer *view_layer = (ViewLayer *)freestyle_scene->view_layers.first;
-  DEG_graph_relations_update(freestyle_depsgraph, freestyle_bmain, freestyle_scene, view_layer);
+  DEG_graph_relations_update(freestyle_depsgraph);
 
   RE_RenderFreestyleStrokes(
       freestyle_render, freestyle_bmain, freestyle_scene, render && get_stroke_count() > 0);
diff --git a/source/blender/io/alembic/exporter/abc_export_capi.cc b/source/blender/io/alembic/exporter/abc_export_capi.cc
index eeb13d31bd4..6412379c126 100644
--- a/source/blender/io/alembic/exporter/abc_export_capi.cc
+++ b/source/blender/io/alembic/exporter/abc_export_capi.cc
@@ -67,16 +67,13 @@ namespace io {
 namespace alembic {
 
 // Construct the depsgraph for exporting.
-static void build_depsgraph(Depsgraph *depsgraph, Main *bmain, const bool visible_objects_only)
+static void build_depsgraph(Depsgraph *depsgraph, const bool visible_objects_only)
 {
-  Scene *scene = DEG_get_input_scene(depsgraph);
-  ViewLayer *view_layer = DEG_get_input_view_layer(depsgraph);
-
   if (visible_objects_only) {
-    DEG_graph_build_from_view_layer(depsgraph, bmain, scene, view_layer);
+    DEG_graph_build_from_view_layer(depsgraph);
   }
   else {
-    DEG_graph_build_for_all_objects(depsgraph, bmain, scene, view_layer);
+    DEG_graph_build_for_all_objects(depsgraph);
   }
 }
 
@@ -97,7 +94,7 @@ static void export_startjob(void *customdata,
   *progress = 0.0f;
   *do_update = true;
 
-  build_depsgraph(data->depsgraph, data->bmain, data->params.visible_objects_only);
+  build_depsgraph(data->depsgraph, data->params.visible_objects_only);
   SubdivModifierDisabler subdiv_disabler(data->depsgraph);
   if (!data->params.apply_subdiv) {
     subdiv_disabler.disable_modifiers();
diff --git a/source/blender/io/common/intern/abstract_hierarchy_iterator_test.cc b/source/blender/io/common/intern/abstract_hierarchy_iterator_test.cc
index 57bc68d25bf..27196994a3c 100644
--- a/source/blender/io/common/intern/abstract_hierarchy_iterator_test.cc
+++ b/source/blender/io/common/intern/abstract_hierarchy_iterator_test.cc
@@ -328,8 +328,7 @@ class AbstractHierarchyIteratorInvisibleTest : public AbstractHierarchyIteratorT
   {
     depsgraph = DEG_graph_new(
         bfile->main, bfile->curscene, bfile->cur_view_layer, depsgraph_evaluation_mode);
-    DEG_graph_build_for_all_objects(
-        depsgraph, bfile->main, bfile->curscene, bfile->cur_view_layer);
+    DEG_graph_build_for_all_objects(depsgraph);
     BKE_scene_graph_update_tagged(depsgraph, bfile->main);
   }
 };
diff --git a/source/blender/io/usd/intern/usd_capi.cc b/source/blender/io/usd/intern/usd_capi.cc
index 1c23535e248..83b8c18d436 100644
--- a/source/blender/io/usd/intern/usd_capi.cc
+++ b/source/blender/io/usd/intern/usd_capi.cc
@@ -75,12 +75,11 @@ static void export_startjob(void *customdata,
 
   // Construct the depsgraph for exporting.
   Scene *scene = DEG_get_input_scene(data->depsgraph);
-  ViewLayer *view_layer = DEG_get_input_view_layer(data->depsgraph);
   if (data->params.visible_objects_only) {
-    DEG_graph_build_from_view_layer(data->depsgraph, data->bmain, scene, view_layer);
+    DEG_graph_build_from_view_layer(data->depsgraph);
   }
   else {
-    DEG_graph_build_for_all_objects(data->depsgraph, data->bmain, scene, view_layer);
+    DEG_graph_build_for_all_objects(data->depsgraph);
   }
   BKE_scene_graph_update_tagged(data->depsgraph, data->bmain);
 
diff --git a/source/blender/render/intern/source/external_engine.c b/source/blender/render/intern/source/external_engine.c
index e3bf3bdc743..adab95d41a9 100644
--- a/source/blender/render/intern/source/external_engine.c
+++ b/source/blender/render/intern/source/external_engine.c
@@ -609,7 +609,7 @@ static void engine_depsgraph_init(RenderEngine *engine, ViewLayer *view_layer)
 
   if (engine->re->r.scemode & R_BUTS_PREVIEW) {
     Depsgraph *depsgraph = engine->depsgraph;
-    DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
+    DEG_graph_relations_update(depsgraph);
     DEG_evaluate_on_framechange(bmain, depsgraph, CFRA);
     DEG_ids_check_recalc(bmain, depsgraph, scene, view_layer, true);
     DEG_ids_clear_recalc(bmain, depsgraph);
diff --git a/source/blender/render/intern/source/pipeline.c b/source/blender/render/intern/source/pipeline.c
index 3236026c69f..8f5469c7a98 100644
--- a/source/blender/render/intern/source/pipeline.c
+++ b/source/blender/render/intern/source/pipeline.c
@@ -1977,7 +1977,7 @@ static void render_init_depsgraph(Render *re)
   DEG_debug_name_set(re->pipeline_depsgraph, "RENDER PIPELINE");
 
   /* Make sure there is a correct evaluated scene pointer. */
-  DEG_graph_build_for_render_pipeline(re->pipeline_depsgraph, re->main, scene, view_layer);
+  DEG_graph_build_for_render_pipeline(re->pipeline_depsgraph);
 
   /* Update immediately so we have proper evaluated scene. */
   render_update_depsgraph(re);
diff --git a/source/blender/windowmanager/intern/wm_event_system.c b/source/blender/windowmanager/intern/wm_event_system.c
index 1b991112f01..c363fdcc9d4 100644
--- a/source/blender/windowmanager/intern/wm_event_system.c
+++ b/source/blender/windowmanager/intern/wm_event_system.c
@@ -352,7 +352,7 @@ void wm_event_do_depsgraph(bContext *C, bool is_after_open_file)
      */
     Depsgraph *depsgraph = BKE_scene_get_depsgraph(bmain, scene, view_layer, true);
     if (is_after_open_file) {
-      DEG_graph_relations_update(depsgraph, bmain, scene, view_layer);
+      DEG_graph_relations_update(depsgraph);
       DEG_graph_on_visible_update(bmain, depsgraph, true);
     }
     DEG_make_active(depsgraph);
-- 
cgit v1.2.3


From 5195d346f436539b71d2897c0a14021c0eff3ab3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sybren=20A=2E=20St=C3=BCvel?= <sybren@blender.org>
Date: Tue, 18 Aug 2020 15:53:28 +0200
Subject: Fix T79714: Projecting texture from camera fails

The evaluated mesh is now only recomputed when the required data layers
are missing. Previously the evaluated mesh was re-evaluated incorrectly,
which caused the stippled result and the failing assert.

Since now only the evaluated mesh is used, and never a temporary mesh,
there is also no more need to keep track of whether the mesh needs
freeing or not.

Reviewed By: sergey

Differential Revision: https://developer.blender.org/D8574
---
 .../editors/sculpt_paint/paint_image_proj.c        | 27 ++++------------------
 1 file changed, 5 insertions(+), 22 deletions(-)

(limited to 'source')

diff --git a/source/blender/editors/sculpt_paint/paint_image_proj.c b/source/blender/editors/sculpt_paint/paint_image_proj.c
index 1b340f532c2..456c1f61cb1 100644
--- a/source/blender/editors/sculpt_paint/paint_image_proj.c
+++ b/source/blender/editors/sculpt_paint/paint_image_proj.c
@@ -407,7 +407,6 @@ typedef struct ProjPaintState {
   SpinLock *tile_lock;
 
   Mesh *me_eval;
-  bool me_eval_free;
   int totlooptri_eval;
   int totloop_eval;
   int totpoly_eval;
@@ -4033,27 +4032,14 @@ static bool proj_paint_state_mesh_eval_init(const bContext *C, ProjPaintState *p
   CustomData_MeshMasks cddata_masks = scene_eval->customdata_mask;
   cddata_masks.fmask |= CD_MASK_MTFACE;
   cddata_masks.lmask |= CD_MASK_MLOOPUV;
-
-  /* Workaround for subsurf selection, try the display mesh first */
-  if (ps->source == PROJ_SRC_IMAGE_CAM) {
-    /* using render mesh, assume only camera was rendered from */
-    ps->me_eval = mesh_create_eval_final(depsgraph, scene_eval, ob_eval, &cddata_masks);
-    ps->me_eval_free = true;
-  }
-  else {
-    if (ps->do_face_sel) {
-      cddata_masks.vmask |= CD_MASK_ORIGINDEX;
-      cddata_masks.emask |= CD_MASK_ORIGINDEX;
-      cddata_masks.pmask |= CD_MASK_ORIGINDEX;
-    }
-    ps->me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &cddata_masks);
-    ps->me_eval_free = false;
+  if (ps->do_face_sel) {
+    cddata_masks.vmask |= CD_MASK_ORIGINDEX;
+    cddata_masks.emask |= CD_MASK_ORIGINDEX;
+    cddata_masks.pmask |= CD_MASK_ORIGINDEX;
   }
+  ps->me_eval = mesh_get_eval_final(depsgraph, scene_eval, ob_eval, &cddata_masks);
 
   if (!CustomData_has_layer(&ps->me_eval->ldata, CD_MLOOPUV)) {
-    if (ps->me_eval_free) {
-      BKE_id_free(NULL, ps->me_eval);
-    }
     ps->me_eval = NULL;
     return false;
   }
@@ -4636,9 +4622,6 @@ static void project_paint_end(ProjPaintState *ps)
       MEM_freeN(ps->cavities);
     }
 
-    if (ps->me_eval_free) {
-      BKE_id_free(NULL, ps->me_eval);
-    }
     ps->me_eval = NULL;
   }
 
-- 
cgit v1.2.3


From b3b67a61b7761508dd3369d12df90bb333200359 Mon Sep 17 00:00:00 2001
From: Antonio Vazquez <blendergit@gmail.com>
Date: Tue, 18 Aug 2020 15:58:53 +0200
Subject: Fix compiler error in MSVSC

Introduced in: rB20a8edaa725ddbae16179d2f7cea88c097c61615

It broke building on windows, initializing a static may not be done with a function in C.
---
 source/blender/blenkernel/intern/blender.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'source')

diff --git a/source/blender/blenkernel/intern/blender.c b/source/blender/blenkernel/intern/blender.c
index af502d30145..1d5c8f76cc5 100644
--- a/source/blender/blenkernel/intern/blender.c
+++ b/source/blender/blenkernel/intern/blender.c
@@ -137,7 +137,7 @@ const char *BKE_blender_version_string(void)
 
 bool BKE_blender_version_is_alpha(void)
 {
-  static bool is_alpha = STREQ(STRINGIFY(BLENDER_VERSION_CYCLE), "alpha");
+  bool is_alpha = STREQ(STRINGIFY(BLENDER_VERSION_CYCLE), "alpha");
   return is_alpha;
 }
 
-- 
cgit v1.2.3