GPU subdiv: smoothly interpolate orco layer

This uses the recently introduced evaluator's vertex
data to smoothly interpolate original coordinates instead
of using linear interpolation.

The orcos are interpolated at the same time as positions
and as such, the specific subdivision routine for the
orco extractor has been removed. The patch evaluation
shader uses a definition to enable code specific to
orco evaluation.

Since the orco layer may not have been requested on first
render, and since orco data is now stored in the OpenSubDiv
evaluator, the evaluator needs to be recreated if an
orco layer is suddenly available. For this, a callback
to check if the evaluator has the data was added. This is
added to the evaluator as the `Subdiv` cache stored in the
modifier is invalidated less often than the Mesh batch cache
and so leads to fewer evaluator recreations.

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

1 files changed, 56 insertions, 0 deletions

diff --git a/source/blender/draw/intern/shaders/common_subdiv_patch_evaluation_comp.glsl b/source/blender/draw/intern/shaders/common_subdiv_patch_evaluation_comp.glsl
index 65cf4ebb90f..bf1f0f95787 100644
--- a/source/blender/draw/intern/shaders/common_subdiv_patch_evaluation_comp.glsl
+++ b/source/blender/draw/intern/shaders/common_subdiv_patch_evaluation_comp.glsl
@@ -89,6 +89,16 @@ layout(std430, binding = 8) writeonly buffer outputVertexData
 {
   PosNorLoop output_verts[];
 };
+#  if defined(ORCO_EVALUATION)
+layout(std430, binding = 9) buffer src_extra_buffer
+{
+  float srcExtraVertexBuffer[];
+};
+layout(std430, binding = 10) writeonly buffer outputOrcoData
+{
+  vec4 output_orcos[];
+};
+#  endif
 #endif
 
 vec2 read_vec2(int index)
@@ -108,6 +118,17 @@ vec3 read_vec3(int index)
   return result;
 }
 
+#if defined(ORCO_EVALUATION)
+vec3 read_vec3_extra(int index)
+{
+  vec3 result;
+  result.x = srcExtraVertexBuffer[index * 3];
+  result.y = srcExtraVertexBuffer[index * 3 + 1];
+  result.z = srcExtraVertexBuffer[index * 3 + 2];
+  return result;
+}
+#endif
+
 OsdPatchArray GetPatchArray(int arrayIndex)
 {
   return patchArrayBuffer[arrayIndex];
@@ -290,6 +311,31 @@ void evaluate_patches_limits(
     dv += src_vertex * wDv[cv];
   }
 }
+
+#  if defined(ORCO_EVALUATION)
+/* Evaluate the patches limits from the extra source vertex buffer. */
+void evaluate_patches_limits_extra(int patch_index, float u, float v, inout vec3 dst)
+{
+  OsdPatchCoord coord = GetPatchCoord(patch_index, u, v);
+  OsdPatchArray array = GetPatchArray(coord.arrayIndex);
+  OsdPatchParam param = GetPatchParam(coord.patchIndex);
+
+  int patchType = OsdPatchParamIsRegular(param) ? array.regDesc : array.desc;
+
+  float wP[20], wDu[20], wDv[20], wDuu[20], wDuv[20], wDvv[20];
+  int nPoints = OsdEvaluatePatchBasis(
+      patchType, param, coord.s, coord.t, wP, wDu, wDv, wDuu, wDuv, wDvv);
+
+  int indexBase = array.indexBase + array.stride * (coord.patchIndex - array.primitiveIdBase);
+
+  for (int cv = 0; cv < nPoints; ++cv) {
+    int index = patchIndexBuffer[indexBase + cv];
+    vec3 src_vertex = read_vec3_extra(index);
+
+    dst += src_vertex * wP[cv];
+  }
+}
+#  endif
 #endif
 
 /* ------------------------------------------------------------------------------
@@ -407,6 +453,16 @@ void main()
     set_vertex_pos(vertex_data, pos);
     set_vertex_nor(vertex_data, nor, flag);
     output_verts[loop_index] = vertex_data;
+
+#  if defined(ORCO_EVALUATION)
+    pos = vec3(0.0);
+    evaluate_patches_limits_extra(patch_co.patch_index, uv.x, uv.y, pos);
+
+    /* Set w = 0.0 to indicate that this is not a generic attribute.
+     * See comments in `extract_mesh_vbo_orco.cc`. */
+    vec4 orco_data = vec4(pos, 0.0);
+    output_orcos[loop_index] = orco_data;
+#  endif
   }
 }
 #endif