65#define USE_AXIS_CONSTRAINTS
69#define MVAL_MAX_PX_DIST 12.0f
82#define RULER_PICK_DIST 12.0f
83#define RULER_PICK_DIST_SQ (RULER_PICK_DIST * RULER_PICK_DIST)
96#ifdef USE_AXIS_CONSTRAINTS
124#ifdef USE_AXIS_CONSTRAINTS
136#ifndef USE_SNAP_DETECT_FROM_KEYMAP_HACK
197 ruler_item->
co[0], ruler_item->
co[1], ruler_item->
co[2]);
205 numstr, numstr_maxncpy,
double(ruler_angle), prec,
B_UNIT_ROTATION, unit,
false,
true);
209 const float ruler_len =
len_v3v3(ruler_item->
co[0], ruler_item->
co[2]);
216 numstr, numstr_maxncpy, ruler_len, prec,
B_UNIT_LENGTH, unit,
false,
true);
231 int co_index_best = -1;
239 for (j = 0; j < 3; j++) {
246 if (dist < dist_best) {
251 const float3 dist_points = {
267 if (dist < dist_best) {
272 const float2 dist_points = {
277 co_index_best = (dist_points[0] < dist_points[1]) ? 0 : 2;
288 *r_co_index = co_index_best;
330 Depsgraph *depsgraph,
334 const bool do_thickness,
338 constexpr float eps_bias = 0.0002f;
348 if (do_thickness && inter->
co_index != 1) {
376 ray_start = co - ray_normal * eps_bias;
391 float3 *prev_point =
nullptr;
397 prev_point = &ruler_item->
co[1];
401 prev_point = &ruler_item->
co[2];
405 prev_point = &ruler_item->
co[0];
409 if (prev_point !=
nullptr) {
411 snap_gizmo->
ptr, ruler_info->
snap_data.prop_prevpoint, *prev_point);
413 snap_gizmo->
ptr, ruler_info->
snap_data.prop_snap_source_type, snap_type);
419#ifdef USE_AXIS_CONSTRAINTS
457 for (
int i = 0; i <= 2; i++) {
462 ruler_item->
co = mat * ruler_item->
co;
510#define RULER_ID "RulerData3D"
519 if (scene->
gpd ==
nullptr) {
537 bool changed =
false;
543 if (gpl ==
nullptr) {
560 gps = MEM_new<bGPDstroke>(
"gp_stroke");
563 pt = gps->
points = MEM_new_array<bGPDspoint>(gps->
totpoints,
"gp_stroke_points");
564 for (j = 0; j < 3; j++) {
573 pt = gps->
points = MEM_new_array<bGPDspoint>(gps->
totpoints,
"gp_stroke_points");
574 for (j = 0; j < 3; j += 2) {
598 bool changed =
false;
613 for (j = 0; j < 3; j++) {
622 for (j = 0; j < 3; j += 2) {
646 if (gpl_scene != gpl) {
694 constexpr int arc_steps = 24;
695 const float4 color_act = {1.0f, 1.0f, 1.0f, 1.0f};
696 const float4 color_base = {0.0f, 0.0f, 0.0f, 1.0f};
699 float4 color_back = {1.0f, 1.0f, 1.0f, 0.5f};
719 if (
int(color_text[0]) +
int(color_text[1]) +
int(color_text[2]) > 127 * 3 * 0.6f) {
723 const bool is_act = (ruler_info->
item_active == ruler_item);
730 for (j = 0; j < 3; j++) {
751 float4 viewport_size(0.0f);
753 immUniform2f(
"viewport_size", viewport_size[2], viewport_size[3]);
756 const float4 &col = is_act ? color_act : color_base;
802 for (j = 0; j <= arc_steps; j++) {
803 ar_coord = ruler_item->
co[1] + dir_tmp * px_scale;
817 float viewport_size[4];
819 immUniform2f(
"viewport_size", viewport_size[2], viewport_size[3]);
822 const float *col = is_act ? color_act : color_base;
852 dir_ruler = co_ss[0] - co_ss[1];
855 dir_ruler = co_ss[1] - co_ss[2];
865 immVertex2f(shdr_pos_2d, co_ss[1][0] - cap_size, co_ss[1][1] - cap_size);
866 immVertex2f(shdr_pos_2d, co_ss[1][0] + cap_size, co_ss[1][1] + cap_size);
867 immVertex2f(shdr_pos_2d, co_ss[1][0] - cap_size, co_ss[1][1] + cap_size);
868 immVertex2f(shdr_pos_2d, co_ss[1][0] + cap_size, co_ss[1][1] - cap_size);
876 if (proj_ok[0] || proj_ok[2] || proj_ok[1]) {
880 cap = co_ss[0] + rot_90_vec_a * cap_size;
882 cap = co_ss[0] - rot_90_vec_a * cap_size;
887 cap = co_ss[2] + rot_90_vec_b * cap_size;
889 cap = co_ss[2] - rot_90_vec_b * cap_size;
895 immVertex2f(shdr_pos_2d, co_ss[1][0] - cap_size, co_ss[1][1] - cap_size);
896 immVertex2f(shdr_pos_2d, co_ss[1][0] + cap_size, co_ss[1][1] + cap_size);
897 immVertex2f(shdr_pos_2d, co_ss[1][0] - cap_size, co_ss[1][1] + cap_size);
898 immVertex2f(shdr_pos_2d, co_ss[1][0] + cap_size, co_ss[1][1] - cap_size);
918 posit[0] = co_ss[1][0] - (numstr_size[0] / 2.0f);
919 posit[1] = co_ss[1][1] - (numstr_size[1] / 2.0f);
923 float rot_90_vec[2] = {-dir_ruler[1], dir_ruler[0]};
925 posit[1] += rot_90_vec[0] * numstr_size[1];
926 posit[0] += (rot_90_vec[1] < 0) ? numstr_size[0] : -numstr_size[0];
933 posit[0] - bg_margin,
934 posit[1] - bg_margin,
935 posit[0] + bg_margin + numstr_size[0],
936 posit[1] + bg_margin + numstr_size[1]);
953 dir_ruler = co_ss[0] - co_ss[2];
964 if (proj_ok[0] || proj_ok[2]) {
968 cap = co_ss[0] + rot_90_vec * cap_size;
970 cap = co_ss[0] - rot_90_vec * cap_size;
975 cap = co_ss[2] + rot_90_vec * cap_size;
977 cap = co_ss[2] - rot_90_vec * cap_size;
997 posit = (co_ss[0] + co_ss[2]) / 2.0f;
1000 posit -= numstr_size / 2.0f;
1006 if ((
len < (numstr_size[1] * 2.5f)) ||
1007 ((
len < (numstr_size[0] + bg_margin + bg_margin)) && (
fabs(rot_90_vec[0]) < 0.5f)))
1010 posit[1] = std::min(co_ss[0][1], co_ss[2][1]) - numstr_size[1] - bg_margin - bg_margin;
1012 else if (
fabs(rot_90_vec[0]) < 0.2f) {
1014 posit[1] -= numstr_size[1];
1018 if (proj_ok[0] && proj_ok[2]) {
1022 posit[0] - bg_margin,
1023 posit[1] - bg_margin,
1024 posit[0] + bg_margin + numstr_size[0],
1025 posit[1] + bg_margin + numstr_size[1]);
1032 if (proj_ok[0] && proj_ok[2]) {
1050 const float mval_fl[2] = {
float(mval[0]),
float(mval[1])};
1055 if (co_index == -1) {
1072 bool do_draw =
false;
1079 ruler_info->
region = region;
1081#ifdef USE_AXIS_CONSTRAINTS
1106 do_cursor_update =
true;
1110#ifndef USE_SNAP_DETECT_FROM_KEYMAP_HACK
1115 C, ruler_info->
snap_data.gizmo,
nullptr,
nullptr,
nullptr,
nullptr);
1121 do_cursor_update =
true;
1124 if (do_cursor_update) {
1128 C, depsgraph, ruler_info, ruler_item, event->
mval, do_thickness, do_snap))
1156#ifdef USE_AXIS_CONSTRAINTS
1180 CLAMP(fac, 0.0f, 1.0f);
1183 ruler_item_pick->
co[0], ruler_item_pick->
co[2], fac);
1189 C, depsgraph, ruler_info, ruler_item_pick, event->
mval,
false,
false);
1212 prev_point = (inter->
co_index != 1) ? &ruler_item_pick->
co[1] :
nullptr;
1216 prev_point = &ruler_item_pick->
co[2];
1217 snap_type = ruler_item_pick->
snap_type[2];
1220 prev_point = &ruler_item_pick->
co[0];
1221 snap_type = ruler_item_pick->
snap_type[2];
1226 ruler_info->
snap_data.gizmo->ptr, ruler_info->
snap_data.prop_prevpoint, *prev_point);
1228 ruler_info->
snap_data.prop_snap_source_type,
1279 gzt->
idname =
"VIEW3D_GT_ruler_item";
1325 ruler_info->
wm =
wm;
1326 ruler_info->
win = win;
1327 ruler_info->
area = area;
1328 ruler_info->
region = region;
1332 "snap_source_type");
1339 gzgt->
name =
"Ruler Widgets";
1402#ifndef USE_SNAP_DETECT_FROM_KEYMAP_HACK
1404 const bool do_snap =
true;
1415 ruler_info->
snap_data.prop_snap_source_type,
1427 ot->
name =
"Ruler Add";
1428 ot->
idname =
"VIEW3D_OT_ruler_add";
1488 ot->
name =
"Ruler Remove";
1489 ot->
idname =
"VIEW3D_OT_ruler_remove";
#define BLI_STR_UTF8_DEGREE_SIGN
Object is a sort of wrapper for general info.
#define OBEDIT_FROM_OBACT(ob)
#define SCE_SNAP_TO_VERTEX
Read Blender memory allocation and freeing.
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
ccl_device_inline dual3 fabs(const ccl_private dual3 &a)
T distance(const T &a, const T &b)
CartesianBasis invert(const CartesianBasis &basis)
AxisSigned cross(const AxisSigned a, const AxisSigned b)
T interpolate(const T &a, const T &b, const FactorT &t)
MatBase< T, NumCol, NumRow > normalize(const MatBase< T, NumCol, NumRow > &a)
T distance_squared(const VecBase< T, Size > &a, const VecBase< T, Size > &b)
void get_color_3ubv(int colorid, unsigned char col[3])
MINLINE float min_ff(float a, float b)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
size_t size_t size_t BLI_snprintf_utf8(char *__restrict dst, size_t dst_maxncpy, const char *__restrict format,...) ATTR_NONNULL(1
float angle_normalized_v3v3(const float v1[3], const float v2[3]) ATTR_WARN_UNUSED_RESULT
static void view3d_ruler_gpencil_ensure(bContext *C)
ScrArea * CTX_wm_area(const bContext *C)
void wmOrtho2_region_pixelspace(const ARegion *region)
void WM_event_drag_start_mval_fl(const wmEvent *event, const ARegion *region, float r_mval[2])
Object * BKE_view_layer_active_object_get(const ViewLayer *view_layer)
static void ruler_item_as_string(RulerItem *ruler_item, const UnitSettings &unit, char *numstr, size_t numstr_maxncpy, int prec)
void BLF_position(int fontid, float x, float y, float z)
static wmOperatorStatus gizmo_ruler_invoke(bContext *C, wmGizmo *gz, const wmEvent *event)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
MINLINE void copy_v2_fl(float r[2], float f)
static void ruler_item_remove(bContext *C, wmGizmoGroup *gzgroup, RulerItem *ruler_item)
struct bGPDframe * BKE_annotations_layer_frame_get(struct bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew)
MINLINE void copy_v3_v3(float r[3], const float a[3])
void ED_gizmotypes_snap_3d_data_get(const bContext *C, wmGizmo *gz, float r_loc[3], float r_nor[3], int r_elem_index[3], eSnapMode *r_snap_elem)
void immUniform2f(const char *name, float x, float y)
void WM_gizmo_set_color(wmGizmo *gz, const float color[4])
void GPU_matrix_identity_set()
const wmGizmoType * WM_gizmotype_find(const StringRef idname, bool quiet)
static void gizmo_ruler_exit(bContext *C, wmGizmo *gz, const bool cancel)
void ED_gizmotypes_snap_3d_flag_set(wmGizmo *gz, int flag)
GPUVertFormat * immVertexFormat()
float angle_v3v3v3(const float a[3], const float b[3], const float c[3]) ATTR_WARN_UNUSED_RESULT
static bool view3d_ruler_to_gpencil(bContext *C, wmGizmoGroup *gzgroup)
struct bGPDlayer * BKE_annotations_layer_addnew(struct bGPdata *gpd, const char *name, bool setactive, bool add_to_header)
MatBase< float, 2, 2 > float2x2
void immBegin(GPUPrimType, uint vertex_len)
static RulerItem * ruler_item_add(wmGizmoGroup *gzgroup)
void GPU_line_smooth(bool enable)
void axis_angle_to_quat(float r[4], const float axis[3], float angle)
int BKE_scene_orientation_get_index(Scene *scene, int slot_index)
MINLINE void sub_v2_v2v2(float r[2], const float a[2], const float b[2])
bool ED_gizmotypes_snap_3d_is_enabled(const wmGizmo *)
wmWindow * CTX_wm_window(const bContext *C)
MINLINE float normalize_v2(float n[2])
void RNA_property_float_set_array(PointerRNA *ptr, PropertyRNA *prop, const float *values)
static void WIDGETGROUP_ruler_setup(const bContext *C, wmGizmoGroup *gzgroup)
void immUniformColor4fv(const float rgba[4])
void ED_region_tag_redraw_editor_overlays(ARegion *region)
@ RULERITEM_USE_ANGLE_ACTIVE
bool WM_gizmo_highlight_set(wmGizmoMap *gzmap, wmGizmo *gz)
void BLF_disable(int fontid, FontFlags flag)
struct bGPdata * BKE_annotations_data_addnew(struct Main *bmain, const char name[])
void immUniformColor3ubv(const unsigned char rgb[3])
void GPU_line_width(float width)
void WM_gizmo_unlink(ListBaseT< wmGizmo > *gizmolist, wmGizmoMap *gzmap, wmGizmo *gz, bContext *C)
bToolRef_Runtime * WM_toolsystem_runtime_from_context(const bContext *C)
void ED_view3d_gizmo_ruler_remove_by_gpencil_layer(struct bContext *C, bGPDlayer *gpl)
float dist_squared_to_line_segment_v2(const float p[2], const float l1[2], const float l2[2])
VecBase< float, 4 > float4
void mul_qt_v3(const float q[4], float r[3])
static void gizmo_ruler_draw(const bContext *C, wmGizmo *gz)
void immBindBuiltinProgram(GPUBuiltinShader shader_id)
ed::transform::SnapObjectContext * ED_gizmotypes_snap_3d_context_ensure(Scene *scene, wmGizmo *)
void BLF_size(int fontid, float size)
static bool gizmo_ruler_check_for_operator(const wmGizmoGroup *gzgroup)
static RulerItem * gzgroup_ruler_item_first_get(wmGizmoGroup *gzgroup)
void WM_gizmo_set_flag(wmGizmo *gz, const int flag, const bool enable)
static wmOperatorStatus gizmo_ruler_modal(bContext *C, wmGizmo *gz, const wmEvent *event, eWM_GizmoFlagTweak tweak_flag)
void DEG_id_tag_update_ex(Main *bmain, ID *id, unsigned int flags)
ViewLayer * DEG_get_input_view_layer(const Depsgraph *graph)
Scene * WM_window_get_active_scene(const wmWindow *win)
VecBase< float, 2 > float2
void immUniform1f(const char *name, float x)
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
void immVertex2f(uint attr_id, float x, float y)
static void view3d_ruler_item_project(RulerInfo *ruler_info, float3 &r_co, const int xy[2])
eWM_GizmoFlagTweak
Gizmo tweak flag. Bit-flag passed to gizmo while tweaking.
void GPU_viewport_size_get_f(float coords[4])
void BKE_report(ReportList *reports, eReportType type, const char *message)
@ V3D_SNAPCURSOR_SNAP_EDIT_GEOM_CAGE
void BLF_color3ubv(int fontid, const unsigned char rgb[3])
float line_point_factor_v2(const float p[2], const float l1[2], const float l2[2])
static wmOperatorStatus view3d_ruler_remove_invoke(bContext *C, wmOperator *op, const wmEvent *)
@ GPU_SHADER_3D_UNIFORM_COLOR
@ GPU_SHADER_3D_LINE_DASHED_UNIFORM_COLOR
void immUniform4fv(const char *name, const float data[4])
wmWindowManager * CTX_wm_manager(const bContext *C)
Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C, bool rna_write_check=false)
eV3DProjStatus ED_view3d_project_float_global(const ARegion *region, const float co[3], float r_co[2], eV3DProjTest flag)
static const char * view3d_gzgt_ruler_id
void VIEW3D_OT_ruler_remove(wmOperatorType *ot)
static bool view3d_ruler_item_mousemove(const bContext *C, Depsgraph *depsgraph, RulerInfo *ruler_info, RulerItem *ruler_item, const int mval[2], const bool do_thickness, const bool do_snap)
void RNA_property_unset(PointerRNA *ptr, PropertyRNA *prop)
MatBase< float, 3, 2 > float3x2
PointerRNA * WM_gizmo_operator_set(wmGizmo *gz, int part_index, wmOperatorType *ot, IDProperty *properties)
static int gizmo_ruler_cursor_get(wmGizmo *gz)
bool BKE_view_layer_synced_ensure(const Main &bmain, const Scene *scene, ViewLayer *view_layer)
static bool view3d_ruler_pick(wmGizmoGroup *gzgroup, RulerItem *ruler_item, const float2 mval, int *r_co_index)
RegionView3D * CTX_wm_region_view3d(const bContext *C)
wmOperatorStatus WM_operator_name_call(bContext *C, const char *opstring, wm::OpCallContext context, PointerRNA *properties, const wmEvent *event)
size_t BKE_unit_value_as_string(char *str, int str_maxncpy, double value, int prec, int type, const UnitSettings &settings, bool pad, bool do_unit_suffix)
void GPU_matrix_projection_set(const float m[4][4])
size_t BKE_unit_value_as_string_scaled(char *str, int str_maxncpy, double value, int prec, int type, const UnitSettings &settings, bool pad, bool do_unit_suffix)
MatBase< float, 3, 3 > float3x3
void BLF_draw(int fontid, const char *str, size_t str_len, ResultBLF *r_info=nullptr) ATTR_NONNULL(2)
uint GPU_vertformat_attr_add(GPUVertFormat *format, StringRef name, gpu::VertAttrType type)
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
void WM_event_drag_start_mval(const wmEvent *event, const ARegion *region, int r_mval[2])
static bool view3d_ruler_poll(bContext *C)
@ WM_GIZMOGROUPTYPE_DRAW_MODAL_ALL
@ WM_GIZMOGROUPTYPE_SCALE
ARegion * BKE_area_find_region_type(const ScrArea *area, int region_type)
wmOperatorType * WM_operatortype_find(const char *idname, bool quiet)
static int gizmo_ruler_test_select(bContext *, wmGizmo *gz, const int mval[2])
void immVertex3fv(uint attr_id, const float data[3])
static void ruler_state_set(RulerInfo *ruler_info, int state)
MINLINE int min_axis_v3(const float vec[3])
void immUniform4f(const char *name, float x, float y, float z, float w)
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Main * CTX_data_main(const bContext *C)
MINLINE void copy_v3_fl(float r[3], float f)
void GPU_matrix_pop_projection()
static bool view3d_ruler_from_gpencil(const bContext *C, wmGizmoGroup *gzgroup)
float ED_view3d_pixel_size_no_ui_scale(const RegionView3D *rv3d, const float co[3])
MINLINE float len_v2v2(const float v1[2], const float v2[2]) ATTR_WARN_UNUSED_RESULT
void VIEW3D_GGT_ruler(wmGizmoGroupType *gzgt)
Scene * DEG_get_input_scene(const Depsgraph *graph)
@ V3D_PROJ_TEST_CLIP_NEAR
void VIEW3D_GT_ruler_item(wmGizmoType *gzt)
void VIEW3D_OT_ruler_add(wmOperatorType *ot)
void RNA_property_enum_set(PointerRNA *ptr, PropertyRNA *prop, int value)
wmGizmoGroup * WM_gizmomap_group_find(wmGizmoMap *gzmap, const char *idname)
void ED_view3d_win_to_3d_int(const View3D *v3d, const ARegion *region, const float depth_pt[3], const int mval[2], float r_out[3])
void DEG_relations_tag_update(Main *bmain)
static wmOperatorStatus view3d_ruler_add_invoke(bContext *C, wmOperator *op, const wmEvent *event)
Scene * CTX_data_scene(const bContext *C)
MINLINE void copy_v4_v4(float r[4], const float a[4])
void immUniformColor3fv(const float rgb[3])
void GPU_blend(GPUBlend blend)
void immUniform1i(const char *name, int x)
VecBase< float, 3 > float3
bool BKE_annotations_free_strokes(struct bGPDframe *gpf)
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
bool ED_gizmo_poll_or_unlink_delayed_from_tool(const bContext *C, wmGizmoGroupType *gzgt)
void BLF_width_and_height(int fontid, const char *str, size_t str_len, float *r_width, float *r_height) ATTR_NONNULL()
void immVertex2fv(uint attr_id, const float data[2])
wmGizmo * WM_gizmo_new_ptr(const wmGizmoType *gzt, wmGizmoGroup *gzgroup, PointerRNA *properties)
void BLF_rotation(int fontid, float angle)
void GPU_matrix_push_projection()
bScreen * WM_window_get_active_screen(const wmWindow *win)
void immRectf(uint pos, float x1, float y1, float x2, float y2)
ARegion * CTX_wm_region(const bContext *C)
void GPU_matrix_set(const float m[4][4])
static bGPDlayer * view3d_ruler_layer_get(bGPdata *gpd)
void BLF_enable(int fontid, FontFlags flag)
View3D * CTX_wm_view3d(const bContext *C)
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
bke::ARegionRuntime * runtime
const c_style_mat & ptr() const
PropertyRNA * prop_snap_source_type
PropertyRNA * prop_prevpoint
struct blender::RulerInfo::@136103126062163333304232217246141175373037271116 drag_state_prev
struct blender::RulerInfo::@223274117047271126344307210166240253015130132207 snap_data
struct ToolSettings * toolsettings
ListBaseT< SpaceLink > spacedata
eView3D_GizmoFlag gizmo_flag
ListBaseT< bGPDstroke > strokes
ListBaseT< bGPDlayer > layers
ListBaseT< struct ScrArea > areabase
wmGizmoMapType_Params gzmap_params
eWM_GizmoFlagGroupTypeFlag flag
wmGizmoMap * parent_gzmap
ListBaseT< wmGizmo > gizmos
wmGizmoFnCursorGet cursor_get
wmGizmoFnTestSelect test_select
wmGizmoGroup * parent_gzgroup
bool(*) poll(bContext *C) ATTR_WARN_UNUSED_RESULT
wmOperatorStatus(*) invoke(bContext *C, wmOperator *op, const wmEvent *event) ATTR_WARN_UNUSED_RESULT
struct ReportList * reports
#define RULER_PICK_DIST_SQ