Merge branch 'master' into soc-2019-openxr

5 files changed, 180 insertions, 43 deletions

diff --git a/source/blender/draw/intern/draw_cache.c b/source/blender/draw/intern/draw_cache.c
index ed099bae2eb..e2e98a2db5a 100644
--- a/source/blender/draw/intern/draw_cache.c
+++ b/source/blender/draw/intern/draw_cache.c
@@ -4037,7 +4037,7 @@ void drw_batch_cache_generate_requested(Object *ob)
   const enum eContextObjectMode mode = CTX_data_mode_enum_ex(
       draw_ctx->object_edit, draw_ctx->obact, draw_ctx->object_mode);
   const bool is_paint_mode = ELEM(
-      mode, CTX_MODE_PAINT_TEXTURE, CTX_MODE_PAINT_VERTEX, CTX_MODE_PAINT_WEIGHT);
+      mode, CTX_MODE_SCULPT, CTX_MODE_PAINT_TEXTURE, CTX_MODE_PAINT_VERTEX, CTX_MODE_PAINT_WEIGHT);
 
   const bool use_hide = ((ob->type == OB_MESH) &&
                          ((is_paint_mode && (ob == draw_ctx->obact) &&
diff --git a/source/blender/draw/intern/draw_cache_impl_mesh.c b/source/blender/draw/intern/draw_cache_impl_mesh.c
index 1ebdab19375..f3089231e8c 100644
--- a/source/blender/draw/intern/draw_cache_impl_mesh.c
+++ b/source/blender/draw/intern/draw_cache_impl_mesh.c
@@ -47,6 +47,7 @@
 #include "BKE_mesh.h"
 #include "BKE_mesh_tangent.h"
 #include "BKE_mesh_runtime.h"
+#include "BKE_modifier.h"
 #include "BKE_object_deform.h"
 
 #include "atomic_ops.h"
@@ -245,17 +246,21 @@ typedef struct MeshRenderData {
   struct {
     struct {
       MLoopUV **uv;
+      MLoopCol **vcol;
+      float (**tangent)[4];
+
       int uv_len;
       int uv_active;
+      int uv_render;
       int uv_mask_active;
 
-      MLoopCol **vcol;
       int vcol_len;
       int vcol_active;
+      int vcol_render;
 
-      float (**tangent)[4];
       int tangent_len;
       int tangent_active;
+      int tangent_render;
 
       bool *auto_vcol;
     } layers;
@@ -470,7 +475,7 @@ static DRW_MeshCDMask mesh_cd_calc_used_gpu_layers(const Mesh *me,
           case CD_MTFACE: {
             if (layer == -1) {
               layer = (name[0] != '\0') ? CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name) :
-                                          CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
+                                          CustomData_get_render_layer(cd_ldata, CD_MLOOPUV);
             }
             if (layer != -1) {
               cd_used.uv |= (1 << layer);
@@ -480,11 +485,11 @@ static DRW_MeshCDMask mesh_cd_calc_used_gpu_layers(const Mesh *me,
           case CD_TANGENT: {
             if (layer == -1) {
               layer = (name[0] != '\0') ? CustomData_get_named_layer(cd_ldata, CD_MLOOPUV, name) :
-                                          CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
+                                          CustomData_get_render_layer(cd_ldata, CD_MLOOPUV);
 
               /* Only fallback to orco (below) when we have no UV layers, see: T56545 */
               if (layer == -1 && name[0] != '\0') {
-                layer = CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
+                layer = CustomData_get_render_layer(cd_ldata, CD_MLOOPUV);
               }
             }
             if (layer != -1) {
@@ -500,7 +505,7 @@ static DRW_MeshCDMask mesh_cd_calc_used_gpu_layers(const Mesh *me,
           case CD_MCOL: {
             if (layer == -1) {
               layer = (name[0] != '\0') ? CustomData_get_named_layer(cd_ldata, CD_MLOOPCOL, name) :
-                                          CustomData_get_active_layer(cd_ldata, CD_MLOOPCOL);
+                                          CustomData_get_render_layer(cd_ldata, CD_MLOOPCOL);
             }
             if (layer != -1) {
               cd_used.vcol |= (1 << layer);
@@ -884,9 +889,12 @@ static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
     }
 
     rdata->cd.layers.uv_active = CustomData_get_active_layer(cd_ldata, CD_MLOOPUV);
+    rdata->cd.layers.uv_render = CustomData_get_render_layer(cd_ldata, CD_MLOOPUV);
     rdata->cd.layers.uv_mask_active = CustomData_get_stencil_layer(cd_ldata, CD_MLOOPUV);
     rdata->cd.layers.vcol_active = CustomData_get_active_layer(cd_ldata, CD_MLOOPCOL);
+    rdata->cd.layers.vcol_render = CustomData_get_render_layer(cd_ldata, CD_MLOOPCOL);
     rdata->cd.layers.tangent_active = rdata->cd.layers.uv_active;
+    rdata->cd.layers.tangent_render = rdata->cd.layers.uv_render;
 
 #define CD_VALIDATE_ACTIVE_LAYER(active_index, used) \
   if ((active_index != -1) && (used & (1 << active_index)) == 0) { \
@@ -895,9 +903,12 @@ static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
   ((void)0)
 
     CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.uv_active, cd_used->uv);
+    CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.uv_render, cd_used->uv);
     CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.uv_mask_active, cd_used->uv);
     CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.tangent_active, cd_used->tan);
+    CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.tangent_render, cd_used->tan);
     CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.vcol_active, cd_used->vcol);
+    CD_VALIDATE_ACTIVE_LAYER(rdata->cd.layers.vcol_render, cd_used->vcol);
 
 #undef CD_VALIDATE_ACTIVE_LAYER
 
@@ -981,6 +992,7 @@ static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
      * NOTE 2 : Replicate changes to code_generate_vertex_new() in gpu_codegen.c */
     if (rdata->cd.layers.vcol_len != 0) {
       int act_vcol = rdata->cd.layers.vcol_active;
+      int ren_vcol = rdata->cd.layers.vcol_render;
       for (int i_src = 0, i_dst = 0; i_src < cd_layers_src.vcol_len; i_src++, i_dst++) {
         if ((cd_used->vcol & (1 << i_src)) == 0) {
           /* This is a non-used VCol slot. Skip. */
@@ -988,6 +1000,9 @@ static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
           if (rdata->cd.layers.vcol_active >= i_src) {
             act_vcol--;
           }
+          if (rdata->cd.layers.vcol_render >= i_src) {
+            ren_vcol--;
+          }
         }
         else {
           const char *name = CustomData_get_layer_name(cd_ldata, CD_MLOOPCOL, i_src);
@@ -1010,10 +1025,13 @@ static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
           }
         }
       }
+      /* Actual active Vcol slot inside vcol layers used for shading. */
       if (rdata->cd.layers.vcol_active != -1) {
-        /* Actual active Vcol slot inside vcol layers used for shading. */
         rdata->cd.layers.vcol_active = act_vcol;
       }
+      if (rdata->cd.layers.vcol_render != -1) {
+        rdata->cd.layers.vcol_render = ren_vcol;
+      }
     }
 
     /* Start Fresh */
@@ -1021,11 +1039,15 @@ static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
     CustomData_free_layers(cd_ldata, CD_MLOOPTANGENT, rdata->loop_len);
 
     if (rdata->cd.layers.uv_len != 0) {
+      int ren_uv = rdata->cd.layers.uv_render;
       int act_uv = rdata->cd.layers.uv_active;
       for (int i_src = 0, i_dst = 0; i_src < cd_layers_src.uv_len; i_src++, i_dst++) {
         if ((cd_used->uv & (1 << i_src)) == 0) {
           /* This is a non-used UV slot. Skip. */
           i_dst--;
+          if (rdata->cd.layers.uv_render >= i_src) {
+            ren_uv--;
+          }
           if (rdata->cd.layers.uv_active >= i_src) {
             act_uv--;
           }
@@ -1044,8 +1066,11 @@ static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
               rdata->cd.uuid.auto_mix[i_dst], sizeof(*rdata->cd.uuid.auto_mix), "a%u", hash);
         }
       }
+      /* Actual active / Render UV slot inside uv layers used for shading. */
+      if (rdata->cd.layers.uv_render != -1) {
+        rdata->cd.layers.uv_render = ren_uv;
+      }
       if (rdata->cd.layers.uv_active != -1) {
-        /* Actual active UV slot inside uv layers used for shading. */
         rdata->cd.layers.uv_active = act_uv;
       }
     }
@@ -1144,9 +1169,13 @@ static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
 
       int i_dst = 0;
       int act_tan = rdata->cd.layers.tangent_active;
+      int ren_tan = rdata->cd.layers.tangent_render;
       for (int i_src = 0; i_src < cd_layers_src.uv_len; i_src++, i_dst++) {
         if ((cd_used->tan & (1 << i_src)) == 0) {
           i_dst--;
+          if (rdata->cd.layers.tangent_render >= i_src) {
+            ren_tan--;
+          }
           if (rdata->cd.layers.tangent_active >= i_src) {
             act_tan--;
           }
@@ -1172,10 +1201,13 @@ static MeshRenderData *mesh_render_data_create_ex(Mesh *me,
           }
         }
       }
+      /* Actual active rangent slot inside uv layers used for shading. */
       if (rdata->cd.layers.tangent_active != -1) {
-        /* Actual active UV slot inside uv layers used for shading. */
         rdata->cd.layers.tangent_active = act_tan;
       }
+      if (rdata->cd.layers.tangent_render != -1) {
+        rdata->cd.layers.tangent_render = ren_tan;
+      }
 
       if (cd_used->tan_orco != 0) {
         const char *name = CustomData_get_layer_name(&rdata->cd.output.ldata, CD_TANGENT, i_dst);
@@ -1813,6 +1845,36 @@ static bool add_edit_facedot_mapped(MeshRenderData *rdata,
 
   return true;
 }
+static bool add_edit_facedot_subdiv(MeshRenderData *rdata,
+                                    GPUVertBuf *vbo,
+                                    const uint fdot_pos_id,
+                                    const uint fdot_nor_flag_id,
+                                    const int vert,
+                                    const int poly,
+                                    const int base_vert_idx)
+{
+  BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY));
+  const int *p_origindex = rdata->mapped.p_origindex;
+  const int p_orig = p_origindex[poly];
+  if (p_orig == ORIGINDEX_NONE) {
+    return false;
+  }
+  BMEditMesh *em = rdata->edit_bmesh;
+  const BMFace *efa = BM_face_at_index(em->bm, p_orig);
+  if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
+    return false;
+  }
+
+  Mesh *me_cage = em->mesh_eval_cage;
+  const MVert *mvert = &me_cage->mvert[vert];
+
+  GPUPackedNormal nor = GPU_normal_convert_i10_s3(mvert->no);
+  nor.w = BM_elem_flag_test(efa, BM_ELEM_SELECT) ? ((efa == em->bm->act_face) ? -1 : 1) : 0;
+  GPU_vertbuf_attr_set(vbo, fdot_nor_flag_id, base_vert_idx, &nor);
+  GPU_vertbuf_attr_set(vbo, fdot_pos_id, base_vert_idx, mvert->co);
+
+  return true;
+}
 
 /** \} */
 
@@ -2233,12 +2295,13 @@ void DRW_mesh_batch_cache_dirty_tag(Mesh *me, int mode)
       GPU_VERTBUF_DISCARD_SAFE(cache->ordered.loop_pos_nor);
       GPU_BATCH_DISCARD_SAFE(cache->batch.surface);
       GPU_BATCH_DISCARD_SAFE(cache->batch.wire_loops);
+      GPU_BATCH_DISCARD_SAFE(cache->batch.wire_edges);
       if (cache->surf_per_mat) {
         for (int i = 0; i < cache->mat_len; i++) {
           GPU_BATCH_DISCARD_SAFE(cache->surf_per_mat[i]);
         }
       }
-      cache->batch_ready &= ~(MBC_SURFACE | MBC_WIRE_LOOPS | MBC_SURF_PER_MAT);
+      cache->batch_ready &= ~(MBC_SURFACE | MBC_WIRE_EDGES | MBC_WIRE_LOOPS | MBC_SURF_PER_MAT);
       break;
     case BKE_MESH_BATCH_DIRTY_ALL:
       cache->is_dirty = true;
@@ -2722,7 +2785,10 @@ static void mesh_create_edit_vertex_loops(MeshRenderData *rdata,
 }
 
 /* TODO: We could use gl_PrimitiveID as index instead of using another VBO. */
-static void mesh_create_edit_facedots_select_id(MeshRenderData *rdata, GPUVertBuf *vbo)
+static void mesh_create_edit_facedots_select_id(MeshRenderData *rdata,
+                                                GPUVertBuf *vbo,
+                                                Scene *scene,
+                                                Object *ob)
 {
   const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata);
 
@@ -2757,12 +2823,32 @@ static void mesh_create_edit_facedots_select_id(MeshRenderData *rdata, GPUVertBu
   }
   else {
     const int *p_origindex = rdata->mapped.p_origindex;
-    for (int poly = 0; poly < poly_len; poly++) {
-      const int p_orig = p_origindex[poly];
-      if (p_orig != ORIGINDEX_NONE) {
-        const BMFace *efa = BM_face_at_index(rdata->edit_bmesh->bm, p_orig);
-        if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
-          *((uint *)GPU_vertbuf_raw_step(&idx_step)) = p_orig;
+    if (modifiers_usesSubsurfFacedots(scene, ob)) {
+      Mesh *me_cage = rdata->mapped.me_cage;
+      const MPoly *mpoly = me_cage->mpoly;
+      for (int p = 0; p < poly_len; p++, mpoly++) {
+        const int p_orig = p_origindex[p];
+        if (p_orig != ORIGINDEX_NONE) {
+          const MLoop *mloop = me_cage->mloop + mpoly->loopstart;
+          for (int l = 0; l < mpoly->totloop; l++, mloop++) {
+            if (me_cage->mvert[mloop->v].flag & ME_VERT_FACEDOT) {
+              const BMFace *efa = BM_face_at_index(rdata->edit_bmesh->bm, p_orig);
+              if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
+                *((uint *)GPU_vertbuf_raw_step(&idx_step)) = p_orig;
+              }
+            }
+          }
+        }
+      }
+    }
+    else {
+      for (int poly = 0; poly < poly_len; poly++) {
+        const int p_orig = p_origindex[poly];
+        if (p_orig != ORIGINDEX_NONE) {
+          const BMFace *efa = BM_face_at_index(rdata->edit_bmesh->bm, p_orig);
+          if (!BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) {
+            *((uint *)GPU_vertbuf_raw_step(&idx_step)) = p_orig;
+          }
         }
       }
     }
@@ -3204,9 +3290,12 @@ static void mesh_create_loop_uv_and_tan(MeshRenderData *rdata, GPUVertBuf *vbo)
     attr_name = mesh_render_data_uv_auto_layer_uuid_get(rdata, i);
     GPU_vertformat_alias_add(&format, attr_name);
 
-    if (i == rdata->cd.layers.uv_active) {
+    if (i == rdata->cd.layers.uv_render) {
       GPU_vertformat_alias_add(&format, "u");
     }
+    if (i == rdata->cd.layers.uv_active) {
+      GPU_vertformat_alias_add(&format, "au");
+    }
     if (i == rdata->cd.layers.uv_mask_active) {
       GPU_vertformat_alias_add(&format, "mu");
     }
@@ -3220,9 +3309,12 @@ static void mesh_create_loop_uv_and_tan(MeshRenderData *rdata, GPUVertBuf *vbo)
 #else
     tangent_id[i] = GPU_vertformat_attr_add(&format, attr_name, GPU_COMP_F32, 4, GPU_FETCH_FLOAT);
 #endif
-    if (i == rdata->cd.layers.tangent_active) {
+    if (i == rdata->cd.layers.tangent_render) {
       GPU_vertformat_alias_add(&format, "t");
     }
+    if (i == rdata->cd.layers.tangent_active) {
+      GPU_vertformat_alias_add(&format, "at");
+    }
   }
 
   /* HACK: Create a dummy attribute in case there is no valid UV/tangent layer. */
@@ -3321,9 +3413,12 @@ static void mesh_create_loop_vcol(MeshRenderData *rdata, GPUVertBuf *vbo)
       attr_name = mesh_render_data_vcol_auto_layer_uuid_get(rdata, i);
       GPU_vertformat_alias_add(&format, attr_name);
     }
-    if (i == rdata->cd.layers.vcol_active) {
+    if (i == rdata->cd.layers.vcol_render) {
       GPU_vertformat_alias_add(&format, "c");
     }
+    if (i == rdata->cd.layers.vcol_active) {
+      GPU_vertformat_alias_add(&format, "ac");
+    }
   }
 
   GPU_vertbuf_init_with_format(vbo, &format);
@@ -3372,7 +3467,10 @@ static void mesh_create_loop_vcol(MeshRenderData *rdata, GPUVertBuf *vbo)
 #undef USE_COMP_MESH_DATA
 }
 
-static void mesh_create_edit_facedots(MeshRenderData *rdata, GPUVertBuf *vbo_facedots_pos_nor_data)
+static void mesh_create_edit_facedots(MeshRenderData *rdata,
+                                      GPUVertBuf *vbo_facedots_pos_nor_data,
+                                      Scene *scene,
+                                      Object *ob)
 {
   const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata);
   const int verts_facedot_len = poly_len;
@@ -3414,21 +3512,37 @@ static void mesh_create_edit_facedots(MeshRenderData *rdata, GPUVertBuf *vbo_fac
     }
   }
   else {
-#if 0 /* TODO(fclem): Mapped facedots are not following the original face. */
-    Mesh *me_cage = rdata->mapped.me_cage;
-    const MVert *mvert = me_cage->mvert;
-    const MEdge *medge = me_cage->medge;
-    const int *e_origindex = rdata->mapped.e_origindex;
-    const int *v_origindex = rdata->mapped.v_origindex;
-#endif
-    for (int i = 0; i < poly_len; i++) {
-      if (add_edit_facedot_mapped(rdata,
-                                  vbo_facedots_pos_nor_data,
-                                  attr_id.fdot_pos,
-                                  attr_id.fdot_nor_flag,
-                                  i,
-                                  facedot_len_used)) {
-        facedot_len_used += 1;
+    if (modifiers_usesSubsurfFacedots(scene, ob)) {
+      /* Facedots that follow surbsurf face center. */
+      Mesh *me_cage = rdata->mapped.me_cage;
+      const MPoly *mpoly = me_cage->mpoly;
+      for (int p = 0; p < poly_len; p++, mpoly++) {
+        const MLoop *mloop = me_cage->mloop + mpoly->loopstart;
+        for (int l = 0; l < mpoly->totloop; l++, mloop++) {
+          if (me_cage->mvert[mloop->v].flag & ME_VERT_FACEDOT) {
+            if (add_edit_facedot_subdiv(rdata,
+                                        vbo_facedots_pos_nor_data,
+                                        attr_id.fdot_pos,
+                                        attr_id.fdot_nor_flag,
+                                        mloop->v,
+                                        p,
+                                        facedot_len_used)) {
+              facedot_len_used += 1;
+            }
+          }
+        }
+      }
+    }
+    else {
+      for (int i = 0; i < poly_len; i++) {
+        if (add_edit_facedot_mapped(rdata,
+                                    vbo_facedots_pos_nor_data,
+                                    attr_id.fdot_pos,
+                                    attr_id.fdot_nor_flag,
+                                    i,
+                                    facedot_len_used)) {
+          facedot_len_used += 1;
+        }
       }
     }
   }
@@ -5447,10 +5561,12 @@ void DRW_mesh_batch_cache_create_requested(
                                   cache->edit.loop_face_idx);
   }
   if (DRW_vbo_requested(cache->edit.facedots_pos_nor_data)) {
-    mesh_create_edit_facedots(rdata, cache->edit.facedots_pos_nor_data);
+    Scene *scene = DRW_context_state_get()->scene;
+    mesh_create_edit_facedots(rdata, cache->edit.facedots_pos_nor_data, scene, ob);
   }
   if (DRW_vbo_requested(cache->edit.facedots_idx)) {
-    mesh_create_edit_facedots_select_id(rdata, cache->edit.facedots_idx);
+    Scene *scene = DRW_context_state_get()->scene;
+    mesh_create_edit_facedots_select_id(rdata, cache->edit.facedots_idx, scene, ob);
   }
   if (DRW_ibo_requested(cache->ibo.edit_loops_points) ||
       DRW_ibo_requested(cache->ibo.edit_loops_lines)) {
diff --git a/source/blender/draw/intern/draw_cache_impl_particles.c b/source/blender/draw/intern/draw_cache_impl_particles.c
index c66a737d684..6cd03d14bfd 100644
--- a/source/blender/draw/intern/draw_cache_impl_particles.c
+++ b/source/blender/draw/intern/draw_cache_impl_particles.c
@@ -835,7 +835,9 @@ static void particle_batch_cache_ensure_procedural_strand_data(PTCacheEdit *edit
                                                                ParticleHairCache *cache)
 {
   int active_uv = 0;
+  int render_uv = 0;
   int active_col = 0;
+  int render_col = 0;
 
   ParticleSystemModifierData *psmd = (ParticleSystemModifierData *)md;
 
@@ -843,10 +845,12 @@ static void particle_batch_cache_ensure_procedural_strand_data(PTCacheEdit *edit
     if (CustomData_has_layer(&psmd->mesh_final->ldata, CD_MLOOPUV)) {
       cache->num_uv_layers = CustomData_number_of_layers(&psmd->mesh_final->ldata, CD_MLOOPUV);
       active_uv = CustomData_get_active_layer(&psmd->mesh_final->ldata, CD_MLOOPUV);
+      render_uv = CustomData_get_render_layer(&psmd->mesh_final->ldata, CD_MLOOPUV);
     }
     if (CustomData_has_layer(&psmd->mesh_final->ldata, CD_MLOOPCOL)) {
       cache->num_col_layers = CustomData_number_of_layers(&psmd->mesh_final->ldata, CD_MLOOPCOL);
       active_col = CustomData_get_active_layer(&psmd->mesh_final->ldata, CD_MLOOPCOL);
+      render_col = CustomData_get_render_layer(&psmd->mesh_final->ldata, CD_MLOOPCOL);
     }
   }
 
@@ -897,7 +901,10 @@ static void particle_batch_cache_ensure_procedural_strand_data(PTCacheEdit *edit
     BLI_snprintf(cache->uv_layer_names[i][n++], MAX_LAYER_NAME_LEN, "a%u", hash);
 
     if (i == active_uv) {
-      BLI_strncpy(cache->uv_layer_names[i][n], "u", MAX_LAYER_NAME_LEN);
+      BLI_strncpy(cache->uv_layer_names[i][n++], "au", MAX_LAYER_NAME_LEN);
+    }
+    if (i == render_uv) {
+      BLI_strncpy(cache->uv_layer_names[i][n++], "u", MAX_LAYER_NAME_LEN);
     }
   }
   /* Vertex colors */
@@ -917,7 +924,10 @@ static void particle_batch_cache_ensure_procedural_strand_data(PTCacheEdit *edit
     }
 
     if (i == active_col) {
-      BLI_strncpy(cache->col_layer_names[i][n], "c", MAX_LAYER_NAME_LEN);
+      BLI_strncpy(cache->col_layer_names[i][n++], "ac", MAX_LAYER_NAME_LEN);
+    }
+    if (i == render_col) {
+      BLI_strncpy(cache->col_layer_names[i][n++], "c", MAX_LAYER_NAME_LEN);
     }
   }
 
@@ -1435,11 +1445,12 @@ static void drw_particle_get_hair_source(Object *object,
                                          PTCacheEdit *edit,
                                          ParticleDrawSource *r_draw_source)
 {
+  const DRWContextState *draw_ctx = DRW_context_state_get();
   r_draw_source->object = object;
   r_draw_source->psys = psys;
   r_draw_source->md = md;
   r_draw_source->edit = edit;
-  if ((object->mode & OB_MODE_PARTICLE_EDIT) != 0) {
+  if (psys_in_edit_mode(draw_ctx->depsgraph, psys)) {
     r_draw_source->object = DEG_get_original_object(object);
     r_draw_source->psys = psys_orig_get(psys);
   }
diff --git a/source/blender/draw/intern/draw_hair_private.h b/source/blender/draw/intern/draw_hair_private.h
index 72c89832d3d..6eaba7e8811 100644
--- a/source/blender/draw/intern/draw_hair_private.h
+++ b/source/blender/draw/intern/draw_hair_private.h
@@ -24,7 +24,7 @@
 #ifndef __DRAW_HAIR_PRIVATE_H__
 #define __DRAW_HAIR_PRIVATE_H__
 
-#define MAX_LAYER_NAME_CT 3 /* u0123456789, u, a0123456789 */
+#define MAX_LAYER_NAME_CT 4 /* u0123456789, u, au, a0123456789 */
 #define MAX_LAYER_NAME_LEN DECIMAL_DIGITS_BOUND(uint) + 2
 #define MAX_THICKRES 2    /* see eHairType */
 #define MAX_HAIR_SUBDIV 4 /* see hair_subdiv rna */
diff --git a/source/blender/draw/intern/draw_manager.c b/source/blender/draw/intern/draw_manager.c
index 47b0a21988a..c17aaa9c58d 100644
--- a/source/blender/draw/intern/draw_manager.c
+++ b/source/blender/draw/intern/draw_manager.c
@@ -207,6 +207,8 @@ bool DRW_object_use_hide_faces(const struct Object *ob)
     const Mesh *me = ob->data;
 
     switch (ob->mode) {
+      case OB_MODE_SCULPT:
+        return true;
       case OB_MODE_TEXTURE_PAINT:
         return (me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
       case OB_MODE_VERTEX_PAINT:
@@ -2730,6 +2732,14 @@ void DRW_draw_select_id_object(Scene *scene,
     select_mode = ts->selectmode;
   }
 
+  /* Init the scene of the draw context. When using face dot selection on
+   * when the subsurf modifier is active on the cage, the scene needs to be
+   * valid. It is read from the context in the
+   * `DRW_mesh_batch_cache_create_requested` and used in the `isDisabled`
+   * method of the SubSurfModifier. */
+  DRWContextState *draw_ctx = &DST.draw_ctx;
+  draw_ctx->scene = scene;
+
   GPU_matrix_mul(ob->obmat);
 
   const float(*world_clip_planes)[4] = NULL;