56 {0,
nullptr, 0,
nullptr,
nullptr},
80 const float threshold_distance)
const
82 const float threshold_distance_sq = threshold_distance * threshold_distance;
84 if (new_distance_squared > threshold_distance_sq) {
88 float old_priority = 1.0f;
89 float new_priority = 1.0f;
96 if (new_distance_squared <
116 if (new_distance_squared * old_priority < this->
distance_squared * new_priority) {
128 const int drawing_index,
136 const IndexRange points = points_by_curve[curve_i];
137 for (
const int point_i : points) {
160 const int drawing_index,
176 r_closest_element.
curve_index = point_to_curve_map[point_i];
185 if (
const std::optional<
Span<float3>> handle_right =
curves.handle_positions_right()) {
195 r_closest_element.
curve_index = point_to_curve_map[point_i];
210 const float2 dif_m = pos - pos_1;
211 const float2 dif_l = pos_2 - pos_1;
213 const float l2 =
math::dot(dif_l, dif_l);
216 return dif_l * t + pos_1;
224 const int drawing_index,
236 const IndexRange src_points = points_by_curve[curve_i];
237 const IndexRange eval_points = evaluated_points_by_curve[curve_i];
241 const int src_i_1 = src_i + src_points.
first();
242 const int src_i_2 = (src_i + 1) % src_points.
size() + src_points.
first();
247 pos_1_proj, pos_2_proj, mouse_co, local_t);
250 const float t = local_t;
257 r_closest_element.
edge_t = t;
265 const Span<int> offsets =
curves.bezier_evaluated_offsets_for_curve(curve_i);
269 const int point_num = eval_range.
size() - 1;
271 for (
const int eval_i :
IndexRange(point_num)) {
272 const int eval_point_i_1 = eval_range.
first() + eval_i;
273 const int eval_point_i_2 = (eval_range.
first() + eval_i + 1 - eval_points.
first()) %
277 evaluated_positions[eval_point_i_1]);
279 evaluated_positions[eval_point_i_2]);
282 pos_1_proj, pos_2_proj, mouse_co, local_t);
285 const float t = (eval_i + local_t) /
float(point_num);
293 r_closest_element.
edge_t = t;
322 ptd,
curves, editable_curves, layer_to_object, curves_index, mouse_co, closest_element);
324 ptd,
curves, bezier_points, layer_to_object, curves_index, mouse_co, closest_element);
326 ptd,
curves, editable_curves, layer_to_object, curves_index, mouse_co, closest_element);
328 return closest_element;
342 using namespace math;
359 const IndexRange points = points_by_curve[curve_i];
364 const float3 depth_point = positions[point_i1];
366 const float3 P0 = positions[point_i1];
367 const float3 P3 = positions[point_i2];
368 const float3 p1 = handles_right[point_i1];
369 const float3 p2 = handles_left[point_i2];
370 const float3 k2 = p1 - p2;
373 const float t_sq = t * t;
374 const float t_cu = t_sq * t;
375 const float one_minus_t = 1.0f - t;
376 const float one_minus_t_sq = one_minus_t * one_minus_t;
377 const float one_minus_t_cu = one_minus_t_sq * one_minus_t;
399 const float denom = 3.0f * one_minus_t * t;
404 const float3 P1 = (Pm - one_minus_t_cu * P0 - t_cu * P3) / denom + k2 * t;
405 const float3 P2 = P1 - k2;
407 handles_right[point_i1] = P1;
408 handles_left[point_i2] = P2;
420 curves.calculate_bezier_auto_handles();
448 const float3 depth_point = positions[point_i];
452 !(left_selected[point_i] || right_selected[point_i])) ||
458 positions[point_i] = ptd.
screen_to_layer(layer_to_world, pos + offset, depth_point);
460 layer_to_world, pos_left + offset, depth_point);
462 layer_to_world, pos_right + offset, depth_point);
466 const bool is_left = !right_selected[point_i];
471 layer_to_world, pos_left + offset, depth_point);
476 layer_to_world, pos_right + offset, depth_point);
501 handle_types_left[point_i] = handle_types_right[point_i];
507 handles_left[point_i] = ptd.
project(center_point + offset);
511 layer_to_world, center_point + offset, depth_point);
515 handles_right[point_i] = 2.0f * depth_point - handles_left[point_i];
522 handle_types_right[point_i] = handle_types_left[point_i];
528 handles_right[point_i] = ptd.
project(center_point + offset);
532 layer_to_world, center_point + offset, depth_point);
536 handles_left[point_i] = 2.0f * depth_point - handles_right[point_i];
542 curves.calculate_bezier_auto_handles();
569 Vector<bool> dst_selected_center(old_points_num,
false);
577 int point_offset = 0;
579 const IndexRange curve_points = points_by_curve[curve_index];
581 if (src_cyclic[curve_index] && curve_points.
size() != 1) {
586 bool first_selected = point_selection[curve_points.
first()];
588 first_selected |= left_selected[curve_points.
first()];
589 first_selected |= right_selected[curve_points.
first()];
592 bool last_selected = point_selection[curve_points.
last()];
594 last_selected |= left_selected[curve_points.
last()];
595 last_selected |= right_selected[curve_points.
last()];
598 if (first_selected) {
599 if (curve_points.
size() != 1) {
601 dst_to_src_points.insert(curve_points.
first() + point_offset, curve_points.
first());
602 dst_selected_start.
insert(curve_points.
first() + point_offset,
true);
603 dst_selected_center.
insert(curve_points.
first() + point_offset, !is_bezier);
604 dst_selected_end.
insert(curve_points.
first() + point_offset,
false);
605 dst_curve_counts[curve_index]++;
612 dst_to_src_points.insert(curve_points.
last() + point_offset + 1, curve_points.
last());
613 dst_selected_end.
insert(curve_points.
last() + point_offset + 1,
true);
614 dst_selected_center.
insert(curve_points.
last() + point_offset + 1, !is_bezier);
615 dst_selected_start.
insert(curve_points.
last() + point_offset + 1,
false);
616 dst_curve_counts[curve_index]++;
621 if (point_offset == 0) {
656 {
".selection",
".selection_handle_left",
".selection_handle_right"}),
667 for (
const int i : dst_to_src_points.index_range()) {
668 if (!(dst_selected_end[i] || dst_selected_start[i])) {
671 const float3 depth_point = src_positions[dst_to_src_points[i]];
674 dst_positions[i] = ptd.
project(pos);
678 dst_cyclic[dst_point_to_curve_map[i]] =
false;
690 return curve_types[curve_index] == CURVE_TYPE_NURBS &&
691 knot_modes[curve_index] == NURBS_KNOT_MODE_CUSTOM &&
692 points_by_curve[curve_index].size() == dst_points_by_curve[curve_index].size();
711 const int dst_point_index = src_point_index + 1;
713 const IndexRange points = points_by_curve[curve_index];
714 const int src_point_index_2 = (src_point_index + 1 - points.
first()) % points.
size() +
716 const int dst_point_index_2 = (dst_point_index - points.
first() + 1) % (points.
size() + 1) +
726 dst_to_src_points.
insert(src_point_index + 1, src_point_index);
727 dst_curve_counts[curve_index]++;
740 for (
const StringRef selection_attribute_name :
748 selection_writer.
finish();
757 {
".selection",
".selection_handle_left",
".selection_handle_right"}),
775 src_positions[src_point_index],
776 src_handles_right[src_point_index],
777 src_handles_left[src_point_index_2],
778 src_positions[src_point_index_2],
781 dst_positions[dst_point_index] = inserted_point.
position;
782 dst_handles_left[dst_point_index] = inserted_point.
left_handle;
783 dst_handles_right[dst_point_index] = inserted_point.
right_handle;
784 dst_handles_right[dst_point_index - 1] = inserted_point.
handle_prev;
785 dst_handles_left[dst_point_index_2] = inserted_point.
handle_next;
790 dst_positions[dst_point_index] =
math::interpolate(src_positions[src_point_index],
791 src_positions[src_point_index_2],
804 return curve_types[curve_index] == CURVE_TYPE_NURBS &&
805 knot_modes[curve_index] == NURBS_KNOT_MODE_CUSTOM &&
806 points_by_curve[curve_index].size() == dst_points_by_curve[curve_index].size();
816 src = std::move(dst);
826 const int num_old_points =
curves.points_num();
828 curves.offsets_for_write().last(1) = num_old_points;
834 curves.positions_for_write().last() = depth_point;
836 curve_attributes_to_skip.
add(
"curve_type");
839 curves.update_curve_types();
840 curves.resolution_for_write().last() = 12;
841 curve_attributes_to_skip.
add(
"resolution");
844 if (material_index != -1) {
847 material_indexes.
span.last() = material_index;
848 material_indexes.
finish();
849 curve_attributes_to_skip.
add(
"material_index");
860 for (
const StringRef selection_attribute_name :
882 ".selection_handle_left",
883 ".selection_handle_right"}),
884 curves.points_range().take_back(1));
888 curves.curves_range().take_back(1));
894 const bool clear_selection)
896 bool changed =
false;
898 for (
const StringRef selection_attribute_name :
914 curves.calculate_bezier_auto_handles();
918 if (clear_selection) {
923 if ((selection_attribute_name ==
".selection" &&
925 (selection_attribute_name ==
".selection_handle_left" &&
927 (selection_attribute_name ==
".selection_handle_right" &&
937 selection_writer.
finish();
961 const int curve_i = point_to_curve_map[point_i];
962 const IndexRange points = points_by_curve[curve_i];
965 if (cyclic[curve_i] && points.
size() != 1) {
969 if (point_i != points.
first() && point_i != points.
last()) {
990 std::atomic<bool> changed =
false;
991 std::atomic<bool> point_added =
false;
992 std::atomic<bool> point_removed =
false;
998 for (const int curves_index : curves_range) {
999 bke::CurvesGeometry &curves = ptd.get_curves(curves_index);
1001 if (curves.is_empty()) {
1005 if (ptd.closest_element.element_mode == ElementMode::Edge) {
1006 if (ptd.move_seg || ptd.insert_point) {
1007 add_single.store(false, std::memory_order_relaxed);
1008 if (ptd.insert_point && ptd.closest_element.drawing_index == curves_index) {
1009 insert_point_to_curve(ptd, curves);
1010 ptd.tag_curve_changed(curves_index);
1011 changed.store(true, std::memory_order_relaxed);
1017 if (ptd.closest_element.element_mode == ElementMode::None || extrude_only) {
1018 if (ptd.extrude_point) {
1019 IndexMaskMemory memory;
1020 const IndexMask editable_curves = ptd.editable_curves(curves_index, memory);
1021 const float4x4 &layer_to_object = ptd.layer_to_object_per_curves[curves_index];
1023 if (std::optional<bke::CurvesGeometry> result = extrude_curves(
1024 ptd, curves, layer_to_object, editable_curves))
1026 curves = std::move(*result);
1029 for (const StringRef selection_attribute_name :
1030 ed::curves::get_curves_selection_attribute_names(curves))
1032 bke::GSpanAttributeWriter selection_writer = ed::curves::ensure_selection_attribute(
1033 curves, bke::AttrDomain::Point, bke::AttrType::Bool, selection_attribute_name);
1034 ed::curves::fill_selection_false(selection_writer.span);
1035 selection_writer.finish();
1040 add_single.store(false, std::memory_order_relaxed);
1041 point_added.store(true, std::memory_order_relaxed);
1042 ptd.tag_curve_changed(curves_index);
1044 changed.store(true, std::memory_order_relaxed);
1051 if (curves_index != ptd.closest_element.drawing_index) {
1052 if (event->val != KM_DBL_CLICK && !ptd.delete_point) {
1053 for (const StringRef selection_attribute_name :
1054 ed::curves::get_curves_selection_attribute_names(curves))
1056 bke::GSpanAttributeWriter selection_writer = ed::curves::ensure_selection_attribute(
1057 curves, bke::AttrDomain::Point, bke::AttrType::Bool, selection_attribute_name);
1058 ed::curves::fill_selection_false(selection_writer.span);
1059 selection_writer.finish();
1066 const OffsetIndices<int> points_by_curve = curves.points_by_curve();
1067 const IndexRange points = points_by_curve[ptd.closest_element.curve_index];
1069 if (event->val == KM_DBL_CLICK && ptd.cycle_handle_type) {
1070 const int8_t handle_type = curves.handle_types_right()[ptd.closest_element.point_index];
1072 const int8_t new_handle_type = (handle_type + 1) % CURVE_HANDLE_TYPES_NUM;
1074 curves.handle_types_left_for_write()[ptd.closest_element.point_index] = new_handle_type;
1075 curves.handle_types_right_for_write()[ptd.closest_element.point_index] = new_handle_type;
1076 curves.calculate_bezier_auto_handles();
1077 ptd.tag_curve_changed(curves_index);
1078 add_single.store(false, std::memory_order_relaxed);
1081 if (ptd.delete_point) {
1082 curves.remove_points(IndexRange::from_single(ptd.closest_element.point_index), {});
1083 add_single.store(false, std::memory_order_relaxed);
1084 point_removed.store(true, std::memory_order_relaxed);
1085 ptd.tag_curve_changed(curves_index);
1089 const bool clear_selection = event->val != KM_DBL_CLICK && !ptd.delete_point;
1090 if (close_curve_and_select(ptd, curves, points, clear_selection)) {
1091 ptd.tag_curve_changed(curves_index);
1092 add_single.store(false, std::memory_order_relaxed);
1095 changed.store(true, std::memory_order_relaxed);
1100 if (ptd.can_create_new_curve(op)) {
1101 const int curves_index = *ptd.active_drawing_index;
1103 const float4x4 &layer_to_world = ptd.layer_to_world_per_curves[curves_index];
1107 ptd.single_point_attributes(
curves, curves_index);
1108 ptd.tag_curve_changed(curves_index);
1110 changed.store(
true, std::memory_order_relaxed);
1115 ptd.point_added = point_added;
1116 ptd.point_removed = point_removed;
1125 const int handle_display,
1132 return curves.points_range();
1152 const bool is_selected = selected_point[point_i] || selected_left[point_i] ||
1153 selected_right[point_i];
1154 const bool is_bezier = types[point_to_curve_map[point_i]] == CURVE_TYPE_BEZIER;
1155 return is_selected && is_bezier;
1158 return selected_points;
1162 const float3 &point)
const
1170 const float3 &depth_point_layer)
const
1260 std::atomic<bool> changed =
false;
1270 changed.store(
true, std::memory_order_relaxed);
1283 changed.store(
true, std::memory_order_relaxed);
1312 const Curves *curves_id = this->all_curves[curves_index];
1320 const Curves *curves_id = this->all_curves[curves_index];
1323 curves, this->
vc.v3d->overlay.handle_display, memory);
1328 const Curves *curves_id = this->all_curves[curves_index];
1330 return curves.curves_range();
1335 Curves *curves_id = this->all_curves[curves_index];
1337 curves.tag_topology_changed();
1342 Curves *curves_id = this->all_curves[curves_index];
1343 return curves_id->geometry.wrap();
1352 const int )
const override
1368 for (
Curves *curves_id : this->all_curves) {
1393 if (unique_curves.
add(id_cast<Curves *>(
object->data))) {
1400 for (
Curves *curves_id : unique_curves) {
1401 this->all_curves.
append(curves_id);
1406 return std::nullopt;
1462 "Add a point connected to the last selected point");
1467 "Extrude Handle Type",
1468 "Type of the extruded handle");
1469 RNA_def_boolean(ot->
srna,
"delete_point",
false,
"Delete Point",
"Delete an existing point");
1471 ot->
srna,
"insert_point",
false,
"Insert Point",
"Insert Point into a curve segment");
1473 ot->
srna,
"move_segment",
false,
"Move Segment",
"Move an existing curve segment");
1475 ot->
srna,
"select_point",
false,
"Select Point",
"Select a point or its handles");
1476 RNA_def_boolean(ot->
srna,
"move_point",
false,
"Move Point",
"Move a point or its handles");
1478 "cycle_handle_type",
1480 "Cycle Handle Type",
1481 "Cycle between all four handle types");
1483 ot->
srna,
"size", 0.01f, 0.0f,
FLT_MAX,
"Size",
"Diameter of new points", 0.0f, 10.0f);
1493 "Move Current Handle",
1494 "Move the current handle of the control point freely"},
1498 "Move Entire Point",
1499 "Move the entire point using its handles"},
1504 "Snap the handle angle to 45 degrees"},
1505 {0,
nullptr, 0,
nullptr,
nullptr},
1526 ot->
name =
"Curves Pen";
1527 ot->
idname =
"CURVES_OT_pen";
1528 ot->
description =
"Construct and edit Bézier curves";
#define CTX_DATA_BEGIN(C, Type, instance, member)
Low-level operations for curves.
Low-level operations for curves.
Low-level operations for grease pencil.
General operations, lookup, etc. for materials.
Span< T > as_span() const
MutableSpan< T > as_mutable_span()
void copy_from(GSpan values)
GMutableSpan slice(const int64_t start, int64_t size) const
static IndexMask from_predicate(const IndexMask &universe, LinearAllocator<> &memory, Fn &&predicate, exec_mode::Mode mode=exec_mode::parallel)
constexpr int64_t first() const
constexpr IndexRange shift(int64_t n) const
constexpr IndexRange drop_back(int64_t n) const
constexpr int64_t last(const int64_t n=0) const
constexpr int64_t size() const
constexpr IndexRange()=default
static constexpr IndexRange from_single(const int64_t index)
constexpr IndexRange index_range() const
static constexpr IndexRange from_begin_end_inclusive(const int64_t begin, const int64_t last)
constexpr MutableSpan drop_back(const int64_t n) const
constexpr T & last(const int64_t n=0) const
void add_new(const Key &key)
void append(const T &value)
void insert(const int64_t insert_index, const T &value)
IndexRange index_range() const
MutableSpan< T > as_mutable_span()
Span< T > as_span() const
void opmodal(std::string text, const wmOperatorType *ot, int propvalue, bool inverted=false)
GAttributeReader lookup_or_default(StringRef name, AttrDomain domain, AttrType data_type, const void *default_value=nullptr) const
MutableSpan< int8_t > handle_types_left_for_write()
VArray< int8_t > curve_types() const
void update_curve_types()
void calculate_bezier_auto_handles()
MutableSpan< float3 > positions_for_write()
MutableSpan< int8_t > handle_types_right_for_write()
std::optional< Span< float3 > > handle_positions_right() const
VArray< bool > cyclic() const
AttributeAccessor attributes() const
Span< float3 > positions() const
MutableSpan< float3 > handle_positions_right_for_write()
bool nurbs_has_custom_knots() const
std::optional< Span< float3 > > handle_positions_left() const
IndexRange curves_range() const
VArray< int8_t > nurbs_knots_modes() const
MutableSpan< float3 > handle_positions_left_for_write()
MutableSpan< int > offsets_for_write()
MutableSpan< float > radius_for_write()
MutableSpan< bool > cyclic_for_write()
OffsetIndices< int > points_by_curve() const
Array< int > point_to_curve_map() const
MutableAttributeAccessor attributes_for_write()
GSpanAttributeWriter lookup_or_add_for_write_span(StringRef name, AttrDomain domain, AttrType data_type, const AttributeInit &initializer=AttributeInitDefaultValue())
void foreach_index(Fn &&fn, Mode mode=exec_mode::serial) const
IndexMask complement(const IndexMask &universe, LinearAllocator<> &memory) const
VecBase< float, D > normalize(VecOp< float, D >) RET
float length(VecOp< float, D >) RET
float distance_squared(VecT a, VecT b)
void copy(const GVArray &src, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
void fill_index_range(MutableSpan< T > span, const T start=0)
Insertion insert(const float3 &point_prev, const float3 &handle_prev, const float3 &handle_next, const float3 &point_next, float parameter)
void gather_custom_knots(const bke::CurvesGeometry &src, const IndexMask &src_curves, int dst_curve_offset, bke::CurvesGeometry &dst)
void update_custom_knot_modes(const IndexMask &mask, const KnotsMode mode_for_regular, const KnotsMode mode_for_cyclic, bke::CurvesGeometry &curves)
auto attribute_filter_from_skip_ref(const Span< StringRef > skip)
void fill_attribute_range_default(MutableAttributeAccessor dst_attributes, AttrDomain domain, const AttributeFilter &attribute_filter, IndexRange range)
void copy_attributes(const AttributeAccessor src_attributes, AttrDomain src_domain, AttrDomain dst_domain, const AttributeFilter &attribute_filter, MutableAttributeAccessor dst_attributes)
void gather_attributes(AttributeAccessor src_attributes, AttrDomain src_domain, AttrDomain dst_domain, const AttributeFilter &attribute_filter, const IndexMask &selection, MutableAttributeAccessor dst_attributes)
bool has_anything_selected(const VArray< bool > &varray, const IndexRange range_to_check)
void fill_selection_false(GMutableSpan selection)
bool object_has_editable_curves(const Main &bmain, const Object &object)
void ED_curves_pentool_modal_keymap(wmKeyConfig *keyconf)
void fill_selection_true(GMutableSpan selection)
Span< StringRef > get_curves_selection_attribute_names(const bke::CurvesGeometry &curves)
void ED_operatortypes_curves_pen()
static void CURVES_OT_pen(wmOperatorType *ot)
IndexMask retrieve_all_selected_points(const bke::CurvesGeometry &curves, const int handle_display, LinearAllocator<> &memory)
bke::GSpanAttributeWriter ensure_selection_attribute(bke::CurvesGeometry &curves, bke::AttrDomain selection_domain, bke::AttrType create_type, StringRef attribute_name)
constexpr ParallelGrainSize grain_size(int grain_size)
T clamp(const T &a, const T &min, const T &max)
T dot(const QuaternionBase< T > &a, const QuaternionBase< T > &b)
CartesianBasis invert(const CartesianBasis &basis)
T interpolate(const T &a, const T &b, const FactorT &t)
T distance_squared(const VecBase< T, Size > &a, const VecBase< T, Size > &b)
VecBase< T, 3 > transform_point(const CartesianBasis &basis, const VecBase< T, 3 > &v)
void copy_group_sizes(OffsetIndices< int > offsets, const IndexMask &mask, MutableSpan< int > sizes)
OffsetIndices< int > accumulate_counts_to_offsets(MutableSpan< int > counts_to_offsets, int start_offset=0)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
void WM_operatortype_append(void(*opfunc)(wmOperatorType *))
int RNA_enum_get(PointerRNA *ptr, const char *name)
wmKeyMap * WM_modalkeymap_find(wmKeyConfig *keyconf, const char *idname)
ViewContext ED_view3d_viewcontext_init(bContext *C, Depsgraph *depsgraph)
float4x4 ED_view3d_ob_project_mat_get(const RegionView3D *rv3d, const Object *ob)
Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
void WM_cursor_modal_set(wmWindow *win, int val)
@ OP_IS_MODAL_CURSOR_REGION
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, const int default_value, const char *ui_name, const char *ui_description)
float2 ED_view3d_project_float_v2_m4(const ARegion *region, const float co[3], const float4x4 &mat)
wmWindow * CTX_wm_window(const bContext *C)
MatBase< float, 4, 4 > float4x4
void ED_region_tag_redraw(ARegion *region)
@ NURBS_KNOT_MODE_ENDPOINT
VecBase< float, 2 > float2
void DEG_id_tag_update(ID *id, unsigned int flags)
void BKE_report(ReportList *reports, eReportType type, const char *message)
void WM_cursor_modal_restore(wmWindow *win)
void WM_operator_properties_mouse_select(wmOperatorType *ot)
ATTR_WARN_UNUSED_RESULT const size_t num
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
wmEventHandler_Op * WM_event_add_modal_handler(bContext *C, wmOperator *op)
Main * CTX_data_main(const bContext *C)
void BKE_defgroup_copy_list(ListBaseT< bDeformGroup > *outbase, const ListBaseT< bDeformGroup > *inbase)
PropertyRNA * RNA_def_float_distance(StructOrFunctionRNA *cont_, const char *identifier, const float default_value, const float hardmin, const float hardmax, const char *ui_name, const char *ui_description, const float softmin, const float softmax)
void WM_modalkeymap_assign(wmKeyMap *km, const char *opname)
wmKeyMap * WM_modalkeymap_ensure(wmKeyConfig *keyconf, const char *idname, const EnumPropertyItem *items)
VecBase< float, 3 > float3
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, const bool default_value, const char *ui_name, const char *ui_description)
float ED_view3d_select_dist_px()
void ED_view3d_win_to_3d(const View3D *v3d, const ARegion *region, const float depth_pt[3], const float mval[2], float r_out[3])
Object * CTX_data_active_object(const bContext *C)
void ED_workspace_status_text(bContext *C, const char *str)
float RNA_float_get(PointerRNA *ptr, const char *name)
static AngleRadian from_degree(float angle_degree)
ListBaseT< struct bDeformGroup > vertex_group_names
static MatBase identity()
MutableVArraySpan< T > span
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) modal(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
struct ReportList * reports
struct wmOperatorType * type