Removal of yocto_shape.cpp

apps/ysamples.cpp

@@ -29,6 +29,8 @@
 #include <yocto/yocto_cli.h>
 #include <yocto/yocto_image.h>
 #include <yocto/yocto_math.h>
+#include <yocto/yocto_modeling.h>
+#include <yocto/yocto_sampling.h>
 #include <yocto/yocto_scene.h>
 #include <yocto/yocto_sceneio.h>
 #include <yocto/yocto_shape.h>
@@ -75,7 +77,8 @@ void run(const vector<string>& args) {
     auto sshape = shape_data{};
     for (auto& point : points) {
       sshape.points.push_back((int)sshape.points.size());
-      sshape.positions.push_back(eval_position(shape, point.element, point.uv));
+      sshape.positions.push_back(
+          eval_position(shape, point.first, point.second));
       sshape.radius.push_back(radius * 10);
     }
 

libs/yocto/CMakeLists.txt

@@ -1,11 +1,10 @@
 add_library(yocto STATIC
   yocto_math.h
   yocto_image.h
+  yocto_shape.h yocto_scene.h yocto_scene.cpp
+  yocto_raycasting.h yocto_raycasting.cpp
   yocto_sampling.h yocto_shading.h
   yocto_modeling.h yocto_animation.h
-  yocto_raycasting.h yocto_raycasting.cpp
-  yocto_shape.h yocto_shape.cpp
-  yocto_scene.h yocto_scene.cpp
   yocto_trace.h yocto_trace.cpp
   yocto_modelio.h yocto_modelio.cpp
   yocto_pbrtio.h yocto_pbrtio.cpp

libs/yocto/yocto_modeling.h

@@ -332,6 +332,13 @@ static pair<vector<vec4i>, vector<T>> subdivide_catmullclark_creased(
     const vector<vec2i>& creases, const vector<int>& corners,
     int subdivisions = 1, bool lock_boundary = false);
 
+// Shape subdivision
+inline shape_data subdivide_shape(
+    const shape_data& shape, int subdivisions, bool catmullclark);
+
+inline fvshape_data subdivide_fvshape(
+    const fvshape_data& shape, int subdivisions, bool catmullclark);
+
 }  // namespace yocto
 
 // -----------------------------------------------------------------------------
@@ -2243,6 +2250,90 @@ static pair<vector<vec4i>, vector<T>> subdivide_catmullclark_illustration(
   return {quads, vertices};
 }
 
+// Shape subdivision
+inline shape_data subdivide_shape(
+    const shape_data& shape, int subdivisions, bool catmullclark) {
+  // This should probably be re-implemented in a faster fashion,
+  // but how it is not obvious
+  if (subdivisions == 0) return shape;
+  auto subdivided = shape_data{};
+  if (!subdivided.points.empty()) {
+    subdivided = shape;
+  } else if (!subdivided.lines.empty()) {
+    std::tie(std::ignore, subdivided.normals) = subdivide_lines(
+        shape.lines, shape.normals, subdivisions);
+    std::tie(std::ignore, subdivided.texcoords) = subdivide_lines(
+        shape.lines, shape.texcoords, subdivisions);
+    std::tie(std::ignore, subdivided.colors) = subdivide_lines(
+        shape.lines, shape.colors, subdivisions);
+    std::tie(std::ignore, subdivided.radius) = subdivide_lines(
+        subdivided.lines, shape.radius, subdivisions);
+    std::tie(subdivided.lines, subdivided.positions) = subdivide_lines(
+        shape.lines, shape.positions, subdivisions);
+  } else if (!subdivided.triangles.empty()) {
+    std::tie(std::ignore, subdivided.normals) = subdivide_triangles(
+        shape.triangles, shape.normals, subdivisions);
+    std::tie(std::ignore, subdivided.texcoords) = subdivide_triangles(
+        shape.triangles, shape.texcoords, subdivisions);
+    std::tie(std::ignore, subdivided.colors) = subdivide_triangles(
+        shape.triangles, shape.colors, subdivisions);
+    std::tie(std::ignore, subdivided.radius) = subdivide_triangles(
+        shape.triangles, shape.radius, subdivisions);
+    std::tie(subdivided.triangles, subdivided.positions) = subdivide_triangles(
+        shape.triangles, shape.positions, subdivisions);
+  } else if (!subdivided.quads.empty() && !catmullclark) {
+    std::tie(std::ignore, subdivided.normals) = subdivide_quads(
+        shape.quads, shape.normals, subdivisions);
+    std::tie(std::ignore, subdivided.texcoords) = subdivide_quads(
+        shape.quads, shape.texcoords, subdivisions);
+    std::tie(std::ignore, subdivided.colors) = subdivide_quads(
+        shape.quads, shape.colors, subdivisions);
+    std::tie(std::ignore, subdivided.radius) = subdivide_quads(
+        shape.quads, shape.radius, subdivisions);
+    std::tie(subdivided.quads, subdivided.positions) = subdivide_quads(
+        shape.quads, shape.positions, subdivisions);
+  } else if (!subdivided.quads.empty() && catmullclark) {
+    std::tie(std::ignore, subdivided.normals) = subdivide_catmullclark(
+        shape.quads, shape.normals, subdivisions);
+    std::tie(std::ignore, subdivided.texcoords) = subdivide_catmullclark(
+        shape.quads, shape.texcoords, subdivisions);
+    std::tie(std::ignore, subdivided.colors) = subdivide_catmullclark(
+        shape.quads, shape.colors, subdivisions);
+    std::tie(std::ignore, subdivided.radius) = subdivide_catmullclark(
+        shape.quads, shape.radius, subdivisions);
+    std::tie(subdivided.quads, subdivided.positions) = subdivide_catmullclark(
+        shape.quads, shape.positions, subdivisions);
+  } else {
+    // empty shape
+  }
+  return subdivided;
+}
+
+// Subdivision
+inline fvshape_data subdivide_fvshape(
+    const fvshape_data& shape, int subdivisions, bool catmullclark) {
+  // This should be probably re-implemeneted in a faster fashion.
+  if (subdivisions == 0) return shape;
+  auto subdivided = fvshape_data{};
+  if (!catmullclark) {
+    std::tie(subdivided.quadspos, subdivided.positions) = subdivide_quads(
+        shape.quadspos, shape.positions, subdivisions);
+    std::tie(subdivided.quadsnorm, subdivided.normals) = subdivide_quads(
+        shape.quadsnorm, shape.normals, subdivisions);
+    std::tie(subdivided.quadstexcoord, subdivided.texcoords) = subdivide_quads(
+        shape.quadstexcoord, shape.texcoords, subdivisions);
+  } else {
+    std::tie(subdivided.quadspos, subdivided.positions) =
+        subdivide_catmullclark(shape.quadspos, shape.positions, subdivisions);
+    std::tie(subdivided.quadsnorm, subdivided.normals) = subdivide_catmullclark(
+        shape.quadsnorm, shape.normals, subdivisions);
+    std::tie(subdivided.quadstexcoord, subdivided.texcoords) =
+        subdivide_catmullclark(
+            shape.quadstexcoord, shape.texcoords, subdivisions, true);
+  }
+  return subdivided;
+}
+
 }  // namespace yocto
 
 // -----------------------------------------------------------------------------

libs/yocto/yocto_sampling.h

@@ -53,6 +53,7 @@
 #include <vector>
 
 #include "yocto_math.h"
+#include "yocto_shape.h"
 
 // -----------------------------------------------------------------------------
 // USING DIRECTIVES
@@ -196,6 +197,13 @@ inline pair<int, vec2f> sample_quads(
 inline vector<float> sample_quads_cdf(
     const vector<vec4i>& quads, const vector<vec3f>& positions);
 
+// Shape sampling
+vector<float>    sample_shape_cdf(const shape_data& shape);
+pair<int, vec2f> sample_shape(
+    const shape_data& shape, const vector<float>& cdf, float rn, vec2f ruv);
+vector<pair<int, vec2f>> sample_shape(
+    const shape_data& shape, int num_samples, uint64_t seed = 98729387);
+
 }  // namespace yocto
 
 // -----------------------------------------------------------------------------
@@ -510,6 +518,52 @@ inline vector<float> sample_quads_cdf(
   return cdf;
 }
 
+// Shape sampling
+inline vector<float> sample_shape_cdf(const shape_data& shape) {
+  if (!shape.points.empty()) {
+    return sample_points_cdf((int)shape.points.size());
+  } else if (!shape.lines.empty()) {
+    return sample_lines_cdf(shape.lines, shape.positions);
+  } else if (!shape.triangles.empty()) {
+    return sample_triangles_cdf(shape.triangles, shape.positions);
+  } else if (!shape.quads.empty()) {
+    return sample_quads_cdf(shape.quads, shape.positions);
+  } else {
+    return sample_points_cdf((int)shape.positions.size());
+  }
+}
+
+inline pair<int, vec2f> sample_shape(
+    const shape_data& shape, const vector<float>& cdf, float rn, vec2f ruv) {
+  if (!shape.points.empty()) {
+    auto element = sample_points(cdf, rn);
+    return {element, {0, 0}};
+  } else if (!shape.lines.empty()) {
+    auto [element, u] = sample_lines(cdf, rn, ruv.x);
+    return {element, {u, 0}};
+  } else if (!shape.triangles.empty()) {
+    auto [element, uv] = sample_triangles(cdf, rn, ruv);
+    return {element, uv};
+  } else if (!shape.quads.empty()) {
+    auto [element, uv] = sample_quads(cdf, rn, ruv);
+    return {element, uv};
+  } else {
+    auto element = sample_points(cdf, rn);
+    return {element, {0, 0}};
+  }
+}
+
+inline vector<pair<int, vec2f>> sample_shape(
+    const shape_data& shape, int num_samples, uint64_t seed) {
+  auto cdf    = sample_shape_cdf(shape);
+  auto points = vector<pair<int, vec2f>>(num_samples);
+  auto rng    = make_rng(seed);
+  for (auto& point : points) {
+    point = sample_shape(shape, cdf, rand1f(rng), rand2f(rng));
+  }
+  return points;
+}
+
 }  // namespace yocto
 
 // -----------------------------------------------------------------------------

libs/yocto/yocto_scene.cpp

@@ -1959,9 +1959,9 @@ shape_data make_hair(const shape_data& base, vec2i steps, vec2f len, vec2f rad,
   auto bnorm     = vector<vec3f>{};
   auto btexcoord = vector<vec2f>{};
   for (auto& point : points) {
-    bpos.push_back(eval_position(base, point.element, point.uv));
-    bnorm.push_back(eval_normal(base, point.element, point.uv));
-    btexcoord.push_back(eval_texcoord(base, point.element, point.uv));
+    bpos.push_back(eval_position(base, point.first, point.second));
+    bnorm.push_back(eval_normal(base, point.first, point.second));
+    btexcoord.push_back(eval_texcoord(base, point.first, point.second));
   }
 
   auto rng  = make_rng(seed, 3);
@@ -2031,9 +2031,9 @@ shape_data make_random_points(
   auto points  = make_points(num, 1, radius);
   for (auto idx : range(num)) {
     points.positions[idx] = eval_position(
-        shape, samples[idx].element, samples[idx].uv);
+        shape, samples[idx].first, samples[idx].second);
     points.normals[idx] = eval_normal(
-        shape, samples[idx].element, samples[idx].uv);
+        shape, samples[idx].first, samples[idx].second);
   }
   return points;
 }
@@ -2046,9 +2046,11 @@ shape_data make_random_hairs(const shape_data& shape, int num, int steps,
   auto rng     = make_rng(seed);
   for (auto idx : range(num)) {
     auto offset   = idx * (steps + 1);
-    auto position = eval_position(shape, samples[idx].element, samples[idx].uv);
-    auto direction = eval_normal(shape, samples[idx].element, samples[idx].uv);
-    auto length    = lerp(len.x, len.y, rand1f(rng));
+    auto position = eval_position(
+        shape, samples[idx].first, samples[idx].second);
+    auto direction = eval_normal(
+        shape, samples[idx].first, samples[idx].second);
+    auto length             = lerp(len.x, len.y, rand1f(rng));
     hairs.positions[offset] = position;
     for (auto iidx = 1; iidx <= steps; iidx++) {
       hairs.positions[offset + iidx] = position;
@@ -2073,9 +2075,9 @@ shape_data make_hair2(const shape_data& base, vec2i steps, vec2f len,
   auto bnormals   = vector<vec3f>{};
   auto btexcoord  = vector<vec2f>{};
   for (auto& point : points) {
-    bpositions.push_back(eval_position(base, point.element, point.uv));
-    bnormals.push_back(eval_normal(base, point.element, point.uv));
-    btexcoord.push_back(eval_texcoord(base, point.element, point.uv));
+    bpositions.push_back(eval_position(base, point.first, point.second));
+    bnormals.push_back(eval_normal(base, point.first, point.second));
+    btexcoord.push_back(eval_texcoord(base, point.first, point.second));
   }
 
   auto shape = make_lines(steps.y, steps.x, {1, 1}, {1, 1}, radius);