tmaq
/
tornavis
1
0
Fork 0
Code Issues 2 Pull Requests 29 Packages Projects 24 Releases Wiki Activity

Cleanup: Rename SCE_SNAP_MODE_ to SCE_SNAP_TO_ 

Also rename:
- `SCE_SNAP_MODE_FACE_NEAREST` to `SCE_SNAP_INDIVIDUAL_NEAREST`
- `SCE_SNAP_MODE_FACE_RAYCAST` to `SCE_SNAP_INDIVIDUAL_PROJECT`

And arrange the enums in numerical order.
This commit is contained in:
Germano Cavalcante 2023-06-23 16:58:16 -03:00
parent e570f13616
commit 1ef9c16218
32 changed files with 305 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
source/blender/blenloader/intern/versioning_260.c
View File

@ -2133,8 +2133,8 @@ if (!MAIN_VERSION_ATLEAST(bmain, 269, 3)) {
}
/* 'Increment' mode disabled for nodes, use true grid snapping instead */
if (scene->toolsettings->snap_node_mode == 0) { /* SCE_SNAP_MODE_INCREMENT */
scene->toolsettings->snap_node_mode = 8; /* SCE_SNAP_MODE_GRID */
if (scene->toolsettings->snap_node_mode == 0) { /* SCE_SNAP_TO_INCREMENT */
scene->toolsettings->snap_node_mode = 8; /* SCE_SNAP_TO_GRID */
}
#ifdef WITH_FFMPEG

26
source/blender/blenloader/intern/versioning_280.cc
View File

@ -3818,42 +3818,42 @@ void blo_do_versions_280(FileData *fd, Library * /*lib*/, Main *bmain)
LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
switch (scene->toolsettings->snap_mode) {
case 0:
scene->toolsettings->snap_mode = (1 << 4); /* SCE_SNAP_MODE_INCREMENT */
scene->toolsettings->snap_mode = (1 << 4); /* SCE_SNAP_TO_INCREMENT */
break;
case 1:
scene->toolsettings->snap_mode = (1 << 0); /* SCE_SNAP_MODE_VERTEX */
scene->toolsettings->snap_mode = (1 << 0); /* SCE_SNAP_TO_VERTEX */
break;
case 2:
scene->toolsettings->snap_mode = (1 << 1); /* SCE_SNAP_MODE_EDGE */
scene->toolsettings->snap_mode = (1 << 1); /* SCE_SNAP_TO_EDGE */
break;
case 3:
scene->toolsettings->snap_mode = (1 << 2); /* SCE_SNAP_MODE_FACE_RAYCAST */
scene->toolsettings->snap_mode = (1 << 2); /* SCE_SNAP_INDIVIDUAL_PROJECT */
break;
case 4:
scene->toolsettings->snap_mode = (1 << 3); /* SCE_SNAP_MODE_VOLUME */
scene->toolsettings->snap_mode = (1 << 3); /* SCE_SNAP_TO_VOLUME */
break;
}
switch (scene->toolsettings->snap_node_mode) {
case 5:
scene->toolsettings->snap_node_mode = (1 << 5); /* SCE_SNAP_MODE_NODE_X */
scene->toolsettings->snap_node_mode = (1 << 5); /* SCE_SNAP_TO_NODE_X */
break;
case 6:
scene->toolsettings->snap_node_mode = (1 << 6); /* SCE_SNAP_MODE_NODE_Y */
scene->toolsettings->snap_node_mode = (1 << 6); /* SCE_SNAP_TO_NODE_Y */
break;
case 7:
scene->toolsettings->snap_node_mode =
(1 << 5) | (1 << 6); /* SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y */
(1 << 5) | (1 << 6); /* SCE_SNAP_TO_NODE_X | SCE_SNAP_TO_NODE_Y */
break;
case 8:
scene->toolsettings->snap_node_mode = (1 << 7); /* SCE_SNAP_MODE_GRID */
scene->toolsettings->snap_node_mode = (1 << 7); /* SCE_SNAP_TO_GRID */
break;
}
switch (scene->toolsettings->snap_uv_mode) {
case 0:
scene->toolsettings->snap_uv_mode = (1 << 4); /* SCE_SNAP_MODE_INCREMENT */
scene->toolsettings->snap_uv_mode = (1 << 4); /* SCE_SNAP_TO_INCREMENT */
break;
case 1:
scene->toolsettings->snap_uv_mode = (1 << 0); /* SCE_SNAP_MODE_VERTEX */
scene->toolsettings->snap_uv_mode = (1 << 0); /* SCE_SNAP_TO_VERTEX */
break;
}
}
@ -5749,8 +5749,8 @@ void blo_do_versions_280(FileData *fd, Library * /*lib*/, Main *bmain)
if (!MAIN_VERSION_ATLEAST(bmain, 281, 15)) {
LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
if (scene->toolsettings->snap_node_mode == SCE_SNAP_MODE_NODE_X) {
scene->toolsettings->snap_node_mode = SCE_SNAP_MODE_GRID;
if (scene->toolsettings->snap_node_mode == SCE_SNAP_TO_NODE_X) {
scene->toolsettings->snap_node_mode = SCE_SNAP_TO_GRID;
}
}

16
source/blender/blenloader/intern/versioning_300.cc
View File

@ -2523,22 +2523,22 @@ void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain)
tool_settings->snap_node_mode &= ~((1 << 5) | (1 << 6));
tool_settings->snap_uv_mode &= ~(1 << 4);
if (snap_mode & (1 << 4)) {
tool_settings->snap_mode |= (1 << 6); /* SCE_SNAP_MODE_INCREMENT */
tool_settings->snap_mode |= (1 << 6); /* SCE_SNAP_TO_INCREMENT */
}
if (snap_mode & (1 << 5)) {
tool_settings->snap_mode |= (1 << 4); /* SCE_SNAP_MODE_EDGE_MIDPOINT */
tool_settings->snap_mode |= (1 << 4); /* SCE_SNAP_TO_EDGE_MIDPOINT */
}
if (snap_mode & (1 << 6)) {
tool_settings->snap_mode |= (1 << 5); /* SCE_SNAP_MODE_EDGE_PERPENDICULAR */
tool_settings->snap_mode |= (1 << 5); /* SCE_SNAP_TO_EDGE_PERPENDICULAR */
}
if (snap_node_mode & (1 << 5)) {
tool_settings->snap_node_mode |= (1 << 0); /* SCE_SNAP_MODE_NODE_X */
tool_settings->snap_node_mode |= (1 << 0); /* SCE_SNAP_TO_NODE_X */
}
if (snap_node_mode & (1 << 6)) {
tool_settings->snap_node_mode |= (1 << 1); /* SCE_SNAP_MODE_NODE_Y */
tool_settings->snap_node_mode |= (1 << 1); /* SCE_SNAP_TO_NODE_Y */
}
if (snap_uv_mode & (1 << 4)) {
tool_settings->snap_uv_mode |= (1 << 6); /* SCE_SNAP_MODE_INCREMENT */
tool_settings->snap_uv_mode |= (1 << 6); /* SCE_SNAP_TO_INCREMENT */
}
SequencerToolSettings *sequencer_tool_settings = SEQ_tool_settings_ensure(scene);
@ -2582,7 +2582,7 @@ void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain)
LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
ToolSettings *tool_settings = scene->toolsettings;
if (tool_settings->snap_uv_mode & (1 << 4)) {
tool_settings->snap_uv_mode |= (1 << 6); /* SCE_SNAP_MODE_INCREMENT */
tool_settings->snap_uv_mode |= (1 << 6); /* SCE_SNAP_TO_INCREMENT */
tool_settings->snap_uv_mode &= ~(1 << 4);
}
}
@ -4472,7 +4472,7 @@ void blo_do_versions_300(FileData *fd, Library * /*lib*/, Main *bmain)
if (!MAIN_VERSION_ATLEAST(bmain, 306, 10)) {
LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
/* Set default values for new members. */
scene->toolsettings->snap_mode_tools = SCE_SNAP_MODE_GEOM;
scene->toolsettings->snap_mode_tools = SCE_SNAP_TO_GEOM;
scene->toolsettings->plane_axis = 2;
}
}

6
source/blender/blenloader/intern/versioning_400.cc
View File

@ -229,13 +229,13 @@ void blo_do_versions_400(FileData *fd, Library * /*lib*/, Main *bmain)
if (!MAIN_VERSION_ATLEAST(bmain, 400, 5)) {
LISTBASE_FOREACH (Scene *, scene, &bmain->scenes) {
ToolSettings *ts = scene->toolsettings;
if (ts->snap_mode_tools != SCE_SNAP_MODE_NONE) {
ts->snap_mode_tools = SCE_SNAP_MODE_GEOM;
if (ts->snap_mode_tools != SCE_SNAP_TO_NONE) {
ts->snap_mode_tools = SCE_SNAP_TO_GEOM;
}
#define SCE_SNAP_PROJECT (1 << 3)
if (ts->snap_flag & SCE_SNAP_PROJECT) {
ts->snap_mode |= SCE_SNAP_MODE_FACE_RAYCAST;
ts->snap_mode |= SCE_SNAP_INDIVIDUAL_PROJECT;
}
#undef SCE_SNAP_PROJECT
}

4
source/blender/editors/curve/editcurve.c
View File

@ -5609,7 +5609,7 @@ static int add_vertex_invoke(bContext *C, wmOperator *op, const wmEvent *event)
Curve *cu;
float location[3];
const bool use_proj = ((vc.scene->toolsettings->snap_flag & SCE_SNAP) &&
(vc.scene->toolsettings->snap_mode == SCE_SNAP_MODE_FACE));
(vc.scene->toolsettings->snap_mode == SCE_SNAP_TO_FACE));
Nurb *nu;
BezTriple *bezt;
@ -5641,7 +5641,7 @@ static int add_vertex_invoke(bContext *C, wmOperator *op, const wmEvent *event)
vc.depsgraph,
vc.region,
vc.v3d,
SCE_SNAP_MODE_FACE,
SCE_SNAP_TO_FACE,
&(const struct SnapObjectParams){
.snap_target_select = (vc.obedit != NULL) ? SCE_SNAP_TARGET_NOT_ACTIVE :
SCE_SNAP_TARGET_ALL,

2
source/blender/editors/gizmo_library/gizmo_types/move3d_gizmo.c
View File

@ -280,7 +280,7 @@ static int gizmo_move_modal(bContext *C,
CTX_data_ensure_evaluated_depsgraph(C),
region,
CTX_wm_view3d(C),
(SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE),
(SCE_SNAP_TO_VERTEX | SCE_SNAP_TO_EDGE | SCE_SNAP_TO_FACE),
&(const struct SnapObjectParams){
.snap_target_select = SCE_SNAP_TARGET_ALL,
.edit_mode_type = SNAP_GEOM_EDIT,

2
source/blender/editors/gizmo_library/gizmo_types/snap3d_gizmo.c
View File

@ -266,7 +266,7 @@ static int snap_gizmo_test_select(bContext *C, wmGizmo *gz, const int mval[2])
ED_view3d_cursor_snap_data_update(snap_gizmo->snap_state, C, x, y);
V3DSnapCursorData *snap_data = ED_view3d_cursor_snap_data_get();
if (snap_data->snap_elem != SCE_SNAP_MODE_NONE) {
if (snap_data->snap_elem != SCE_SNAP_TO_NONE) {
return 0;
}
return -1;

2
source/blender/editors/mesh/editmesh_extrude.c
View File

@ -710,7 +710,7 @@ static int edbm_dupli_extrude_cursor_invoke(bContext *C, wmOperator *op, const w
const bool rot_src = RNA_boolean_get(op->ptr, "rotate_source");
const bool use_proj = ((vc.scene->toolsettings->snap_flag & SCE_SNAP) &&
(vc.scene->toolsettings->snap_mode == SCE_SNAP_MODE_FACE));
(vc.scene->toolsettings->snap_mode == SCE_SNAP_TO_FACE));
/* First calculate the center of transformation. */
zero_v3(center);

2
source/blender/editors/mesh/editmesh_utils.cc
View File

@ -1951,7 +1951,7 @@ void EDBM_project_snap_verts(
depsgraph,
region,
CTX_wm_view3d(C),
SCE_SNAP_MODE_FACE,
SCE_SNAP_TO_FACE,
&params,
nullptr,
mval,

48
source/blender/editors/space_view3d/view3d_cursor_snap.c
View File

@ -434,7 +434,7 @@ void ED_view3d_cursor_snap_draw_util(RegionView3D *rv3d,
immVertex3fv(pos, v2);
immEnd();
if (loc_curr && (snap_elem_type & SCE_SNAP_MODE_EDGE_PERPENDICULAR)) {
if (loc_curr && (snap_elem_type & SCE_SNAP_TO_EDGE_PERPENDICULAR)) {
/* Dashed line. */
immUnbindProgram();
@ -550,8 +550,8 @@ static bool v3d_cursor_is_snap_invert(SnapCursorDataIntern *data_intern, const w
static eSnapMode v3d_cursor_snap_elements(ToolSettings *tool_settings)
{
return tool_settings->snap_mode_tools == SCE_SNAP_MODE_NONE ? tool_settings->snap_mode :
tool_settings->snap_mode_tools;
return tool_settings->snap_mode_tools == SCE_SNAP_TO_NONE ? tool_settings->snap_mode :
tool_settings->snap_mode_tools;
}
static void v3d_cursor_snap_context_ensure(Scene *scene)
@ -597,7 +597,7 @@ static void v3d_cursor_snap_update(V3DSnapCursorState *state,
const bool calc_plane_omat = v3d_cursor_snap_calc_plane();
float co[3], no[3], face_nor[3], obmat[4][4], omat[3][3];
eSnapMode snap_elem = SCE_SNAP_MODE_NONE;
eSnapMode snap_elem = SCE_SNAP_TO_NONE;
eSnapMode snap_elements = v3d_cursor_snap_elements(tool_settings);
int snap_elem_index[3] = {-1, -1, -1};
int index = -1;
@ -610,10 +610,10 @@ static void v3d_cursor_snap_update(V3DSnapCursorState *state,
if (use_surface_nor || use_surface_co) {
v3d_cursor_snap_context_ensure(scene);
data_intern->snap_elem_hidden = SCE_SNAP_MODE_NONE;
if (calc_plane_omat && !(snap_elements & SCE_SNAP_MODE_FACE)) {
data_intern->snap_elem_hidden = SCE_SNAP_MODE_FACE;
snap_elements |= SCE_SNAP_MODE_FACE;
data_intern->snap_elem_hidden = SCE_SNAP_TO_NONE;
if (calc_plane_omat && !(snap_elements & SCE_SNAP_TO_FACE)) {
data_intern->snap_elem_hidden = SCE_SNAP_TO_FACE;
snap_elements |= SCE_SNAP_TO_FACE;
}
snap_data->is_enabled = true;
@ -625,21 +625,21 @@ static void v3d_cursor_snap_update(V3DSnapCursorState *state,
if (snap_data->is_snap_invert != !(ts->snap_flag & SCE_SNAP)) {
snap_data->is_enabled = false;
if (!calc_plane_omat) {
snap_data->snap_elem = SCE_SNAP_MODE_NONE;
snap_data->snap_elem = SCE_SNAP_TO_NONE;
return;
}
snap_elements = data_intern->snap_elem_hidden = SCE_SNAP_MODE_FACE;
snap_elements = data_intern->snap_elem_hidden = SCE_SNAP_TO_FACE;
}
}
#endif
if (snap_elements & SCE_SNAP_MODE_GEOM) {
if (snap_elements & SCE_SNAP_TO_GEOM) {
float prev_co[3] = {0.0f};
if (state->prevpoint) {
copy_v3_v3(prev_co, state->prevpoint);
}
else {
snap_elements &= ~SCE_SNAP_MODE_EDGE_PERPENDICULAR;
snap_elements &= ~SCE_SNAP_TO_EDGE_PERPENDICULAR;
}
eSnapEditType edit_mode_type = (state->flag & V3D_SNAPCURSOR_SNAP_EDIT_GEOM_FINAL) ?
@ -684,7 +684,7 @@ static void v3d_cursor_snap_update(V3DSnapCursorState *state,
if (calc_plane_omat) {
RegionView3D *rv3d = region->regiondata;
bool orient_surface = use_surface_nor && (snap_elem != SCE_SNAP_MODE_NONE);
bool orient_surface = use_surface_nor && (snap_elem != SCE_SNAP_TO_NONE);
if (orient_surface) {
copy_m3_m4(omat, obmat);
}
@ -713,7 +713,7 @@ static void v3d_cursor_snap_update(V3DSnapCursorState *state,
/* Negate the face normal according to the view. */
float ray_dir[3];
if (rv3d->is_persp) {
BLI_assert_msg(snap_elem != SCE_SNAP_MODE_NONE,
BLI_assert_msg(snap_elem != SCE_SNAP_TO_NONE,
"Use of variable `co` without it being computed");
sub_v3_v3v3(ray_dir, co, rv3d->viewinv[3]); /* No need to normalize. */
@ -737,12 +737,12 @@ static void v3d_cursor_snap_update(V3DSnapCursorState *state,
}
if (!use_surface_co) {
snap_elem = SCE_SNAP_MODE_NONE;
snap_elem = SCE_SNAP_TO_NONE;
}
float *co_depth = (snap_elem != SCE_SNAP_MODE_NONE) ? co : scene->cursor.location;
float *co_depth = (snap_elem != SCE_SNAP_TO_NONE) ? co : scene->cursor.location;
snap_elem &= ~data_intern->snap_elem_hidden;
if (snap_elem == SCE_SNAP_MODE_NONE) {
if (snap_elem == SCE_SNAP_TO_NONE) {
RegionView3D *rv3d = region->regiondata;
const float *plane_normal = omat[tool_settings->plane_axis];
bool do_plane_isect = (tool_settings->plane_depth != V3D_PLACE_DEPTH_CURSOR_VIEW) &&
@ -759,19 +759,19 @@ static void v3d_cursor_snap_update(V3DSnapCursorState *state,
ED_view3d_win_to_3d(v3d, region, co_depth, mval_fl, co);
}
if (snap_data->is_enabled && (snap_elements & SCE_SNAP_MODE_INCREMENT)) {
if (snap_data->is_enabled && (snap_elements & SCE_SNAP_TO_INCREMENT)) {
v3d_cursor_snap_calc_incremental(scene, v3d, region, state->prevpoint, co);
}
}
else if (snap_elem == SCE_SNAP_MODE_VERTEX) {
else if (snap_elem == SCE_SNAP_TO_VERTEX) {
snap_elem_index[0] = index;
}
else if (snap_elem &
(SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_EDGE_MIDPOINT | SCE_SNAP_MODE_EDGE_PERPENDICULAR))
(SCE_SNAP_TO_EDGE | SCE_SNAP_TO_EDGE_MIDPOINT | SCE_SNAP_TO_EDGE_PERPENDICULAR))
{
snap_elem_index[1] = index;
}
else if (snap_elem == SCE_SNAP_MODE_FACE) {
else if (snap_elem == SCE_SNAP_TO_FACE) {
snap_elem_index[2] = index;
}
@ -853,7 +853,7 @@ static void v3d_cursor_snap_draw_fn(bContext *C, int x, int y, void *UNUSED(cust
}
const bool draw_plane = state->draw_plane || state->draw_box;
if (snap_data->snap_elem == SCE_SNAP_MODE_NONE && !draw_plane) {
if (snap_data->snap_elem == SCE_SNAP_TO_NONE && !draw_plane) {
return;
}
@ -871,8 +871,8 @@ static void v3d_cursor_snap_draw_fn(bContext *C, int x, int y, void *UNUSED(cust
v3d_cursor_plane_draw(rv3d, scene->toolsettings->plane_axis, matrix);
}
if (snap_data->snap_elem != SCE_SNAP_MODE_NONE && (state->draw_point || state->draw_box)) {
const float *prev_point = (snap_data->snap_elem & SCE_SNAP_MODE_EDGE_PERPENDICULAR) ?
if (snap_data->snap_elem != SCE_SNAP_TO_NONE && (state->draw_point || state->draw_box)) {
const float *prev_point = (snap_data->snap_elem & SCE_SNAP_TO_EDGE_PERPENDICULAR) ?
state->prevpoint :
NULL;

2
source/blender/editors/space_view3d/view3d_edit.c
View File

@ -911,7 +911,7 @@ void ED_view3d_cursor3d_position_rotation(bContext *C,
CTX_data_ensure_evaluated_depsgraph(C),
region,
v3d,
SCE_SNAP_MODE_FACE,
SCE_SNAP_TO_FACE,
&(const struct SnapObjectParams){
.snap_target_select = SCE_SNAP_TARGET_ALL,
.edit_mode_type = SNAP_GEOM_FINAL,

2
source/blender/editors/space_view3d/view3d_gizmo_ruler.cc
View File

@ -376,7 +376,7 @@ static bool view3d_ruler_item_mousemove(const bContext *C,
depsgraph,
ruler_info->region,
v3d,
SCE_SNAP_MODE_FACE,
SCE_SNAP_TO_FACE,
&snap_object_params,
nullptr,
mval_fl,

8
source/blender/editors/space_view3d/view3d_placement.c
View File

@ -690,7 +690,7 @@ static bool view3d_interactive_add_calc_snap(bContext *UNUSED(C),
if (r_is_snap_invert) {
*r_is_snap_invert = snap_data->is_snap_invert;
}
return snap_data->snap_elem != SCE_SNAP_MODE_NONE;
return snap_data->snap_elem != SCE_SNAP_TO_NONE;
}
/** \} */
@ -762,7 +762,7 @@ static void view3d_interactive_add_begin(bContext *C, wmOperator *op, const wmEv
ipd->step_index = STEP_BASE;
ipd->snap_to = tool_settings->snap_mode_tools;
if (ipd->snap_to == SCE_SNAP_MODE_NONE) {
if (ipd->snap_to == SCE_SNAP_TO_NONE) {
ipd->snap_to = tool_settings->snap_mode;
}
@ -1204,7 +1204,7 @@ static int view3d_interactive_add_modal(bContext *C, wmOperator *op, const wmEve
/* pass */
}
if (ipd->use_snap && (ipd->snap_to & SCE_SNAP_MODE_INCREMENT)) {
if (ipd->use_snap && (ipd->snap_to & SCE_SNAP_TO_INCREMENT)) {
if (idp_snap_calc_incremental(
ipd->scene, ipd->v3d, ipd->region, ipd->co_src, ipd->step[STEP_BASE].co_dst))
{
@ -1228,7 +1228,7 @@ static int view3d_interactive_add_modal(bContext *C, wmOperator *op, const wmEve
/* pass */
}
if (ipd->use_snap && (ipd->snap_to & SCE_SNAP_MODE_INCREMENT)) {
if (ipd->use_snap && (ipd->snap_to & SCE_SNAP_TO_INCREMENT)) {
if (idp_snap_calc_incremental(
ipd->scene, ipd->v3d, ipd->region, ipd->co_src, ipd->step[STEP_DEPTH].co_dst))
{

4
source/blender/editors/transform/transform.c
View File

@ -577,7 +577,7 @@ static bool transform_modal_item_poll(const wmOperator *op, int value)
if (t->spacetype != SPACE_VIEW3D) {
return false;
}
if ((t->tsnap.mode & ~(SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)) == 0) {
if ((t->tsnap.mode & ~(SCE_SNAP_TO_INCREMENT | SCE_SNAP_TO_GRID)) == 0) {
return false;
}
if (value == TFM_MODAL_ADD_SNAP) {
@ -1659,7 +1659,7 @@ void saveTransform(bContext *C, TransInfo *t, wmOperator *op)
if ((prop = RNA_struct_find_property(op->ptr, "snap_elements"))) {
RNA_property_enum_set(op->ptr, prop, t->tsnap.mode);
RNA_boolean_set(
op->ptr, "use_snap_project", (t->tsnap.mode & SCE_SNAP_MODE_FACE_RAYCAST) != 0);
op->ptr, "use_snap_project", (t->tsnap.mode & SCE_SNAP_INDIVIDUAL_PROJECT) != 0);
RNA_enum_set(op->ptr, "snap_target", t->tsnap.source_operation);
eSnapTargetOP target = t->tsnap.target_operation;

6
source/blender/editors/transform/transform_constraints.c
View File

@ -399,11 +399,11 @@ static void applyAxisConstraintVec(const TransInfo *t,
if (transform_snap_is_active(t)) {
if (validSnap(t)) {
is_snap_to_edge = (t->tsnap.snapElem & SCE_SNAP_MODE_EDGE) != 0;
is_snap_to_face = (t->tsnap.snapElem & SCE_SNAP_MODE_FACE) != 0;
is_snap_to_edge = (t->tsnap.snapElem & SCE_SNAP_TO_EDGE) != 0;
is_snap_to_face = (t->tsnap.snapElem & SCE_SNAP_TO_FACE) != 0;
is_snap_to_point = !is_snap_to_edge && !is_snap_to_face;
}
else if (t->tsnap.snapElem & SCE_SNAP_MODE_GRID) {
else if (t->tsnap.snapElem & SCE_SNAP_TO_GRID) {
is_snap_to_point = true;
}
}

3
source/blender/editors/transform/transform_convert_node.cc
View File

@ -154,8 +154,7 @@ static void node_snap_grid_apply(TransInfo *t)
using namespace blender;
if (!(transform_snap_is_active(t) &&
(t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID))))
{
(t->tsnap.mode & (SCE_SNAP_TO_INCREMENT | SCE_SNAP_TO_GRID)))) {
return;
}

2
source/blender/editors/transform/transform_mode_bend.c
View File

@ -204,7 +204,7 @@ static void Bend(TransInfo *t, const int UNUSED(mval[2]))
#else
/* hrmf, snapping radius is using 'angle' steps, need to convert to something else
* this isn't essential but nicer to give reasonable snapping values for radius. */
if (t->tsnap.mode & SCE_SNAP_MODE_INCREMENT) {
if (t->tsnap.mode & SCE_SNAP_TO_INCREMENT) {
const float radius_snap = 0.1f;
const float snap_hack = (t->snap[0] * bend_data->warp_init_dist) / radius_snap;
values.scale *= snap_hack;

4
source/blender/editors/transform/transform_mode_edge_slide.c
View File

@ -1294,11 +1294,11 @@ static void edge_slide_snap_apply(TransInfo *t, float *value)
side_index = t_snap >= t_mid;
}
if (t->tsnap.snapElem & (SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE)) {
if (t->tsnap.snapElem & (SCE_SNAP_TO_EDGE | SCE_SNAP_TO_FACE)) {
float co_dir[3];
sub_v3_v3v3(co_dir, co_dest[side_index], co_orig);
normalize_v3(co_dir);
if (t->tsnap.snapElem & SCE_SNAP_MODE_EDGE) {
if (t->tsnap.snapElem & SCE_SNAP_TO_EDGE) {
transform_constraint_snap_axis_to_edge(t, co_dir, dvec);
}
else {

14
source/blender/editors/transform/transform_mode_snapsource.c
View File

@ -110,7 +110,7 @@ static void snapsource_confirm(TransInfo *t)
transform_input_reset(t, mval);
/* Remote individual snap projection since this mode does not use the new `snap_source`. */
t->tsnap.mode &= ~(SCE_SNAP_MODE_FACE_RAYCAST | SCE_SNAP_MODE_FACE_NEAREST);
t->tsnap.mode &= ~(SCE_SNAP_INDIVIDUAL_PROJECT | SCE_SNAP_INDIVIDUAL_NEAREST);
}
static eRedrawFlag snapsource_handle_event_fn(TransInfo *t, const wmEvent *event)
@ -188,15 +188,15 @@ void transform_mode_snap_source_init(TransInfo *t, wmOperator *UNUSED(op))
t->tsnap.status &= ~SNAP_SOURCE_FOUND;
customdata->snap_mode_confirm = t->tsnap.mode;
t->tsnap.mode &= ~(SCE_SNAP_MODE_EDGE_PERPENDICULAR | SCE_SNAP_MODE_FACE_RAYCAST |
SCE_SNAP_MODE_FACE_NEAREST);
t->tsnap.mode &= ~(SCE_SNAP_TO_EDGE_PERPENDICULAR | SCE_SNAP_INDIVIDUAL_PROJECT |
SCE_SNAP_INDIVIDUAL_NEAREST);
if ((t->tsnap.mode & ~(SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)) == 0) {
if ((t->tsnap.mode & ~(SCE_SNAP_TO_INCREMENT | SCE_SNAP_TO_GRID)) == 0) {
/* Initialize snap modes for geometry. */
t->tsnap.mode &= ~(SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID);
t->tsnap.mode |= SCE_SNAP_MODE_GEOM;
t->tsnap.mode &= ~(SCE_SNAP_TO_INCREMENT | SCE_SNAP_TO_GRID);
t->tsnap.mode |= SCE_SNAP_TO_GEOM;
if (!(customdata->snap_mode_confirm & SCE_SNAP_MODE_EDGE_PERPENDICULAR)) {
if (!(customdata->snap_mode_confirm & SCE_SNAP_TO_EDGE_PERPENDICULAR)) {
customdata->snap_mode_confirm = t->tsnap.mode;
}
}

8
source/blender/editors/transform/transform_mode_translate.c
View File

@ -384,7 +384,7 @@ static void translate_snap_grid_apply(TransInfo *t,
float in[3];
if (t->con.mode & CON_APPLY) {
BLI_assert(t->tsnap.snapElem == SCE_SNAP_MODE_NONE);
BLI_assert(t->tsnap.snapElem == SCE_SNAP_TO_NONE);
t->con.applyVec(t, NULL, NULL, loc, in);
}
else {
@ -403,7 +403,7 @@ static bool translate_snap_grid(TransInfo *t, float *val)
return false;
}
if (!(t->tsnap.mode & SCE_SNAP_MODE_GRID) || validSnap(t)) {
if (!(t->tsnap.mode & SCE_SNAP_TO_GRID) || validSnap(t)) {
/* Don't do grid snapping if there is a valid snap point. */
return false;
}
@ -429,7 +429,7 @@ static bool translate_snap_grid(TransInfo *t, float *val)
}
translate_snap_grid_apply(t, t->idx_max, grid_dist, val, val);
t->tsnap.snapElem = SCE_SNAP_MODE_GRID;
t->tsnap.snapElem = SCE_SNAP_TO_GRID;
return true;
}
@ -627,7 +627,7 @@ static void applyTranslation(TransInfo *t, const int UNUSED(mval[2]))
/* Test for mixed snap with grid. */
float snap_dist_sq = FLT_MAX;
if (t->tsnap.snapElem != SCE_SNAP_MODE_NONE) {
if (t->tsnap.snapElem != SCE_SNAP_TO_NONE) {
snap_dist_sq = len_squared_v3v3(t->values, global_dir);
}
if ((snap_dist_sq == FLT_MAX) || (len_squared_v3v3(global_dir, incr_dir) < snap_dist_sq)) {

4
source/blender/editors/transform/transform_mode_vert_slide.c
View File

@ -539,11 +539,11 @@ static void vert_slide_snap_apply(TransInfo *t, float *value)
getSnapPoint(t, dvec);
sub_v3_v3(dvec, t->tsnap.snap_source);
if (t->tsnap.snapElem & (SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE)) {
if (t->tsnap.snapElem & (SCE_SNAP_TO_EDGE | SCE_SNAP_TO_FACE)) {
float co_dir[3];
sub_v3_v3v3(co_dir, co_curr_3d, co_orig_3d);
normalize_v3(co_dir);
if (t->tsnap.snapElem & SCE_SNAP_MODE_EDGE) {
if (t->tsnap.snapElem & SCE_SNAP_TO_EDGE) {
transform_constraint_snap_axis_to_edge(t, co_dir, dvec);
}
else {

2
source/blender/editors/transform/transform_ops.c
View File

@ -700,7 +700,7 @@ void Transform_Properties(wmOperatorType *ot, int flags)
prop = RNA_def_enum(ot->srna,
"snap_elements",
rna_enum_snap_element_items,
SCE_SNAP_MODE_INCREMENT,
SCE_SNAP_TO_INCREMENT,
"Snap to Elements",
"");
RNA_def_property_flag(prop, PROP_HIDDEN | PROP_ENUM_FLAG);

75
source/blender/editors/transform/transform_snap.cc
View File

@ -371,7 +371,7 @@ static bool applyFaceProject(TransInfo *t, TransDataContainer *tc, TransData *td
t->depsgraph,
t->region,
static_cast<const View3D *>(t->view),
SCE_SNAP_MODE_FACE,
SCE_SNAP_TO_FACE,
&snap_object_params,
nullptr,
mval_fl,
@ -379,7 +379,7 @@ static bool applyFaceProject(TransInfo *t, TransDataContainer *tc, TransData *td
nullptr,
loc,
no);
if (hit != SCE_SNAP_MODE_FACE) {
if (hit != SCE_SNAP_TO_FACE) {
return false;
}
@ -436,7 +436,7 @@ static void applyFaceNearest(TransInfo *t, TransDataContainer *tc, TransData *td
t->depsgraph,
t->region,
static_cast<const View3D *>(t->view),
SCE_SNAP_MODE_FACE_NEAREST,
SCE_SNAP_INDIVIDUAL_NEAREST,
&snap_object_params,
init_loc,
nullptr,
@ -445,7 +445,7 @@ static void applyFaceNearest(TransInfo *t, TransDataContainer *tc, TransData *td
snap_loc,
snap_no);
if (hit != SCE_SNAP_MODE_FACE_NEAREST) {
if (hit != SCE_SNAP_INDIVIDUAL_NEAREST) {
return;
}
@ -454,7 +454,7 @@ static void applyFaceNearest(TransInfo *t, TransDataContainer *tc, TransData *td
mul_m3_v3(td->smtx, tvec);
add_v3_v3(td->loc, tvec);
/* TODO: support snap alignment similar to #SCE_SNAP_MODE_FACE_RAYCAST? */
/* TODO: support snap alignment similar to #SCE_SNAP_INDIVIDUAL_PROJECT? */
}
bool transform_snap_project_individual_is_active(const TransInfo *t)
@ -463,7 +463,7 @@ bool transform_snap_project_individual_is_active(const TransInfo *t)
return false;
}
return (t->tsnap.mode & (SCE_SNAP_MODE_FACE_RAYCAST | SCE_SNAP_MODE_FACE_NEAREST)) != 0;
return (t->tsnap.mode & (SCE_SNAP_INDIVIDUAL_PROJECT | SCE_SNAP_INDIVIDUAL_NEAREST)) != 0;
}
void transform_snap_project_individual_apply(TransInfo *t)
@ -487,11 +487,11 @@ void transform_snap_project_individual_apply(TransInfo *t)
/* If both face ray-cast and face nearest methods are enabled, start with face ray-cast and
* fallback to face nearest ray-cast does not hit. */
bool hit = false;
if (t->tsnap.mode & SCE_SNAP_MODE_FACE_RAYCAST) {
if (t->tsnap.mode & SCE_SNAP_INDIVIDUAL_PROJECT) {
hit = applyFaceProject(t, tc, td);
}
if (!hit && t->tsnap.mode & SCE_SNAP_MODE_FACE_NEAREST) {
if (!hit && t->tsnap.mode & SCE_SNAP_INDIVIDUAL_NEAREST) {
applyFaceNearest(t, tc, td);
}
#if 0 /* TODO: support this? */
@ -508,8 +508,8 @@ static bool transform_snap_mixed_is_active(const TransInfo *t)
}
return (t->tsnap.mode &
(SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE | SCE_SNAP_MODE_VOLUME |
SCE_SNAP_MODE_EDGE_MIDPOINT | SCE_SNAP_MODE_EDGE_PERPENDICULAR)) != 0;
(SCE_SNAP_TO_VERTEX | SCE_SNAP_TO_EDGE | SCE_SNAP_TO_FACE | SCE_SNAP_TO_VOLUME |
SCE_SNAP_TO_EDGE_MIDPOINT | SCE_SNAP_TO_EDGE_PERPENDICULAR)) != 0;
}
void transform_snap_mixed_apply(TransInfo *t, float *vec)
@ -518,7 +518,7 @@ void transform_snap_mixed_apply(TransInfo *t, float *vec)
return;
}
if (t->tsnap.mode & ~(SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)) {
if (t->tsnap.mode & ~(SCE_SNAP_TO_INCREMENT | SCE_SNAP_TO_GRID)) {
double current = PIL_check_seconds_timer();
/* Time base quirky code to go around find-nearest slowness. */
@ -543,8 +543,8 @@ void transform_snap_mixed_apply(TransInfo *t, float *vec)
void resetSnapping(TransInfo *t)
{
t->tsnap.status = SNAP_RESETTED;
t->tsnap.snapElem = SCE_SNAP_MODE_NONE;
t->tsnap.mode = SCE_SNAP_MODE_NONE;
t->tsnap.snapElem = SCE_SNAP_TO_NONE;
t->tsnap.mode = SCE_SNAP_TO_NONE;
t->tsnap.target_operation = SCE_SNAP_TARGET_ALL;
t->tsnap.source_operation = SCE_SNAP_SOURCE_CLOSEST;
t->tsnap.last = 0;
@ -634,11 +634,11 @@ static eSnapMode snap_mode_from_spacetype(TransInfo *t)
if (t->spacetype == SPACE_IMAGE) {
eSnapMode snap_mode = eSnapMode(ts->snap_uv_mode);
if ((snap_mode & SCE_SNAP_MODE_INCREMENT) && (ts->snap_uv_flag & SCE_SNAP_ABS_GRID) &&
if ((snap_mode & SCE_SNAP_TO_INCREMENT) && (ts->snap_uv_flag & SCE_SNAP_ABS_GRID) &&
(t->mode == TFM_TRANSLATION))
{
snap_mode &= ~SCE_SNAP_MODE_INCREMENT;
snap_mode |= SCE_SNAP_MODE_GRID;
snap_mode &= ~SCE_SNAP_TO_INCREMENT;
snap_mode |= SCE_SNAP_TO_GRID;
}
return snap_mode;
}
@ -649,16 +649,16 @@ static eSnapMode snap_mode_from_spacetype(TransInfo *t)
if (t->spacetype == SPACE_VIEW3D) {
if (t->options & (CTX_CAMERA | CTX_EDGE_DATA | CTX_PAINT_CURVE)) {
return SCE_SNAP_MODE_INCREMENT;
return SCE_SNAP_TO_INCREMENT;
}
eSnapMode snap_mode = eSnapMode(ts->snap_mode);
if ((snap_mode & SCE_SNAP_MODE_INCREMENT) && (ts->snap_flag & SCE_SNAP_ABS_GRID) &&
if ((snap_mode & SCE_SNAP_TO_INCREMENT) && (ts->snap_flag & SCE_SNAP_ABS_GRID) &&
(t->mode == TFM_TRANSLATION))
{
/* Special case in which snap to increments is transformed to snap to grid. */
snap_mode &= ~SCE_SNAP_MODE_INCREMENT;
snap_mode |= SCE_SNAP_MODE_GRID;
snap_mode &= ~SCE_SNAP_TO_INCREMENT;
snap_mode |= SCE_SNAP_TO_GRID;
}
return snap_mode;
}
@ -668,7 +668,7 @@ static eSnapMode snap_mode_from_spacetype(TransInfo *t)
return eSnapMode(0);
}
return SCE_SNAP_MODE_INCREMENT;
return SCE_SNAP_TO_INCREMENT;
}
static eSnapTargetOP snap_target_select_from_spacetype(TransInfo *t)
@ -757,15 +757,15 @@ static void initSnappingMode(TransInfo *t)
}
if (doForceIncrementSnap(t)) {
t->tsnap.mode = SCE_SNAP_MODE_INCREMENT;
t->tsnap.mode = SCE_SNAP_TO_INCREMENT;
}
if ((t->spacetype != SPACE_VIEW3D) || (t->flag & T_NO_PROJECT)) {
/* Force project off when not supported. */
t->tsnap.mode &= ~(SCE_SNAP_MODE_FACE_RAYCAST | SCE_SNAP_MODE_FACE_NEAREST);
t->tsnap.mode &= ~(SCE_SNAP_INDIVIDUAL_PROJECT | SCE_SNAP_INDIVIDUAL_NEAREST);
}
if (t->tsnap.mode & SCE_SNAP_MODE_EDGE_PERPENDICULAR) {
if (t->tsnap.mode & SCE_SNAP_TO_EDGE_PERPENDICULAR) {
t->flag |= T_DRAW_SNAP_SOURCE;
}
@ -839,7 +839,7 @@ void initSnapping(TransInfo *t, wmOperator *op)
RNA_property_is_set(op->ptr, prop))
{
SET_FLAG_FROM_TEST(
t->tsnap.mode, RNA_property_boolean_get(op->ptr, prop), SCE_SNAP_MODE_FACE_RAYCAST);
t->tsnap.mode, RNA_property_boolean_get(op->ptr, prop), SCE_SNAP_INDIVIDUAL_PROJECT);
}
/* use_snap_self is misnamed and should be use_snap_active */
@ -1093,23 +1093,23 @@ static void snap_target_view3d_fn(TransInfo *t, float * /*vec*/)
float no[3];
float mval[2];
bool found = false;
eSnapMode snap_elem = SCE_SNAP_MODE_NONE;
eSnapMode snap_elem = SCE_SNAP_TO_NONE;
float dist_px = SNAP_MIN_DISTANCE; /* Use a user defined value here. */
mval[0] = t->mval[0];
mval[1] = t->mval[1];
if (t->tsnap.mode & SCE_SNAP_MODE_GEOM) {
if (t->tsnap.mode & SCE_SNAP_TO_GEOM) {
zero_v3(no); /* objects won't set this */
snap_elem = snapObjectsTransform(t, mval, &dist_px, loc, no);
found = (snap_elem != SCE_SNAP_MODE_NONE);
found = (snap_elem != SCE_SNAP_TO_NONE);
}
if ((found == false) && (t->tsnap.mode & SCE_SNAP_MODE_VOLUME)) {
if ((found == false) && (t->tsnap.mode & SCE_SNAP_TO_VOLUME)) {
bool use_peel = (t->settings->snap_flag & SCE_SNAP_PEEL_OBJECT) != 0;
found = peelObjectsTransform(t, mval, use_peel, loc, no, nullptr);
if (found) {
snap_elem = SCE_SNAP_MODE_VOLUME;
snap_elem = SCE_SNAP_TO_VOLUME;
}
}
@ -1129,7 +1129,7 @@ static void snap_target_view3d_fn(TransInfo *t, float * /*vec*/)
static void snap_target_uv_fn(TransInfo *t, float * /*vec*/)
{
BLI_assert(t->spacetype == SPACE_IMAGE);
if (t->tsnap.mode & SCE_SNAP_MODE_VERTEX) {
if (t->tsnap.mode & SCE_SNAP_TO_VERTEX) {
uint objects_len = 0;
Object **objects = BKE_view_layer_array_from_objects_in_edit_mode_unique_data_with_uvs(
t->scene, t->view_layer, nullptr, &objects_len);
@ -1159,7 +1159,7 @@ static void snap_target_uv_fn(TransInfo *t, float * /*vec*/)
static void snap_target_node_fn(TransInfo *t, float * /*vec*/)
{
BLI_assert(t->spacetype == SPACE_NODE);
if (t->tsnap.mode & (SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y)) {
if (t->tsnap.mode & (SCE_SNAP_TO_NODE_X | SCE_SNAP_TO_NODE_Y)) {
float loc[2];
float dist_px = SNAP_MIN_DISTANCE; /* Use a user defined value here. */
char node_border;
@ -1513,10 +1513,10 @@ static bool snapNodeTest(View2D *v2d, bNode *node, eSnapTargetOP snap_target_sel
static NodeBorder snapNodeBorder(eSnapMode snap_node_mode)
{
NodeBorder flag = NodeBorder(0);
if (snap_node_mode & SCE_SNAP_MODE_NODE_X) {
if (snap_node_mode & SCE_SNAP_TO_NODE_X) {
flag |= NODE_LEFT | NODE_RIGHT;
}
if (snap_node_mode & SCE_SNAP_MODE_NODE_Y) {
if (snap_node_mode & SCE_SNAP_TO_NODE_Y) {
flag |= NODE_TOP | NODE_BOTTOM;
}
return flag;
@ -1644,7 +1644,7 @@ static void snap_increment_apply(const TransInfo *t,
const float increment_dist,
float *r_val)
{
BLI_assert(t->tsnap.mode & SCE_SNAP_MODE_INCREMENT);
BLI_assert(t->tsnap.mode & SCE_SNAP_TO_INCREMENT);
BLI_assert(max_index <= 2);
/* Early bailing out if no need to snap */
@ -1678,7 +1678,7 @@ bool transform_snap_increment_ex(const TransInfo *t, bool use_local_space, float
return false;
}
if (!(t->tsnap.mode & SCE_SNAP_MODE_INCREMENT)) {
if (!(t->tsnap.mode & SCE_SNAP_TO_INCREMENT)) {
return false;
}
@ -1710,8 +1710,7 @@ bool transform_snap_increment(const TransInfo *t, float *r_val)
float transform_snap_increment_get(const TransInfo *t)
{
if (transform_snap_is_active(t) &&
(t->tsnap.mode & (SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)))
if (transform_snap_is_active(t) && (t->tsnap.mode & (SCE_SNAP_TO_INCREMENT | SCE_SNAP_TO_GRID)))
{
return (t->modifiers & MOD_PRECISION) ? t->snap[1] : t->snap[0];
}

134
source/blender/editors/transform/transform_snap_object.cc
View File

@ -228,7 +228,7 @@ bool Nearest2dUserData::snap_edge(const float3 &va, const float3 &vb, int edge_i
eSnapMode Nearest2dUserData::snap_edge_points(int edge_index, float dist_px_sq_orig)
{
eSnapMode elem = SCE_SNAP_MODE_EDGE;
eSnapMode elem = SCE_SNAP_TO_EDGE;
SnapObjectContext *sctx = this->sctx_;
int vindex[2];
@ -251,13 +251,12 @@ eSnapMode Nearest2dUserData::snap_edge_points(int edge_index, float dist_px_sq_o
this->nearest_point.dist_sq = dist_px_sq_orig;
eSnapMode snap_to = sctx->runtime.snap_to_flag;
int e_mode_len = ((snap_to & SCE_SNAP_MODE_EDGE) != 0) +
((snap_to & SCE_SNAP_MODE_VERTEX) != 0) +
((snap_to & SCE_SNAP_MODE_EDGE_MIDPOINT) != 0);
int e_mode_len = ((snap_to & SCE_SNAP_TO_EDGE) != 0) + ((snap_to & SCE_SNAP_TO_VERTEX) != 0) +
((snap_to & SCE_SNAP_TO_EDGE_MIDPOINT) != 0);
float range = 1.0f / (2 * e_mode_len - 1);
if (snap_to & SCE_SNAP_MODE_EDGE_MIDPOINT) {
if (snap_to & SCE_SNAP_TO_EDGE_MIDPOINT) {
range *= e_mode_len - 1;
if ((range) < lambda && lambda < (1.0f - range)) {
float vmid[3];
@ -265,12 +264,12 @@ eSnapMode Nearest2dUserData::snap_edge_points(int edge_index, float dist_px_sq_o
if (this->snap_point(vmid, edge_index)) {
sub_v3_v3v3(this->nearest_point.no, v_pair[1], v_pair[0]);
elem = SCE_SNAP_MODE_EDGE_MIDPOINT;
elem = SCE_SNAP_TO_EDGE_MIDPOINT;
}
}
}
if (snap_to & SCE_SNAP_MODE_EDGE_PERPENDICULAR) {
if (snap_to & SCE_SNAP_TO_EDGE_PERPENDICULAR) {
float v_near[3], va_g[3], vb_g[3];
mul_v3_m4v3(va_g, this->obmat_.ptr(), v_pair[0]);
@ -282,18 +281,18 @@ eSnapMode Nearest2dUserData::snap_edge_points(int edge_index, float dist_px_sq_o
if (this->snap_point(v_near, edge_index)) {
sub_v3_v3v3(this->nearest_point.no, v_pair[1], v_pair[0]);
elem = SCE_SNAP_MODE_EDGE_PERPENDICULAR;
elem = SCE_SNAP_TO_EDGE_PERPENDICULAR;
}
}
}
/* Leave this one for last so it doesn't change the normal. */
if (snap_to & SCE_SNAP_MODE_VERTEX) {
if (snap_to & SCE_SNAP_TO_VERTEX) {
if (lambda < (range) || (1.0f - range) < lambda) {
int v_id = lambda < 0.5f ? 0 : 1;
if (this->snap_point(v_pair[v_id], v_id)) {
elem = SCE_SNAP_MODE_VERTEX;
elem = SCE_SNAP_TO_VERTEX;
this->copy_vert_no(vindex[v_id], this->nearest_point.no);
}
}
@ -432,7 +431,7 @@ static bool snap_object_is_snappable(const SnapObjectContext *sctx,
*/
static eSnapMode iter_snap_objects(SnapObjectContext *sctx, IterSnapObjsCallback sob_callback)
{
eSnapMode ret = SCE_SNAP_MODE_NONE;
eSnapMode ret = SCE_SNAP_TO_NONE;
eSnapMode tmp;
Scene *scene = DEG_get_input_scene(sctx->runtime.depsgraph);
@ -455,7 +454,7 @@ static eSnapMode iter_snap_objects(SnapObjectContext *sctx, IterSnapObjsCallback
BLI_assert(DEG_is_evaluated_object(dupli_ob->ob));
if ((tmp = sob_callback(
sctx, dupli_ob->ob, dupli_ob->ob_data, dupli_ob->mat, is_object_active, false)) !=
SCE_SNAP_MODE_NONE)
SCE_SNAP_TO_NONE)
{
ret = tmp;
}
@ -467,7 +466,7 @@ static eSnapMode iter_snap_objects(SnapObjectContext *sctx, IterSnapObjsCallback
ID *ob_data = data_for_snap(obj_eval, sctx->runtime.params.edit_mode_type, &use_hide);
if ((tmp = sob_callback(
sctx, obj_eval, ob_data, obj_eval->object_to_world, is_object_active, use_hide)) !=
SCE_SNAP_MODE_NONE)
SCE_SNAP_TO_NONE)
{
ret = tmp;
}
@ -551,38 +550,38 @@ static eSnapMode raycast_obj_fn(SnapObjectContext *sctx,
if (ob_data == nullptr) {
if (sctx->runtime.use_occlusion_test_edit && ELEM(ob_eval->dt, OB_BOUNDBOX, OB_WIRE)) {
/* Do not hit objects that are in wire or bounding box display mode. */
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
if (ob_eval->type == OB_MESH) {
if (snap_object_editmesh(sctx, ob_eval, nullptr, obmat, SCE_SNAP_MODE_FACE, use_hide)) {
if (snap_object_editmesh(sctx, ob_eval, nullptr, obmat, SCE_SNAP_TO_FACE, use_hide)) {
retval = true;
}
}
else {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
}
else if (sctx->runtime.params.use_occlusion_test && ELEM(ob_eval->dt, OB_BOUNDBOX, OB_WIRE)) {
/* Do not hit objects that are in wire or bounding box display mode. */
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
else if (GS(ob_data->name) != ID_ME) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
else if (is_object_active && ELEM(ob_eval->type, OB_CURVES_LEGACY, OB_SURF, OB_FONT)) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
else {
retval = snap_object_mesh(sctx, ob_eval, ob_data, obmat, SCE_SNAP_MODE_FACE, use_hide);
retval = snap_object_mesh(sctx, ob_eval, ob_data, obmat, SCE_SNAP_TO_FACE, use_hide);
}
if (retval) {
copy_m4_m4(sctx->ret.obmat, obmat);
sctx->ret.ob = ob_eval;
sctx->ret.data = ob_data;
return SCE_SNAP_MODE_FACE;
return SCE_SNAP_TO_FACE;
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
/**
@ -601,7 +600,7 @@ static eSnapMode raycast_obj_fn(SnapObjectContext *sctx,
*/
static bool raycastObjects(SnapObjectContext *sctx)
{
return iter_snap_objects(sctx, raycast_obj_fn) != SCE_SNAP_MODE_NONE;
return iter_snap_objects(sctx, raycast_obj_fn) != SCE_SNAP_TO_NONE;
}
/** \} */
@ -718,21 +717,22 @@ static eSnapMode nearest_world_object_fn(SnapObjectContext *sctx,
if (ob_data == nullptr) {
if (ob_eval->type == OB_MESH) {
if (snap_object_editmesh(
sctx, ob_eval, nullptr, obmat, SCE_SNAP_MODE_FACE_NEAREST, use_hide)) {
sctx, ob_eval, nullptr, obmat, SCE_SNAP_INDIVIDUAL_NEAREST, use_hide)) {
retval = true;
}
}
else {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
}
else if (GS(ob_data->name) != ID_ME) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
else if (is_object_active && ELEM(ob_eval->type, OB_CURVES_LEGACY, OB_SURF, OB_FONT)) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
else if (snap_object_mesh(sctx, ob_eval, ob_data, obmat, SCE_SNAP_MODE_FACE_NEAREST, use_hide)) {
else if (snap_object_mesh(sctx, ob_eval, ob_data, obmat, SCE_SNAP_INDIVIDUAL_NEAREST, use_hide))
{
retval = true;
}
@ -740,9 +740,9 @@ static eSnapMode nearest_world_object_fn(SnapObjectContext *sctx,
copy_m4_m4(sctx->ret.obmat, obmat);
sctx->ret.ob = ob_eval;
sctx->ret.data = ob_data;
return SCE_SNAP_MODE_FACE_NEAREST;
return SCE_SNAP_INDIVIDUAL_NEAREST;
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
/**
@ -758,7 +758,7 @@ static eSnapMode nearest_world_object_fn(SnapObjectContext *sctx,
*/
static bool nearestWorldObjects(SnapObjectContext *sctx)
{
return iter_snap_objects(sctx, nearest_world_object_fn) != SCE_SNAP_MODE_NONE;
return iter_snap_objects(sctx, nearest_world_object_fn) != SCE_SNAP_TO_NONE;
}
/** \} */
@ -818,11 +818,11 @@ void cb_snap_edge(void *userdata,
static eSnapMode snap_polygon(SnapObjectContext *sctx, eSnapMode snap_to_flag)
{
if (sctx->ret.ob->type != OB_MESH) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
if (sctx->ret.data && GS(sctx->ret.data->name) != ID_ME) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
if (sctx->ret.data) {
@ -837,7 +837,7 @@ static eSnapMode snap_polygon(SnapObjectContext *sctx, eSnapMode snap_to_flag)
static eSnapMode snap_edge_points(SnapObjectContext *sctx, const float dist_px_sq_orig)
{
eSnapMode elem = SCE_SNAP_MODE_EDGE;
eSnapMode elem = SCE_SNAP_TO_EDGE;
if (sctx->ret.ob->type != OB_MESH) {
return elem;
@ -864,22 +864,22 @@ eSnapMode snap_object_center(SnapObjectContext *sctx,
eSnapMode snap_to_flag)
{
if (ob_eval->transflag & OB_DUPLI) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
/* For now only vertex supported. */
if ((snap_to_flag & SCE_SNAP_MODE_VERTEX) == 0) {
return SCE_SNAP_MODE_NONE;
if ((snap_to_flag & SCE_SNAP_TO_VERTEX) == 0) {
return SCE_SNAP_TO_NONE;
}
Nearest2dUserData nearest2d(
sctx, ob_eval, static_cast<const ID *>(ob_eval->data), float4x4(obmat));
if (nearest2d.snap_point(float3(0.0f))) {
return SCE_SNAP_MODE_VERTEX;
return SCE_SNAP_TO_VERTEX;
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
/**
@ -892,7 +892,7 @@ static eSnapMode snap_obj_fn(SnapObjectContext *sctx,
bool is_object_active,
bool use_hide)
{
eSnapMode retval = SCE_SNAP_MODE_NONE;
eSnapMode retval = SCE_SNAP_TO_NONE;
if (ob_data == nullptr && (ob_eval->type == OB_MESH)) {
retval = snap_object_editmesh(
@ -906,7 +906,7 @@ static eSnapMode snap_obj_fn(SnapObjectContext *sctx,
case OB_MESH: {
if (ob_eval->dt == OB_BOUNDBOX) {
/* Do not snap to objects that are in bounding box display mode */
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
if (GS(ob_data->name) == ID_ME) {
retval = snap_object_mesh(
@ -1031,22 +1031,22 @@ static bool snap_object_context_runtime_init(SnapObjectContext *sctx,
ListBase *hit_list,
bool use_occlusion_test)
{
if (snap_to_flag & (SCE_SNAP_MODE_EDGE_PERPENDICULAR | SCE_SNAP_MODE_FACE_NEAREST)) {
if (snap_to_flag & (SCE_SNAP_TO_EDGE_PERPENDICULAR | SCE_SNAP_INDIVIDUAL_NEAREST)) {
if (prev_co) {
copy_v3_v3(sctx->runtime.curr_co, prev_co);
if (init_co) {
copy_v3_v3(sctx->runtime.init_co, init_co);
}
else {
snap_to_flag &= ~SCE_SNAP_MODE_FACE_NEAREST;
snap_to_flag &= ~SCE_SNAP_INDIVIDUAL_NEAREST;
}
}
else {
snap_to_flag &= ~(SCE_SNAP_MODE_EDGE_PERPENDICULAR | SCE_SNAP_MODE_FACE_NEAREST);
snap_to_flag &= ~(SCE_SNAP_TO_EDGE_PERPENDICULAR | SCE_SNAP_INDIVIDUAL_NEAREST);
}
}
if (snap_to_flag == SCE_SNAP_MODE_NONE) {
if (snap_to_flag == SCE_SNAP_TO_NONE) {
return false;
}
@ -1057,7 +1057,7 @@ static bool snap_object_context_runtime_init(SnapObjectContext *sctx,
sctx->runtime.params = *params;
sctx->runtime.params.use_occlusion_test = use_occlusion_test;
sctx->runtime.use_occlusion_test_edit = use_occlusion_test &&
(snap_to_flag & SCE_SNAP_MODE_FACE) == 0;
(snap_to_flag & SCE_SNAP_TO_FACE) == 0;
sctx->runtime.has_occlusion_plane = false;
sctx->runtime.object_index = 0;
@ -1115,7 +1115,7 @@ bool ED_transform_snap_object_project_ray_ex(SnapObjectContext *sctx,
depsgraph,
nullptr,
v3d,
SCE_SNAP_MODE_FACE,
SCE_SNAP_TO_FACE,
params,
ray_start,
ray_normal,
@ -1167,7 +1167,7 @@ bool ED_transform_snap_object_project_ray_all(SnapObjectContext *sctx,
depsgraph,
nullptr,
v3d,
SCE_SNAP_MODE_FACE,
SCE_SNAP_TO_FACE,
params,
ray_start,
ray_normal,
@ -1246,18 +1246,18 @@ eSnapMode ED_transform_snap_object_project_view3d_ex(SnapObjectContext *sctx,
float r_obmat[4][4],
float r_face_nor[3])
{
eSnapMode retval = SCE_SNAP_MODE_NONE;
eSnapMode retval = SCE_SNAP_TO_NONE;
bool use_occlusion_test = params->use_occlusion_test;
if (use_occlusion_test && XRAY_ENABLED(v3d)) {
if (snap_to_flag != SCE_SNAP_MODE_FACE) {
if (snap_to_flag != SCE_SNAP_TO_FACE) {
/* In theory everything is visible in X-Ray except faces. */
snap_to_flag &= ~SCE_SNAP_MODE_FACE;
snap_to_flag &= ~SCE_SNAP_TO_FACE;
use_occlusion_test = false;
}
}
if (use_occlusion_test || (snap_to_flag & SCE_SNAP_MODE_FACE)) {
if (use_occlusion_test || (snap_to_flag & SCE_SNAP_TO_FACE)) {
if (!ED_view3d_win_to_ray_clipped_ex(depsgraph,
region,
v3d,
@ -1267,7 +1267,7 @@ eSnapMode ED_transform_snap_object_project_view3d_ex(SnapObjectContext *sctx,
sctx->runtime.ray_start,
true))
{
snap_to_flag &= ~SCE_SNAP_MODE_FACE;
snap_to_flag &= ~SCE_SNAP_TO_FACE;
use_occlusion_test = false;
}
}
@ -1297,17 +1297,17 @@ eSnapMode ED_transform_snap_object_project_view3d_ex(SnapObjectContext *sctx,
snap_to_flag = sctx->runtime.snap_to_flag;
BLI_assert(snap_to_flag & (SCE_SNAP_MODE_GEOM | SCE_SNAP_MODE_FACE_NEAREST));
BLI_assert(snap_to_flag & (SCE_SNAP_TO_GEOM | SCE_SNAP_INDIVIDUAL_NEAREST));
bool has_hit = false;
/* NOTE: if both face ray-cast and face nearest are enabled, first find result of nearest, then
* override with ray-cast. */
if ((snap_to_flag & SCE_SNAP_MODE_FACE_NEAREST) && !has_hit) {
if ((snap_to_flag & SCE_SNAP_INDIVIDUAL_NEAREST) && !has_hit) {
has_hit = nearestWorldObjects(sctx);
if (has_hit) {
retval = SCE_SNAP_MODE_FACE_NEAREST;
retval = SCE_SNAP_INDIVIDUAL_NEAREST;
copy_v3_v3(r_loc, sctx->ret.loc);
if (r_no) {
@ -1325,7 +1325,7 @@ eSnapMode ED_transform_snap_object_project_view3d_ex(SnapObjectContext *sctx,
}
}
if ((snap_to_flag & SCE_SNAP_MODE_FACE) || sctx->runtime.params.use_occlusion_test) {
if ((snap_to_flag & SCE_SNAP_TO_FACE) || sctx->runtime.params.use_occlusion_test) {
has_hit = raycastObjects(sctx);
if (has_hit) {
@ -1333,8 +1333,8 @@ eSnapMode ED_transform_snap_object_project_view3d_ex(SnapObjectContext *sctx,
copy_v3_v3(r_face_nor, sctx->ret.no);
}
if (snap_to_flag & SCE_SNAP_MODE_FACE) {
retval = SCE_SNAP_MODE_FACE;
if (snap_to_flag & SCE_SNAP_TO_FACE) {
retval = SCE_SNAP_TO_FACE;
copy_v3_v3(r_loc, sctx->ret.loc);
if (r_no) {
@ -1353,15 +1353,15 @@ eSnapMode ED_transform_snap_object_project_view3d_ex(SnapObjectContext *sctx,
}
}
if (snap_to_flag & (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_EDGE_MIDPOINT |
SCE_SNAP_MODE_EDGE_PERPENDICULAR))
if (snap_to_flag & (SCE_SNAP_TO_VERTEX | SCE_SNAP_TO_EDGE | SCE_SNAP_TO_EDGE_MIDPOINT |
SCE_SNAP_TO_EDGE_PERPENDICULAR))
{
eSnapMode elem_test, elem = SCE_SNAP_MODE_NONE;
eSnapMode elem_test, elem = SCE_SNAP_TO_NONE;
/* First snap to edge instead of middle or perpendicular. */
sctx->runtime.snap_to_flag &= (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE);
if (snap_to_flag & (SCE_SNAP_MODE_EDGE_MIDPOINT | SCE_SNAP_MODE_EDGE_PERPENDICULAR)) {
sctx->runtime.snap_to_flag |= SCE_SNAP_MODE_EDGE;
sctx->runtime.snap_to_flag &= (SCE_SNAP_TO_VERTEX | SCE_SNAP_TO_EDGE);
if (snap_to_flag & (SCE_SNAP_TO_EDGE_MIDPOINT | SCE_SNAP_TO_EDGE_PERPENDICULAR)) {
sctx->runtime.snap_to_flag |= SCE_SNAP_TO_EDGE;
}
/* By convention we only snap to the original elements of a curve. */
@ -1398,9 +1398,9 @@ eSnapMode ED_transform_snap_object_project_view3d_ex(SnapObjectContext *sctx,
elem = elem_test;
}
if ((elem == SCE_SNAP_MODE_EDGE) &&
if ((elem == SCE_SNAP_TO_EDGE) &&
(snap_to_flag &
(SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE_MIDPOINT | SCE_SNAP_MODE_EDGE_PERPENDICULAR)))
(SCE_SNAP_TO_VERTEX | SCE_SNAP_TO_EDGE_MIDPOINT | SCE_SNAP_TO_EDGE_PERPENDICULAR)))
{
sctx->runtime.snap_to_flag = snap_to_flag;
elem = snap_edge_points(sctx, square_f(*dist_px));

12
source/blender/editors/transform/transform_snap_object_armature.cc
View File

@ -25,9 +25,9 @@ eSnapMode snapArmature(SnapObjectContext *sctx,
const float obmat[4][4],
bool is_object_active)
{
eSnapMode retval = SCE_SNAP_MODE_NONE;
eSnapMode retval = SCE_SNAP_TO_NONE;
if (sctx->runtime.snap_to_flag == SCE_SNAP_MODE_FACE) {
if (sctx->runtime.snap_to_flag == SCE_SNAP_TO_FACE) {
/* Currently only edge and vert. */
return retval;
}
@ -95,16 +95,16 @@ eSnapMode snapArmature(SnapObjectContext *sctx,
}
if (nearest2d.nearest_point.index != -2) {
retval = sctx->runtime.snap_to_flag & SCE_SNAP_MODE_EDGE;
if (retval == SCE_SNAP_MODE_NONE) {
retval = sctx->runtime.snap_to_flag & SCE_SNAP_TO_EDGE;
if (retval == SCE_SNAP_TO_NONE) {
nearest2d.nearest_point.index = -2;
}
if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX) {
if (sctx->runtime.snap_to_flag & SCE_SNAP_TO_VERTEX) {
float dist_px_sq_edge = nearest2d.nearest_point.dist_sq;
nearest2d.nearest_point.dist_sq = sctx->ret.dist_px_sq;
if (nearest2d.snap_point(head_vec) || nearest2d.snap_point(tail_vec)) {
retval = SCE_SNAP_MODE_VERTEX;
retval = SCE_SNAP_TO_VERTEX;
}
else if (retval) {
nearest2d.nearest_point.dist_sq = dist_px_sq_edge;

8
source/blender/editors/transform/transform_snap_object_camera.cc
View File

@ -23,9 +23,9 @@ eSnapMode snapCamera(SnapObjectContext *sctx,
const float obmat[4][4],
eSnapMode snap_to_flag)
{
eSnapMode retval = SCE_SNAP_MODE_NONE;
eSnapMode retval = SCE_SNAP_TO_NONE;
if (!(sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX)) {
if (!(sctx->runtime.snap_to_flag & SCE_SNAP_TO_VERTEX)) {
return retval;
}
@ -77,10 +77,10 @@ eSnapMode snapCamera(SnapObjectContext *sctx,
mul_m4_v3(vertex_obmat, bundle_pos);
if (nearest2d.snap_point(bundle_pos)) {
retval = SCE_SNAP_MODE_VERTEX;
retval = SCE_SNAP_TO_VERTEX;
}
}
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}

10
source/blender/editors/transform/transform_snap_object_curve.cc
View File

@ -27,8 +27,8 @@ eSnapMode snapCurve(SnapObjectContext *sctx, Object *ob_eval, const float obmat[
bool has_snap = false;
/* Only vertex snapping mode (eg control points and handles) supported for now). */
if ((sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX) == 0) {
return SCE_SNAP_MODE_NONE;
if ((sctx->runtime.snap_to_flag & SCE_SNAP_TO_VERTEX) == 0) {
return SCE_SNAP_TO_NONE;
}
Curve *cu = static_cast<Curve *>(ob_eval->data);
@ -41,7 +41,7 @@ eSnapMode snapCurve(SnapObjectContext *sctx, Object *ob_eval, const float obmat[
/* Test BoundBox */
BoundBox *bb = BKE_curve_boundbox_get(ob_eval);
if (bb && !nearest2d.snap_boundbox(bb->vec[0], bb->vec[6])) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
}
@ -52,7 +52,7 @@ eSnapMode snapCurve(SnapObjectContext *sctx, Object *ob_eval, const float obmat[
LISTBASE_FOREACH (Nurb *, nu, (use_obedit ? &cu->editnurb->nurbs : &cu->nurb)) {
for (int u = 0; u < nu->pntsu; u++) {
if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX) {
if (sctx->runtime.snap_to_flag & SCE_SNAP_TO_VERTEX) {
if (use_obedit) {
if (nu->bezt) {
if (nu->bezt[u].hide) {
@ -109,5 +109,5 @@ eSnapMode snapCurve(SnapObjectContext *sctx, Object *ob_eval, const float obmat[
}
}
return has_snap ? SCE_SNAP_MODE_VERTEX : SCE_SNAP_MODE_NONE;
return has_snap ? SCE_SNAP_TO_VERTEX : SCE_SNAP_TO_NONE;
}

56
source/blender/editors/transform/transform_snap_object_editmesh.cc
View File

@ -196,16 +196,16 @@ static BVHTreeFromEditMesh *snap_object_data_editmesh_treedata_get(SnapData_Edit
static eSnapMode editmesh_snap_mode_supported(BMEditMesh *em)
{
eSnapMode snap_mode_supported = SCE_SNAP_MODE_NONE;
eSnapMode snap_mode_supported = SCE_SNAP_TO_NONE;
if (em->bm->totface) {
snap_mode_supported |= SCE_SNAP_MODE_FACE | SCE_SNAP_MODE_FACE_NEAREST;
snap_mode_supported |= SCE_SNAP_TO_FACE | SCE_SNAP_INDIVIDUAL_NEAREST;
}
if (em->bm->totedge) {
snap_mode_supported |= SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_EDGE_MIDPOINT |
SCE_SNAP_MODE_EDGE_PERPENDICULAR;
snap_mode_supported |= SCE_SNAP_TO_EDGE | SCE_SNAP_TO_EDGE_MIDPOINT |
SCE_SNAP_TO_EDGE_PERPENDICULAR;
}
if (em->bm->totvert) {
snap_mode_supported |= SCE_SNAP_MODE_VERTEX;
snap_mode_supported |= SCE_SNAP_TO_VERTEX;
}
return snap_mode_supported;
}
@ -225,7 +225,7 @@ static SnapData_EditMesh *editmesh_snapdata_init(SnapObjectContext *sctx,
}
eSnapMode snap_mode_used = snap_to_flag & editmesh_snap_mode_supported(em);
if (snap_mode_used == SCE_SNAP_MODE_NONE) {
if (snap_mode_used == SCE_SNAP_TO_NONE) {
return nullptr;
}
@ -447,7 +447,7 @@ eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx,
eSnapMode snap_to_flag,
int polygon)
{
eSnapMode elem = SCE_SNAP_MODE_NONE;
eSnapMode elem = SCE_SNAP_TO_NONE;
BMEditMesh *em = BKE_editmesh_from_object(ob_eval);
Nearest2dUserData_EditMesh nearest2d(sctx, ob_eval, em->bm, float4x4(obmat));
@ -461,8 +461,8 @@ eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx,
BMFace *f = BM_face_at_index(em->bm, polygon);
BMLoop *l_iter, *l_first;
l_iter = l_first = BM_FACE_FIRST_LOOP(f);
if (snap_to_flag & SCE_SNAP_MODE_EDGE) {
elem = SCE_SNAP_MODE_EDGE;
if (snap_to_flag & SCE_SNAP_TO_EDGE) {
elem = SCE_SNAP_TO_EDGE;
BM_mesh_elem_index_ensure(em->bm, BM_VERT | BM_EDGE);
BM_mesh_elem_table_ensure(em->bm, BM_VERT | BM_EDGE);
do {
@ -475,7 +475,7 @@ eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx,
} while ((l_iter = l_iter->next) != l_first);
}
else {
elem = SCE_SNAP_MODE_VERTEX;
elem = SCE_SNAP_TO_VERTEX;
BM_mesh_elem_index_ensure(em->bm, BM_VERT);
BM_mesh_elem_table_ensure(em->bm, BM_VERT);
do {
@ -493,7 +493,7 @@ eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx,
return elem;
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
eSnapMode snap_edge_points_editmesh(SnapObjectContext *sctx,
@ -515,16 +515,16 @@ static eSnapMode snapEditMesh(SnapData_EditMesh *sod,
const float obmat[4][4],
eSnapMode snap_to_flag)
{
BLI_assert(snap_to_flag != SCE_SNAP_MODE_FACE);
BLI_assert(snap_to_flag != SCE_SNAP_TO_FACE);
Nearest2dUserData_EditMesh nearest2d(sctx, ob_eval, em->bm, float4x4(obmat));
/* Was BKE_boundbox_ray_hit_check, see: cf6ca226fa58. */
if (!nearest2d.snap_boundbox(sod->min, sod->max)) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
if (snap_to_flag & SCE_SNAP_MODE_VERTEX) {
if (snap_to_flag & SCE_SNAP_TO_VERTEX) {
BVHTreeFromEditMesh treedata{};
treedata.tree = sod->bvhtree[0];
@ -554,7 +554,7 @@ static eSnapMode snapEditMesh(SnapData_EditMesh *sod,
}
}
if (snap_to_flag & SCE_SNAP_MODE_EDGE) {
if (snap_to_flag & SCE_SNAP_TO_EDGE) {
BVHTreeFromEditMesh treedata{};
treedata.tree = sod->bvhtree[1];
@ -590,9 +590,9 @@ static eSnapMode snapEditMesh(SnapData_EditMesh *sod,
nearest.index = -1;
nearest.dist_sq = sctx->ret.dist_px_sq;
eSnapMode elem = SCE_SNAP_MODE_VERTEX;
eSnapMode elem = SCE_SNAP_TO_VERTEX;
if (sod->bvhtree[0] && (snap_to_flag & SCE_SNAP_MODE_VERTEX)) {
if (sod->bvhtree[0] && (snap_to_flag & SCE_SNAP_TO_VERTEX)) {
BM_mesh_elem_table_ensure(em->bm, BM_VERT);
BM_mesh_elem_index_ensure(em->bm, BM_VERT);
BLI_bvhtree_find_nearest_projected(sod->bvhtree[0],
@ -606,7 +606,7 @@ static eSnapMode snapEditMesh(SnapData_EditMesh *sod,
&nearest2d);
}
if (sod->bvhtree[1] && (snap_to_flag & SCE_SNAP_MODE_EDGE)) {
if (sod->bvhtree[1] && (snap_to_flag & SCE_SNAP_TO_EDGE)) {
int last_index = nearest.index;
nearest.index = -1;
BM_mesh_elem_table_ensure(em->bm, BM_EDGE | BM_VERT);
@ -622,7 +622,7 @@ static eSnapMode snapEditMesh(SnapData_EditMesh *sod,
&nearest2d);
if (nearest.index != -1) {
elem = SCE_SNAP_MODE_EDGE;
elem = SCE_SNAP_TO_EDGE;
}
else {
nearest.index = last_index;
@ -634,7 +634,7 @@ static eSnapMode snapEditMesh(SnapData_EditMesh *sod,
return elem;
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
/** \} */
@ -646,7 +646,7 @@ eSnapMode snap_object_editmesh(SnapObjectContext *sctx,
eSnapMode snap_to_flag,
bool /*use_hide*/)
{
eSnapMode elem = SCE_SNAP_MODE_NONE;
eSnapMode elem = SCE_SNAP_TO_NONE;
SnapData_EditMesh *sod = editmesh_snapdata_init(sctx, ob_eval, snap_to_flag);
if (sod == nullptr) {
@ -656,8 +656,8 @@ eSnapMode snap_object_editmesh(SnapObjectContext *sctx,
BMEditMesh *em = sod->treedata_editmesh.em;
eSnapMode snap_mode_used = snap_to_flag & editmesh_snap_mode_supported(em);
if (snap_mode_used & (SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_EDGE_MIDPOINT |
SCE_SNAP_MODE_EDGE_PERPENDICULAR | SCE_SNAP_MODE_VERTEX))
if (snap_mode_used & (SCE_SNAP_TO_EDGE | SCE_SNAP_TO_EDGE_MIDPOINT |
SCE_SNAP_TO_EDGE_PERPENDICULAR | SCE_SNAP_TO_VERTEX))
{
elem = snapEditMesh(sod, sctx, ob_eval, em, obmat, snap_to_flag);
if (elem) {
@ -665,17 +665,17 @@ eSnapMode snap_object_editmesh(SnapObjectContext *sctx,
}
}
if (snap_mode_used & SCE_SNAP_MODE_FACE) {
if (snap_mode_used & SCE_SNAP_TO_FACE) {
if (raycastEditMesh(sod, sctx, em, obmat, sctx->runtime.object_index++)) {
return SCE_SNAP_MODE_FACE;
return SCE_SNAP_TO_FACE;
}
}
if (snap_mode_used & SCE_SNAP_MODE_FACE_NEAREST) {
if (snap_mode_used & SCE_SNAP_INDIVIDUAL_NEAREST) {
if (nearest_world_editmesh(sod, sctx, em, obmat)) {
return SCE_SNAP_MODE_FACE_NEAREST;
return SCE_SNAP_INDIVIDUAL_NEAREST;
}
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}

60
source/blender/editors/transform/transform_snap_object_mesh.cc
View File

@ -408,7 +408,7 @@ eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
eSnapMode snap_to_flag,
int polygon)
{
eSnapMode elem = SCE_SNAP_MODE_NONE;
eSnapMode elem = SCE_SNAP_TO_NONE;
const Mesh *mesh_eval = reinterpret_cast<const Mesh *>(id);
@ -421,8 +421,8 @@ eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
const blender::IndexRange poly = mesh_eval->polys()[polygon];
if (snap_to_flag & SCE_SNAP_MODE_EDGE) {
elem = SCE_SNAP_MODE_EDGE;
if (snap_to_flag & SCE_SNAP_TO_EDGE) {
elem = SCE_SNAP_TO_EDGE;
BLI_assert(nearest2d.edges != nullptr);
const int *poly_edges = &nearest2d.corner_edges[poly.start()];
for (int i = poly.size(); i--;) {
@ -435,7 +435,7 @@ eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
}
}
else {
elem = SCE_SNAP_MODE_VERTEX;
elem = SCE_SNAP_TO_VERTEX;
const int *poly_verts = &nearest2d.corner_verts[poly.start()];
for (int i = poly.size(); i--;) {
cb_snap_vert(&nearest2d,
@ -452,7 +452,7 @@ eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
return elem;
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
eSnapMode snap_edge_points_mesh(SnapObjectContext *sctx,
@ -472,12 +472,12 @@ static eSnapMode snapMesh(SnapObjectContext *sctx,
const float obmat[4][4],
bool use_hide)
{
BLI_assert(sctx->runtime.snap_to_flag != SCE_SNAP_MODE_FACE);
BLI_assert(sctx->runtime.snap_to_flag != SCE_SNAP_TO_FACE);
if (me_eval->totvert == 0) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
if (me_eval->totedge == 0 && !(sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX)) {
return SCE_SNAP_MODE_NONE;
if (me_eval->totedge == 0 && !(sctx->runtime.snap_to_flag & SCE_SNAP_TO_VERTEX)) {
return SCE_SNAP_TO_NONE;
}
Nearest2dUserData_Mesh nearest2d(sctx, ob_eval, &me_eval->id, float4x4(obmat));
@ -485,7 +485,7 @@ static eSnapMode snapMesh(SnapObjectContext *sctx,
if (ob_eval->data == me_eval) {
const BoundBox *bb = BKE_mesh_boundbox_get(ob_eval);
if (!nearest2d.snap_boundbox(bb->vec[0], bb->vec[6])) {
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
}
@ -495,7 +495,7 @@ static eSnapMode snapMesh(SnapObjectContext *sctx,
BVHTree *bvhtree[2] = {nullptr};
bvhtree[0] = BKE_bvhtree_from_mesh_get(&treedata_dummy, me_eval, BVHTREE_FROM_LOOSEEDGES, 2);
BLI_assert(treedata_dummy.cached);
if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX) {
if (sctx->runtime.snap_to_flag & SCE_SNAP_TO_VERTEX) {
bvhtree[1] = BKE_bvhtree_from_mesh_get(&treedata_dummy, me_eval, BVHTREE_FROM_LOOSEVERTS, 2);
BLI_assert(treedata_dummy.cached);
}
@ -507,10 +507,10 @@ static eSnapMode snapMesh(SnapObjectContext *sctx,
nearest.dist_sq = sctx->ret.dist_px_sq;
int last_index = nearest.index;
eSnapMode elem = SCE_SNAP_MODE_VERTEX;
eSnapMode elem = SCE_SNAP_TO_VERTEX;
if (bvhtree[1]) {
BLI_assert(sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX);
BLI_assert(sctx->runtime.snap_to_flag & SCE_SNAP_TO_VERTEX);
/* snap to loose verts */
BLI_bvhtree_find_nearest_projected(bvhtree[1],
nearest2d.pmat_local.ptr(),
@ -525,7 +525,7 @@ static eSnapMode snapMesh(SnapObjectContext *sctx,
last_index = nearest.index;
}
if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_EDGE) {
if (sctx->runtime.snap_to_flag & SCE_SNAP_TO_EDGE) {
if (bvhtree[0]) {
/* Snap to loose edges. */
BLI_bvhtree_find_nearest_projected(
@ -555,11 +555,11 @@ static eSnapMode snapMesh(SnapObjectContext *sctx,
}
if (last_index != nearest.index) {
elem = SCE_SNAP_MODE_EDGE;
elem = SCE_SNAP_TO_EDGE;
}
}
else {
BLI_assert(sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX);
BLI_assert(sctx->runtime.snap_to_flag & SCE_SNAP_TO_VERTEX);
if (bvhtree[0]) {
/* Snap to loose edge verts. */
BLI_bvhtree_find_nearest_projected(
@ -594,23 +594,23 @@ static eSnapMode snapMesh(SnapObjectContext *sctx,
return elem;
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}
/** \} */
static eSnapMode mesh_snap_mode_supported(const Mesh *mesh)
{
eSnapMode snap_mode_supported = SCE_SNAP_MODE_NONE;
eSnapMode snap_mode_supported = SCE_SNAP_TO_NONE;
if (mesh->totpoly) {
snap_mode_supported |= SCE_SNAP_MODE_FACE | SCE_SNAP_MODE_FACE_NEAREST;
snap_mode_supported |= SCE_SNAP_TO_FACE | SCE_SNAP_INDIVIDUAL_NEAREST;
}
if (mesh->totedge) {
snap_mode_supported |= SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_EDGE_MIDPOINT |
SCE_SNAP_MODE_EDGE_PERPENDICULAR;
snap_mode_supported |= SCE_SNAP_TO_EDGE | SCE_SNAP_TO_EDGE_MIDPOINT |
SCE_SNAP_TO_EDGE_PERPENDICULAR;
}
if (mesh->totvert) {
snap_mode_supported |= SCE_SNAP_MODE_VERTEX;
snap_mode_supported |= SCE_SNAP_TO_VERTEX;
}
return snap_mode_supported;
}
@ -622,13 +622,13 @@ eSnapMode snap_object_mesh(SnapObjectContext *sctx,
eSnapMode snap_to_flag,
bool use_hide)
{
eSnapMode elem = SCE_SNAP_MODE_NONE;
eSnapMode elem = SCE_SNAP_TO_NONE;
const Mesh *mesh_eval = reinterpret_cast<const Mesh *>(id);
eSnapMode snap_mode_used = snap_to_flag & mesh_snap_mode_supported(mesh_eval);
if (snap_mode_used & (SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_EDGE_MIDPOINT |
SCE_SNAP_MODE_EDGE_PERPENDICULAR | SCE_SNAP_MODE_VERTEX))
if (snap_mode_used & (SCE_SNAP_TO_EDGE | SCE_SNAP_TO_EDGE_MIDPOINT |
SCE_SNAP_TO_EDGE_PERPENDICULAR | SCE_SNAP_TO_VERTEX))
{
elem = snapMesh(sctx, ob_eval, mesh_eval, obmat, use_hide);
if (elem) {
@ -636,17 +636,17 @@ eSnapMode snap_object_mesh(SnapObjectContext *sctx,
}
}
if (snap_mode_used & SCE_SNAP_MODE_FACE) {
if (snap_mode_used & SCE_SNAP_TO_FACE) {
if (raycastMesh(sctx, ob_eval, mesh_eval, obmat, sctx->runtime.object_index++, use_hide)) {
return SCE_SNAP_MODE_FACE;
return SCE_SNAP_TO_FACE;
}
}
if (snap_mode_used & SCE_SNAP_MODE_FACE_NEAREST) {
if (snap_mode_used & SCE_SNAP_INDIVIDUAL_NEAREST) {
if (nearest_world_mesh(sctx, mesh_eval, obmat, use_hide)) {
return SCE_SNAP_MODE_FACE_NEAREST;
return SCE_SNAP_INDIVIDUAL_NEAREST;
}
}
return SCE_SNAP_MODE_NONE;
return SCE_SNAP_TO_NONE;
}

8
source/blender/makesdna/DNA_scene_defaults.h
View File

@ -336,9 +336,9 @@
.autokey_mode = AUTOKEY_MODE_NORMAL, \
\
.transform_pivot_point = V3D_AROUND_CENTER_MEDIAN, \
.snap_mode = SCE_SNAP_MODE_INCREMENT, \
.snap_node_mode = SCE_SNAP_MODE_GRID, \
.snap_uv_mode = SCE_SNAP_MODE_INCREMENT, \
.snap_mode = SCE_SNAP_TO_INCREMENT, \
.snap_node_mode = SCE_SNAP_TO_GRID, \
.snap_uv_mode = SCE_SNAP_TO_INCREMENT, \
.snap_flag = SCE_SNAP_TO_INCLUDE_EDITED | SCE_SNAP_TO_INCLUDE_NONEDITED, \
.snap_transform_mode_flag = SCE_SNAP_TRANSFORM_MODE_TRANSLATE, \
.snap_face_nearest_steps = 1, \
@ -370,7 +370,7 @@
.uv_relax_method = UV_SCULPT_TOOL_RELAX_LAPLACIAN, \
\
/* Placement */ \
.snap_mode_tools = SCE_SNAP_MODE_GEOM,\
.snap_mode_tools = SCE_SNAP_TO_GEOM,\
.plane_axis = 2,\
}

44
source/blender/makesdna/DNA_scene_types.h
View File

@ -1697,7 +1697,7 @@ typedef struct ToolSettings {
struct SequencerToolSettings *sequencer_tool_settings;
short snap_mode_tools; /* If SCE_SNAP_MODE_NONE, use #ToolSettings::snap_mode. #eSnapMode. */
short snap_mode_tools; /* If SCE_SNAP_TO_NONE, use #ToolSettings::snap_mode. #eSnapMode. */
char plane_axis; /* X, Y or Z. */
char plane_depth; /* #eV3DPlaceDepth. */
char plane_orient; /* #eV3DPlaceOrient. */
@ -2254,7 +2254,7 @@ typedef enum eSnapFlag {
SCE_SNAP = (1 << 0),
SCE_SNAP_ROTATE = (1 << 1),
SCE_SNAP_PEEL_OBJECT = (1 << 2),
// SCE_SNAP_PROJECT = (1 << 3), /* DEPRECATED, see #SCE_SNAP_MODE_FACE_RAYCAST. */
// SCE_SNAP_PROJECT = (1 << 3), /* DEPRECATED, see #SCE_SNAP_INDIVIDUAL_PROJECT. */
/** Was `SCE_SNAP_NO_SELF`, but self should be active. */
SCE_SNAP_NOT_TO_ACTIVE = (1 << 4),
SCE_SNAP_ABS_GRID = (1 << 5),
@ -2298,37 +2298,35 @@ ENUM_OPERATORS(eSnapTargetOP, SCE_SNAP_TARGET_NOT_NONEDITED)
/** #ToolSettings.snap_mode */
typedef enum eSnapMode {
SCE_SNAP_MODE_NONE = 0,
SCE_SNAP_MODE_VERTEX = (1 << 0),
SCE_SNAP_MODE_EDGE = (1 << 1),
SCE_SNAP_MODE_FACE = (1 << 2),
SCE_SNAP_MODE_VOLUME = (1 << 3),
SCE_SNAP_MODE_EDGE_MIDPOINT = (1 << 4),
SCE_SNAP_MODE_EDGE_PERPENDICULAR = (1 << 5),
/* For snap individual elements. */
SCE_SNAP_MODE_FACE_NEAREST = (1 << 8),
/** Project individual elements instead of whole object. */
SCE_SNAP_MODE_FACE_RAYCAST = (1 << 9),
SCE_SNAP_TO_NONE = 0,
/** #ToolSettings.snap_node_mode */
SCE_SNAP_MODE_NODE_X = (1 << 0),
SCE_SNAP_MODE_NODE_Y = (1 << 1),
SCE_SNAP_TO_NODE_X = (1 << 0),
SCE_SNAP_TO_NODE_Y = (1 << 1),
/** #ToolSettings.snap_mode and #ToolSettings.snap_node_mode and #ToolSettings.snap_uv_mode */
SCE_SNAP_MODE_INCREMENT = (1 << 6),
SCE_SNAP_MODE_GRID = (1 << 7),
SCE_SNAP_TO_VERTEX = (1 << 0),
SCE_SNAP_TO_EDGE = (1 << 1),
SCE_SNAP_TO_FACE = (1 << 2),
SCE_SNAP_TO_VOLUME = (1 << 3),
SCE_SNAP_TO_EDGE_MIDPOINT = (1 << 4),
SCE_SNAP_TO_EDGE_PERPENDICULAR = (1 << 5),
SCE_SNAP_TO_INCREMENT = (1 << 6),
SCE_SNAP_TO_GRID = (1 << 7),
/** For snap individual elements. */
SCE_SNAP_INDIVIDUAL_NEAREST = (1 << 8),
SCE_SNAP_INDIVIDUAL_PROJECT = (1 << 9),
} eSnapMode;
/* Due to dependency conflicts with Cycles, header cannot directly include `BLI_utildefines.h`. */
/* TODO: move this macro to a more general place. */
#ifdef ENUM_OPERATORS
ENUM_OPERATORS(eSnapMode, SCE_SNAP_MODE_FACE_RAYCAST)
ENUM_OPERATORS(eSnapMode, SCE_SNAP_INDIVIDUAL_PROJECT)
#endif
#define SCE_SNAP_MODE_GEOM \
(SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE | \
SCE_SNAP_MODE_EDGE_PERPENDICULAR | SCE_SNAP_MODE_EDGE_MIDPOINT)
#define SCE_SNAP_TO_GEOM \
(SCE_SNAP_TO_VERTEX | SCE_SNAP_TO_EDGE | SCE_SNAP_TO_FACE | SCE_SNAP_TO_EDGE_PERPENDICULAR | \
SCE_SNAP_TO_EDGE_MIDPOINT)
/** #SequencerToolSettings.snap_mode */
#define SEQ_SNAP_TO_STRIPS (1 << 0)

36
source/blender/makesrna/intern/rna_scene.c
View File

@ -153,23 +153,23 @@ const EnumPropertyItem rna_enum_mesh_select_mode_uv_items[] = {
/* clang-format off */
#define RNA_SNAP_ELEMENTS_BASE \
{SCE_SNAP_MODE_INCREMENT, "INCREMENT", ICON_SNAP_INCREMENT, "Increment", "Snap to increments"}, \
{SCE_SNAP_MODE_VERTEX, "VERTEX", ICON_SNAP_VERTEX, "Vertex", "Snap to vertices"}, \
{SCE_SNAP_MODE_EDGE, "EDGE", ICON_SNAP_EDGE, "Edge", "Snap to edges"}, \
{SCE_SNAP_MODE_FACE, "FACE", ICON_SNAP_FACE, "Face", "Snap by projecting onto faces"}, \
{SCE_SNAP_MODE_VOLUME, "VOLUME", ICON_SNAP_VOLUME, "Volume", "Snap to volume"}, \
{SCE_SNAP_MODE_EDGE_MIDPOINT, "EDGE_MIDPOINT", ICON_SNAP_MIDPOINT, "Edge Center", "Snap to the middle of edges"}, \
{SCE_SNAP_MODE_EDGE_PERPENDICULAR, "EDGE_PERPENDICULAR", ICON_SNAP_PERPENDICULAR, "Edge Perpendicular", "Snap to the nearest point on an edge"}
{SCE_SNAP_TO_INCREMENT, "INCREMENT", ICON_SNAP_INCREMENT, "Increment", "Snap to increments"}, \
{SCE_SNAP_TO_VERTEX, "VERTEX", ICON_SNAP_VERTEX, "Vertex", "Snap to vertices"}, \
{SCE_SNAP_TO_EDGE, "EDGE", ICON_SNAP_EDGE, "Edge", "Snap to edges"}, \
{SCE_SNAP_TO_FACE, "FACE", ICON_SNAP_FACE, "Face", "Snap by projecting onto faces"}, \
{SCE_SNAP_TO_VOLUME, "VOLUME", ICON_SNAP_VOLUME, "Volume", "Snap to volume"}, \
{SCE_SNAP_TO_EDGE_MIDPOINT, "EDGE_MIDPOINT", ICON_SNAP_MIDPOINT, "Edge Center", "Snap to the middle of edges"}, \
{SCE_SNAP_TO_EDGE_PERPENDICULAR, "EDGE_PERPENDICULAR", ICON_SNAP_PERPENDICULAR, "Edge Perpendicular", "Snap to the nearest point on an edge"}
/* clang-format on */
const EnumPropertyItem rna_enum_snap_element_items[] = {
RNA_SNAP_ELEMENTS_BASE,
{SCE_SNAP_MODE_FACE_RAYCAST,
{SCE_SNAP_INDIVIDUAL_PROJECT,
"FACE_PROJECT",
ICON_SNAP_FACE,
"Face Project",
"Snap by projecting onto faces"},
{SCE_SNAP_MODE_FACE_NEAREST,
{SCE_SNAP_INDIVIDUAL_NEAREST,
"FACE_NEAREST",
ICON_SNAP_FACE_NEAREST,
"Face Nearest",
@ -189,10 +189,10 @@ static const EnumPropertyItem *rna_enum_snap_element_individual_items =
#endif
const EnumPropertyItem rna_enum_snap_node_element_items[] = {
{SCE_SNAP_MODE_GRID, "GRID", ICON_SNAP_GRID, "Grid", "Snap to grid"},
{SCE_SNAP_MODE_NODE_X, "NODE_X", ICON_NODE_SIDE, "Node X", "Snap to left/right node border"},
{SCE_SNAP_MODE_NODE_Y, "NODE_Y", ICON_NODE_TOP, "Node Y", "Snap to top/bottom node border"},
{SCE_SNAP_MODE_NODE_X | SCE_SNAP_MODE_NODE_Y,
{SCE_SNAP_TO_GRID, "GRID", ICON_SNAP_GRID, "Grid", "Snap to grid"},
{SCE_SNAP_TO_NODE_X, "NODE_X", ICON_NODE_SIDE, "Node X", "Snap to left/right node border"},
{SCE_SNAP_TO_NODE_Y, "NODE_Y", ICON_NODE_TOP, "Node Y", "Snap to top/bottom node border"},
{SCE_SNAP_TO_NODE_X | SCE_SNAP_TO_NODE_Y,
"NODE_XY",
ICON_NODE_CORNER,
"Node X / Y",
@ -202,12 +202,12 @@ const EnumPropertyItem rna_enum_snap_node_element_items[] = {
#ifndef RNA_RUNTIME
static const EnumPropertyItem snap_uv_element_items[] = {
{SCE_SNAP_MODE_INCREMENT,
{SCE_SNAP_TO_INCREMENT,
"INCREMENT",
ICON_SNAP_INCREMENT,
"Increment",
"Snap to increments of grid"},
{SCE_SNAP_MODE_VERTEX, "VERTEX", ICON_SNAP_VERTEX, "Vertex", "Snap to vertices"},
{SCE_SNAP_TO_VERTEX, "VERTEX", ICON_SNAP_VERTEX, "Vertex", "Snap to vertices"},
{0, NULL, 0, NULL, NULL},
};
@ -679,8 +679,8 @@ static const EnumPropertyItem plane_orientation_items[] = {
};
static const EnumPropertyItem snap_to_items[] = {
{SCE_SNAP_MODE_GEOM, "GEOMETRY", 0, "Geometry", "Snap to all geometry"},
{SCE_SNAP_MODE_NONE, "DEFAULT", 0, "Default", "Use the current snap settings"},
{SCE_SNAP_TO_GEOM, "GEOMETRY", 0, "Geometry", "Snap to all geometry"},
{SCE_SNAP_TO_NONE, "DEFAULT", 0, "Default", "Use the current snap settings"},
{0, NULL, 0, NULL, NULL},
};
@ -3569,7 +3569,7 @@ static void rna_def_tool_settings(BlenderRNA *brna)
prop = RNA_def_property(srna, "snap_elements_tool", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "snap_mode_tools");
RNA_def_property_enum_items(prop, snap_to_items);
RNA_def_property_enum_default(prop, SCE_SNAP_MODE_GEOM);
RNA_def_property_enum_default(prop, SCE_SNAP_TO_GEOM);
RNA_def_property_ui_text(prop, "Snap to", "The target to use while snapping");
/* Grease Pencil */