Merge branch 'geometry-nodes' into geometry-nodes-transform-nodegeometry-nodes-transform-node

18 files changed, 825 insertions, 944 deletions

diff --git a/intern/cycles/blender/blender_object.cpp b/intern/cycles/blender/blender_object.cpp
index c3420c24469..23faacc15da 100644
--- a/intern/cycles/blender/blender_object.cpp
+++ b/intern/cycles/blender/blender_object.cpp
@@ -393,6 +393,11 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
     /* Load per-object culling data. */
     culling.init_object(scene, b_ob);
 
+    /* Ensure the object geom supporting the hair is processed before adding
+     * the hair processing task to the task pool, calling .to_mesh() on the
+     * same object in parallel does not work. */
+    const bool sync_hair = b_instance.show_particles() && object_has_particle_hair(b_ob);
+
     /* Object itself. */
     if (b_instance.show_self()) {
       sync_object(b_depsgraph,
@@ -403,11 +408,11 @@ void BlenderSync::sync_objects(BL::Depsgraph &b_depsgraph,
                   show_lights,
                   culling,
                   &use_portal,
-                  &geom_task_pool);
+                  sync_hair ? NULL : &geom_task_pool);
     }
 
     /* Particle hair as separate object. */
-    if (b_instance.show_particles() && object_has_particle_hair(b_ob)) {
+    if (sync_hair) {
       sync_object(b_depsgraph,
                   b_view_layer,
                   b_instance,
diff --git a/intern/cycles/bvh/bvh_embree.cpp b/intern/cycles/bvh/bvh_embree.cpp
index 13bad3659d7..53776a55257 100644
--- a/intern/cycles/bvh/bvh_embree.cpp
+++ b/intern/cycles/bvh/bvh_embree.cpp
@@ -585,7 +585,7 @@ void BVHEmbree::add_triangles(const Object *ob, const Mesh *mesh, int i)
     rtc_indices[j * 3 + 2] = t.v[2];
   }
 
-  update_tri_vertex_buffer(geom_id, mesh);
+  set_tri_vertex_buffer(geom_id, mesh, false);
 
   size_t prim_object_size = pack.prim_object.size();
   pack.prim_object.resize(prim_object_size + num_triangles);
@@ -612,7 +612,7 @@ void BVHEmbree::add_triangles(const Object *ob, const Mesh *mesh, int i)
   rtcReleaseGeometry(geom_id);
 }
 
-void BVHEmbree::update_tri_vertex_buffer(RTCGeometry geom_id, const Mesh *mesh)
+void BVHEmbree::set_tri_vertex_buffer(RTCGeometry geom_id, const Mesh *mesh, const bool update)
 {
   const Attribute *attr_mP = NULL;
   size_t num_motion_steps = 1;
@@ -640,8 +640,15 @@ void BVHEmbree::update_tri_vertex_buffer(RTCGeometry geom_id, const Mesh *mesh)
       verts = &attr_mP->data_float3()[t_ * num_verts];
     }
 
-    float *rtc_verts = (float *)rtcSetNewGeometryBuffer(
-        geom_id, RTC_BUFFER_TYPE_VERTEX, t, RTC_FORMAT_FLOAT3, sizeof(float) * 3, num_verts + 1);
+    float *rtc_verts = (update) ?
+                           (float *)rtcGetGeometryBufferData(geom_id, RTC_BUFFER_TYPE_VERTEX, t) :
+                           (float *)rtcSetNewGeometryBuffer(geom_id,
+                                                            RTC_BUFFER_TYPE_VERTEX,
+                                                            t,
+                                                            RTC_FORMAT_FLOAT3,
+                                                            sizeof(float) * 3,
+                                                            num_verts + 1);
+
     assert(rtc_verts);
     if (rtc_verts) {
       for (size_t j = 0; j < num_verts; ++j) {
@@ -651,10 +658,14 @@ void BVHEmbree::update_tri_vertex_buffer(RTCGeometry geom_id, const Mesh *mesh)
         rtc_verts += 3;
       }
     }
+
+    if (update) {
+      rtcUpdateGeometryBuffer(geom_id, RTC_BUFFER_TYPE_VERTEX, t);
+    }
   }
 }
 
-void BVHEmbree::update_curve_vertex_buffer(RTCGeometry geom_id, const Hair *hair)
+void BVHEmbree::set_curve_vertex_buffer(RTCGeometry geom_id, const Hair *hair, const bool update)
 {
   const Attribute *attr_mP = NULL;
   size_t num_motion_steps = 1;
@@ -689,8 +700,14 @@ void BVHEmbree::update_curve_vertex_buffer(RTCGeometry geom_id, const Hair *hair
       verts = &attr_mP->data_float3()[t_ * num_keys];
     }
 
-    float4 *rtc_verts = (float4 *)rtcSetNewGeometryBuffer(
-        geom_id, RTC_BUFFER_TYPE_VERTEX, t, RTC_FORMAT_FLOAT4, sizeof(float) * 4, num_keys_embree);
+    float4 *rtc_verts = (update) ? (float4 *)rtcGetGeometryBufferData(
+                                       geom_id, RTC_BUFFER_TYPE_VERTEX, t) :
+                                   (float4 *)rtcSetNewGeometryBuffer(geom_id,
+                                                                     RTC_BUFFER_TYPE_VERTEX,
+                                                                     t,
+                                                                     RTC_FORMAT_FLOAT4,
+                                                                     sizeof(float) * 4,
+                                                                     num_keys_embree);
 
     assert(rtc_verts);
     if (rtc_verts) {
@@ -709,6 +726,10 @@ void BVHEmbree::update_curve_vertex_buffer(RTCGeometry geom_id, const Hair *hair
         rtc_verts += c.num_keys + 2;
       }
     }
+
+    if (update) {
+      rtcUpdateGeometryBuffer(geom_id, RTC_BUFFER_TYPE_VERTEX, t);
+    }
   }
 }
 
@@ -779,7 +800,7 @@ void BVHEmbree::add_curves(const Object *ob, const Hair *hair, int i)
   rtcSetGeometryBuildQuality(geom_id, build_quality);
   rtcSetGeometryTimeStepCount(geom_id, num_motion_steps);
 
-  update_curve_vertex_buffer(geom_id, hair);
+  set_curve_vertex_buffer(geom_id, hair, false);
 
   rtcSetGeometryUserData(geom_id, (void *)prim_offset);
   if (hair->curve_shape == CURVE_RIBBON) {
@@ -933,15 +954,17 @@ void BVHEmbree::refit_nodes()
       if (geom->type == Geometry::MESH || geom->type == Geometry::VOLUME) {
         Mesh *mesh = static_cast<Mesh *>(geom);
         if (mesh->num_triangles() > 0) {
-          update_tri_vertex_buffer(rtcGetGeometry(scene, geom_id), mesh);
-          rtcCommitGeometry(rtcGetGeometry(scene, geom_id));
+          RTCGeometry geom = rtcGetGeometry(scene, geom_id);
+          set_tri_vertex_buffer(geom, mesh, true);
+          rtcCommitGeometry(geom);
         }
       }
       else if (geom->type == Geometry::HAIR) {
         Hair *hair = static_cast<Hair *>(geom);
         if (hair->num_curves() > 0) {
-          update_curve_vertex_buffer(rtcGetGeometry(scene, geom_id + 1), hair);
-          rtcCommitGeometry(rtcGetGeometry(scene, geom_id + 1));
+          RTCGeometry geom = rtcGetGeometry(scene, geom_id + 1);
+          set_curve_vertex_buffer(geom, hair, true);
+          rtcCommitGeometry(geom);
         }
       }
     }
diff --git a/intern/cycles/bvh/bvh_embree.h b/intern/cycles/bvh/bvh_embree.h
index 841f02eccec..3e895e7b588 100644
--- a/intern/cycles/bvh/bvh_embree.h
+++ b/intern/cycles/bvh/bvh_embree.h
@@ -71,8 +71,8 @@ class BVHEmbree : public BVH {
 
  private:
   void delete_rtcScene();
-  void update_tri_vertex_buffer(RTCGeometry geom_id, const Mesh *mesh);
-  void update_curve_vertex_buffer(RTCGeometry geom_id, const Hair *hair);
+  void set_tri_vertex_buffer(RTCGeometry geom_id, const Mesh *mesh, const bool update);
+  void set_curve_vertex_buffer(RTCGeometry geom_id, const Hair *hair, const bool update);
 
   RTCDevice rtc_device;
 
diff --git a/release/scripts/startup/bl_operators/__init__.py b/release/scripts/startup/bl_operators/__init__.py
index 7682effaf41..71b2de41d9e 100644
--- a/release/scripts/startup/bl_operators/__init__.py
+++ b/release/scripts/startup/bl_operators/__init__.py
@@ -48,7 +48,6 @@ _modules = [
     "uvcalc_lightmap",
     "vertexpaint_dirt",
     "view3d",
-    "gpencil_mesh_bake",
     "wm",
 ]
 
diff --git a/release/scripts/startup/bl_operators/gpencil_mesh_bake.py b/release/scripts/startup/bl_operators/gpencil_mesh_bake.py
deleted file mode 100644
index 251e0af5854..00000000000
--- a/release/scripts/startup/bl_operators/gpencil_mesh_bake.py
+++ /dev/null
@@ -1,163 +0,0 @@
-# ##### BEGIN GPL LICENSE BLOCK #####
-#
-#  This program is free software; you can redistribute it and/or
-#  modify it under the terms of the GNU General Public License
-#  as published by the Free Software Foundation; either version 2
-#  of the License, or (at your option) any later version.
-#
-#  This program is distributed in the hope that it will be useful,
-#  but WITHOUT ANY WARRANTY; without even the implied warranty of
-#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-#  GNU General Public License for more details.
-#
-#  You should have received a copy of the GNU General Public License
-#  along with this program; if not, write to the Free Software Foundation,
-#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
-#
-# ##### END GPL LICENSE BLOCK #####
-
-# <pep8-80 compliant>
-
-import bpy
-from bpy.types import Operator
-from bpy.props import (
-    IntProperty,
-    FloatProperty,
-    BoolProperty,
-    EnumProperty,
-)
-
-gp_object_items = []
-
-
-def my_objlist_callback(scene, context):
-    gp_object_items.clear()
-    gp_object_items.append(('*NEW', "New Object", ""))
-    for o in context.scene.objects:
-        if o.type == 'GPENCIL':
-            gp_object_items.append((o.name, o.name, ""))
-
-    return gp_object_items
-
-
-class GPENCIL_OT_mesh_bake(Operator):
-    """Bake all mesh animation into grease pencil strokes"""
-    bl_idname = "gpencil.mesh_bake"
-    bl_label = "Bake Mesh to Grease Pencil"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    frame_start: IntProperty(
-        name="Start Frame",
-        description="Start frame for baking",
-        min=0, max=300000,
-        default=1,
-    )
-    frame_end: IntProperty(
-        name="End Frame",
-        description="End frame for baking",
-        min=1, max=300000,
-        default=250,
-    )
-    step: IntProperty(
-        name="Frame Step",
-        description="Frame Step",
-        min=1, max=120,
-        default=1,
-    )
-    thickness: IntProperty(
-        name="Thickness",
-        description="Thickness of the stroke lines",
-        min=1, max=100,
-        default=1,
-    )
-    angle: FloatProperty(
-        name="Threshold Angle",
-        description="Threshold to determine ends of the strokes",
-        min=0,
-        max=+3.141592,
-        default=+1.22173,  # 70 Degress
-        subtype='ANGLE',
-    )
-    offset: FloatProperty(
-        name="Stroke Offset",
-        description="Offset strokes from fill",
-        soft_min=0.0, soft_max=100.0,
-        min=0.0, max=100.0,
-        default=0.001,
-        precision=3,
-        step=1,
-        subtype='DISTANCE',
-        unit='LENGTH',
-    )
-    seams: BoolProperty(
-        name="Only Seam Edges",
-        description="Convert only seam edges",
-        default=False,
-    )
-    faces: BoolProperty(
-        name="Export Faces",
-        description="Export faces as filled strokes",
-        default=True,
-    )
-    only_selected: BoolProperty(
-        name="Only Selected Keyframes",
-        description="Convert only selected keyframes",
-        default=False,
-    )
-    target: EnumProperty(
-        name="Target Object",
-        description="Grease Pencil Object",
-        items=my_objlist_callback
-    )
-    frame_target: IntProperty(
-        name="Target Frame",
-        description="Destination frame for the baked animation",
-        min=1, max=300000,
-        default=1,
-    )
-    project_type: EnumProperty(
-        name="Reproject Type",
-        description="Type of projection",
-        items=(
-            ("KEEP", "No Reproject", ""),
-            ("FRONT", "Front", "Reproject the strokes using the X-Z plane"),
-            ("SIDE", "Side", "Reproject the strokes using the Y-Z plane"),
-            ("TOP", "Top", "Reproject the strokes using the X-Y plane"),
-            ("VIEW", "View", "Reproject the strokes to current viewpoint"),
-            ("CURSOR", "Cursor", "Reproject the strokes using the orientation of 3D cursor")
-        )
-    )
-
-    @classmethod
-    def poll(self, context):
-        ob = context.active_object
-        return ((ob is not None) and
-                (ob.type in {'EMPTY', 'MESH'}) and
-                (context.mode == 'OBJECT'))
-
-    def execute(self, context):
-        bpy.ops.gpencil.bake_mesh_animation(
-            frame_start=self.frame_start,
-            frame_end=self.frame_end,
-            step=self.step,
-            angle=self.angle,
-            thickness=self.thickness,
-            seams=self.seams,
-            faces=self.faces,
-            only_selected=self.only_selected,
-            offset=self.offset,
-            target=self.target,
-            frame_target=self.frame_target,
-            project_type=self.project_type
-        )
-
-        return {'FINISHED'}
-
-    def invoke(self, context, _event):
-        wm = context.window_manager
-        return wm.invoke_props_dialog(self)
-
-
-classes = (
-    GPENCIL_OT_mesh_bake,
-)
diff --git a/release/scripts/startup/bl_ui/space_view3d.py b/release/scripts/startup/bl_ui/space_view3d.py
index 07ccdfa8416..af6e752227e 100644
--- a/release/scripts/startup/bl_ui/space_view3d.py
+++ b/release/scripts/startup/bl_ui/space_view3d.py
@@ -2292,7 +2292,7 @@ class VIEW3D_MT_object_animation(Menu):
         layout.separator()
 
         layout.operator("nla.bake", text="Bake Action...")
-        layout.operator("gpencil.mesh_bake", text="Bake Mesh to Grease Pencil...")
+        layout.operator("gpencil.bake_mesh_animation", text="Bake Mesh to Grease Pencil...")
 
 
 class VIEW3D_MT_object_rigid_body(Menu):
diff --git a/source/blender/blenkernel/intern/curve.c b/source/blender/blenkernel/intern/curve.c
index 7e9ee1ad153..82548112096 100644
--- a/source/blender/blenkernel/intern/curve.c
+++ b/source/blender/blenkernel/intern/curve.c
@@ -461,15 +461,14 @@ short BKE_curve_type_get(const Curve *cu)
 void BKE_curve_curve_dimension_update(Curve *cu)
 {
   ListBase *nurbs = BKE_curve_nurbs_get(cu);
-  Nurb *nu = nurbs->first;
 
   if (cu->flag & CU_3D) {
-    for (; nu; nu = nu->next) {
+    LISTBASE_FOREACH (Nurb *, nu, nurbs) {
       nu->flag &= ~CU_2D;
     }
   }
   else {
-    for (; nu; nu = nu->next) {
+    LISTBASE_FOREACH (Nurb *, nu, nurbs) {
       nu->flag |= CU_2D;
       BKE_nurb_test_2d(nu);
 
@@ -2673,6 +2672,17 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
       continue;
     }
 
+    /* check we are a single point? also check we are not a surface and that the orderu is sane,
+     * enforced in the UI but can go wrong possibly */
+    if (!BKE_nurb_check_valid_u(nu)) {
+      BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelList1");
+      bl->bevpoints = MEM_calloc_arrayN(1, sizeof(BevPoint), "makeBevelPoints1");
+      BLI_addtail(bev, bl);
+      bl->nr = 0;
+      bl->charidx = nu->charidx;
+      continue;
+    }
+
     /* check if we will calculate tilt data */
     do_tilt = CU_DO_TILT(cu, nu);
 
@@ -2681,89 +2691,231 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
 
     do_weight = true;
 
-    /* check we are a single point? also check we are not a surface and that the orderu is sane,
-     * enforced in the UI but can go wrong possibly */
-    if (!BKE_nurb_check_valid_u(nu)) {
-      BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelList1");
-      bl->bevpoints = MEM_calloc_arrayN(1, sizeof(BevPoint), "makeBevelPoints1");
+    BevPoint *bevp;
+
+    if (for_render && cu->resolu_ren != 0) {
+      resolu = cu->resolu_ren;
+    }
+    else {
+      resolu = nu->resolu;
+    }
+
+    segcount = SEGMENTSU(nu);
+
+    if (nu->type == CU_POLY) {
+      len = nu->pntsu;
+      BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelList2");
+      bl->bevpoints = MEM_calloc_arrayN(len, sizeof(BevPoint), "makeBevelPoints2");
+      if (need_seglen && (nu->flagu & CU_NURB_CYCLIC) == 0) {
+        bl->seglen = MEM_malloc_arrayN(segcount, sizeof(float), "makeBevelList2_seglen");
+        bl->segbevcount = MEM_malloc_arrayN(segcount, sizeof(int), "makeBevelList2_segbevcount");
+      }
       BLI_addtail(bev, bl);
-      bl->nr = 0;
+
+      bl->poly = (nu->flagu & CU_NURB_CYCLIC) ? 0 : -1;
+      bl->nr = len;
+      bl->dupe_nr = 0;
       bl->charidx = nu->charidx;
+      bevp = bl->bevpoints;
+      bevp->offset = 0;
+      bp = nu->bp;
+      seglen = bl->seglen;
+      segbevcount = bl->segbevcount;
+
+      while (len--) {
+        copy_v3_v3(bevp->vec, bp->vec);
+        bevp->tilt = bp->tilt;
+        bevp->radius = bp->radius;
+        bevp->weight = bp->weight;
+        bevp->split_tag = true;
+        bp++;
+        if (seglen != NULL && len != 0) {
+          *seglen = len_v3v3(bevp->vec, bp->vec);
+          bevp++;
+          bevp->offset = *seglen;
+          if (*seglen > treshold) {
+            *segbevcount = 1;
+          }
+          else {
+            *segbevcount = 0;
+          }
+          seglen++;
+          segbevcount++;
+        }
+        else {
+          bevp++;
+        }
+      }
+
+      if ((nu->flagu & CU_NURB_CYCLIC) == 0) {
+        bevlist_firstlast_direction_calc_from_bpoint(nu, bl);
+      }
     }
-    else {
-      BevPoint *bevp;
+    else if (nu->type == CU_BEZIER) {
+      /* in case last point is not cyclic */
+      len = segcount * resolu + 1;
 
-      if (for_render && cu->resolu_ren != 0) {
-        resolu = cu->resolu_ren;
+      BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelBPoints");
+      bl->bevpoints = MEM_calloc_arrayN(len, sizeof(BevPoint), "makeBevelBPointsPoints");
+      if (need_seglen && (nu->flagu & CU_NURB_CYCLIC) == 0) {
+        bl->seglen = MEM_malloc_arrayN(segcount, sizeof(float), "makeBevelBPoints_seglen");
+        bl->segbevcount = MEM_malloc_arrayN(segcount, sizeof(int), "makeBevelBPoints_segbevcount");
+      }
+      BLI_addtail(bev, bl);
+
+      bl->poly = (nu->flagu & CU_NURB_CYCLIC) ? 0 : -1;
+      bl->charidx = nu->charidx;
+
+      bevp = bl->bevpoints;
+      seglen = bl->seglen;
+      segbevcount = bl->segbevcount;
+
+      bevp->offset = 0;
+      if (seglen != NULL) {
+        *seglen = 0;
+        *segbevcount = 0;
+      }
+
+      a = nu->pntsu - 1;
+      bezt = nu->bezt;
+      if (nu->flagu & CU_NURB_CYCLIC) {
+        a++;
+        prevbezt = nu->bezt + (nu->pntsu - 1);
       }
       else {
-        resolu = nu->resolu;
+        prevbezt = bezt;
+        bezt++;
       }
 
-      segcount = SEGMENTSU(nu);
+      sub_v3_v3v3(bevp->dir, prevbezt->vec[2], prevbezt->vec[1]);
+      normalize_v3(bevp->dir);
 
-      if (nu->type == CU_POLY) {
-        len = nu->pntsu;
-        BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelList2");
-        bl->bevpoints = MEM_calloc_arrayN(len, sizeof(BevPoint), "makeBevelPoints2");
-        if (need_seglen && (nu->flagu & CU_NURB_CYCLIC) == 0) {
-          bl->seglen = MEM_malloc_arrayN(segcount, sizeof(float), "makeBevelList2_seglen");
-          bl->segbevcount = MEM_malloc_arrayN(segcount, sizeof(int), "makeBevelList2_segbevcount");
-        }
-        BLI_addtail(bev, bl);
+      BLI_assert(segcount >= a);
 
-        bl->poly = (nu->flagu & CU_NURB_CYCLIC) ? 0 : -1;
-        bl->nr = len;
-        bl->dupe_nr = 0;
-        bl->charidx = nu->charidx;
-        bevp = bl->bevpoints;
-        bevp->offset = 0;
-        bp = nu->bp;
-        seglen = bl->seglen;
-        segbevcount = bl->segbevcount;
+      while (a--) {
+        if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) {
 
-        while (len--) {
-          copy_v3_v3(bevp->vec, bp->vec);
-          bevp->tilt = bp->tilt;
-          bevp->radius = bp->radius;
-          bevp->weight = bp->weight;
+          copy_v3_v3(bevp->vec, prevbezt->vec[1]);
+          bevp->tilt = prevbezt->tilt;
+          bevp->radius = prevbezt->radius;
+          bevp->weight = prevbezt->weight;
           bevp->split_tag = true;
-          bp++;
-          if (seglen != NULL && len != 0) {
-            *seglen = len_v3v3(bevp->vec, bp->vec);
-            bevp++;
+          bevp->dupe_tag = false;
+          bevp++;
+          bl->nr++;
+          bl->dupe_nr = 1;
+          if (seglen != NULL) {
+            *seglen = len_v3v3(prevbezt->vec[1], bezt->vec[1]);
             bevp->offset = *seglen;
-            if (*seglen > treshold) {
+            seglen++;
+            /* match segbevcount to the cleaned up bevel lists (see STEP 2) */
+            if (bevp->offset > treshold) {
               *segbevcount = 1;
             }
-            else {
-              *segbevcount = 0;
+            segbevcount++;
+          }
+        }
+        else {
+          /* always do all three, to prevent data hanging around */
+          int j;
+
+          /* BevPoint must stay aligned to 4 so sizeof(BevPoint)/sizeof(float) works */
+          for (j = 0; j < 3; j++) {
+            BKE_curve_forward_diff_bezier(prevbezt->vec[1][j],
+                                          prevbezt->vec[2][j],
+                                          bezt->vec[0][j],
+                                          bezt->vec[1][j],
+                                          &(bevp->vec[j]),
+                                          resolu,
+                                          sizeof(BevPoint));
+          }
+
+          /* if both arrays are NULL do nothiong */
+          tilt_bezpart(prevbezt,
+                       bezt,
+                       nu,
+                       do_tilt ? &bevp->tilt : NULL,
+                       do_radius ? &bevp->radius : NULL,
+                       do_weight ? &bevp->weight : NULL,
+                       resolu,
+                       sizeof(BevPoint));
+
+          if (cu->twist_mode == CU_TWIST_TANGENT) {
+            forward_diff_bezier_cotangent(prevbezt->vec[1],
+                                          prevbezt->vec[2],
+                                          bezt->vec[0],
+                                          bezt->vec[1],
+                                          bevp->tan,
+                                          resolu,
+                                          sizeof(BevPoint));
+          }
+
+          /* indicate with handlecodes double points */
+          if (prevbezt->h1 == prevbezt->h2) {
+            if (prevbezt->h1 == 0 || prevbezt->h1 == HD_VECT) {
+              bevp->split_tag = true;
+            }
+          }
+          else {
+            if (prevbezt->h1 == 0 || prevbezt->h1 == HD_VECT) {
+              bevp->split_tag = true;
+            }
+            else if (prevbezt->h2 == 0 || prevbezt->h2 == HD_VECT) {
+              bevp->split_tag = true;
+            }
+          }
+
+          /* seglen */
+          if (seglen != NULL) {
+            *seglen = 0;
+            *segbevcount = 0;
+            for (j = 0; j < resolu; j++) {
+              bevp0 = bevp;
+              bevp++;
+              bevp->offset = len_v3v3(bevp0->vec, bevp->vec);
+              /* match seglen and segbevcount to the cleaned up bevel lists (see STEP 2) */
+              if (bevp->offset > treshold) {
+                *seglen += bevp->offset;
+                *segbevcount += 1;
+              }
             }
             seglen++;
             segbevcount++;
           }
           else {
-            bevp++;
+            bevp += resolu;
           }
+          bl->nr += resolu;
         }
+        prevbezt = bezt;
+        bezt++;
+      }
 
-        if ((nu->flagu & CU_NURB_CYCLIC) == 0) {
-          bevlist_firstlast_direction_calc_from_bpoint(nu, bl);
-        }
+      if ((nu->flagu & CU_NURB_CYCLIC) == 0) { /* not cyclic: endpoint */
+        copy_v3_v3(bevp->vec, prevbezt->vec[1]);
+        bevp->tilt = prevbezt->tilt;
+        bevp->radius = prevbezt->radius;
+        bevp->weight = prevbezt->weight;
+
+        sub_v3_v3v3(bevp->dir, prevbezt->vec[1], prevbezt->vec[0]);
+        normalize_v3(bevp->dir);
+
+        bl->nr++;
       }
-      else if (nu->type == CU_BEZIER) {
-        /* in case last point is not cyclic */
-        len = segcount * resolu + 1;
+    }
+    else if (nu->type == CU_NURBS) {
+      if (nu->pntsv == 1) {
+        len = (resolu * segcount);
 
-        BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelBPoints");
-        bl->bevpoints = MEM_calloc_arrayN(len, sizeof(BevPoint), "makeBevelBPointsPoints");
+        BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelList3");
+        bl->bevpoints = MEM_calloc_arrayN(len, sizeof(BevPoint), "makeBevelPoints3");
         if (need_seglen && (nu->flagu & CU_NURB_CYCLIC) == 0) {
-          bl->seglen = MEM_malloc_arrayN(segcount, sizeof(float), "makeBevelBPoints_seglen");
-          bl->segbevcount = MEM_malloc_arrayN(
-              segcount, sizeof(int), "makeBevelBPoints_segbevcount");
+          bl->seglen = MEM_malloc_arrayN(segcount, sizeof(float), "makeBevelList3_seglen");
+          bl->segbevcount = MEM_malloc_arrayN(segcount, sizeof(int), "makeBevelList3_segbevcount");
         }
         BLI_addtail(bev, bl);
-
+        bl->nr = len;
+        bl->dupe_nr = 0;
         bl->poly = (nu->flagu & CU_NURB_CYCLIC) ? 0 : -1;
         bl->charidx = nu->charidx;
 
@@ -2771,196 +2923,41 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
         seglen = bl->seglen;
         segbevcount = bl->segbevcount;
 
-        bevp->offset = 0;
-        if (seglen != NULL) {
-          *seglen = 0;
-          *segbevcount = 0;
-        }
-
-        a = nu->pntsu - 1;
-        bezt = nu->bezt;
-        if (nu->flagu & CU_NURB_CYCLIC) {
-          a++;
-          prevbezt = nu->bezt + (nu->pntsu - 1);
-        }
-        else {
-          prevbezt = bezt;
-          bezt++;
-        }
-
-        sub_v3_v3v3(bevp->dir, prevbezt->vec[2], prevbezt->vec[1]);
-        normalize_v3(bevp->dir);
+        BKE_nurb_makeCurve(nu,
+                           &bevp->vec[0],
+                           do_tilt ? &bevp->tilt : NULL,
+                           do_radius ? &bevp->radius : NULL,
+                           do_weight ? &bevp->weight : NULL,
+                           resolu,
+                           sizeof(BevPoint));
 
-        BLI_assert(segcount >= a);
-
-        while (a--) {
-          if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) {
-
-            copy_v3_v3(bevp->vec, prevbezt->vec[1]);
-            bevp->tilt = prevbezt->tilt;
-            bevp->radius = prevbezt->radius;
-            bevp->weight = prevbezt->weight;
-            bevp->split_tag = true;
-            bevp->dupe_tag = false;
-            bevp++;
-            bl->nr++;
-            bl->dupe_nr = 1;
-            if (seglen != NULL) {
-              *seglen = len_v3v3(prevbezt->vec[1], bezt->vec[1]);
-              bevp->offset = *seglen;
-              seglen++;
-              /* match segbevcount to the cleaned up bevel lists (see STEP 2) */
-              if (bevp->offset > treshold) {
-                *segbevcount = 1;
-              }
-              segbevcount++;
-            }
-          }
-          else {
-            /* always do all three, to prevent data hanging around */
+        /* match seglen and segbevcount to the cleaned up bevel lists (see STEP 2) */
+        if (seglen != NULL) {
+          nr = segcount;
+          bevp0 = bevp;
+          bevp++;
+          while (nr) {
             int j;
-
-            /* BevPoint must stay aligned to 4 so sizeof(BevPoint)/sizeof(float) works */
-            for (j = 0; j < 3; j++) {
-              BKE_curve_forward_diff_bezier(prevbezt->vec[1][j],
-                                            prevbezt->vec[2][j],
-                                            bezt->vec[0][j],
-                                            bezt->vec[1][j],
-                                            &(bevp->vec[j]),
-                                            resolu,
-                                            sizeof(BevPoint));
-            }
-
-            /* if both arrays are NULL do nothiong */
-            tilt_bezpart(prevbezt,
-                         bezt,
-                         nu,
-                         do_tilt ? &bevp->tilt : NULL,
-                         do_radius ? &bevp->radius : NULL,
-                         do_weight ? &bevp->weight : NULL,
-                         resolu,
-                         sizeof(BevPoint));
-
-            if (cu->twist_mode == CU_TWIST_TANGENT) {
-              forward_diff_bezier_cotangent(prevbezt->vec[1],
-                                            prevbezt->vec[2],
-                                            bezt->vec[0],
-                                            bezt->vec[1],
-                                            bevp->tan,
-                                            resolu,
-                                            sizeof(BevPoint));
-            }
-
-            /* indicate with handlecodes double points */
-            if (prevbezt->h1 == prevbezt->h2) {
-              if (prevbezt->h1 == 0 || prevbezt->h1 == HD_VECT) {
-                bevp->split_tag = true;
-              }
-            }
-            else {
-              if (prevbezt->h1 == 0 || prevbezt->h1 == HD_VECT) {
-                bevp->split_tag = true;
-              }
-              else if (prevbezt->h2 == 0 || prevbezt->h2 == HD_VECT) {
-                bevp->split_tag = true;
-              }
-            }
-
-            /* seglen */
-            if (seglen != NULL) {
-              *seglen = 0;
-              *segbevcount = 0;
-              for (j = 0; j < resolu; j++) {
-                bevp0 = bevp;
-                bevp++;
-                bevp->offset = len_v3v3(bevp0->vec, bevp->vec);
-                /* match seglen and segbevcount to the cleaned up bevel lists (see STEP 2) */
-                if (bevp->offset > treshold) {
-                  *seglen += bevp->offset;
-                  *segbevcount += 1;
-                }
+            *seglen = 0;
+            *segbevcount = 0;
+            /* We keep last bevel segment zero-length. */
+            for (j = 0; j < ((nr == 1) ? (resolu - 1) : resolu); j++) {
+              bevp->offset = len_v3v3(bevp0->vec, bevp->vec);
+              if (bevp->offset > treshold) {
+                *seglen += bevp->offset;
+                *segbevcount += 1;
               }
-              seglen++;
-              segbevcount++;
-            }
-            else {
-              bevp += resolu;
+              bevp0 = bevp;
+              bevp++;
             }
-            bl->nr += resolu;
+            seglen++;
+            segbevcount++;
+            nr--;
           }
-          prevbezt = bezt;
-          bezt++;
-        }
-
-        if ((nu->flagu & CU_NURB_CYCLIC) == 0) { /* not cyclic: endpoint */
-          copy_v3_v3(bevp->vec, prevbezt->vec[1]);
-          bevp->tilt = prevbezt->tilt;
-          bevp->radius = prevbezt->radius;
-          bevp->weight = prevbezt->weight;
-
-          sub_v3_v3v3(bevp->dir, prevbezt->vec[1], prevbezt->vec[0]);
-          normalize_v3(bevp->dir);
-
-          bl->nr++;
         }
-      }
-      else if (nu->type == CU_NURBS) {
-        if (nu->pntsv == 1) {
-          len = (resolu * segcount);
 
-          BevList *bl = MEM_callocN(sizeof(BevList), "makeBevelList3");
-          bl->bevpoints = MEM_calloc_arrayN(len, sizeof(BevPoint), "makeBevelPoints3");
-          if (need_seglen && (nu->flagu & CU_NURB_CYCLIC) == 0) {
-            bl->seglen = MEM_malloc_arrayN(segcount, sizeof(float), "makeBevelList3_seglen");
-            bl->segbevcount = MEM_malloc_arrayN(
-                segcount, sizeof(int), "makeBevelList3_segbevcount");
-          }
-          BLI_addtail(bev, bl);
-          bl->nr = len;
-          bl->dupe_nr = 0;
-          bl->poly = (nu->flagu & CU_NURB_CYCLIC) ? 0 : -1;
-          bl->charidx = nu->charidx;
-
-          bevp = bl->bevpoints;
-          seglen = bl->seglen;
-          segbevcount = bl->segbevcount;
-
-          BKE_nurb_makeCurve(nu,
-                             &bevp->vec[0],
-                             do_tilt ? &bevp->tilt : NULL,
-                             do_radius ? &bevp->radius : NULL,
-                             do_weight ? &bevp->weight : NULL,
-                             resolu,
-                             sizeof(BevPoint));
-
-          /* match seglen and segbevcount to the cleaned up bevel lists (see STEP 2) */
-          if (seglen != NULL) {
-            nr = segcount;
-            bevp0 = bevp;
-            bevp++;
-            while (nr) {
-              int j;
-              *seglen = 0;
-              *segbevcount = 0;
-              /* We keep last bevel segment zero-length. */
-              for (j = 0; j < ((nr == 1) ? (resolu - 1) : resolu); j++) {
-                bevp->offset = len_v3v3(bevp0->vec, bevp->vec);
-                if (bevp->offset > treshold) {
-                  *seglen += bevp->offset;
-                  *segbevcount += 1;
-                }
-                bevp0 = bevp;
-                bevp++;
-              }
-              seglen++;
-              segbevcount++;
-              nr--;
-            }
-          }
-
-          if ((nu->flagu & CU_NURB_CYCLIC) == 0) {
-            bevlist_firstlast_direction_calc_from_bpoint(nu, bl);
-          }
+        if ((nu->flagu & CU_NURB_CYCLIC) == 0) {
+          bevlist_firstlast_direction_calc_from_bpoint(nu, bl);
         }
       }
     }
@@ -2968,74 +2965,78 @@ void BKE_curve_bevelList_make(Object *ob, ListBase *nurbs, bool for_render)
 
   /* STEP 2: DOUBLE POINTS AND AUTOMATIC RESOLUTION, REDUCE DATABLOCKS */
   LISTBASE_FOREACH (BevList *, bl, bev) {
-    if (bl->nr) { /* null bevel items come from single points */
-      bool is_cyclic = bl->poly != -1;
-      nr = bl->nr;
-      if (is_cyclic) {
-        bevp1 = bl->bevpoints;
-        bevp0 = bevp1 + (nr - 1);
+    if (bl->nr == 0) { /* null bevel items come from single points */
+      continue;
+    }
+
+    bool is_cyclic = bl->poly != -1;
+    nr = bl->nr;
+    if (is_cyclic) {
+      bevp1 = bl->bevpoints;
+      bevp0 = bevp1 + (nr - 1);
+    }
+    else {
+      bevp0 = bl->bevpoints;
+      bevp0->offset = 0;
+      bevp1 = bevp0 + 1;
+    }
+    nr--;
+    while (nr--) {
+      if (seglen != NULL) {
+        if (fabsf(bevp1->offset) < treshold) {
+          bevp0->dupe_tag = true;
+          bl->dupe_nr++;
+        }
       }
       else {
-        bevp0 = bl->bevpoints;
-        bevp0->offset = 0;
-        bevp1 = bevp0 + 1;
-      }
-      nr--;
-      while (nr--) {
-        if (seglen != NULL) {
-          if (fabsf(bevp1->offset) < treshold) {
-            bevp0->dupe_tag = true;
-            bl->dupe_nr++;
-          }
-        }
-        else {
-          if (fabsf(bevp0->vec[0] - bevp1->vec[0]) < 0.00001f) {
-            if (fabsf(bevp0->vec[1] - bevp1->vec[1]) < 0.00001f) {
-              if (fabsf(bevp0->vec[2] - bevp1->vec[2]) < 0.00001f) {
-                bevp0->dupe_tag = true;
-                bl->dupe_nr++;
-              }
+        if (fabsf(bevp0->vec[0] - bevp1->vec[0]) < 0.00001f) {
+          if (fabsf(bevp0->vec[1] - bevp1->vec[1]) < 0.00001f) {
+            if (fabsf(bevp0->vec[2] - bevp1->vec[2]) < 0.00001f) {
+              bevp0->dupe_tag = true;
+              bl->dupe_nr++;
             }
           }
         }
-        bevp0 = bevp1;
-        bevp1++;
       }
+      bevp0 = bevp1;
+      bevp1++;
     }
   }
 
   LISTBASE_FOREACH_MUTABLE (BevList *, bl, bev) {
-    if (bl->nr && bl->dupe_nr) {
-      nr = bl->nr - bl->dupe_nr + 1; /* +1 because vectorbezier sets flag too */
-      blnew = MEM_mallocN(sizeof(BevList), "makeBevelList4");
-      memcpy(blnew, bl, sizeof(BevList));
-      blnew->bevpoints = MEM_calloc_arrayN(nr, sizeof(BevPoint), "makeBevelPoints4");
-      if (!blnew->bevpoints) {
-        MEM_freeN(blnew);
-        break;
-      }
-      blnew->segbevcount = bl->segbevcount;
-      blnew->seglen = bl->seglen;
-      blnew->nr = 0;
-      BLI_remlink(bev, bl);
-      BLI_insertlinkbefore(bev, bl->next, blnew); /* to make sure bevlist is tuned with nurblist */
-      bevp0 = bl->bevpoints;
-      bevp1 = blnew->bevpoints;
-      nr = bl->nr;
-      while (nr--) {
-        if (bevp0->dupe_tag == 0) {
-          memcpy(bevp1, bevp0, sizeof(BevPoint));
-          bevp1++;
-          blnew->nr++;
-        }
-        bevp0++;
-      }
-      if (bl->bevpoints != NULL) {
-        MEM_freeN(bl->bevpoints);
+    if (bl->nr == 0 || bl->dupe_nr == 0) {
+      continue;
+    }
+
+    nr = bl->nr - bl->dupe_nr + 1; /* +1 because vectorbezier sets flag too */
+    blnew = MEM_mallocN(sizeof(BevList), "makeBevelList4");
+    memcpy(blnew, bl, sizeof(BevList));
+    blnew->bevpoints = MEM_calloc_arrayN(nr, sizeof(BevPoint), "makeBevelPoints4");
+    if (!blnew->bevpoints) {
+      MEM_freeN(blnew);
+      break;
+    }
+    blnew->segbevcount = bl->segbevcount;
+    blnew->seglen = bl->seglen;
+    blnew->nr = 0;
+    BLI_remlink(bev, bl);
+    BLI_insertlinkbefore(bev, bl->next, blnew); /* to make sure bevlist is tuned with nurblist */
+    bevp0 = bl->bevpoints;
+    bevp1 = blnew->bevpoints;
+    nr = bl->nr;
+    while (nr--) {
+      if (bevp0->dupe_tag == 0) {
+        memcpy(bevp1, bevp0, sizeof(BevPoint));
+        bevp1++;
+        blnew->nr++;
       }
-      MEM_freeN(bl);
-      blnew->dupe_nr = 0;
+      bevp0++;
     }
+    if (bl->bevpoints != NULL) {
+      MEM_freeN(bl->bevpoints);
+    }
+    MEM_freeN(bl);
+    blnew->dupe_nr = 0;
   }
 
   /* STEP 3: POLYS COUNT AND AUTOHOLE */
@@ -3645,7 +3646,7 @@ static bool tridiagonal_solve_with_limits(float *a,
  * is affected by all other points of the curve segment, in practice the influence
  * decreases exponentially with distance.
  *
- * Note: this algorithm assumes that the handle horizontal size if always 1/3 of the
+ * Note: this algorithm assumes that the handle horizontal size is always 1/3 of the
  * of the interval to the next point. This rule ensures linear interpolation of time.
  *
  * ^ height (co 1)
@@ -4389,50 +4390,52 @@ void BKE_nurbList_handles_recalculate(ListBase *editnurb,
   int a;
 
   LISTBASE_FOREACH (Nurb *, nu, editnurb) {
-    if (nu->type == CU_BEZIER) {
-      bool changed = false;
+    if (nu->type != CU_BEZIER) {
+      continue;
+    }
 
-      for (a = nu->pntsu, bezt = nu->bezt; a--; bezt++) {
+    bool changed = false;
 
-        const bool h1_select = (bezt->f1 & flag) == flag;
-        const bool h2_select = (bezt->f3 & flag) == flag;
+    for (a = nu->pntsu, bezt = nu->bezt; a--; bezt++) {
 
-        if (h1_select || h2_select) {
+      const bool h1_select = (bezt->f1 & flag) == flag;
+      const bool h2_select = (bezt->f3 & flag) == flag;
 
-          float co1_back[3], co2_back[3];
+      if (h1_select || h2_select) {
 
-          copy_v3_v3(co1_back, bezt->vec[0]);
-          copy_v3_v3(co2_back, bezt->vec[2]);
+        float co1_back[3], co2_back[3];
 
-          BKE_nurb_handle_calc_simple_auto(nu, bezt);
+        copy_v3_v3(co1_back, bezt->vec[0]);
+        copy_v3_v3(co2_back, bezt->vec[2]);
 
-          if (h1_select) {
-            if (!calc_length) {
-              dist_ensure_v3_v3fl(bezt->vec[0], bezt->vec[1], len_v3v3(co1_back, bezt->vec[1]));
-            }
-          }
-          else {
-            copy_v3_v3(bezt->vec[0], co1_back);
-          }
+        BKE_nurb_handle_calc_simple_auto(nu, bezt);
 
-          if (h2_select) {
-            if (!calc_length) {
-              dist_ensure_v3_v3fl(bezt->vec[2], bezt->vec[1], len_v3v3(co2_back, bezt->vec[1]));
-            }
-          }
-          else {
-            copy_v3_v3(bezt->vec[2], co2_back);
+        if (h1_select) {
+          if (!calc_length) {
+            dist_ensure_v3_v3fl(bezt->vec[0], bezt->vec[1], len_v3v3(co1_back, bezt->vec[1]));
           }
+        }
+        else {
+          copy_v3_v3(bezt->vec[0], co1_back);
+        }
 
-          changed = true;
+        if (h2_select) {
+          if (!calc_length) {
+            dist_ensure_v3_v3fl(bezt->vec[2], bezt->vec[1], len_v3v3(co2_back, bezt->vec[1]));
+          }
+        }
+        else {
+          copy_v3_v3(bezt->vec[2], co2_back);
         }
-      }
 
-      if (changed) {
-        /* Recalculate the whole curve */
-        BKE_nurb_handles_calc(nu);
+        changed = true;
       }
     }
+
+    if (changed) {
+      /* Recalculate the whole curve */
+      BKE_nurb_handles_calc(nu);
+    }
   }
 }
 
diff --git a/source/blender/blenkernel/intern/displist.c b/source/blender/blenkernel/intern/displist.c
index ff03731b2aa..f5257eb12ab 100644
--- a/source/blender/blenkernel/intern/displist.c
+++ b/source/blender/blenkernel/intern/displist.c
@@ -152,7 +152,6 @@ void BKE_displist_normals_add(ListBase *lb)
   int a, b, p1, p2, p3, p4;
 
   LISTBASE_FOREACH (DispList *, dl, lb) {
-
     if (dl->type == DL_INDEX3) {
       if (dl->nors == NULL) {
         dl->nors = MEM_callocN(sizeof(float[3]), "dlnors");
@@ -306,149 +305,151 @@ static void curve_to_displist(Curve *cu,
   const bool editmode = (!for_render && (cu->editnurb || cu->editfont));
 
   LISTBASE_FOREACH (Nurb *, nu, nubase) {
-    if (nu->hide == 0 || editmode == false) {
-      if (for_render && cu->resolu_ren != 0) {
-        resolu = cu->resolu_ren;
-      }
-      else {
-        resolu = nu->resolu;
-      }
-
-      if (!BKE_nurb_check_valid_u(nu)) {
-        /* pass */
-      }
-      else if (nu->type == CU_BEZIER) {
-        /* count */
-        len = 0;
-        a = nu->pntsu - 1;
-        if (nu->flagu & CU_NURB_CYCLIC) {
-          a++;
-        }
-
-        prevbezt = nu->bezt;
-        bezt = prevbezt + 1;
-        while (a--) {
-          if (a == 0 && (nu->flagu & CU_NURB_CYCLIC)) {
-            bezt = nu->bezt;
-          }
+    if (nu->hide != 0 && editmode) {
+      continue;
+    }
 
-          if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) {
-            len++;
-          }
-          else {
-            len += resolu;
-          }
+    if (for_render && cu->resolu_ren != 0) {
+      resolu = cu->resolu_ren;
+    }
+    else {
+      resolu = nu->resolu;
+    }
 
-          if (a == 0 && (nu->flagu & CU_NURB_CYCLIC) == 0) {
-            len++;
-          }
+    if (!BKE_nurb_check_valid_u(nu)) {
+      /* pass */
+    }
+    else if (nu->type == CU_BEZIER) {
+      /* count */
+      len = 0;
+      a = nu->pntsu - 1;
+      if (nu->flagu & CU_NURB_CYCLIC) {
+        a++;
+      }
 
-          prevbezt = bezt;
-          bezt++;
+      prevbezt = nu->bezt;
+      bezt = prevbezt + 1;
+      while (a--) {
+        if (a == 0 && (nu->flagu & CU_NURB_CYCLIC)) {
+          bezt = nu->bezt;
         }
 
-        dl = MEM_callocN(sizeof(DispList), "makeDispListbez");
-        /* len+1 because of 'forward_diff_bezier' function */
-        dl->verts = MEM_mallocN((len + 1) * sizeof(float[3]), "dlverts");
-        BLI_addtail(dispbase, dl);
-        dl->parts = 1;
-        dl->nr = len;
-        dl->col = nu->mat_nr;
-        dl->charidx = nu->charidx;
-
-        data = dl->verts;
-
-        /* check that (len != 2) so we don't immediately loop back on ourselves */
-        if (nu->flagu & CU_NURB_CYCLIC && (dl->nr != 2)) {
-          dl->type = DL_POLY;
-          a = nu->pntsu;
+        if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) {
+          len++;
         }
         else {
-          dl->type = DL_SEGM;
-          a = nu->pntsu - 1;
+          len += resolu;
         }
 
-        prevbezt = nu->bezt;
-        bezt = prevbezt + 1;
+        if (a == 0 && (nu->flagu & CU_NURB_CYCLIC) == 0) {
+          len++;
+        }
 
-        while (a--) {
-          if (a == 0 && dl->type == DL_POLY) {
-            bezt = nu->bezt;
-          }
+        prevbezt = bezt;
+        bezt++;
+      }
 
-          if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) {
-            copy_v3_v3(data, prevbezt->vec[1]);
-            data += 3;
-          }
-          else {
-            int j;
-            for (j = 0; j < 3; j++) {
-              BKE_curve_forward_diff_bezier(prevbezt->vec[1][j],
-                                            prevbezt->vec[2][j],
-                                            bezt->vec[0][j],
-                                            bezt->vec[1][j],
-                                            data + j,
-                                            resolu,
-                                            sizeof(float[3]));
-            }
+      dl = MEM_callocN(sizeof(DispList), "makeDispListbez");
+      /* len+1 because of 'forward_diff_bezier' function */
+      dl->verts = MEM_mallocN((len + 1) * sizeof(float[3]), "dlverts");
+      BLI_addtail(dispbase, dl);
+      dl->parts = 1;
+      dl->nr = len;
+      dl->col = nu->mat_nr;
+      dl->charidx = nu->charidx;
+
+      data = dl->verts;
+
+      /* check that (len != 2) so we don't immediately loop back on ourselves */
+      if (nu->flagu & CU_NURB_CYCLIC && (dl->nr != 2)) {
+        dl->type = DL_POLY;
+        a = nu->pntsu;
+      }
+      else {
+        dl->type = DL_SEGM;
+        a = nu->pntsu - 1;
+      }
 
-            data += 3 * resolu;
-          }
+      prevbezt = nu->bezt;
+      bezt = prevbezt + 1;
 
-          if (a == 0 && dl->type == DL_SEGM) {
-            copy_v3_v3(data, bezt->vec[1]);
+      while (a--) {
+        if (a == 0 && dl->type == DL_POLY) {
+          bezt = nu->bezt;
+        }
+
+        if (prevbezt->h2 == HD_VECT && bezt->h1 == HD_VECT) {
+          copy_v3_v3(data, prevbezt->vec[1]);
+          data += 3;
+        }
+        else {
+          int j;
+          for (j = 0; j < 3; j++) {
+            BKE_curve_forward_diff_bezier(prevbezt->vec[1][j],
+                                          prevbezt->vec[2][j],
+                                          bezt->vec[0][j],
+                                          bezt->vec[1][j],
+                                          data + j,
+                                          resolu,
+                                          sizeof(float[3]));
           }
 
-          prevbezt = bezt;
-          bezt++;
+          data += 3 * resolu;
         }
+
+        if (a == 0 && dl->type == DL_SEGM) {
+          copy_v3_v3(data, bezt->vec[1]);
+        }
+
+        prevbezt = bezt;
+        bezt++;
       }
-      else if (nu->type == CU_NURBS) {
-        len = (resolu * SEGMENTSU(nu));
+    }
+    else if (nu->type == CU_NURBS) {
+      len = (resolu * SEGMENTSU(nu));
 
-        dl = MEM_callocN(sizeof(DispList), "makeDispListsurf");
-        dl->verts = MEM_mallocN(len * sizeof(float[3]), "dlverts");
-        BLI_addtail(dispbase, dl);
-        dl->parts = 1;
+      dl = MEM_callocN(sizeof(DispList), "makeDispListsurf");
+      dl->verts = MEM_mallocN(len * sizeof(float[3]), "dlverts");
+      BLI_addtail(dispbase, dl);
+      dl->parts = 1;
 
-        dl->nr = len;
-        dl->col = nu->mat_nr;
-        dl->charidx = nu->charidx;
+      dl->nr = len;
+      dl->col = nu->mat_nr;
+      dl->charidx = nu->charidx;
 
-        data = dl->verts;
-        if (nu->flagu & CU_NURB_CYCLIC) {
-          dl->type = DL_POLY;
-        }
-        else {
-          dl->type = DL_SEGM;
-        }
-        BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, sizeof(float[3]));
+      data = dl->verts;
+      if (nu->flagu & CU_NURB_CYCLIC) {
+        dl->type = DL_POLY;
+      }
+      else {
+        dl->type = DL_SEGM;
+      }
+      BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, sizeof(float[3]));
+    }
+    else if (nu->type == CU_POLY) {
+      len = nu->pntsu;
+      dl = MEM_callocN(sizeof(DispList), "makeDispListpoly");
+      dl->verts = MEM_mallocN(len * sizeof(float[3]), "dlverts");
+      BLI_addtail(dispbase, dl);
+      dl->parts = 1;
+      dl->nr = len;
+      dl->col = nu->mat_nr;
+      dl->charidx = nu->charidx;
+
+      data = dl->verts;
+      if ((nu->flagu & CU_NURB_CYCLIC) && (dl->nr != 2)) {
+        dl->type = DL_POLY;
+      }
+      else {
+        dl->type = DL_SEGM;
       }
-      else if (nu->type == CU_POLY) {
-        len = nu->pntsu;
-        dl = MEM_callocN(sizeof(DispList), "makeDispListpoly");
-        dl->verts = MEM_mallocN(len * sizeof(float[3]), "dlverts");
-        BLI_addtail(dispbase, dl);
-        dl->parts = 1;
-        dl->nr = len;
-        dl->col = nu->mat_nr;
-        dl->charidx = nu->charidx;
-
-        data = dl->verts;
-        if ((nu->flagu & CU_NURB_CYCLIC) && (dl->nr != 2)) {
-          dl->type = DL_POLY;
-        }
-        else {
-          dl->type = DL_SEGM;
-        }
 
-        a = len;
-        bp = nu->bp;
-        while (a--) {
-          copy_v3_v3(data, bp->vec);
-          bp++;
-          data += 3;
-        }
+      a = len;
+      bp = nu->bp;
+      while (a--) {
+        copy_v3_v3(data, bp->vec);
+        bp++;
+        data += 3;
       }
     }
   }
@@ -468,7 +469,7 @@ void BKE_displist_fill(ListBase *dispbase,
   ScanFillVert *sf_vert, *sf_vert_new, *sf_vert_last;
   ScanFillFace *sf_tri;
   MemArena *sf_arena;
-  DispList *dlnew = NULL, *dl;
+  DispList *dlnew = NULL;
   float *f1;
   int colnr = 0, charidx = 0, cont = 1, tot, a, *index, nextcol = 0;
   int totvert;
@@ -492,8 +493,7 @@ void BKE_displist_fill(ListBase *dispbase,
 
     BLI_scanfill_begin_arena(&sf_ctx, sf_arena);
 
-    dl = dispbase->first;
-    while (dl) {
+    LISTBASE_FOREACH (DispList *, dl, dispbase) {
       if (dl->type == DL_POLY) {
         if (charidx < dl->charidx) {
           cont = 1;
@@ -535,7 +535,6 @@ void BKE_displist_fill(ListBase *dispbase,
         }
         dl_flag_accum |= dl->flag;
       }
-      dl = dl->next;
     }
 
     /* XXX (obedit && obedit->actcol) ? (obedit->actcol - 1) : 0)) { */
@@ -1208,75 +1207,77 @@ void BKE_displist_make_surf(Depsgraph *depsgraph,
   }
 
   LISTBASE_FOREACH (Nurb *, nu, &nubase) {
-    if ((for_render || nu->hide == 0) && BKE_nurb_check_valid_uv(nu)) {
-      int resolu = nu->resolu, resolv = nu->resolv;
+    if (!(for_render || nu->hide == 0) || !BKE_nurb_check_valid_uv(nu)) {
+      continue;
+    }
 
-      if (for_render) {
-        if (cu->resolu_ren) {
-          resolu = cu->resolu_ren;
-        }
-        if (cu->resolv_ren) {
-          resolv = cu->resolv_ren;
-        }
-      }
+    int resolu = nu->resolu, resolv = nu->resolv;
 
-      if (nu->pntsv == 1) {
-        len = SEGMENTSU(nu) * resolu;
+    if (for_render) {
+      if (cu->resolu_ren) {
+        resolu = cu->resolu_ren;
+      }
+      if (cu->resolv_ren) {
+        resolv = cu->resolv_ren;
+      }
+    }
 
-        dl = MEM_callocN(sizeof(DispList), "makeDispListsurf");
-        dl->verts = MEM_mallocN(len * sizeof(float[3]), "dlverts");
+    if (nu->pntsv == 1) {
+      len = SEGMENTSU(nu) * resolu;
 
-        BLI_addtail(dispbase, dl);
-        dl->parts = 1;
-        dl->nr = len;
-        dl->col = nu->mat_nr;
-        dl->charidx = nu->charidx;
+      dl = MEM_callocN(sizeof(DispList), "makeDispListsurf");
+      dl->verts = MEM_mallocN(len * sizeof(float[3]), "dlverts");
 
-        /* dl->rt will be used as flag for render face and */
-        /* CU_2D conflicts with R_NOPUNOFLIP */
-        dl->rt = nu->flag & ~CU_2D;
+      BLI_addtail(dispbase, dl);
+      dl->parts = 1;
+      dl->nr = len;
+      dl->col = nu->mat_nr;
+      dl->charidx = nu->charidx;
 
-        data = dl->verts;
-        if (nu->flagu & CU_NURB_CYCLIC) {
-          dl->type = DL_POLY;
-        }
-        else {
-          dl->type = DL_SEGM;
-        }
+      /* dl->rt will be used as flag for render face and */
+      /* CU_2D conflicts with R_NOPUNOFLIP */
+      dl->rt = nu->flag & ~CU_2D;
 
-        BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, sizeof(float[3]));
+      data = dl->verts;
+      if (nu->flagu & CU_NURB_CYCLIC) {
+        dl->type = DL_POLY;
       }
       else {
-        len = (nu->pntsu * resolu) * (nu->pntsv * resolv);
-
-        dl = MEM_callocN(sizeof(DispList), "makeDispListsurf");
-        dl->verts = MEM_mallocN(len * sizeof(float[3]), "dlverts");
-        BLI_addtail(dispbase, dl);
+        dl->type = DL_SEGM;
+      }
 
-        dl->col = nu->mat_nr;
-        dl->charidx = nu->charidx;
+      BKE_nurb_makeCurve(nu, data, NULL, NULL, NULL, resolu, sizeof(float[3]));
+    }
+    else {
+      len = (nu->pntsu * resolu) * (nu->pntsv * resolv);
 
-        /* dl->rt will be used as flag for render face and */
-        /* CU_2D conflicts with R_NOPUNOFLIP */
-        dl->rt = nu->flag & ~CU_2D;
+      dl = MEM_callocN(sizeof(DispList), "makeDispListsurf");
+      dl->verts = MEM_mallocN(len * sizeof(float[3]), "dlverts");
+      BLI_addtail(dispbase, dl);
 
-        data = dl->verts;
-        dl->type = DL_SURF;
+      dl->col = nu->mat_nr;
+      dl->charidx = nu->charidx;
 
-        dl->parts = (nu->pntsu * resolu); /* in reverse, because makeNurbfaces works that way */
-        dl->nr = (nu->pntsv * resolv);
-        if (nu->flagv & CU_NURB_CYCLIC) {
-          dl->flag |= DL_CYCL_U; /* reverse too! */
-        }
-        if (nu->flagu & CU_NURB_CYCLIC) {
-          dl->flag |= DL_CYCL_V;
-        }
+      /* dl->rt will be used as flag for render face and */
+      /* CU_2D conflicts with R_NOPUNOFLIP */
+      dl->rt = nu->flag & ~CU_2D;
 
-        BKE_nurb_makeFaces(nu, data, 0, resolu, resolv);
+      data = dl->verts;
+      dl->type = DL_SURF;
 
-        /* gl array drawing: using indices */
-        displist_surf_indices(dl);
+      dl->parts = (nu->pntsu * resolu); /* in reverse, because makeNurbfaces works that way */
+      dl->nr = (nu->pntsv * resolv);
+      if (nu->flagv & CU_NURB_CYCLIC) {
+        dl->flag |= DL_CYCL_U; /* reverse too! */
+      }
+      if (nu->flagu & CU_NURB_CYCLIC) {
+        dl->flag |= DL_CYCL_V;
       }
+
+      BKE_nurb_makeFaces(nu, data, 0, resolu, resolv);
+
+      /* gl array drawing: using indices */
+      displist_surf_indices(dl);
     }
   }
 
diff --git a/source/blender/blenkernel/intern/multires_reshape.c b/source/blender/blenkernel/intern/multires_reshape.c
index 5bcf8f62f86..04ad78ec0de 100644
--- a/source/blender/blenkernel/intern/multires_reshape.c
+++ b/source/blender/blenkernel/intern/multires_reshape.c
@@ -225,7 +225,7 @@ void multiresModifier_subdivide_to_level(struct Object *object,
 
   multires_flush_sculpt_updates(object);
 
-  if (!multires_reshape_context_create_from_subdivide(&reshape_context, object, mmd, top_level)) {
+  if (!multires_reshape_context_create_from_modifier(&reshape_context, object, mmd, top_level)) {
     return;
   }
 
diff --git a/source/blender/blenkernel/intern/multires_reshape.h b/source/blender/blenkernel/intern/multires_reshape.h
index d6c1d79dfd7..9dec1423eba 100644
--- a/source/blender/blenkernel/intern/multires_reshape.h
+++ b/source/blender/blenkernel/intern/multires_reshape.h
@@ -167,10 +167,10 @@ bool multires_reshape_context_create_from_ccg(MultiresReshapeContext *reshape_co
                                               struct Mesh *base_mesh,
                                               int top_level);
 
-bool multires_reshape_context_create_from_subdivide(MultiresReshapeContext *reshape_context,
-                                                    struct Object *object,
-                                                    struct MultiresModifierData *mmd,
-                                                    int top_level);
+bool multires_reshape_context_create_from_modifier(MultiresReshapeContext *reshape_context,
+                                                   struct Object *object,
+                                                   struct MultiresModifierData *mmd,
+                                                   int top_level);
 
 void multires_reshape_free_original_grids(MultiresReshapeContext *reshape_context);
 void multires_reshape_context_free(MultiresReshapeContext *reshape_context);
diff --git a/source/blender/blenkernel/intern/multires_reshape_subdivide.c b/source/blender/blenkernel/intern/multires_reshape_subdivide.c
index 7b7c1efc533..d42a061084f 100644
--- a/source/blender/blenkernel/intern/multires_reshape_subdivide.c
+++ b/source/blender/blenkernel/intern/multires_reshape_subdivide.c
@@ -96,7 +96,7 @@ void multires_subdivide_create_tangent_displacement_linear_grids(Object *object,
   /* Convert the new grids to tangent displacement. */
   multires_set_tot_level(object, mmd, new_top_level);
 
-  if (!multires_reshape_context_create_from_subdivide(
+  if (!multires_reshape_context_create_from_modifier(
           &reshape_context, object, mmd, new_top_level)) {
     return;
   }
diff --git a/source/blender/blenkernel/intern/multires_reshape_util.c b/source/blender/blenkernel/intern/multires_reshape_util.c
index c8179dd8a2d..f3b19961e29 100644
--- a/source/blender/blenkernel/intern/multires_reshape_util.c
+++ b/source/blender/blenkernel/intern/multires_reshape_util.c
@@ -242,10 +242,10 @@ bool multires_reshape_context_create_from_ccg(MultiresReshapeContext *reshape_co
   return context_verify_or_free(reshape_context);
 }
 
-bool multires_reshape_context_create_from_subdivide(MultiresReshapeContext *reshape_context,
-                                                    struct Object *object,
-                                                    struct MultiresModifierData *mmd,
-                                                    int top_level)
+bool multires_reshape_context_create_from_modifier(MultiresReshapeContext *reshape_context,
+                                                   struct Object *object,
+                                                   struct MultiresModifierData *mmd,
+                                                   int top_level)
 {
   context_zero(reshape_context);
 
diff --git a/source/blender/editors/curve/editcurve.c b/source/blender/editors/curve/editcurve.c
index 49c75e0b4a1..15f3939b2f6 100644
--- a/source/blender/editors/curve/editcurve.c
+++ b/source/blender/editors/curve/editcurve.c
@@ -307,12 +307,8 @@ static void keyIndex_delNurb(EditNurb *editnurb, Nurb *nu)
 
 static void keyIndex_delNurbList(EditNurb *editnurb, ListBase *nubase)
 {
-  Nurb *nu = nubase->first;
-
-  while (nu) {
+  LISTBASE_FOREACH (Nurb *, nu, nubase) {
     keyIndex_delNurb(editnurb, nu);
-
-    nu = nu->next;
   }
 }
 
@@ -646,250 +642,247 @@ static void calc_shapeKeys(Object *obedit, ListBase *newnurbs)
 {
   Curve *cu = (Curve *)obedit->data;
 
-  /* are there keys? */
-  if (cu->key) {
-    int a, i;
-    EditNurb *editnurb = cu->editnurb;
-    KeyBlock *currkey;
-    KeyBlock *actkey = BLI_findlink(&cu->key->block, editnurb->shapenr - 1);
-    BezTriple *bezt, *oldbezt;
-    BPoint *bp, *oldbp;
-    Nurb *newnu;
-    int totvert = BKE_keyblock_curve_element_count(&editnurb->nurbs);
+  if (cu->key == NULL) {
+    return;
+  }
+
+  int a, i;
+  EditNurb *editnurb = cu->editnurb;
+  KeyBlock *actkey = BLI_findlink(&cu->key->block, editnurb->shapenr - 1);
+  BezTriple *bezt, *oldbezt;
+  BPoint *bp, *oldbp;
+  Nurb *newnu;
+  int totvert = BKE_keyblock_curve_element_count(&editnurb->nurbs);
 
-    float(*ofs)[3] = NULL;
-    float *oldkey, *newkey, *ofp;
+  float(*ofs)[3] = NULL;
+  float *oldkey, *newkey, *ofp;
 
-    /* editing the base key should update others */
-    if (cu->key->type == KEY_RELATIVE) {
-      if (BKE_keyblock_is_basis(cu->key, editnurb->shapenr - 1)) { /* active key is a base */
-        int totvec = 0;
+  /* editing the base key should update others */
+  if (cu->key->type == KEY_RELATIVE) {
+    if (BKE_keyblock_is_basis(cu->key, editnurb->shapenr - 1)) { /* active key is a base */
+      int totvec = 0;
 
-        /* Calculate needed memory to store offset */
-        LISTBASE_FOREACH (Nurb *, nu, &editnurb->nurbs) {
+      /* Calculate needed memory to store offset */
+      LISTBASE_FOREACH (Nurb *, nu, &editnurb->nurbs) {
 
-          if (nu->bezt) {
-            /* Three vects to store handles and one for tilt. */
-            totvec += nu->pntsu * 4;
-          }
-          else {
-            totvec += 2 * nu->pntsu * nu->pntsv;
-          }
+        if (nu->bezt) {
+          /* Three vects to store handles and one for tilt. */
+          totvec += nu->pntsu * 4;
+        }
+        else {
+          totvec += 2 * nu->pntsu * nu->pntsv;
         }
+      }
 
-        ofs = MEM_callocN(sizeof(float[3]) * totvec, "currkey->data");
-        i = 0;
-        LISTBASE_FOREACH (Nurb *, nu, &editnurb->nurbs) {
-          if (nu->bezt) {
-            bezt = nu->bezt;
-            a = nu->pntsu;
-            while (a--) {
-              oldbezt = getKeyIndexOrig_bezt(editnurb, bezt);
+      ofs = MEM_callocN(sizeof(float[3]) * totvec, "currkey->data");
+      i = 0;
+      LISTBASE_FOREACH (Nurb *, nu, &editnurb->nurbs) {
+        if (nu->bezt) {
+          bezt = nu->bezt;
+          a = nu->pntsu;
+          while (a--) {
+            oldbezt = getKeyIndexOrig_bezt(editnurb, bezt);
 
-              if (oldbezt) {
-                int j;
-                for (j = 0; j < 3; j++) {
-                  sub_v3_v3v3(ofs[i], bezt->vec[j], oldbezt->vec[j]);
-                  i++;
-                }
-                ofs[i][0] = bezt->tilt - oldbezt->tilt;
-                ofs[i][1] = bezt->radius - oldbezt->radius;
+            if (oldbezt) {
+              int j;
+              for (j = 0; j < 3; j++) {
+                sub_v3_v3v3(ofs[i], bezt->vec[j], oldbezt->vec[j]);
                 i++;
               }
-              else {
-                i += 4;
-              }
-              bezt++;
+              ofs[i][0] = bezt->tilt - oldbezt->tilt;
+              ofs[i][1] = bezt->radius - oldbezt->radius;
+              i++;
+            }
+            else {
+              i += 4;
             }
+            bezt++;
           }
-          else {
-            bp = nu->bp;
-            a = nu->pntsu * nu->pntsv;
-            while (a--) {
-              oldbp = getKeyIndexOrig_bp(editnurb, bp);
-              if (oldbp) {
-                sub_v3_v3v3(ofs[i], bp->vec, oldbp->vec);
-                ofs[i + 1][0] = bp->tilt - oldbp->tilt;
-                ofs[i + 1][1] = bp->radius - oldbp->radius;
-              }
-              i += 2;
-              bp++;
+        }
+        else {
+          bp = nu->bp;
+          a = nu->pntsu * nu->pntsv;
+          while (a--) {
+            oldbp = getKeyIndexOrig_bp(editnurb, bp);
+            if (oldbp) {
+              sub_v3_v3v3(ofs[i], bp->vec, oldbp->vec);
+              ofs[i + 1][0] = bp->tilt - oldbp->tilt;
+              ofs[i + 1][1] = bp->radius - oldbp->radius;
             }
+            i += 2;
+            bp++;
           }
         }
       }
     }
+  }
 
-    currkey = cu->key->block.first;
-    while (currkey) {
-      const bool apply_offset = (ofs && (currkey != actkey) &&
-                                 (editnurb->shapenr - 1 == currkey->relative));
-
-      float *fp = newkey = MEM_callocN(cu->key->elemsize * totvert, "currkey->data");
-      ofp = oldkey = currkey->data;
-
-      Nurb *nu = editnurb->nurbs.first;
-      /* We need to restore to original curve into newnurb, *not* editcurve's nurbs.
-       * Otherwise, in case we update obdata *without* leaving editmode (e.g. viewport render),
-       * we would invalidate editcurve. */
-      newnu = newnurbs->first;
-      i = 0;
-      while (nu) {
-        if (currkey == actkey) {
-          const bool restore = actkey != cu->key->refkey;
-
-          if (nu->bezt) {
-            bezt = nu->bezt;
-            a = nu->pntsu;
-            BezTriple *newbezt = newnu->bezt;
-            while (a--) {
-              int j;
-              oldbezt = getKeyIndexOrig_bezt(editnurb, bezt);
+  LISTBASE_FOREACH (KeyBlock *, currkey, &cu->key->block) {
+    const bool apply_offset = (ofs && (currkey != actkey) &&
+                               (editnurb->shapenr - 1 == currkey->relative));
+
+    float *fp = newkey = MEM_callocN(cu->key->elemsize * totvert, "currkey->data");
+    ofp = oldkey = currkey->data;
+
+    Nurb *nu = editnurb->nurbs.first;
+    /* We need to restore to original curve into newnurb, *not* editcurve's nurbs.
+     * Otherwise, in case we update obdata *without* leaving editmode (e.g. viewport render),
+     * we would invalidate editcurve. */
+    newnu = newnurbs->first;
+    i = 0;
+    while (nu) {
+      if (currkey == actkey) {
+        const bool restore = actkey != cu->key->refkey;
 
-              for (j = 0; j < 3; j++, i++) {
-                copy_v3_v3(&fp[j * 3], bezt->vec[j]);
+        if (nu->bezt) {
+          bezt = nu->bezt;
+          a = nu->pntsu;
+          BezTriple *newbezt = newnu->bezt;
+          while (a--) {
+            int j;
+            oldbezt = getKeyIndexOrig_bezt(editnurb, bezt);
 
-                if (restore && oldbezt) {
-                  copy_v3_v3(newbezt->vec[j], oldbezt->vec[j]);
-                }
-              }
-              fp[9] = bezt->tilt;
-              fp[10] = bezt->radius;
+            for (j = 0; j < 3; j++, i++) {
+              copy_v3_v3(&fp[j * 3], bezt->vec[j]);
 
               if (restore && oldbezt) {
-                newbezt->tilt = oldbezt->tilt;
-                newbezt->radius = oldbezt->radius;
+                copy_v3_v3(newbezt->vec[j], oldbezt->vec[j]);
               }
+            }
+            fp[9] = bezt->tilt;
+            fp[10] = bezt->radius;
 
-              fp += KEYELEM_FLOAT_LEN_BEZTRIPLE;
-              i++;
-              bezt++;
-              newbezt++;
+            if (restore && oldbezt) {
+              newbezt->tilt = oldbezt->tilt;
+              newbezt->radius = oldbezt->radius;
             }
-          }
-          else {
-            bp = nu->bp;
-            a = nu->pntsu * nu->pntsv;
-            BPoint *newbp = newnu->bp;
-            while (a--) {
-              oldbp = getKeyIndexOrig_bp(editnurb, bp);
 
-              copy_v3_v3(fp, bp->vec);
+            fp += KEYELEM_FLOAT_LEN_BEZTRIPLE;
+            i++;
+            bezt++;
+            newbezt++;
+          }
+        }
+        else {
+          bp = nu->bp;
+          a = nu->pntsu * nu->pntsv;
+          BPoint *newbp = newnu->bp;
+          while (a--) {
+            oldbp = getKeyIndexOrig_bp(editnurb, bp);
 
-              fp[3] = bp->tilt;
-              fp[4] = bp->radius;
+            copy_v3_v3(fp, bp->vec);
 
-              if (restore && oldbp) {
-                copy_v3_v3(newbp->vec, oldbp->vec);
-                newbp->tilt = oldbp->tilt;
-                newbp->radius = oldbp->radius;
-              }
+            fp[3] = bp->tilt;
+            fp[4] = bp->radius;
 
-              fp += KEYELEM_FLOAT_LEN_BPOINT;
-              bp++;
-              newbp++;
-              i += 2;
+            if (restore && oldbp) {
+              copy_v3_v3(newbp->vec, oldbp->vec);
+              newbp->tilt = oldbp->tilt;
+              newbp->radius = oldbp->radius;
             }
+
+            fp += KEYELEM_FLOAT_LEN_BPOINT;
+            bp++;
+            newbp++;
+            i += 2;
           }
         }
-        else {
-          int index;
-          const float *curofp;
-
-          if (oldkey) {
-            if (nu->bezt) {
-              bezt = nu->bezt;
-              a = nu->pntsu;
+      }
+      else {
+        int index;
+        const float *curofp;
 
-              while (a--) {
-                index = getKeyIndexOrig_keyIndex(editnurb, bezt);
-                if (index >= 0) {
-                  int j;
-                  curofp = ofp + index;
+        if (oldkey) {
+          if (nu->bezt) {
+            bezt = nu->bezt;
+            a = nu->pntsu;
 
-                  for (j = 0; j < 3; j++, i++) {
-                    copy_v3_v3(&fp[j * 3], &curofp[j * 3]);
+            while (a--) {
+              index = getKeyIndexOrig_keyIndex(editnurb, bezt);
+              if (index >= 0) {
+                int j;
+                curofp = ofp + index;
 
-                    if (apply_offset) {
-                      add_v3_v3(&fp[j * 3], ofs[i]);
-                    }
-                  }
-                  fp[9] = curofp[9];
-                  fp[10] = curofp[10];
+                for (j = 0; j < 3; j++, i++) {
+                  copy_v3_v3(&fp[j * 3], &curofp[j * 3]);
 
                   if (apply_offset) {
-                    /* Apply tilt offsets. */
-                    add_v3_v3(fp + 9, ofs[i]);
-                    i++;
+                    add_v3_v3(&fp[j * 3], ofs[i]);
                   }
+                }
+                fp[9] = curofp[9];
+                fp[10] = curofp[10];
 
-                  fp += KEYELEM_FLOAT_LEN_BEZTRIPLE;
+                if (apply_offset) {
+                  /* Apply tilt offsets. */
+                  add_v3_v3(fp + 9, ofs[i]);
+                  i++;
                 }
-                else {
-                  int j;
-                  for (j = 0; j < 3; j++, i++) {
-                    copy_v3_v3(&fp[j * 3], bezt->vec[j]);
-                  }
-                  fp[9] = bezt->tilt;
-                  fp[10] = bezt->radius;
 
-                  fp += KEYELEM_FLOAT_LEN_BEZTRIPLE;
+                fp += KEYELEM_FLOAT_LEN_BEZTRIPLE;
+              }
+              else {
+                int j;
+                for (j = 0; j < 3; j++, i++) {
+                  copy_v3_v3(&fp[j * 3], bezt->vec[j]);
                 }
-                bezt++;
+                fp[9] = bezt->tilt;
+                fp[10] = bezt->radius;
+
+                fp += KEYELEM_FLOAT_LEN_BEZTRIPLE;
               }
+              bezt++;
             }
-            else {
-              bp = nu->bp;
-              a = nu->pntsu * nu->pntsv;
-              while (a--) {
-                index = getKeyIndexOrig_keyIndex(editnurb, bp);
+          }
+          else {
+            bp = nu->bp;
+            a = nu->pntsu * nu->pntsv;
+            while (a--) {
+              index = getKeyIndexOrig_keyIndex(editnurb, bp);
 
-                if (index >= 0) {
-                  curofp = ofp + index;
-                  copy_v3_v3(fp, curofp);
-                  fp[3] = curofp[3];
-                  fp[4] = curofp[4];
+              if (index >= 0) {
+                curofp = ofp + index;
+                copy_v3_v3(fp, curofp);
+                fp[3] = curofp[3];
+                fp[4] = curofp[4];
 
-                  if (apply_offset) {
-                    add_v3_v3(fp, ofs[i]);
-                    add_v3_v3(&fp[3], ofs[i + 1]);
-                  }
-                }
-                else {
-                  copy_v3_v3(fp, bp->vec);
-                  fp[3] = bp->tilt;
-                  fp[4] = bp->radius;
+                if (apply_offset) {
+                  add_v3_v3(fp, ofs[i]);
+                  add_v3_v3(&fp[3], ofs[i + 1]);
                 }
-
-                fp += KEYELEM_FLOAT_LEN_BPOINT;
-                bp++;
-                i += 2;
               }
+              else {
+                copy_v3_v3(fp, bp->vec);
+                fp[3] = bp->tilt;
+                fp[4] = bp->radius;
+              }
+
+              fp += KEYELEM_FLOAT_LEN_BPOINT;
+              bp++;
+              i += 2;
             }
           }
         }
-
-        nu = nu->next;
-        newnu = newnu->next;
-      }
-
-      if (apply_offset) {
-        /* handles could become malicious after offsets applying */
-        calc_keyHandles(&editnurb->nurbs, newkey);
       }
 
-      currkey->totelem = totvert;
-      if (currkey->data) {
-        MEM_freeN(currkey->data);
-      }
-      currkey->data = newkey;
+      nu = nu->next;
+      newnu = newnu->next;
+    }
 
-      currkey = currkey->next;
+    if (apply_offset) {
+      /* handles could become malicious after offsets applying */
+      calc_keyHandles(&editnurb->nurbs, newkey);
     }
 
-    if (ofs) {
-      MEM_freeN(ofs);
+    currkey->totelem = totvert;
+    if (currkey->data) {
+      MEM_freeN(currkey->data);
     }
+    currkey->data = newkey;
+  }
+
+  if (ofs) {
+    MEM_freeN(ofs);
   }
 }
 
diff --git a/source/blender/editors/gpencil/gpencil_mesh.c b/source/blender/editors/gpencil/gpencil_mesh.c
index 7cf4325d03b..c136ef2070e 100644
--- a/source/blender/editors/gpencil/gpencil_mesh.c
+++ b/source/blender/editors/gpencil/gpencil_mesh.c
@@ -221,27 +221,17 @@ static int gpencil_bake_mesh_animation_exec(bContext *C, wmOperator *op)
   const bool only_selected = RNA_boolean_get(op->ptr, "only_selected");
   const float offset = RNA_float_get(op->ptr, "offset");
   const int frame_offset = RNA_int_get(op->ptr, "frame_target") - frame_start;
-  char target[64];
-  RNA_string_get(op->ptr, "target", target);
   const int project_type = RNA_enum_get(op->ptr, "project_type");
+  ob_gpencil = (Object *)RNA_pointer_get(op->ptr, "target").data;
 
   /* Create a new grease pencil object in origin. */
   bool newob = false;
-  if (STREQ(target, "*NEW")) {
+  if (ob_gpencil == NULL) {
     ushort local_view_bits = (v3d && v3d->localvd) ? v3d->local_view_uuid : 0;
     const float loc[3] = {0.0f, 0.0f, 0.0f};
     ob_gpencil = ED_gpencil_add_object(C, loc, local_view_bits);
     newob = true;
   }
-  else {
-    ob_gpencil = BLI_findstring(&bmain->objects, target, offsetof(ID, name) + 2);
-  }
-
-  if ((ob_gpencil == NULL) || (ob_gpencil->type != OB_GPENCIL)) {
-    BKE_report(op->reports, RPT_ERROR, "Target grease pencil object not valid");
-    gpencil_bake_free_ob_list(&ob_selected_list);
-    return OPERATOR_CANCELLED;
-  }
 
   bGPdata *gpd = (bGPdata *)ob_gpencil->data;
   gpd->draw_mode = (project_type == GP_REPROJECT_KEEP) ? GP_DRAWMODE_3D : GP_DRAWMODE_2D;
@@ -384,6 +374,19 @@ static int gpencil_bake_mesh_animation_exec(bContext *C, wmOperator *op)
   return OPERATOR_FINISHED;
 }
 
+static int gpencil_bake_mesh_animation_invoke(bContext *C,
+                                              wmOperator *op,
+                                              const wmEvent *UNUSED(event))
+{
+  /* Show popup dialog to allow editing. */
+  /* FIXME: hard-coded dimensions here are just arbitrary. */
+  return WM_operator_props_dialog_popup(C, op, 250);
+}
+
+static bool rna_GPencil_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
+{
+  return ((Object *)value.owner_id)->type == OB_GPENCIL;
+}
 void GPENCIL_OT_bake_mesh_animation(wmOperatorType *ot)
 {
   static const EnumPropertyItem reproject_type[] = {
@@ -413,6 +416,7 @@ void GPENCIL_OT_bake_mesh_animation(wmOperatorType *ot)
   ot->description = "Bake Mesh Animation to Grease Pencil strokes";
 
   /* callbacks */
+  ot->invoke = gpencil_bake_mesh_animation_invoke;
   ot->exec = gpencil_bake_mesh_animation_exec;
   ot->poll = gpencil_bake_mesh_animation_poll;
 
@@ -420,7 +424,15 @@ void GPENCIL_OT_bake_mesh_animation(wmOperatorType *ot)
   ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
 
   /* properties */
-  ot->prop = RNA_def_int(
+  ot->prop = RNA_def_pointer_runtime(ot->srna,
+                                     "target",
+                                     &RNA_Object,
+                                     "Target Object",
+                                     "Target grease pencil object. Leave empty for new object");
+  RNA_def_property_poll_runtime(ot->prop, rna_GPencil_object_poll);
+  RNA_def_property_flag(ot->prop, PROP_SKIP_SAVE);
+
+  prop = RNA_def_int(
       ot->srna, "frame_start", 1, 1, 100000, "Start Frame", "The start frame", 1, 100000);
 
   prop = RNA_def_int(
@@ -429,6 +441,8 @@ void GPENCIL_OT_bake_mesh_animation(wmOperatorType *ot)
 
   prop = RNA_def_int(ot->srna, "step", 1, 1, 100, "Step", "Step between generated frames", 1, 100);
 
+  RNA_def_int(ot->srna, "thickness", 1, 1, 100, "Thickness", "", 1, 100);
+
   prop = RNA_def_float_rotation(ot->srna,
                                 "angle",
                                 0,
@@ -441,20 +455,22 @@ void GPENCIL_OT_bake_mesh_animation(wmOperatorType *ot)
                                 DEG2RADF(180.0f));
   RNA_def_property_float_default(prop, DEG2RADF(70.0f));
 
-  RNA_def_int(ot->srna, "thickness", 1, 1, 100, "Thickness", "", 1, 100);
+  RNA_def_float_distance(ot->srna,
+                         "offset",
+                         0.001f,
+                         0.0,
+                         100.0,
+                         "Stroke Offset",
+                         "Offset strokes from fill",
+                         0.0,
+                         100.00);
+
   RNA_def_boolean(ot->srna, "seams", 0, "Only Seam Edges", "Convert only seam edges");
   RNA_def_boolean(ot->srna, "faces", 1, "Export Faces", "Export faces as filled strokes");
   RNA_def_boolean(
       ot->srna, "only_selected", 0, "Only Selected Keyframes", "Convert only selected keyframes");
-  RNA_def_float_distance(
-      ot->srna, "offset", 0.001f, 0.0, 100.0, "Offset", "Offset strokes from fill", 0.0, 100.00);
-  RNA_def_int(ot->srna, "frame_target", 1, 1, 100000, "Frame Target", "", 1, 100000);
-  RNA_def_string(ot->srna,
-                 "target",
-                 "*NEW",
-                 64,
-                 "Target Object",
-                 "Target grease pencil object name. Leave empty for new object");
+  RNA_def_int(
+      ot->srna, "frame_target", 1, 1, 100000, "Target Frame", "Destination frame", 1, 100000);
 
   RNA_def_enum(ot->srna, "project_type", reproject_type, GP_REPROJECT_VIEW, "Projection Type", "");
 }
diff --git a/source/blender/editors/space_file/fsmenu.c b/source/blender/editors/space_file/fsmenu.c
index 329b5fe67fd..b7d47902fe8 100644
--- a/source/blender/editors/space_file/fsmenu.c
+++ b/source/blender/editors/space_file/fsmenu.c
@@ -203,7 +203,7 @@ static void fsmenu_xdg_insert_entry(GHash *xdg_map,
     xdg_path = xdg_path_buf;
   }
   fsmenu_insert_entry(
-      fsmenu, FS_CATEGORY_SYSTEM_BOOKMARKS, xdg_path, IFACE_(default_path), icon, FS_INSERT_LAST);
+      fsmenu, FS_CATEGORY_SYSTEM_BOOKMARKS, xdg_path, N_(default_path), icon, FS_INSERT_LAST);
 }
 
 /** \} */
@@ -698,49 +698,49 @@ void fsmenu_read_system(struct FSMenu *fsmenu, int read_bookmarks)
       fsmenu_add_windows_folder(fsmenu,
                                 FS_CATEGORY_SYSTEM_BOOKMARKS,
                                 &FOLDERID_Profile,
-                                IFACE_("Home"),
+                                N_("Home"),
                                 ICON_HOME,
                                 FS_INSERT_LAST);
       fsmenu_add_windows_folder(fsmenu,
                                 FS_CATEGORY_SYSTEM_BOOKMARKS,
                                 &FOLDERID_Desktop,
-                                IFACE_("Desktop"),
+                                N_("Desktop"),
                                 ICON_DESKTOP,
                                 FS_INSERT_LAST);
       fsmenu_add_windows_folder(fsmenu,
                                 FS_CATEGORY_SYSTEM_BOOKMARKS,
                                 &FOLDERID_Documents,
-                                IFACE_("Documents"),
+                                N_("Documents"),
                                 ICON_DOCUMENTS,
                                 FS_INSERT_LAST);
       fsmenu_add_windows_folder(fsmenu,
                                 FS_CATEGORY_SYSTEM_BOOKMARKS,
                                 &FOLDERID_Downloads,
-                                IFACE_("Downloads"),
+                                N_("Downloads"),
                                 ICON_IMPORT,
                                 FS_INSERT_LAST);
       fsmenu_add_windows_folder(fsmenu,
                                 FS_CATEGORY_SYSTEM_BOOKMARKS,
                                 &FOLDERID_Music,
-                                IFACE_("Music"),
+                                N_("Music"),
                                 ICON_FILE_SOUND,
                                 FS_INSERT_LAST);
       fsmenu_add_windows_folder(fsmenu,
                                 FS_CATEGORY_SYSTEM_BOOKMARKS,
                                 &FOLDERID_Pictures,
-                                IFACE_("Pictures"),
+                                N_("Pictures"),
                                 ICON_FILE_IMAGE,
                                 FS_INSERT_LAST);
       fsmenu_add_windows_folder(fsmenu,
                                 FS_CATEGORY_SYSTEM_BOOKMARKS,
                                 &FOLDERID_Videos,
-                                IFACE_("Videos"),
+                                N_("Videos"),
                                 ICON_FILE_MOVIE,
                                 FS_INSERT_LAST);
       fsmenu_add_windows_folder(fsmenu,
                                 FS_CATEGORY_SYSTEM_BOOKMARKS,
                                 &FOLDERID_Fonts,
-                                IFACE_("Fonts"),
+                                N_("Fonts"),
                                 ICON_FILE_FONT,
                                 FS_INSERT_LAST);
 
@@ -757,16 +757,12 @@ void fsmenu_read_system(struct FSMenu *fsmenu, int read_bookmarks)
   {
     /* We store some known macOS system paths and corresponding icons
      * and names in the FS_CATEGORY_OTHER (not displayed directly) category. */
-    fsmenu_insert_entry(fsmenu,
-                        FS_CATEGORY_OTHER,
-                        "/Library/Fonts/",
-                        IFACE_("Fonts"),
-                        ICON_FILE_FONT,
-                        FS_INSERT_LAST);
+    fsmenu_insert_entry(
+        fsmenu, FS_CATEGORY_OTHER, "/Library/Fonts/", N_("Fonts"), ICON_FILE_FONT, FS_INSERT_LAST);
     fsmenu_insert_entry(fsmenu,
                         FS_CATEGORY_OTHER,
                         "/Applications/",
-                        IFACE_("Applications"),
+                        N_("Applications"),
                         ICON_FILE_FOLDER,
                         FS_INSERT_LAST);
 
@@ -777,13 +773,13 @@ void fsmenu_read_system(struct FSMenu *fsmenu, int read_bookmarks)
     fsmenu_insert_entry(fsmenu, FS_CATEGORY_OTHER, line, name, icon, FS_INSERT_LAST);
 
     FS_MACOS_PATH("%s/", NULL, ICON_HOME)
-    FS_MACOS_PATH("%s/Desktop/", IFACE_("Desktop"), ICON_DESKTOP)
-    FS_MACOS_PATH("%s/Documents/", IFACE_("Documents"), ICON_DOCUMENTS)
-    FS_MACOS_PATH("%s/Downloads/", IFACE_("Downloads"), ICON_IMPORT)
-    FS_MACOS_PATH("%s/Movies/", IFACE_("Movies"), ICON_FILE_MOVIE)
-    FS_MACOS_PATH("%s/Music/", IFACE_("Music"), ICON_FILE_SOUND)
-    FS_MACOS_PATH("%s/Pictures/", IFACE_("Pictures"), ICON_FILE_IMAGE)
-    FS_MACOS_PATH("%s/Library/Fonts/", IFACE_("Fonts"), ICON_FILE_FONT)
+    FS_MACOS_PATH("%s/Desktop/", N_("Desktop"), ICON_DESKTOP)
+    FS_MACOS_PATH("%s/Documents/", N_("Documents"), ICON_DOCUMENTS)
+    FS_MACOS_PATH("%s/Downloads/", N_("Downloads"), ICON_IMPORT)
+    FS_MACOS_PATH("%s/Movies/", N_("Movies"), ICON_FILE_MOVIE)
+    FS_MACOS_PATH("%s/Music/", N_("Music"), ICON_FILE_SOUND)
+    FS_MACOS_PATH("%s/Pictures/", N_("Pictures"), ICON_FILE_IMAGE)
+    FS_MACOS_PATH("%s/Library/Fonts/", N_("Fonts"), ICON_FILE_FONT)
 
 #  undef FS_MACOS_PATH
 
@@ -902,7 +898,7 @@ void fsmenu_read_system(struct FSMenu *fsmenu, int read_bookmarks)
     if (read_bookmarks && home) {
 
       fsmenu_insert_entry(
-          fsmenu, FS_CATEGORY_SYSTEM_BOOKMARKS, home, IFACE_("Home"), ICON_HOME, FS_INSERT_LAST);
+          fsmenu, FS_CATEGORY_SYSTEM_BOOKMARKS, home, N_("Home"), ICON_HOME, FS_INSERT_LAST);
 
       /* Follow the XDG spec, check if these are available. */
       GHash *xdg_map = fsmenu_xdg_user_dirs_parse(home);
diff --git a/source/blender/editors/space_graph/graph_draw.c b/source/blender/editors/space_graph/graph_draw.c
index d430e331b6c..2e33f3ef4c7 100644
--- a/source/blender/editors/space_graph/graph_draw.c
+++ b/source/blender/editors/space_graph/graph_draw.c
@@ -321,10 +321,12 @@ static void draw_fcurve_active_handle_vertices(const FCurve *fcu,
   immUniformColor3fvAlpha(active_col, 0.01f); /* Almost invisible - only keep for smoothness. */
   immBeginAtMost(GPU_PRIM_POINTS, 2);
 
-  if ((bezt->f1 & SELECT)) {
+  const BezTriple *left_bezt = active_keyframe_index > 0 ? &fcu->bezt[active_keyframe_index - 1] :
+                                                           bezt;
+  if (left_bezt->ipo == BEZT_IPO_BEZ && (bezt->f1 & SELECT)) {
     immVertex2fv(pos, bezt->vec[0]);
   }
-  if ((bezt->f3 & SELECT)) {
+  if (bezt->ipo == BEZT_IPO_BEZ && (bezt->f3 & SELECT)) {
     immVertex2fv(pos, bezt->vec[2]);
   }
   immEnd();
diff --git a/source/blender/editors/space_graph/graph_select.c b/source/blender/editors/space_graph/graph_select.c
index df89a4ff725..57aaa1fefce 100644
--- a/source/blender/editors/space_graph/graph_select.c
+++ b/source/blender/editors/space_graph/graph_select.c
@@ -1481,6 +1481,7 @@ static int mouse_graph_keys(bAnimContext *ac,
 
   /* if points can be selected on this F-Curve */
   /* TODO: what about those with no keyframes? */
+  bool something_was_selected = false;
   if (!curves_only && ((nvi->fcu->flag & FCURVE_PROTECTED) == 0)) {
     /* only if there's keyframe */
     if (nvi->bezt) {
@@ -1488,14 +1489,17 @@ static int mouse_graph_keys(bAnimContext *ac,
       if (select_mode == SELECT_INVERT) {
         if (nvi->hpoint == NEAREST_HANDLE_KEY) {
           bezt->f2 ^= SELECT;
+          something_was_selected = (bezt->f2 & SELECT);
         }
         else if (nvi->hpoint == NEAREST_HANDLE_LEFT) {
           /* toggle selection */
           bezt->f1 ^= SELECT;
+          something_was_selected = (bezt->f1 & SELECT);
         }
         else {
           /* toggle selection */
           bezt->f3 ^= SELECT;
+          something_was_selected = (bezt->f3 & SELECT);
         }
       }
       else {
@@ -1508,6 +1512,7 @@ static int mouse_graph_keys(bAnimContext *ac,
         else {
           bezt->f3 |= SELECT;
         }
+        something_was_selected = true;
       }
 
       if (!run_modal && BEZT_ISSEL_ANY(bezt) && !already_selected) {
@@ -1558,10 +1563,10 @@ static int mouse_graph_keys(bAnimContext *ac,
     }
   }
 
-  /* Set active F-Curve, except when dragging the selected keys.
-   * needs to be called with (sipo->flag & SIPO_SELCUVERTSONLY)
+  /* Set active F-Curve when something was actually selected (so not on a deselect), except when
+   * dragging the selected keys. Needs to be called with (sipo->flag & SIPO_SELCUVERTSONLY),
    * otherwise the active flag won't be set T26452. */
-  if (!run_modal && nvi->fcu->flag & FCURVE_SELECTED) {
+  if (!run_modal && (nvi->fcu->flag & FCURVE_SELECTED) && something_was_selected) {
     /* NOTE: Sync the filter flags with findnearest_fcurve_vert. */
     int filter = (ANIMFILTER_DATA_VISIBLE | ANIMFILTER_CURVE_VISIBLE | ANIMFILTER_NODUPLIS);
     ANIM_set_active_channel(ac, ac->data, ac->datatype, filter, nvi->fcu, nvi->ctype);
diff --git a/source/blender/gpu/intern/gpu_state.cc b/source/blender/gpu/intern/gpu_state.cc
index fae196b202a..0b2e4989a33 100644
--- a/source/blender/gpu/intern/gpu_state.cc
+++ b/source/blender/gpu/intern/gpu_state.cc
@@ -394,8 +394,9 @@ StateManager::StateManager(void)
   state.logic_op_xor = false;
   state.invert_facing = false;
   state.shadow_bias = false;
-  state.polygon_smooth = false;
   state.clip_distances = 0;
+  state.polygon_smooth = false;
+  state.line_smooth = false;
 
   mutable_state.depth_range[0] = 0.0f;
   mutable_state.depth_range[1] = 1.0f;