OpenSubdiv: Cleanup, Remove from legacy SubsurfCCG code

The CPU side implementation is done on a new dedicate base ground.
The GPU side must be redone anyway.

1 files changed, 32 insertions, 245 deletions

diff --git a/source/blender/blenkernel/intern/subsurf_ccg.c b/source/blender/blenkernel/intern/subsurf_ccg.c
index c21d640a4c1..7a0a5645b80 100644
--- a/source/blender/blenkernel/intern/subsurf_ccg.c
+++ b/source/blender/blenkernel/intern/subsurf_ccg.c
@@ -71,18 +71,13 @@
 
 #include "CCGSubSurf.h"
 
-#ifdef WITH_OPENSUBDIV
-#  include "opensubdiv_capi.h"
-#endif
-
 /* assumes MLoop's are laid out 4 for each poly, in order */
 #define USE_LOOP_LAYOUT_FAST
 
 static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
                                          int drawInteriorEdges,
                                          int useSubsurfUv,
-                                         DerivedMesh *dm,
-                                         bool use_gpu_backend);
+                                         DerivedMesh *dm);
 ///
 
 static void *arena_alloc(CCGAllocatorHDL a, int numBytes)
@@ -404,82 +399,6 @@ static int ss_sync_from_uv(CCGSubSurf *ss, CCGSubSurf *origss, DerivedMesh *dm,
   return 1;
 }
 
-#ifdef WITH_OPENSUBDIV
-static void UNUSED_FUNCTION(set_subsurf_osd_ccg_uv)(CCGSubSurf *ss,
-                                                    DerivedMesh *dm,
-                                                    DerivedMesh *result,
-                                                    int layer_index)
-{
-  CCGFace **faceMap;
-  MTFace *tf;
-  MLoopUV *mluv;
-  CCGFaceIterator fi;
-  int index, gridSize, gridFaces, totface, x, y, S;
-  MLoopUV *dmloopuv = CustomData_get_layer_n(&dm->loopData, CD_MLOOPUV, layer_index);
-  /* need to update both CD_MTFACE & CD_MLOOPUV, hrmf, we could get away with
-   * just tface except applying the modifier then looses subsurf UV */
-  MTFace *tface = CustomData_get_layer_n(&result->faceData, CD_MTFACE, layer_index);
-  MLoopUV *mloopuv = CustomData_get_layer_n(&result->loopData, CD_MLOOPUV, layer_index);
-
-  if (dmloopuv == NULL || (tface == NULL && mloopuv == NULL)) {
-    return;
-  }
-
-  ccgSubSurf_evaluatorSetFVarUV(ss, dm, layer_index);
-
-  /* get some info from CCGSubSurf */
-  totface = ccgSubSurf_getNumFaces(ss);
-  gridSize = ccgSubSurf_getGridSize(ss);
-  gridFaces = gridSize - 1;
-
-  /* make a map from original faces to CCGFaces */
-  faceMap = MEM_mallocN(totface * sizeof(*faceMap), "facemapuv");
-  for (ccgSubSurf_initFaceIterator(ss, &fi); !ccgFaceIterator_isStopped(&fi);
-       ccgFaceIterator_next(&fi)) {
-    CCGFace *f = ccgFaceIterator_getCurrent(&fi);
-    faceMap[POINTER_AS_INT(ccgSubSurf_getFaceFaceHandle(f))] = f;
-  }
-
-  /* load coordinates from uvss into tface */
-  tf = tface;
-  mluv = mloopuv;
-  for (index = 0; index < totface; index++) {
-    CCGFace *f = faceMap[index];
-    int numVerts = ccgSubSurf_getFaceNumVerts(f);
-    for (S = 0; S < numVerts; S++) {
-      for (y = 0; y < gridFaces; y++) {
-        for (x = 0; x < gridFaces; x++) {
-          const int delta[4][2] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};
-          float uv[4][2];
-          int i;
-          for (i = 0; i < 4; i++) {
-            const int dx = delta[i][0], dy = delta[i][1];
-            const float grid_u = ((float)(x + dx)) / (gridSize - 1),
-                        grid_v = ((float)(y + dy)) / (gridSize - 1);
-            ccgSubSurf_evaluatorFVarUV(ss, index, S, grid_u, grid_v, uv[i]);
-          }
-          if (tf) {
-            copy_v2_v2(tf->uv[0], uv[0]);
-            copy_v2_v2(tf->uv[1], uv[1]);
-            copy_v2_v2(tf->uv[2], uv[2]);
-            copy_v2_v2(tf->uv[3], uv[3]);
-            tf++;
-          }
-          if (mluv) {
-            copy_v2_v2(mluv[0].uv, uv[0]);
-            copy_v2_v2(mluv[1].uv, uv[1]);
-            copy_v2_v2(mluv[2].uv, uv[2]);
-            copy_v2_v2(mluv[3].uv, uv[3]);
-            mluv += 4;
-          }
-        }
-      }
-    }
-  }
-  MEM_freeN(faceMap);
-}
-#endif /* WITH_OPENSUBDIV */
-
 static void set_subsurf_legacy_uv(CCGSubSurf *ss, DerivedMesh *dm, DerivedMesh *result, int n)
 {
   CCGSubSurf *uvss;
@@ -564,16 +483,7 @@ static void set_subsurf_legacy_uv(CCGSubSurf *ss, DerivedMesh *dm, DerivedMesh *
 
 static void set_subsurf_uv(CCGSubSurf *ss, DerivedMesh *dm, DerivedMesh *result, int layer_index)
 {
-#ifdef WITH_OPENSUBDIV
-  if (!ccgSubSurf_needGrids(ss)) {
-    /* GPU backend is used, no need to evaluate UVs on CPU. */
-    /* TODO(sergey): Think of how to support edit mode of UVs. */
-  }
-  else
-#endif
-  {
-    set_subsurf_legacy_uv(ss, dm, result, layer_index);
-  }
+  set_subsurf_legacy_uv(ss, dm, result, layer_index);
 }
 
 /* face weighting */
@@ -763,40 +673,13 @@ static void ss_sync_ccg_from_derivedmesh(CCGSubSurf *ss,
 #endif
 }
 
-#ifdef WITH_OPENSUBDIV
-static void ss_sync_osd_from_derivedmesh(CCGSubSurf *ss, DerivedMesh *dm)
-{
-  ccgSubSurf_initFullSync(ss);
-  ccgSubSurf_prepareTopologyRefiner(ss, dm);
-  ccgSubSurf_processSync(ss);
-}
-#endif /* WITH_OPENSUBDIV */
-
 static void ss_sync_from_derivedmesh(CCGSubSurf *ss,
                                      DerivedMesh *dm,
                                      float (*vertexCos)[3],
                                      int use_flat_subdiv,
-                                     bool use_subdiv_uvs)
+                                     bool UNUSED(use_subdiv_uvs))
 {
-#ifndef WITH_OPENSUBDIV
-  UNUSED_VARS(use_subdiv_uvs);
-#endif
-
-#ifdef WITH_OPENSUBDIV
-  /* Reset all related descriptors if actual mesh topology changed or if
-   * other evaluation-related settings changed.
-   */
-  if (!ccgSubSurf_needGrids(ss)) {
-    /* TODO(sergey): Use vertex coordinates and flat subdiv flag. */
-    ccgSubSurf__sync_subdivUvs(ss, use_subdiv_uvs);
-    ccgSubSurf_checkTopologyChanged(ss, dm);
-    ss_sync_osd_from_derivedmesh(ss, dm);
-  }
-  else
-#endif
-  {
-    ss_sync_ccg_from_derivedmesh(ss, dm, vertexCos, use_flat_subdiv);
-  }
+  ss_sync_ccg_from_derivedmesh(ss, dm, vertexCos, use_flat_subdiv);
 }
 
 /***/
@@ -850,13 +733,6 @@ static void UNUSED_FUNCTION(ccgDM_getMinMax)(DerivedMesh *dm, float r_min[3], fl
   int i, edgeSize = ccgSubSurf_getEdgeSize(ss);
   int gridSize = ccgSubSurf_getGridSize(ss);
 
-#ifdef WITH_OPENSUBDIV
-  if (ccgdm->useGpuBackend) {
-    ccgSubSurf_getMinMax(ccgdm->ss, r_min, r_max);
-    return;
-  }
-#endif
-
   CCG_key_top_level(&key, ss);
 
   if (!ccgSubSurf_getNumVerts(ss)) {
@@ -1642,11 +1518,9 @@ static void ccgDM_release(DerivedMesh *dm)
     }
     MEM_freeN(ccgdm->edgeFlags);
     MEM_freeN(ccgdm->faceFlags);
-    if (ccgdm->useGpuBackend == false) {
-      MEM_freeN(ccgdm->vertMap);
-      MEM_freeN(ccgdm->edgeMap);
-      MEM_freeN(ccgdm->faceMap);
-    }
+    MEM_freeN(ccgdm->vertMap);
+    MEM_freeN(ccgdm->edgeMap);
+    MEM_freeN(ccgdm->faceMap);
 
     BLI_mutex_end(&ccgdm->loops_cache_lock);
     BLI_rw_mutex_end(&ccgdm->origindex_cache_rwlock);
@@ -2417,76 +2291,44 @@ static void set_ccgdm_all_geometry(CCGDerivedMesh *ccgdm,
   BLI_assert(faceNum == ccgSubSurf_getNumFinalFaces(ss));
 }
 
-/* Fill in only geometry arrays needed for the GPU tessellation. */
-static void set_ccgdm_gpu_geometry(CCGDerivedMesh *ccgdm, DerivedMesh *dm)
-{
-  const int totface = dm->getNumPolys(dm);
-  MPoly *mpoly = CustomData_get_layer(&dm->polyData, CD_MPOLY);
-  int index;
-  DMFlagMat *faceFlags = ccgdm->faceFlags;
-
-  for (index = 0; index < totface; index++) {
-    faceFlags->flag = mpoly ? mpoly[index].flag : 0;
-    faceFlags->mat_nr = mpoly ? mpoly[index].mat_nr : 0;
-    faceFlags++;
-  }
-
-  /* TODO(sergey): Fill in edge flags. */
-}
-
-static CCGDerivedMesh *getCCGDerivedMesh(
-    CCGSubSurf *ss, int drawInteriorEdges, int useSubsurfUv, DerivedMesh *dm, bool use_gpu_backend)
+static CCGDerivedMesh *getCCGDerivedMesh(CCGSubSurf *ss,
+                                         int drawInteriorEdges,
+                                         int useSubsurfUv,
+                                         DerivedMesh *dm)
 {
-#ifdef WITH_OPENSUBDIV
-  const int totedge = dm->getNumEdges(dm);
-  const int totface = dm->getNumPolys(dm);
-#else
   const int totedge = ccgSubSurf_getNumEdges(ss);
   const int totface = ccgSubSurf_getNumFaces(ss);
-#endif
   CCGDerivedMesh *ccgdm = MEM_callocN(sizeof(*ccgdm), "ccgdm");
 
-  if (use_gpu_backend == false) {
-    BLI_assert(totedge == ccgSubSurf_getNumEdges(ss));
-    BLI_assert(totface == ccgSubSurf_getNumFaces(ss));
-    DM_from_template(&ccgdm->dm,
-                     dm,
-                     DM_TYPE_CCGDM,
-                     ccgSubSurf_getNumFinalVerts(ss),
-                     ccgSubSurf_getNumFinalEdges(ss),
-                     0,
-                     ccgSubSurf_getNumFinalFaces(ss) * 4,
-                     ccgSubSurf_getNumFinalFaces(ss));
+  BLI_assert(totedge == ccgSubSurf_getNumEdges(ss));
+  BLI_assert(totface == ccgSubSurf_getNumFaces(ss));
+  DM_from_template(&ccgdm->dm,
+                   dm,
+                   DM_TYPE_CCGDM,
+                   ccgSubSurf_getNumFinalVerts(ss),
+                   ccgSubSurf_getNumFinalEdges(ss),
+                   0,
+                   ccgSubSurf_getNumFinalFaces(ss) * 4,
+                   ccgSubSurf_getNumFinalFaces(ss));
 
-    CustomData_free_layer_active(&ccgdm->dm.polyData, CD_NORMAL, ccgdm->dm.numPolyData);
+  CustomData_free_layer_active(&ccgdm->dm.polyData, CD_NORMAL, ccgdm->dm.numPolyData);
 
-    ccgdm->reverseFaceMap = MEM_callocN(sizeof(int) * ccgSubSurf_getNumFinalFaces(ss),
-                                        "reverseFaceMap");
+  ccgdm->reverseFaceMap = MEM_callocN(sizeof(int) * ccgSubSurf_getNumFinalFaces(ss),
+                                      "reverseFaceMap");
 
-    create_ccgdm_maps(ccgdm, ss);
-  }
-  else {
-    DM_from_template(&ccgdm->dm, dm, DM_TYPE_CCGDM, 0, 0, 0, 0, dm->getNumPolys(dm));
-    CustomData_copy_data(&dm->polyData, &ccgdm->dm.polyData, 0, 0, dm->getNumPolys(dm));
-  }
+  create_ccgdm_maps(ccgdm, ss);
 
   set_default_ccgdm_callbacks(ccgdm);
 
   ccgdm->ss = ss;
   ccgdm->drawInteriorEdges = drawInteriorEdges;
   ccgdm->useSubsurfUv = useSubsurfUv;
-  ccgdm->useGpuBackend = use_gpu_backend;
 
   /* CDDM hack. */
   ccgdm->edgeFlags = MEM_callocN(sizeof(short) * totedge, "edgeFlags");
   ccgdm->faceFlags = MEM_callocN(sizeof(DMFlagMat) * totface, "faceFlags");
 
-  if (use_gpu_backend == false) {
-    set_ccgdm_all_geometry(ccgdm, ss, dm, useSubsurfUv != 0);
-  }
-  else {
-    set_ccgdm_gpu_geometry(ccgdm, dm);
-  }
+  set_ccgdm_all_geometry(ccgdm, ss, dm, useSubsurfUv != 0);
 
   ccgdm->dm.numVertData = ccgSubSurf_getNumFinalVerts(ss);
   ccgdm->dm.numEdgeData = ccgSubSurf_getNumFinalEdges(ss);
@@ -2502,21 +2344,6 @@ static CCGDerivedMesh *getCCGDerivedMesh(
 
 /***/
 
-static bool subsurf_use_gpu_backend(SubsurfFlags flags)
-{
-#ifdef WITH_OPENSUBDIV
-  /* Use GPU backend if it's a last modifier in the stack
-   * and user chose to use any of the OSD compute devices,
-   * but also check if GPU has all needed features.
-   */
-  return (flags & SUBSURF_USE_GPU_BACKEND) != 0 &&
-         (U.opensubdiv_compute_type != USER_OPENSUBDIV_COMPUTE_NONE);
-#else
-  (void)flags;
-  return false;
-#endif
-}
-
 struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
                                                       struct SubsurfModifierData *smd,
                                                       const struct Scene *scene,
@@ -2527,7 +2354,6 @@ struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
   const CCGFlags useAging = (smd->flags & eSubsurfModifierFlag_DebugIncr) ? CCG_USE_AGING : 0;
   const int useSubsurfUv = (smd->uv_smooth != SUBSURF_UV_SMOOTH_NONE);
   const int drawInteriorEdges = !(smd->flags & eSubsurfModifierFlag_ControlEdges);
-  const bool use_gpu_backend = subsurf_use_gpu_backend(flags);
   const bool ignore_simplify = (flags & SUBSURF_IGNORE_SIMPLIFY);
   CCGDerivedMesh *result;
 
@@ -2546,11 +2372,8 @@ struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
 
     smd->emCache = _getSubSurf(smd->emCache, levels, 3, useSimple | useAging | CCG_CALC_NORMALS);
 
-#ifdef WITH_OPENSUBDIV
-    ccgSubSurf_setSkipGrids(smd->emCache, use_gpu_backend);
-#endif
     ss_sync_from_derivedmesh(smd->emCache, dm, vertCos, useSimple, useSubsurfUv);
-    result = getCCGDerivedMesh(smd->emCache, drawInteriorEdges, useSubsurfUv, dm, use_gpu_backend);
+    result = getCCGDerivedMesh(smd->emCache, drawInteriorEdges, useSubsurfUv, dm);
   }
   else if (flags & SUBSURF_USE_RENDER_PARAMS) {
     /* Do not use cache in render mode. */
@@ -2567,7 +2390,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
 
     ss_sync_from_derivedmesh(ss, dm, vertCos, useSimple, useSubsurfUv);
 
-    result = getCCGDerivedMesh(ss, drawInteriorEdges, useSubsurfUv, dm, false);
+    result = getCCGDerivedMesh(ss, drawInteriorEdges, useSubsurfUv, dm);
 
     result->freeSS = 1;
   }
@@ -2600,32 +2423,15 @@ struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
 
       ss_sync_from_derivedmesh(ss, dm, vertCos, useSimple, useSubsurfUv);
 
-      result = getCCGDerivedMesh(smd->mCache, drawInteriorEdges, useSubsurfUv, dm, false);
+      result = getCCGDerivedMesh(smd->mCache, drawInteriorEdges, useSubsurfUv, dm);
     }
     else {
       CCGFlags ccg_flags = useSimple | CCG_USE_ARENA | CCG_CALC_NORMALS;
       CCGSubSurf *prevSS = NULL;
 
       if (smd->mCache && (flags & SUBSURF_IS_FINAL_CALC)) {
-#ifdef WITH_OPENSUBDIV
-        /* With OpenSubdiv enabled we always tries to re-use previous
-         * subsurf structure in order to save computation time since
-         * re-creation is rather a complicated business.
-         *
-         * TODO(sergey): There was a good reason why final calculation
-         * used to free entirely cached subsurf structure. reason of
-         * this is to be investigated still to be sure we don't have
-         * regressions here.
-         */
-        if (use_gpu_backend) {
-          prevSS = smd->mCache;
-        }
-        else
-#endif
-        {
-          ccgSubSurf_free(smd->mCache);
-          smd->mCache = NULL;
-        }
+        ccgSubSurf_free(smd->mCache);
+        smd->mCache = NULL;
       }
 
       if (flags & SUBSURF_ALLOC_PAINT_MASK) {
@@ -2633,12 +2439,9 @@ struct DerivedMesh *subsurf_make_derived_from_derived(struct DerivedMesh *dm,
       }
 
       ss = _getSubSurf(prevSS, levels, 3, ccg_flags);
-#ifdef WITH_OPENSUBDIV
-      ccgSubSurf_setSkipGrids(ss, use_gpu_backend);
-#endif
       ss_sync_from_derivedmesh(ss, dm, vertCos, useSimple, useSubsurfUv);
 
-      result = getCCGDerivedMesh(ss, drawInteriorEdges, useSubsurfUv, dm, use_gpu_backend);
+      result = getCCGDerivedMesh(ss, drawInteriorEdges, useSubsurfUv, dm);
 
       if (flags & SUBSURF_IS_FINAL_CALC) {
         smd->mCache = ss;
@@ -2710,26 +2513,10 @@ void subsurf_calculate_limit_positions(Mesh *me, float (*r_positions)[3])
 
 bool subsurf_has_edges(DerivedMesh *dm)
 {
-  CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
-#ifdef WITH_OPENSUBDIV
-  if (ccgdm->useGpuBackend) {
-    return true;
-  }
-#else
-  (void)ccgdm;
-#endif
   return dm->getNumEdges(dm) != 0;
 }
 
 bool subsurf_has_faces(DerivedMesh *dm)
 {
-  CCGDerivedMesh *ccgdm = (CCGDerivedMesh *)dm;
-#ifdef WITH_OPENSUBDIV
-  if (ccgdm->useGpuBackend) {
-    return true;
-  }
-#else
-  (void)ccgdm;
-#endif
   return dm->getNumPolys(dm) != 0;
 }