ED_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 "BKE_crazyspace.hh"
#include "BKE_curves.hh"
 
#include "BLI_index_mask_fwd.hh"
#include "BLI_vector.hh"
#include "BLI_vector_set.hh"
 
#include "DNA_view3d_types.h"
#include "DNA_windowmanager_enums.h"
 
#include "ED_select_utils.hh"
#include "ED_view3d.hh"
 
struct bContext;
struct Curves;
struct UndoType;
struct rcti;
struct TransVertStore;
struct wmKeyConfig;
struct wmOperator;
struct wmKeyMap;
struct EnumPropertyItem;
namespace blender::bke {
enum class AttrDomain : int8_t;
struct GSpanAttributeWriter;
}  // namespace blender::bke
 
namespace blender::ed::curves {
 
void operatortypes_curves();
void operatormacros_curves();
void undosys_type_register(UndoType *ut);
void keymap_curves(wmKeyConfig *keyconf);
 
void ED_operatortypes_curves_pen();
void ED_curves_pentool_modal_keymap(wmKeyConfig *keyconf);
 
namespace pen_tool {
 
enum class ElementMode : int8_t {
  None = 0,
  Point = 1,
  Edge = 2,
  HandleLeft = 3,
  HandleRight = 4,
};
 
struct ClosestElement {
  float distance_squared = std::numeric_limits<float>::max();
  ElementMode element_mode;
  int point_index = -1;
  int curve_index = -1;
  float edge_t = -1.0f;
  int drawing_index = -1;
 
  bool is_closer(const float new_distance_squared,
                 const ElementMode new_element_mode,
                 const float threshold_distance) const;
};
 
class PenToolOperation {
 public:
  ViewContext vc;
 
  float threshold_distance;
  float threshold_distance_edge;
 
  bool extrude_point;
  bool delete_point;
  bool insert_point;
  bool move_seg;
  bool select_point;
  bool move_point;
  bool cycle_handle_type;
  int extrude_handle;
  float radius;
 
  bool move_entire;
  bool snap_angle;
  bool move_handle;
 
  bool point_added;
  bool point_removed;
  /* Used to go back to `aligned` after `move_handle` becomes `false` */
  bool handle_moved;
 
  float4x4 projection;
  float2 mouse_co;
  float2 xy;
  float2 prev_xy;
  float2 center_of_mass_co;
  ClosestElement closest_element;
 
  std::optional<int> active_drawing_index;
  Vector<float4x4> layer_to_world_per_curves;
  /* Only used for Grease Pencil. */
  Vector<float4x4> layer_to_object_per_curves;
 
  virtual ~PenToolOperation() = default;
 
  virtual float3 project(const float2 &screen_co) const = 0;
  virtual IndexMask all_selected_points(int curves_index, IndexMaskMemory &memory) const = 0;
  virtual IndexMask visible_bezier_handle_points(int curves_index,
                                                 IndexMaskMemory &memory) const = 0;
  virtual IndexMask editable_curves(int curves_index, IndexMaskMemory &memory) const = 0;
  virtual void tag_curve_changed(int curves_index) const = 0;
  virtual bke::CurvesGeometry &get_curves(int curves_index) const = 0;
  virtual IndexRange curves_range() const = 0;
  virtual void single_point_attributes(bke::CurvesGeometry &curves, int curves_index) const = 0;
  virtual bool can_create_new_curve(wmOperator *op) const = 0;
  virtual void update_view(bContext *C) const = 0;
  virtual std::optional<wmOperatorStatus> initialize(bContext *C,
                                                     wmOperator *op,
                                                     const wmEvent *event) = 0;
 
  float2 layer_to_screen(const float4x4 &layer_to_object, const float3 &point) const;
 
  float3 screen_to_layer(const float4x4 &layer_to_world,
                         const float2 &screen_co,
                         const float3 &depth_point_layer) const;
 
  wmOperatorStatus invoke(bContext *C, wmOperator *op, const wmEvent *event);
  wmOperatorStatus modal(bContext *C, wmOperator *op, const wmEvent *event);
};
 
void pen_tool_common_props(wmOperatorType *ot);
wmKeyMap *ensure_keymap(wmKeyConfig *keyconf);
 
}  // namespace pen_tool

float (*point_normals_array_create(const Curves *curves_id))[3];

Span<StringRef> get_curves_selection_attribute_names(const bke::CurvesGeometry &curves);

Vector<MutableSpan<float3>> get_curves_positions_for_write(bke::CurvesGeometry &curves);

Vector<Span<float3>> get_curves_positions(const bke::CurvesGeometry &curves);
 
/* Get all possible curve selection attribute names. */
Span<StringRef> get_curves_all_selection_attribute_names();

Span<StringRef> get_curves_bezier_selection_attribute_names(const bke::CurvesGeometry &curves);

void remove_selection_attributes(
    bke::MutableAttributeAccessor &attributes,
    Span<StringRef> selection_attribute_names = get_curves_all_selection_attribute_names());

std::optional<Span<float3>> get_selection_attribute_positions(
    const bke::CurvesGeometry &curves,
    const bke::crazyspace::GeometryDeformation &deformation,
    StringRef attribute_name);
 
using SelectionRangeFn = FunctionRef<void(
    IndexRange range, Span<float3> positions, StringRef selection_attribute_name)>;
void foreach_selectable_point_range(const bke::CurvesGeometry &curves,
                                    const bke::crazyspace::GeometryDeformation &deformation,
                                    eHandleDisplay handle_display,
                                    SelectionRangeFn range_consumer);

void foreach_selectable_curve_range(const bke::CurvesGeometry &curves,
                                    const bke::crazyspace::GeometryDeformation &deformation,
                                    eHandleDisplay handle_display,
                                    SelectionRangeFn range_consumer);
 
bool object_has_editable_curves(const Main &bmain, const Object &object);
bke::CurvesGeometry primitive_random_sphere(int curves_size, int points_per_curve);
VectorSet<Curves *> get_unique_editable_curves(const bContext &C);
void ensure_surface_deformation_node_exists(bContext &C, Object &curves_ob);

void transverts_from_curves_positions_create(bke::CurvesGeometry &curves,
                                             TransVertStore *tvs,
                                             const bool skip_handles);
 
/* -------------------------------------------------------------------- */
 
bool editable_curves_with_surface_poll(bContext *C);
bool editable_curves_in_edit_mode_poll(bContext *C);
bool curves_with_surface_poll(bContext *C);
bool editable_curves_poll(bContext *C);
bool curves_poll(bContext *C);

 
/* -------------------------------------------------------------------- */
 
void CURVES_OT_attribute_set(wmOperatorType *ot);
void CURVES_OT_draw(wmOperatorType *ot);
void CURVES_OT_extrude(wmOperatorType *ot);
void CURVES_OT_select_linked_pick(wmOperatorType *ot);
void CURVES_OT_separate(wmOperatorType *ot);

 
/* -------------------------------------------------------------------- */

IndexMask curve_mask_from_points(const bke::CurvesGeometry &curves,
                                 const IndexMask &point_mask,
                                 const GrainSize grain_size,
                                 IndexMaskMemory &memory);

IndexMask end_points(const bke::CurvesGeometry &curves,
                     int amount_start,
                     int amount_end,
                     bool inverted,
                     IndexMaskMemory &memory);
IndexMask end_points(const bke::CurvesGeometry &curves,
                     const IndexMask &curves_mask,
                     int amount_start,
                     int amount_end,
                     bool inverted,
                     IndexMaskMemory &memory);

 
/* -------------------------------------------------------------------- */
 
void fill_selection_false(GMutableSpan selection);
void fill_selection_true(GMutableSpan selection);
void fill_selection(GMutableSpan selection, bool value);
void fill_selection_false(GMutableSpan selection, const IndexMask &mask);
void fill_selection_true(GMutableSpan selection, const IndexMask &mask);

bool has_anything_selected(const bke::CurvesGeometry &curves);
bool has_anything_selected(const bke::CurvesGeometry &curves, bke::AttrDomain selection_domain);
bool has_anything_selected(const bke::CurvesGeometry &curves,
                           bke::AttrDomain selection_domain,
                           const IndexMask &mask);

bool has_anything_selected(GSpan selection);
bool has_anything_selected(const VArray<bool> &varray, IndexRange range_to_check);
bool has_anything_selected(const VArray<bool> &varray, const IndexMask &indices_to_check);

IndexMask retrieve_selected_curves(const bke::CurvesGeometry &curves, IndexMaskMemory &memory);
IndexMask retrieve_selected_curves(const Curves &curves_id, IndexMaskMemory &memory);

IndexMask retrieve_selected_points(const bke::CurvesGeometry &curves, IndexMaskMemory &memory);
IndexMask retrieve_selected_points(const Curves &curves_id, IndexMaskMemory &memory);
IndexMask retrieve_selected_points(const bke::CurvesGeometry &curves,
                                   StringRef attribute_name,
                                   const IndexMask &bezier_points,
                                   IndexMaskMemory &memory);

IndexMask retrieve_all_selected_points(const bke::CurvesGeometry &curves,
                                       int handle_display,
                                       IndexMaskMemory &memory);

bke::GSpanAttributeWriter ensure_selection_attribute(bke::CurvesGeometry &curves,
                                                     bke::AttrDomain selection_domain,
                                                     bke::AttrType create_type,
                                                     StringRef attribute_name = ".selection");
 
void foreach_selection_attribute_writer(
    bke::CurvesGeometry &curves,
    bke::AttrDomain selection_domain,
    FunctionRef<void(bke::GSpanAttributeWriter &selection)> fn);

void apply_selection_operation_at_index(GMutableSpan selection, int index, eSelectOp sel_op);

void select_all(bke::CurvesGeometry &curves, bke::AttrDomain selection_domain, int action);
void select_all(bke::CurvesGeometry &curves,
                const IndexMask &mask,
                bke::AttrDomain selection_domain,
                int action);

void select_linked(bke::CurvesGeometry &curves);
void select_linked(bke::CurvesGeometry &curves, const IndexMask &curves_mask);

void select_alternate(bke::CurvesGeometry &curves, const bool deselect_ends);
void select_alternate(bke::CurvesGeometry &curves,
                      const IndexMask &curves_mask,
                      const bool deselect_ends);

void select_adjacent(bke::CurvesGeometry &curves, bool deselect);
void select_adjacent(bke::CurvesGeometry &curves, const IndexMask &curves_mask, bool deselect);

struct FindClosestData {
  int index = -1;
  float distance_sq = FLT_MAX;
};

std::optional<FindClosestData> closest_elem_find_screen_space(const ViewContext &vc,
                                                              OffsetIndices<int> points_by_curve,
                                                              Span<float3> deformed_positions,
                                                              const VArray<bool> &cyclic,
                                                              const float4x4 &projection,
                                                              const IndexMask &mask,
                                                              bke::AttrDomain domain,
                                                              int2 coord,
                                                              const FindClosestData &initial);

bool select_box(const ViewContext &vc,
                bke::CurvesGeometry &curves,
                const bke::crazyspace::GeometryDeformation &deformation,
                const float4x4 &projection,
                const IndexMask &selection_mask,
                const IndexMask &bezier_mask,
                bke::AttrDomain selection_domain,
                const rcti &rect,
                eSelectOp sel_op);

bool select_lasso(const ViewContext &vc,
                  bke::CurvesGeometry &curves,
                  const bke::crazyspace::GeometryDeformation &deformation,
                  const float4x4 &projection,
                  const IndexMask &selection_mask,
                  const IndexMask &bezier_mask,
                  bke::AttrDomain selection_domain,
                  Span<int2> lasso_coords,
                  eSelectOp sel_op);

bool select_circle(const ViewContext &vc,
                   bke::CurvesGeometry &curves,
                   const bke::crazyspace::GeometryDeformation &deformation,
                   const float4x4 &projection,
                   const IndexMask &selection_mask,
                   const IndexMask &bezier_mask,
                   bke::AttrDomain selection_domain,
                   int2 coord,
                   float radius,
                   eSelectOp sel_op);

IndexMask select_adjacent_mask(const bke::CurvesGeometry &curves,
                               StringRef attribute_name,
                               bool deselect,
                               IndexMaskMemory &memory);
IndexMask select_adjacent_mask(const bke::CurvesGeometry &curves,
                               const IndexMask &curves_mask,
                               StringRef attribute_name,
                               bool deselect,
                               IndexMaskMemory &memory);

IndexMask select_box_mask(const ViewContext &vc,
                          const bke::CurvesGeometry &curves,
                          const bke::crazyspace::GeometryDeformation &deformation,
                          const float4x4 &projection,
                          const IndexMask &selection_mask,
                          const IndexMask &bezier_mask,
                          bke::AttrDomain selection_domain,
                          StringRef attribute_name,
                          const rcti &rect,
                          IndexMaskMemory &memory);

IndexMask select_lasso_mask(const ViewContext &vc,
                            const bke::CurvesGeometry &curves,
                            const bke::crazyspace::GeometryDeformation &deformation,
                            const float4x4 &projection,
                            const IndexMask &selection_mask,
                            const IndexMask &bezier_mask,
                            bke::AttrDomain selection_domain,
                            StringRef attribute_name,
                            Span<int2> lasso_coords,
                            IndexMaskMemory &memory);

IndexMask select_circle_mask(const ViewContext &vc,
                             const bke::CurvesGeometry &curves,
                             const bke::crazyspace::GeometryDeformation &deformation,
                             const float4x4 &projection,
                             const IndexMask &selection_mask,
                             const IndexMask &bezier_mask,
                             bke::AttrDomain selection_domain,
                             StringRef attribute_name,
                             int2 coord,
                             float radius,
                             IndexMaskMemory &memory);
 
/* -------------------------------------------------------------------- */

bool remove_selection(bke::CurvesGeometry &curves, bke::AttrDomain selection_domain);
 
void duplicate_points(bke::CurvesGeometry &curves, const IndexMask &mask);
void duplicate_curves(bke::CurvesGeometry &curves, const IndexMask &mask);
 
void separate_points(const bke::CurvesGeometry &curves,
                     const IndexMask &points_to_separate,
                     bke::CurvesGeometry &separated,
                     bke::CurvesGeometry &retained);
 
bke::CurvesGeometry split_points(const bke::CurvesGeometry &curves,
                                 const IndexMask &points_to_split);

void add_curves(bke::CurvesGeometry &curves, Span<int> new_sizes);

void resize_curves(bke::CurvesGeometry &curves,
                   const IndexMask &curves_to_resize,
                   Span<int> new_sizes);
void reorder_curves(bke::CurvesGeometry &curves, Span<int> old_by_new_indices_map);
 
wmOperatorStatus join_objects_exec(bContext *C, wmOperator *op);
 
enum class SetHandleType : uint8_t {
  Free = 0,
  Auto = 1,
  Vector = 2,
  Align = 3,
  Toggle = 4,
};
 
extern const EnumPropertyItem rna_enum_set_handle_type_items[];

 
}  // namespace blender::ed::curves