BKE_curves.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#include "BLI_bounds_types.hh"
#include "BLI_implicit_sharing_ptr.hh"
#include "BLI_index_mask_fwd.hh"
#include "BLI_math_matrix_types.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_memory_counter_fwd.hh"
#include "BLI_offset_indices.hh"
#include "BLI_shared_cache.hh"
#include "BLI_span.hh"
#include "BLI_vector.hh"
#include "BLI_virtual_array_fwd.hh"
 
#include "BKE_attribute_math.hh"
#include "BKE_attribute_storage.hh"
#include "BKE_curves.h"
 
struct BlendDataReader;
struct BlendWriter;
struct MDeformVert;
namespace blender::bke {
class AttributeAccessor;
class MutableAttributeAccessor;
enum class AttrDomain : int8_t;
struct AttributeAccessorFunctions;
}  // namespace blender::bke
namespace blender::bke::bake {
struct BakeMaterialsList;
}
namespace blender {
class GVArray;
}
 
namespace blender::bke {
 
namespace curves::nurbs {
 
struct BasisCache {
  Vector<float> weights;
  Vector<int> start_indices;

  bool invalid = false;
};
 
}  // namespace curves::nurbs

class CurvesGeometryRuntime {
 public:
  const ImplicitSharingInfo *curve_offsets_sharing_info = nullptr;

  const ImplicitSharingInfo *custom_knots_sharing_info = nullptr;

  std::array<int, CURVE_TYPES_NUM> type_counts;

  struct EvaluatedOffsets {
    Vector<int> evaluated_offsets;
    Vector<int> all_bezier_offsets;
  };
  mutable SharedCache<EvaluatedOffsets> evaluated_offsets_cache;
 
  mutable SharedCache<Vector<curves::nurbs::BasisCache>> nurbs_basis_cache;

  mutable SharedCache<Vector<float3>> evaluated_position_cache;

  mutable SharedCache<Bounds<float3>> bounds_cache;
  mutable SharedCache<Bounds<float3>> bounds_with_radius_cache;

  mutable SharedCache<Vector<float>> evaluated_length_cache;

  mutable SharedCache<Vector<float3>> evaluated_tangent_cache;

  mutable SharedCache<Vector<float3>> evaluated_normal_cache;

  mutable SharedCache<std::optional<int>> max_material_index_cache;

  mutable SharedCache<Vector<int>> custom_knot_offsets_cache;

  std::unique_ptr<bake::BakeMaterialsList> bake_materials;

  bool check_type_counts = true;
};

class CurvesGeometry : public ::CurvesGeometry {
 public:
  CurvesGeometry();
  CurvesGeometry(int point_num, int curve_num);
  CurvesGeometry(const CurvesGeometry &other);
  CurvesGeometry(CurvesGeometry &&other);
  CurvesGeometry &operator=(const CurvesGeometry &other);
  CurvesGeometry &operator=(CurvesGeometry &&other);
  ~CurvesGeometry();
 
  /* --------------------------------------------------------------------
   * Accessors.
   */

  int points_num() const;
  int curves_num() const;
  bool is_empty() const;
 
  IndexRange points_range() const;
  IndexRange curves_range() const;

  Span<int> offsets() const;
  MutableSpan<int> offsets_for_write();

  OffsetIndices<int> points_by_curve() const;

  VArray<int8_t> curve_types() const;
  MutableSpan<int8_t> curve_types_for_write();
  void fill_curve_types(CurveType type);
  void fill_curve_types(const IndexMask &selection, CurveType type);
  void update_curve_types();
 
  bool has_curve_with_type(CurveType type) const;
  bool has_curve_with_type(Span<CurveType> types) const;
  bool is_single_type(CurveType type) const;
  const std::array<int, CURVE_TYPES_NUM> &curve_type_counts() const;
  IndexMask indices_for_curve_type(CurveType type, IndexMaskMemory &memory) const;
  IndexMask indices_for_curve_type(CurveType type,
                                   const IndexMask &selection,
                                   IndexMaskMemory &memory) const;
 
  Array<int> point_to_curve_map() const;
 
  Span<float3> positions() const;
  MutableSpan<float3> positions_for_write();
 
  VArray<float> radius() const;
  MutableSpan<float> radius_for_write();

  VArray<bool> cyclic() const;
  MutableSpan<bool> cyclic_for_write();

  VArray<int> resolution() const;
  MutableSpan<int> resolution_for_write();

  VArray<float> tilt() const;
  MutableSpan<float> tilt_for_write();

  VArray<int8_t> normal_mode() const;
  MutableSpan<int8_t> normal_mode_for_write();

  VArray<int8_t> handle_types_left() const;
  MutableSpan<int8_t> handle_types_left_for_write();
  VArray<int8_t> handle_types_right() const;
  MutableSpan<int8_t> handle_types_right_for_write();

  Span<float3> handle_positions_left() const;
  MutableSpan<float3> handle_positions_left_for_write();
  Span<float3> handle_positions_right() const;
  MutableSpan<float3> handle_positions_right_for_write();

  VArray<int8_t> nurbs_orders() const;
  MutableSpan<int8_t> nurbs_orders_for_write();

  VArray<int8_t> nurbs_knots_modes() const;
  MutableSpan<int8_t> nurbs_knots_modes_for_write();

  Span<float> nurbs_weights() const;
  MutableSpan<float> nurbs_weights_for_write();

  Span<float2> surface_uv_coords() const;
  MutableSpan<float2> surface_uv_coords_for_write();

  Span<float> nurbs_custom_knots() const;
  MutableSpan<float> nurbs_custom_knots_for_write();

  OffsetIndices<int> nurbs_custom_knots_by_curve() const;

  IndexMask nurbs_custom_knot_curves(IndexMaskMemory &memory) const;
 
  bool nurbs_has_custom_knots() const;

  void nurbs_custom_knots_update_size();

  void nurbs_custom_knots_resize(int knots_num);

  Span<MDeformVert> deform_verts() const;
  MutableSpan<MDeformVert> deform_verts_for_write();

  std::optional<Bounds<float3>> bounds_min_max(bool use_radius = true) const;
 
  void count_memory(MemoryCounter &memory) const;

  std::optional<int> material_index_max() const;
 
 private:
  /* --------------------------------------------------------------------
   * Evaluation.
   */
 
 public:
  int evaluated_points_num() const;

  OffsetIndices<int> evaluated_points_by_curve() const;

  Span<int> bezier_evaluated_offsets_for_curve(int curve_index) const;
 
  Span<float3> evaluated_positions() const;
  Span<float3> evaluated_tangents() const;
  Span<float3> evaluated_normals() const;

  Span<float> evaluated_lengths_for_curve(int curve_index, bool cyclic) const;
  float evaluated_length_total_for_curve(int curve_index, bool cyclic) const;

  void ensure_evaluated_lengths() const;
 
  void ensure_can_interpolate_to_evaluated() const;

  void interpolate_to_evaluated(int curve_index, GSpan src, GMutableSpan dst) const;
  void interpolate_to_evaluated(GSpan src, GMutableSpan dst) const;
 
 private:
  void ensure_nurbs_basis_cache() const;

  IndexRange lengths_range_for_curve(int curve_index, bool cyclic) const;
 
  /* --------------------------------------------------------------------
   * Operations.
   */
 
 public:
  void resize(int points_num, int curves_num);

  void tag_positions_changed();
  void tag_topology_changed();
  void tag_normals_changed();
  void tag_radii_changed();
  void tag_material_index_changed();
 
  void translate(const float3 &translation);
  void transform(const float4x4 &matrix);
 
  void calculate_bezier_auto_handles();
 
  void remove_points(const IndexMask &points_to_delete, const AttributeFilter &attribute_filter);
  void remove_curves(const IndexMask &curves_to_delete, const AttributeFilter &attribute_filter);

  void reverse_curves(const IndexMask &curves_to_reverse);

  void remove_attributes_based_on_types();
 
  AttributeAccessor attributes() const;
  MutableAttributeAccessor attributes_for_write();
 
  /* --------------------------------------------------------------------
   * Attributes.
   */
 
  GVArray adapt_domain(const GVArray &varray, AttrDomain from, AttrDomain to) const;
  template<typename T>
  VArray<T> adapt_domain(const VArray<T> &varray, AttrDomain from, AttrDomain to) const
  {
    return this->adapt_domain(GVArray(varray), from, to).typed<T>();
  }
 
  /* --------------------------------------------------------------------
   * File Read/Write.
   */
  void blend_read(BlendDataReader &reader);
  struct BlendWriteData {
    ResourceScope &scope;
    Vector<CustomDataLayer, 16> &point_layers;
    Vector<CustomDataLayer, 16> &curve_layers;
    AttributeStorage::BlendWriteData attribute_data;
    explicit BlendWriteData(ResourceScope &scope);
  };

  void blend_write_prepare(BlendWriteData &write_data);
  void blend_write(BlendWriter &writer, ID &id, const BlendWriteData &write_data);
};
 
static_assert(sizeof(blender::bke::CurvesGeometry) == sizeof(::CurvesGeometry));

class CurvesEditHints {
 public:
  const Curves &curves_id_orig;
  ImplicitSharingPtrAndData positions_data;
  std::optional<Array<float3x3>> deform_mats;
 
  CurvesEditHints(const Curves &curves_id_orig) : curves_id_orig(curves_id_orig) {}
 
  std::optional<Span<float3>> positions() const;
  std::optional<MutableSpan<float3>> positions_for_write();

  bool is_valid() const;
};
 
void curves_normals_point_domain_calc(const CurvesGeometry &curves, MutableSpan<float3> normals);
 
namespace curves {
 
/* -------------------------------------------------------------------- */

inline int segments_num(const int points_num, const bool cyclic)
{
  BLI_assert(points_num > 0);
  return (cyclic && points_num > 1) ? points_num : points_num - 1;
}
 
inline float2 encode_surface_bary_coord(const float3 &v)
{
  BLI_assert(std::abs(v.x + v.y + v.z - 1.0f) < 0.00001f);
  return {v.x, v.y};
}
 
inline float3 decode_surface_bary_coord(const float2 &v)
{
  return {v.x, v.y, 1.0f - v.x - v.y};
}

inline IndexRange per_curve_point_offsets_range(const IndexRange points, const int curve_index)
{
  return {curve_index + points.start(), points.size() + 1};
}

 
/* -------------------------------------------------------------------- */
 
namespace poly {

void calculate_tangents(Span<float3> positions, bool is_cyclic, MutableSpan<float3> tangents);

void calculate_normals_minimum(Span<float3> tangents, bool cyclic, MutableSpan<float3> normals);

void calculate_normals_z_up(Span<float3> tangents, MutableSpan<float3> normals);
 
}  // namespace poly

 
/* -------------------------------------------------------------------- */
 
namespace bezier {

bool segment_is_vector(const HandleType left, const HandleType right);
bool segment_is_vector(const int8_t left, const int8_t right);
bool segment_is_vector(Span<int8_t> handle_types_left,
                       Span<int8_t> handle_types_right,
                       int segment_index);

bool has_vector_handles(int num_curve_points, int64_t evaluated_size, bool cyclic, int resolution);

bool last_cyclic_segment_is_vector(Span<int8_t> handle_types_left,
                                   Span<int8_t> handle_types_right);

bool point_is_sharp(Span<int8_t> handle_types_left, Span<int8_t> handle_types_right, int index);

void calculate_evaluated_offsets(Span<int8_t> handle_types_left,
                                 Span<int8_t> handle_types_right,
                                 bool cyclic,
                                 int resolution,
                                 MutableSpan<int> evaluated_offsets);

struct Insertion {
  float3 handle_prev;
  float3 left_handle;
  float3 position;
  float3 right_handle;
  float3 handle_next;
};

Insertion insert(const float3 &point_prev,
                 const float3 &handle_prev,
                 const float3 &handle_next,
                 const float3 &point_next,
                 float parameter);

float3 calculate_vector_handle(const float3 &point, const float3 &next_point);

void calculate_auto_handles(bool cyclic,
                            Span<int8_t> types_left,
                            Span<int8_t> types_right,
                            Span<float3> positions,
                            MutableSpan<float3> positions_left,
                            MutableSpan<float3> positions_right);
 
void calculate_aligned_handles(const IndexMask &selection,
                               Span<float3> positions,
                               Span<float3> align_by,
                               MutableSpan<float3> align);

void set_handle_position(const float3 &position,
                         HandleType type,
                         HandleType type_other,
                         const float3 &new_handle,
                         float3 &handle,
                         float3 &handle_other);

template<typename T>
void evaluate_segment(
    const T &point_0, const T &point_1, const T &point_2, const T &point_3, MutableSpan<T> result);

void calculate_evaluated_positions(Span<float3> positions,
                                   Span<float3> handles_left,
                                   Span<float3> handles_right,
                                   OffsetIndices<int> evaluated_offsets,
                                   MutableSpan<float3> evaluated_positions);

void interpolate_to_evaluated(GSpan src, OffsetIndices<int> evaluated_offsets, GMutableSpan dst);
 
}  // namespace bezier

 
/* -------------------------------------------------------------------- */
 
namespace catmull_rom {

int calculate_evaluated_num(int points_num, bool cyclic, int resolution);

void interpolate_to_evaluated(GSpan src, bool cyclic, int resolution, GMutableSpan dst);

void interpolate_to_evaluated(const GSpan src,
                              const bool cyclic,
                              const OffsetIndices<int> evaluated_offsets,
                              GMutableSpan dst);
 
float4 calculate_basis(const float parameter);

template<typename T>
T interpolate(const T &a, const T &b, const T &c, const T &d, const float parameter)
{
  BLI_assert(0.0f <= parameter && parameter <= 1.0f);
  const float4 weights = calculate_basis(parameter);
  if constexpr (is_same_any_v<T, float, float2, float3>) {
    /* Save multiplications by adjusting weights after mix. */
    return 0.5f * attribute_math::mix4<T>(weights, a, b, c, d);
  }
  else {
    return attribute_math::mix4<T>(weights * 0.5f, a, b, c, d);
  }
}
 
}  // namespace catmull_rom

 
/* -------------------------------------------------------------------- */
 
namespace nurbs {

bool check_valid_num_and_order(int points_num, int8_t order, bool cyclic, KnotsMode knots_mode);

int calculate_evaluated_num(
    int points_num, int8_t order, bool cyclic, int resolution, KnotsMode knots_mode);

int knots_num(int points_num, int8_t order, bool cyclic);

void load_curve_knots(KnotsMode mode,
                      int points_num,
                      int8_t order,
                      bool cyclic,
                      IndexRange curve_knots,
                      Span<float> custom_knots,
                      MutableSpan<float> knots);

void calculate_knots(
    int points_num, KnotsMode mode, int8_t order, bool cyclic, MutableSpan<float> knots);

Vector<int> calculate_multiplicity_sequence(Span<float> knots);

void calculate_basis_cache(int points_num,
                           int evaluated_num,
                           int8_t order,
                           bool cyclic,
                           Span<float> knots,
                           BasisCache &basis_cache);

void interpolate_to_evaluated(const BasisCache &basis_cache,
                              int8_t order,
                              Span<float> control_weights,
                              GSpan src,
                              GMutableSpan dst);
 
}  // namespace nurbs

 
}  // namespace curves
 
Curves *curves_new_nomain(int points_num, int curves_num);
Curves *curves_new_nomain(CurvesGeometry curves);

Curves *curves_new_nomain_single(int points_num, CurveType type);

void curves_copy_parameters(const Curves &src, Curves &dst);
 
CurvesGeometry curves_copy_point_selection(const CurvesGeometry &curves,
                                           const IndexMask &points_to_copy,
                                           const AttributeFilter &attribute_filter);
 
CurvesGeometry curves_copy_curve_selection(const CurvesGeometry &curves,
                                           const IndexMask &curves_to_copy,
                                           const AttributeFilter &attribute_filter);
 
CurvesGeometry curves_new_no_attributes(int point_num, int curve_num);
 
std::array<int, CURVE_TYPES_NUM> calculate_type_counts(const VArray<int8_t> &types);
 
/* -------------------------------------------------------------------- */
 
inline int CurvesGeometry::points_num() const
{
  return this->point_num;
}
inline int CurvesGeometry::curves_num() const
{
  return this->curve_num;
}
inline bool CurvesGeometry::nurbs_has_custom_knots() const
{
  return this->custom_knot_num != 0;
}
inline bool CurvesGeometry::is_empty() const
{
  /* Each curve must have at least one point. */
  BLI_assert((this->curve_num == 0) == (this->point_num == 0));
  return this->curve_num == 0;
}
inline IndexRange CurvesGeometry::points_range() const
{
  return IndexRange(this->points_num());
}
inline IndexRange CurvesGeometry::curves_range() const
{
  return IndexRange(this->curves_num());
}
 
inline bool CurvesGeometry::is_single_type(const CurveType type) const
{
  return this->curve_type_counts()[type] == this->curves_num();
}
 
inline bool CurvesGeometry::has_curve_with_type(const CurveType type) const
{
  return this->curve_type_counts()[type] > 0;
}
 
inline bool CurvesGeometry::has_curve_with_type(const Span<CurveType> types) const
{
  return std::any_of(
      types.begin(), types.end(), [&](CurveType type) { return this->has_curve_with_type(type); });
}
 
inline const std::array<int, CURVE_TYPES_NUM> &CurvesGeometry::curve_type_counts() const
{
#ifndef NDEBUG
 
  if (this->runtime->check_type_counts) {
    const std::array<int, CURVE_TYPES_NUM> actual_type_counts = calculate_type_counts(
        this->curve_types());
    BLI_assert(this->runtime->type_counts == actual_type_counts);
    this->runtime->check_type_counts = false;
  }
#endif
  return this->runtime->type_counts;
}
 
inline OffsetIndices<int> CurvesGeometry::points_by_curve() const
{
  return OffsetIndices<int>({this->curve_offsets, this->curve_num + 1},
                            offset_indices::NoSortCheck{});
}
 
inline int CurvesGeometry::evaluated_points_num() const
{
  /* This could avoid calculating offsets in the future in simple circumstances. */
  return this->evaluated_points_by_curve().total_size();
}
 
inline Span<int> CurvesGeometry::bezier_evaluated_offsets_for_curve(const int curve_index) const
{
  const OffsetIndices points_by_curve = this->points_by_curve();
  const IndexRange points = points_by_curve[curve_index];
  const IndexRange range = curves::per_curve_point_offsets_range(points, curve_index);
  const Span<int> offsets = this->runtime->evaluated_offsets_cache.data().all_bezier_offsets;
  return offsets.slice(range);
}
 
inline IndexRange CurvesGeometry::lengths_range_for_curve(const int curve_index,
                                                          const bool cyclic) const
{
  BLI_assert(cyclic == this->cyclic()[curve_index]);
  const IndexRange points = this->evaluated_points_by_curve()[curve_index];
  const int start = points.start() + curve_index;
  return {start, curves::segments_num(points.size(), cyclic)};
}
 
inline Span<float> CurvesGeometry::evaluated_lengths_for_curve(const int curve_index,
                                                               const bool cyclic) const
{
  const IndexRange range = this->lengths_range_for_curve(curve_index, cyclic);
  return this->runtime->evaluated_length_cache.data().as_span().slice(range);
}
 
inline float CurvesGeometry::evaluated_length_total_for_curve(const int curve_index,
                                                              const bool cyclic) const
{
  const Span<float> lengths = this->evaluated_lengths_for_curve(curve_index, cyclic);
  if (lengths.is_empty()) {
    return 0.0f;
  }
  return lengths.last();
}

 
namespace curves {
 
/* -------------------------------------------------------------------- */
 
namespace bezier {
 
inline bool point_is_sharp(const Span<int8_t> handle_types_left,
                           const Span<int8_t> handle_types_right,
                           const int index)
{
  return ELEM(handle_types_left[index], BEZIER_HANDLE_VECTOR, BEZIER_HANDLE_FREE) ||
         ELEM(handle_types_right[index], BEZIER_HANDLE_VECTOR, BEZIER_HANDLE_FREE);
}
 
inline bool segment_is_vector(const HandleType left, const HandleType right)
{
  return left == BEZIER_HANDLE_VECTOR && right == BEZIER_HANDLE_VECTOR;
}
 
inline bool segment_is_vector(const int8_t left, const int8_t right)
{
  return segment_is_vector(HandleType(left), HandleType(right));
}
 
inline bool has_vector_handles(const int num_curve_points,
                               const int64_t evaluated_size,
                               const bool cyclic,
                               const int resolution)
{
  return evaluated_size - !cyclic != int64_t(segments_num(num_curve_points, cyclic)) * resolution;
}
 
inline float3 calculate_vector_handle(const float3 &point, const float3 &next_point)
{
  return math::interpolate(point, next_point, 1.0f / 3.0f);
}
 
}  // namespace bezier

 
const AttributeAccessorFunctions &get_attribute_accessor_functions();
 
}  // namespace curves
 
struct CurvesSurfaceTransforms {
  float4x4 curves_to_world;
  float4x4 curves_to_surface;
  float4x4 world_to_curves;
  float4x4 world_to_surface;
  float4x4 surface_to_world;
  float4x4 surface_to_curves;
  float4x4 surface_to_curves_normal;
 
  CurvesSurfaceTransforms() = default;
  CurvesSurfaceTransforms(const Object &curves_ob, const Object *surface_ob);
};
 
}  // namespace blender::bke
 
inline blender::bke::CurvesGeometry &CurvesGeometry::wrap()
{
  return *reinterpret_cast<blender::bke::CurvesGeometry *>(this);
}
inline const blender::bke::CurvesGeometry &CurvesGeometry::wrap() const
{
  return *reinterpret_cast<const blender::bke::CurvesGeometry *>(this);
}