Refactor: Extract color attributes as generic attributes

Previously there was a special extraction process for "vertex colors"
that copied the color data to the GPU with a special format. Instead,
this patch replaces this with use of the generic attribute extraction.
This reduces the number of code paths, allowing easier optimization
in the future.

To make it possible to use the generic extraction system for attributes
but also assign aliases for use by shaders, some changes are necessary.
First, the GPU material attribute can now store whether it actually refers
to the default color attribute, rather than a specific name. This replaces
the hack to use `CD_MCOL` in the color attribute shader node. Second,
the extraction code checks the names against the default and active
names and assigns aliases if the request corresponds to a special active
attribute. Finally, support for byte color attributes was added to the
generic attribute extraction.

Differential Revision: https://developer.blender.org/D15205

3 files changed, 113 insertions, 391 deletions

diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh.hh b/source/blender/draw/intern/mesh_extractors/extract_mesh.hh
index 8052b277d45..a4773736f0c 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh.hh
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh.hh
@@ -86,6 +86,9 @@ struct MeshRenderData {
   float (*loop_normals)[3];
   int *lverts, *ledges;
 
+  const char *active_color_name;
+  const char *default_color_name;
+
   struct {
     int *tri_first_index;
     int *mat_tri_len;
@@ -93,6 +96,82 @@ struct MeshRenderData {
   } poly_sorted;
 };
 
+BLI_INLINE const Mesh *editmesh_final_or_this(const Object *object, const Mesh *me)
+{
+  if (me->edit_mesh != nullptr) {
+    Mesh *editmesh_eval_final = BKE_object_get_editmesh_eval_final(object);
+    if (editmesh_eval_final != nullptr) {
+      return editmesh_eval_final;
+    }
+  }
+
+  return me;
+}
+
+BLI_INLINE const CustomData *mesh_cd_ldata_get_from_mesh(const Mesh *me)
+{
+  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+    case ME_WRAPPER_TYPE_SUBD:
+    case ME_WRAPPER_TYPE_MDATA:
+      return &me->ldata;
+      break;
+    case ME_WRAPPER_TYPE_BMESH:
+      return &me->edit_mesh->bm->ldata;
+      break;
+  }
+
+  BLI_assert(0);
+  return &me->ldata;
+}
+
+BLI_INLINE const CustomData *mesh_cd_pdata_get_from_mesh(const Mesh *me)
+{
+  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+    case ME_WRAPPER_TYPE_SUBD:
+    case ME_WRAPPER_TYPE_MDATA:
+      return &me->pdata;
+      break;
+    case ME_WRAPPER_TYPE_BMESH:
+      return &me->edit_mesh->bm->pdata;
+      break;
+  }
+
+  BLI_assert(0);
+  return &me->pdata;
+}
+
+BLI_INLINE const CustomData *mesh_cd_edata_get_from_mesh(const Mesh *me)
+{
+  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+    case ME_WRAPPER_TYPE_SUBD:
+    case ME_WRAPPER_TYPE_MDATA:
+      return &me->edata;
+      break;
+    case ME_WRAPPER_TYPE_BMESH:
+      return &me->edit_mesh->bm->edata;
+      break;
+  }
+
+  BLI_assert(0);
+  return &me->edata;
+}
+
+BLI_INLINE const CustomData *mesh_cd_vdata_get_from_mesh(const Mesh *me)
+{
+  switch ((eMeshWrapperType)me->runtime.wrapper_type) {
+    case ME_WRAPPER_TYPE_SUBD:
+    case ME_WRAPPER_TYPE_MDATA:
+      return &me->vdata;
+      break;
+    case ME_WRAPPER_TYPE_BMESH:
+      return &me->edit_mesh->bm->vdata;
+      break;
+  }
+
+  BLI_assert(0);
+  return &me->vdata;
+}
+
 BLI_INLINE BMFace *bm_original_face_get(const MeshRenderData *mr, int idx)
 {
   return ((mr->p_origindex != NULL) && (mr->p_origindex[idx] != ORIGINDEX_NONE) && mr->bm) ?
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc
index b98af3be17f..7f16837022c 100644
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc
+++ b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_attributes.cc
@@ -9,6 +9,7 @@
 
 #include <functional>
 
+#include "BLI_color.hh"
 #include "BLI_math_vec_types.hh"
 #include "BLI_string.h"
 
@@ -74,6 +75,18 @@ template<> struct AttributeTypeConverter<MPropCol, gpuMeshCol> {
   }
 };
 
+template<> struct AttributeTypeConverter<ColorGeometry4b, gpuMeshCol> {
+  static gpuMeshCol convert_value(ColorGeometry4b value)
+  {
+    gpuMeshCol result;
+    result.r = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[value.r]);
+    result.g = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[value.g]);
+    result.b = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[value.b]);
+    result.a = unit_float_to_ushort_clamp(value.a * (1.0f / 255.0f));
+    return result;
+  }
+};
+
 /* Return the number of component for the attribute's value type, or 0 if is it unsupported. */
 static uint gpu_component_size_for_attribute_type(eCustomDataType type)
 {
@@ -90,6 +103,7 @@ static uint gpu_component_size_for_attribute_type(eCustomDataType type)
     case CD_PROP_FLOAT3:
       return 3;
     case CD_PROP_COLOR:
+    case CD_PROP_BYTE_COLOR:
       return 4;
     default:
       return 0;
@@ -102,6 +116,7 @@ static GPUVertFetchMode get_fetch_mode_for_type(eCustomDataType type)
     case CD_PROP_INT32:
       return GPU_FETCH_INT_TO_FLOAT;
     case CD_PROP_COLOR:
+    case CD_PROP_BYTE_COLOR:
       return GPU_FETCH_INT_TO_FLOAT_UNIT;
     default:
       return GPU_FETCH_FLOAT;
@@ -114,13 +129,15 @@ static GPUVertCompType get_comp_type_for_type(eCustomDataType type)
     case CD_PROP_INT32:
       return GPU_COMP_I32;
     case CD_PROP_COLOR:
+    case CD_PROP_BYTE_COLOR:
       return GPU_COMP_U16;
     default:
       return GPU_COMP_F32;
   }
 }
 
-static void init_vbo_for_attribute(GPUVertBuf *vbo,
+static void init_vbo_for_attribute(const MeshRenderData &mr,
+                                   GPUVertBuf *vbo,
                                    const DRW_AttributeRequest &request,
                                    bool build_on_device,
                                    uint32_t len)
@@ -140,6 +157,13 @@ static void init_vbo_for_attribute(GPUVertBuf *vbo,
   GPU_vertformat_deinterleave(&format);
   GPU_vertformat_attr_add(&format, attr_name, comp_type, comp_size, fetch_mode);
 
+  if (mr.active_color_name && STREQ(request.attribute_name, mr.active_color_name)) {
+    GPU_vertformat_alias_add(&format, "ac");
+  }
+  if (mr.default_color_name && STREQ(request.attribute_name, mr.default_color_name)) {
+    GPU_vertformat_alias_add(&format, "c");
+  }
+
   if (build_on_device) {
     GPU_vertbuf_init_build_on_device(vbo, &format, len);
   }
@@ -262,7 +286,7 @@ static void extract_attr_init(
 
   GPUVertBuf *vbo = static_cast<GPUVertBuf *>(buf);
 
-  init_vbo_for_attribute(vbo, request, false, static_cast<uint32_t>(mr->loop_len));
+  init_vbo_for_attribute(*mr, vbo, request, false, static_cast<uint32_t>(mr->loop_len));
 
   /* TODO(@kevindietrich): float3 is used for scalar attributes as the implicit conversion done by
    * OpenGL to vec4 for a scalar `s` will produce a `vec4(s, 0, 0, 1)`. However, following the
@@ -290,6 +314,9 @@ static void extract_attr_init(
     case CD_PROP_COLOR:
       extract_attr_generic<MPropCol, gpuMeshCol>(mr, vbo, request);
       break;
+    case CD_PROP_BYTE_COLOR:
+      extract_attr_generic<ColorGeometry4b, gpuMeshCol>(mr, vbo, request);
+      break;
     default:
       BLI_assert_unreachable();
   }
@@ -338,12 +365,15 @@ static void extract_attr_init_subdiv(const DRWSubdivCache *subdiv_cache,
     case CD_PROP_COLOR:
       extract_attr_generic<MPropCol, gpuMeshCol>(mr, src_data, request);
       break;
+    case CD_PROP_BYTE_COLOR:
+      extract_attr_generic<ColorGeometry4b, gpuMeshCol>(mr, src_data, request);
+      break;
     default:
       BLI_assert_unreachable();
   }
 
   GPUVertBuf *dst_buffer = static_cast<GPUVertBuf *>(buffer);
-  init_vbo_for_attribute(dst_buffer, request, true, subdiv_cache->num_subdiv_loops);
+  init_vbo_for_attribute(*mr, dst_buffer, request, true, subdiv_cache->num_subdiv_loops);
 
   /* Ensure data is uploaded properly. */
   GPU_vertbuf_tag_dirty(src_data);
@@ -352,7 +382,7 @@ static void extract_attr_init_subdiv(const DRWSubdivCache *subdiv_cache,
                                  dst_buffer,
                                  static_cast<int>(dimensions),
                                  0,
-                                 request.cd_type == CD_PROP_COLOR);
+                                 ELEM(request.cd_type, CD_PROP_COLOR, CD_PROP_BYTE_COLOR));
 
   GPU_vertbuf_discard(src_data);
 }
diff --git a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_vcol.cc b/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_vcol.cc
deleted file mode 100644
index 419cbb0267f..00000000000
--- a/source/blender/draw/intern/mesh_extractors/extract_mesh_vbo_vcol.cc
+++ /dev/null
@@ -1,387 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later
- * Copyright 2021 Blender Foundation. All rights reserved. */
-
-/** \file
- * \ingroup draw
- */
-
-#include "MEM_guardedalloc.h"
-
-#include "BKE_attribute.h"
-#include "BLI_string.h"
-#include "BLI_vector.hh"
-
-#include "draw_subdivision.h"
-#include "extract_mesh.hh"
-
-namespace blender::draw {
-
-struct VColRef {
-  const CustomDataLayer *layer;
-  eAttrDomain domain;
-};
-
-/** Get all vcol layers as AttributeRefs.
- *
- * \param vcol_layers: bitmask to filter vcol layers by, each bit
- *                     corresponds to the integer position of the attribute
- *                     within the global color attribute list.
- */
-static Vector<VColRef> get_vcol_refs(const CustomData *cd_vdata,
-                                     const CustomData *cd_ldata,
-                                     const uint vcol_layers)
-{
-  Vector<VColRef> refs;
-  uint layeri = 0;
-
-  auto buildList = [&](const CustomData *cdata, eAttrDomain domain) {
-    for (int i = 0; i < cdata->totlayer; i++) {
-      const CustomDataLayer *layer = cdata->layers + i;
-
-      if (!(CD_TYPE_AS_MASK(layer->type) & CD_MASK_COLOR_ALL)) {
-        continue;
-      }
-
-      if (layer->flag & CD_FLAG_TEMPORARY) {
-        continue;
-      }
-
-      if (!(vcol_layers & (1UL << layeri))) {
-        layeri++;
-        continue;
-      }
-
-      VColRef ref = {};
-      ref.domain = domain;
-      ref.layer = layer;
-
-      refs.append(ref);
-      layeri++;
-    }
-  };
-
-  buildList(cd_vdata, ATTR_DOMAIN_POINT);
-  buildList(cd_ldata, ATTR_DOMAIN_CORNER);
-
-  return refs;
-}
-
-/* ---------------------------------------------------------------------- */
-/** \name Extract VCol
- * \{ */
-
-/* Initialize the common vertex format for vcol for coarse and subdivided meshes. */
-static void init_vcol_format(GPUVertFormat *format,
-                             const MeshBatchCache *cache,
-                             const CustomData *cd_vdata,
-                             const CustomData *cd_ldata,
-                             const CustomDataLayer *active,
-                             const CustomDataLayer *render)
-{
-  GPU_vertformat_deinterleave(format);
-
-  const uint32_t vcol_layers = cache->cd_used.vcol;
-
-  Vector<VColRef> refs = get_vcol_refs(cd_vdata, cd_ldata, vcol_layers);
-
-  for (const VColRef &ref : refs) {
-    char attr_name[32], attr_safe_name[GPU_MAX_SAFE_ATTR_NAME];
-
-    GPU_vertformat_safe_attr_name(ref.layer->name, attr_safe_name, GPU_MAX_SAFE_ATTR_NAME);
-
-    /* VCol layer name. */
-    BLI_snprintf(attr_name, sizeof(attr_name), "a%s", attr_safe_name);
-    GPU_vertformat_attr_add(format, attr_name, GPU_COMP_U16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
-
-    /* Active layer name. */
-    if (ref.layer == active) {
-      GPU_vertformat_alias_add(format, "ac");
-    }
-
-    /* Active render layer name. */
-    if (ref.layer == render) {
-      GPU_vertformat_alias_add(format, "c");
-    }
-  }
-}
-
-/* Vertex format for vertex colors, only used during the coarse data upload for the subdivision
- * case. */
-static GPUVertFormat *get_coarse_vcol_format()
-{
-  static GPUVertFormat format = {0};
-  if (format.attr_len == 0) {
-    GPU_vertformat_attr_add(&format, "cCol", GPU_COMP_U16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
-    GPU_vertformat_alias_add(&format, "c");
-    GPU_vertformat_alias_add(&format, "ac");
-  }
-  return &format;
-}
-
-struct gpuMeshVcol {
-  ushort r, g, b, a;
-};
-
-static void extract_vcol_init(const MeshRenderData *mr,
-                              MeshBatchCache *cache,
-                              void *buf,
-                              void *UNUSED(tls_data))
-{
-  GPUVertBuf *vbo = static_cast<GPUVertBuf *>(buf);
-  GPUVertFormat format = {0};
-
-  const CustomData *cd_vdata = (mr->extract_type == MR_EXTRACT_BMESH) ? &mr->bm->vdata :
-                                                                        &mr->me->vdata;
-  const CustomData *cd_ldata = (mr->extract_type == MR_EXTRACT_BMESH) ? &mr->bm->ldata :
-                                                                        &mr->me->ldata;
-
-  Mesh me_query = blender::dna::shallow_zero_initialize();
-
-  BKE_id_attribute_copy_domains_temp(
-      ID_ME, cd_vdata, nullptr, cd_ldata, nullptr, nullptr, &me_query.id);
-
-  const CustomDataLayer *active_color = BKE_id_attributes_active_color_get(&me_query.id);
-  const CustomDataLayer *render_color = BKE_id_attributes_render_color_get(&me_query.id);
-
-  const uint32_t vcol_layers = cache->cd_used.vcol;
-  init_vcol_format(&format, cache, cd_vdata, cd_ldata, active_color, render_color);
-
-  GPU_vertbuf_init_with_format(vbo, &format);
-  GPU_vertbuf_data_alloc(vbo, mr->loop_len);
-
-  gpuMeshVcol *vcol_data = (gpuMeshVcol *)GPU_vertbuf_get_data(vbo);
-
-  Vector<VColRef> refs = get_vcol_refs(cd_vdata, cd_ldata, vcol_layers);
-
-  for (const VColRef &ref : refs) {
-    const CustomData *cdata = ref.domain == ATTR_DOMAIN_POINT ? cd_vdata : cd_ldata;
-
-    if (mr->extract_type == MR_EXTRACT_BMESH) {
-      int cd_ofs = ref.layer->offset;
-
-      if (cd_ofs == -1) {
-        vcol_data += ref.domain == ATTR_DOMAIN_POINT ? mr->bm->totvert : mr->bm->totloop;
-        continue;
-      }
-
-      BMIter iter;
-      const bool is_byte = ref.layer->type == CD_PROP_BYTE_COLOR;
-      const bool is_point = ref.domain == ATTR_DOMAIN_POINT;
-
-      BMFace *f;
-      BM_ITER_MESH (f, &iter, mr->bm, BM_FACES_OF_MESH) {
-        const BMLoop *l_iter = f->l_first;
-        do {
-          const BMElem *elem = is_point ? reinterpret_cast<const BMElem *>(l_iter->v) :
-                                          reinterpret_cast<const BMElem *>(l_iter);
-          if (is_byte) {
-            const MLoopCol *mloopcol = (const MLoopCol *)BM_ELEM_CD_GET_VOID_P(elem, cd_ofs);
-            vcol_data->r = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mloopcol->r]);
-            vcol_data->g = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mloopcol->g]);
-            vcol_data->b = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mloopcol->b]);
-            vcol_data->a = unit_float_to_ushort_clamp(mloopcol->a * (1.0f / 255.0f));
-            vcol_data++;
-          }
-          else {
-            const MPropCol *mpcol = (const MPropCol *)BM_ELEM_CD_GET_VOID_P(elem, cd_ofs);
-            vcol_data->r = unit_float_to_ushort_clamp(mpcol->color[0]);
-            vcol_data->g = unit_float_to_ushort_clamp(mpcol->color[1]);
-            vcol_data->b = unit_float_to_ushort_clamp(mpcol->color[2]);
-            vcol_data->a = unit_float_to_ushort_clamp(mpcol->color[3]);
-            vcol_data++;
-          }
-        } while ((l_iter = l_iter->next) != f->l_first);
-      }
-    }
-    else {
-      int totloop = mr->loop_len;
-      const int idx = CustomData_get_named_layer_index(cdata, ref.layer->type, ref.layer->name);
-
-      const MLoopCol *mcol = nullptr;
-      const MPropCol *pcol = nullptr;
-      const MLoop *mloop = mr->mloop;
-
-      if (ref.layer->type == CD_PROP_COLOR) {
-        pcol = static_cast<const MPropCol *>(cdata->layers[idx].data);
-      }
-      else {
-        mcol = static_cast<const MLoopCol *>(cdata->layers[idx].data);
-      }
-
-      const bool is_corner = ref.domain == ATTR_DOMAIN_CORNER;
-
-      for (int i = 0; i < totloop; i++, mloop++) {
-        const int v_i = is_corner ? i : mloop->v;
-
-        if (mcol) {
-          vcol_data->r = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol[v_i].r]);
-          vcol_data->g = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol[v_i].g]);
-          vcol_data->b = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol[v_i].b]);
-          vcol_data->a = unit_float_to_ushort_clamp(mcol[v_i].a * (1.0f / 255.0f));
-          vcol_data++;
-        }
-        else if (pcol) {
-          vcol_data->r = unit_float_to_ushort_clamp(pcol[v_i].color[0]);
-          vcol_data->g = unit_float_to_ushort_clamp(pcol[v_i].color[1]);
-          vcol_data->b = unit_float_to_ushort_clamp(pcol[v_i].color[2]);
-          vcol_data->a = unit_float_to_ushort_clamp(pcol[v_i].color[3]);
-          vcol_data++;
-        }
-      }
-    }
-  }
-}
-
-static void extract_vcol_init_subdiv(const DRWSubdivCache *subdiv_cache,
-                                     const MeshRenderData *mr,
-                                     MeshBatchCache *cache,
-                                     void *buffer,
-                                     void *UNUSED(data))
-{
-  GPUVertBuf *dst_buffer = static_cast<GPUVertBuf *>(buffer);
-  const Mesh *coarse_mesh = subdiv_cache->mesh;
-
-  bool extract_bmesh = mr->extract_type == MR_EXTRACT_BMESH;
-
-  const CustomData *cd_vdata = extract_bmesh ? &coarse_mesh->edit_mesh->bm->vdata :
-                                               &coarse_mesh->vdata;
-  const CustomData *cd_ldata = extract_bmesh ? &coarse_mesh->edit_mesh->bm->ldata :
-                                               &coarse_mesh->ldata;
-  const int totloop = extract_bmesh ? coarse_mesh->edit_mesh->bm->totloop : coarse_mesh->totloop;
-
-  Mesh me_query = blender::dna::shallow_copy(*coarse_mesh);
-  BKE_id_attribute_copy_domains_temp(
-      ID_ME, cd_vdata, nullptr, cd_ldata, nullptr, nullptr, &me_query.id);
-
-  const CustomDataLayer *active_color = BKE_id_attributes_active_color_get(&me_query.id);
-  const CustomDataLayer *render_color = BKE_id_attributes_render_color_get(&me_query.id);
-
-  GPUVertFormat format = {0};
-  init_vcol_format(
-      &format, cache, &coarse_mesh->vdata, &coarse_mesh->ldata, active_color, render_color);
-
-  GPU_vertbuf_init_build_on_device(dst_buffer, &format, subdiv_cache->num_subdiv_loops);
-
-  GPUVertBuf *src_data = GPU_vertbuf_calloc();
-  /* Dynamic as we upload and interpolate layers one at a time. */
-  GPU_vertbuf_init_with_format_ex(src_data, get_coarse_vcol_format(), GPU_USAGE_DYNAMIC);
-
-  GPU_vertbuf_data_alloc(src_data, totloop);
-
-  gpuMeshVcol *mesh_vcol = (gpuMeshVcol *)GPU_vertbuf_get_data(src_data);
-
-  const uint vcol_layers = cache->cd_used.vcol;
-
-  Vector<VColRef> refs = get_vcol_refs(cd_vdata, cd_ldata, vcol_layers);
-
-  /* Index of the vertex color layer in the compact buffer. Used vertex color layers are stored in
-   * a single buffer. */
-  int pack_layer_index = 0;
-  for (const VColRef &ref : refs) {
-    /* Include stride in offset, we use a stride of 2 since colors are packed into 2 uints. */
-    const int dst_offset = (int)subdiv_cache->num_subdiv_loops * 2 * pack_layer_index++;
-
-    const CustomData *cdata = ref.domain == ATTR_DOMAIN_POINT ? cd_vdata : cd_ldata;
-    int layer_i = CustomData_get_named_layer_index(cdata, ref.layer->type, ref.layer->name);
-
-    if (layer_i == -1) {
-      printf("%s: missing color layer %s\n", __func__, ref.layer->name);
-      continue;
-    }
-
-    gpuMeshVcol *vcol = mesh_vcol;
-
-    const bool is_vert = ref.domain == ATTR_DOMAIN_POINT;
-
-    if (extract_bmesh) {
-      BMesh *bm = coarse_mesh->edit_mesh->bm;
-      BMIter iter;
-      BMFace *f;
-      int cd_ofs = cdata->layers[layer_i].offset;
-      const bool is_byte = ref.layer->type == CD_PROP_BYTE_COLOR;
-
-      BM_ITER_MESH (f, &iter, bm, BM_FACES_OF_MESH) {
-        const BMLoop *l_iter = f->l_first;
-
-        do {
-          const BMElem *elem = is_vert ? reinterpret_cast<const BMElem *>(l_iter->v) :
-                                         reinterpret_cast<const BMElem *>(l_iter);
-
-          if (is_byte) {
-            const MLoopCol *mcol2 = static_cast<const MLoopCol *>(
-                BM_ELEM_CD_GET_VOID_P(elem, cd_ofs));
-
-            vcol->r = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol2->r]);
-            vcol->g = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol2->g]);
-            vcol->b = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol2->b]);
-            vcol->a = unit_float_to_ushort_clamp(mcol2->a * (1.0f / 255.0f));
-          }
-          else {
-            const MPropCol *pcol2 = static_cast<const MPropCol *>(
-                BM_ELEM_CD_GET_VOID_P(elem, cd_ofs));
-
-            vcol->r = unit_float_to_ushort_clamp(pcol2->color[0]);
-            vcol->g = unit_float_to_ushort_clamp(pcol2->color[1]);
-            vcol->b = unit_float_to_ushort_clamp(pcol2->color[2]);
-            vcol->a = unit_float_to_ushort_clamp(pcol2->color[3]);
-          }
-
-          vcol++;
-        } while ((l_iter = l_iter->next) != f->l_first);
-      }
-    }
-    else {
-      const MLoop *ml = coarse_mesh->mloop;
-      const MLoopCol *mcol = nullptr;
-      const MPropCol *pcol = nullptr;
-
-      if (ref.layer->type == CD_PROP_COLOR) {
-        pcol = static_cast<const MPropCol *>(cdata->layers[layer_i].data);
-      }
-      else {
-        mcol = static_cast<const MLoopCol *>(cdata->layers[layer_i].data);
-      }
-
-      for (int ml_index = 0; ml_index < coarse_mesh->totloop; ml_index++, vcol++, ml++) {
-        int idx = is_vert ? ml->v : ml_index;
-
-        if (mcol) {
-          vcol->r = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol[idx].r]);
-          vcol->g = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol[idx].g]);
-          vcol->b = unit_float_to_ushort_clamp(BLI_color_from_srgb_table[mcol[idx].b]);
-          vcol->a = unit_float_to_ushort_clamp(mcol[idx].a * (1.0f / 255.0f));
-        }
-        else if (pcol) {
-          vcol->r = unit_float_to_ushort_clamp(pcol[idx].color[0]);
-          vcol->g = unit_float_to_ushort_clamp(pcol[idx].color[1]);
-          vcol->b = unit_float_to_ushort_clamp(pcol[idx].color[2]);
-          vcol->a = unit_float_to_ushort_clamp(pcol[idx].color[3]);
-        }
-      }
-    }
-
-    /* Ensure data is uploaded properly. */
-    GPU_vertbuf_tag_dirty(src_data);
-    draw_subdiv_interp_custom_data(subdiv_cache, src_data, dst_buffer, 4, dst_offset, true);
-  }
-
-  GPU_vertbuf_discard(src_data);
-}
-
-constexpr MeshExtract create_extractor_vcol()
-{
-  MeshExtract extractor = {nullptr};
-  extractor.init = extract_vcol_init;
-  extractor.init_subdiv = extract_vcol_init_subdiv;
-  extractor.data_type = MR_DATA_NONE;
-  extractor.data_size = 0;
-  extractor.use_threading = false;
-  extractor.mesh_buffer_offset = offsetof(MeshBufferList, vbo.vcol);
-  return extractor;
-}
-
-/** \} */
-
-}  // namespace blender::draw
-
-const MeshExtract extract_vcol = blender::draw::create_extractor_vcol();