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 "ED_select_utils.hh"
 
struct bContext;
struct Curves;
struct UndoType;
struct ViewContext;
struct rcti;
struct TransVertStore;
struct wmKeyConfig;
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);
 
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);
 
/* 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());
 
Span<float3> get_selection_attribute_positions(
    const bke::CurvesGeometry &curves,
    const bke::crazyspace::GeometryDeformation &deformation,
    const 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,
                                    SelectionRangeFn range_consumer);
 
void foreach_selectable_curve_range(const bke::CurvesGeometry &curves,
                                    const bke::crazyspace::GeometryDeformation &deformation,
                                    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);
 
/* -------------------------------------------------------------------- */
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);
 
/* -------------------------------------------------------------------- */
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);
 
IndexMask random_mask(const bke::CurvesGeometry &curves,
                      bke::AttrDomain selection_domain,
                      uint32_t random_seed,
                      float probability,
                      IndexMaskMemory &memory);
IndexMask random_mask(const bke::CurvesGeometry &curves,
                      const IndexMask &mask,
                      bke::AttrDomain selection_domain,
                      uint32_t random_seed,
                      float probability,
                      IndexMaskMemory &memory);
 
/* -------------------------------------------------------------------- */
void fill_selection_false(GMutableSpan span);
void fill_selection_true(GMutableSpan span);
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 bke::CurvesGeometry &curves,
                                   StringRef attribute_name,
                                   IndexMaskMemory &memory);
IndexMask retrieve_selected_points(const Curves &curves_id, IndexMaskMemory &memory);
 
bke::GSpanAttributeWriter ensure_selection_attribute(bke::CurvesGeometry &curves,
                                                     bke::AttrDomain selection_domain,
                                                     eCustomDataType 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 = 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_matrix,
                  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 add_curves(bke::CurvesGeometry &curves, Span<int> new_sizes);
 
void resize_curves(bke::CurvesGeometry &curves,
                   const IndexMask &curves_to_resize,
                   Span<int> new_sizes);
 
}  // namespace blender::ed::curves