blender
/
blender
135
403
Fork 586
Code Issues 6.2k Pull Requests 763 Projects 19 Wiki Activity

Cleanup: rename variables to distinguish between target and source 

From --> To

**Struct Members:**
|snapTarget|snap_source
|snapPoint|snap_target
|snapTargetGrid|snap_target_grid
|calcSnap|snap_target_fn
|targetSnap|snap_source_fn
|applySnap|snap_mode_apply_fn
|distance|snap_mode_distance_fn
|source_select|source_operation
|target_select|target_operation

**Functions:**
|snap_calc_view3d_fn|snap_target_view3d_fn
|snap_calc_uv_fn|snap_target_uv_fn
|snap_calc_node_fn|snap_target_node_fn
|snap_calc_sequencer_fn|snap_target_sequencer_fn
|TargetSnapMedian|snap_source_median_fn
|TargetSnapCenter|snap_source_center_fn
|TargetSnapClosest|snap_source_closest_fn
|TargetSnapActive|snap_source_active_fn

**Enums:**
|TARGET_INIT|SNAP_SOURCE_FOUND
|TARGET_GRID_INIT|SNAP_TARGET_GRID_FOUND
|POINT_INIT|SNAP_TARGET_FOUND
|MULTI_POINTS|SNAP_MULTI_POINTS

**Types:**
|eSnapSourceSelect|eSnapSourceOP
|eSnapTargetSelect|eSnapTargetOP

Also rename Select to Operation.

Reviewed By: campbellbarton

Differential Revision: https://developer.blender.org/D16967
This commit is contained in:
Germano Cavalcante 2023-01-12 10:16:25 -03:00 committed by Germano Cavalcante
parent 16fc928068
commit 589d1be147
15 changed files with 196 additions and 195 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/editors/include/ED_transform_snap_object_context.h
View File

@ -53,7 +53,7 @@ struct SnapObjectHitDepth {
/** parameters that define which objects will be used to snap. */
struct SnapObjectParams {
/* Special context sensitive handling for the active or selected object. */
eSnapTargetSelect snap_target_select;
eSnapTargetOP snap_target_select;
/* Geometry for snapping in edit mode. */
eSnapEditType edit_mode_type;
/* snap to the closest element, use when using more than one snap type */

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

@ -1573,9 +1573,9 @@ 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.project);
RNA_enum_set(op->ptr, "snap_target", t->tsnap.source_select);
RNA_enum_set(op->ptr, "snap_target", t->tsnap.source_operation);
eSnapTargetSelect target = t->tsnap.target_select;
eSnapTargetOP target = t->tsnap.target_operation;
RNA_boolean_set(op->ptr, "use_snap_self", (target & SCE_SNAP_TARGET_NOT_ACTIVE) == 0);
RNA_boolean_set(op->ptr, "use_snap_edit", (target & SCE_SNAP_TARGET_NOT_EDITED) == 0);
RNA_boolean_set(op->ptr, "use_snap_nonedit", (target & SCE_SNAP_TARGET_NOT_NONEDITED) == 0);

28
source/blender/editors/transform/transform.h
View File

@ -160,13 +160,13 @@ ENUM_OPERATORS(eTModifier, MOD_NODE_ATTACH)
typedef enum eTSnap {
SNAP_RESETTED = 0,
SNAP_FORCED = 1 << 0,
TARGET_INIT = 1 << 1,
SNAP_SOURCE_FOUND = 1 << 1,
/* Special flag for snap to grid. */
TARGET_GRID_INIT = 1 << 2,
POINT_INIT = 1 << 3,
MULTI_POINTS = 1 << 4,
SNAP_TARGET_GRID_FOUND = 1 << 2,
SNAP_TARGET_FOUND = 1 << 3,
SNAP_MULTI_POINTS = 1 << 4,
} eTSnap;
ENUM_OPERATORS(eTSnap, MULTI_POINTS)
ENUM_OPERATORS(eTSnap, SNAP_MULTI_POINTS)
/** #TransCon.mode, #TransInfo.con.mode */
typedef enum {
@ -276,9 +276,9 @@ typedef struct TransSnap {
/* Method(s) used for snapping source to target */
eSnapMode mode;
/* Part of source to snap to target */
eSnapSourceSelect source_select;
eSnapSourceOP source_operation;
/* Determines which objects are possible target */
eSnapTargetSelect target_select;
eSnapTargetOP target_operation;
bool align;
bool project;
bool peel;
@ -288,25 +288,25 @@ typedef struct TransSnap {
/* Snapped Element Type (currently for objects only). */
eSnapMode snapElem;
/** snapping from this point (in global-space). */
float snapTarget[3];
float snap_source[3];
/** to this point (in global-space). */
float snapPoint[3];
float snapTargetGrid[3];
float snap_target[3];
float snap_target_grid[3];
float snapNormal[3];
char snapNodeBorder;
ListBase points;
TransSnapPoint *selectedPoint;
double last;
void (*applySnap)(struct TransInfo *, float *);
void (*calcSnap)(struct TransInfo *, float *);
void (*targetSnap)(struct TransInfo *);
void (*snap_target_fn)(struct TransInfo *, float *);
void (*snap_source_fn)(struct TransInfo *);
/**
* Get the transform distance between two points (used by Closest snap)
*
* \note Return value can be anything,
* where the smallest absolute value defines what's closest.
*/
float (*distance)(struct TransInfo *t, const float p1[3], const float p2[3]);
float (*snap_mode_distance_fn)(struct TransInfo *t, const float p1[3], const float p2[3]);
void (*snap_mode_apply_fn)(struct TransInfo *, float *);
/**
* Re-usable snap context data.

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

@ -270,12 +270,12 @@ static void axisProjection(const TransInfo *t,
static void constraint_snap_plane_to_edge(const TransInfo *t, const float plane[4], float r_out[3])
{
float lambda;
const float *edge_snap_point = t->tsnap.snapPoint;
const float *edge_snap_point = t->tsnap.snap_target;
const float *edge_dir = t->tsnap.snapNormal;
bool is_aligned = fabsf(dot_v3v3(edge_dir, plane)) < CONSTRAIN_EPSILON;
if (!is_aligned && isect_ray_plane_v3(edge_snap_point, edge_dir, plane, &lambda, false)) {
madd_v3_v3v3fl(r_out, edge_snap_point, edge_dir, lambda);
sub_v3_v3(r_out, t->tsnap.snapTarget);
sub_v3_v3(r_out, t->tsnap.snap_source);
}
}
@ -284,13 +284,13 @@ static void UNUSED_FUNCTION(constraint_snap_plane_to_face(const TransInfo *t,
float r_out[3]))
{
float face_plane[4], isect_orig[3], isect_dir[3];
const float *face_snap_point = t->tsnap.snapPoint;
const float *face_snap_point = t->tsnap.snap_target;
const float *face_normal = t->tsnap.snapNormal;
plane_from_point_normal_v3(face_plane, face_snap_point, face_normal);
bool is_aligned = fabsf(dot_v3v3(plane, face_plane)) > (1.0f - CONSTRAIN_EPSILON);
if (!is_aligned && isect_plane_plane_v3(plane, face_plane, isect_orig, isect_dir)) {
closest_to_ray_v3(r_out, face_snap_point, isect_orig, isect_dir);
sub_v3_v3(r_out, t->tsnap.snapTarget);
sub_v3_v3(r_out, t->tsnap.snap_source);
}
}
@ -299,11 +299,11 @@ void transform_constraint_snap_axis_to_edge(const TransInfo *t,
float r_out[3])
{
float lambda;
const float *edge_snap_point = t->tsnap.snapPoint;
const float *edge_snap_point = t->tsnap.snap_target;
const float *edge_dir = t->tsnap.snapNormal;
bool is_aligned = fabsf(dot_v3v3(axis, edge_dir)) > (1.0f - CONSTRAIN_EPSILON);
if (!is_aligned &&
isect_ray_ray_v3(t->tsnap.snapTarget, axis, edge_snap_point, edge_dir, &lambda, NULL)) {
isect_ray_ray_v3(t->tsnap.snap_source, axis, edge_snap_point, edge_dir, &lambda, NULL)) {
mul_v3_v3fl(r_out, axis, lambda);
}
}
@ -314,11 +314,11 @@ void transform_constraint_snap_axis_to_face(const TransInfo *t,
{
float lambda;
float face_plane[4];
const float *face_snap_point = t->tsnap.snapPoint;
const float *face_snap_point = t->tsnap.snap_target;
const float *face_normal = t->tsnap.snapNormal;
plane_from_point_normal_v3(face_plane, face_snap_point, face_normal);
bool is_aligned = fabsf(dot_v3v3(axis, face_plane)) < CONSTRAIN_EPSILON;
if (!is_aligned && isect_ray_plane_v3(t->tsnap.snapTarget, axis, face_plane, &lambda, false)) {
if (!is_aligned && isect_ray_plane_v3(t->tsnap.snap_source, axis, face_plane, &lambda, false)) {
mul_v3_v3fl(r_out, axis, lambda);
}
}

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

@ -110,7 +110,7 @@ static void applySeqSlide(TransInfo *t, const int UNUSED(mval[2]))
void initSeqSlide(TransInfo *t)
{
t->transform = applySeqSlide;
t->tsnap.applySnap = transform_snap_sequencer_apply_translate;
t->tsnap.snap_mode_apply_fn = transform_snap_sequencer_apply_translate;
initMouseInputMode(t, &t->mouse, INPUT_VECTOR);

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

@ -1272,7 +1272,7 @@ static void edge_slide_snap_apply(TransInfo *t, float *value)
}
getSnapPoint(t, dvec);
sub_v3_v3(dvec, t->tsnap.snapTarget);
sub_v3_v3(dvec, t->tsnap.snap_source);
add_v3_v3v3(snap_point, co_orig, dvec);
float perc = *value;
@ -1498,8 +1498,8 @@ void initEdgeSlide_ex(
t->mode = TFM_EDGE_SLIDE;
t->transform = applyEdgeSlide;
t->handleEvent = handleEventEdgeSlide;
t->tsnap.applySnap = edge_slide_snap_apply;
t->tsnap.distance = transform_snap_distance_len_squared_fn;
t->tsnap.snap_mode_apply_fn = edge_slide_snap_apply;
t->tsnap.snap_mode_distance_fn = transform_snap_distance_len_squared_fn;
{
EdgeSlideParams *slp = MEM_callocN(sizeof(*slp), __func__);

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

@ -79,7 +79,7 @@ static void ApplySnapResize(TransInfo *t, float vec[3])
float point[3];
getSnapPoint(t, point);
float dist = ResizeBetween(t, t->tsnap.snapTarget, point);
float dist = ResizeBetween(t, t->tsnap.snap_source, point);
if (dist != TRANSFORM_DIST_INVALID) {
copy_v3_fl(vec, dist);
}
@ -287,8 +287,8 @@ void initResize(TransInfo *t, float mouse_dir_constraint[3])
{
t->mode = TFM_RESIZE;
t->transform = applyResize;
t->tsnap.applySnap = ApplySnapResize;
t->tsnap.distance = ResizeBetween;
t->tsnap.snap_mode_apply_fn = ApplySnapResize;
t->tsnap.snap_mode_distance_fn = ResizeBetween;
if (is_zero_v3(mouse_dir_constraint)) {
initMouseInputMode(t, &t->mouse, INPUT_SPRING_FLIP);

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

@ -219,7 +219,7 @@ static void ApplySnapRotation(TransInfo *t, float *value)
float point[3];
getSnapPoint(t, point);
float dist = RotationBetween(t, t->tsnap.snapTarget, point);
float dist = RotationBetween(t, t->tsnap.snap_source, point);
*value = dist;
}
@ -429,8 +429,8 @@ void initRotation(TransInfo *t)
t->mode = TFM_ROTATION;
t->transform = applyRotation;
t->transform_matrix = applyRotationMatrix;
t->tsnap.applySnap = ApplySnapRotation;
t->tsnap.distance = RotationBetween;
t->tsnap.snap_mode_apply_fn = ApplySnapRotation;
t->tsnap.snap_mode_distance_fn = RotationBetween;
initMouseInputMode(t, &t->mouse, INPUT_ANGLE);

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

@ -351,22 +351,22 @@ static void headerTranslation(TransInfo *t, const float vec[3], char str[UI_MAX_
static void translate_snap_target_grid_ensure(TransInfo *t)
{
/* Only need to calculate once. */
if ((t->tsnap.status & TARGET_GRID_INIT) == 0) {
if ((t->tsnap.status & SNAP_TARGET_GRID_FOUND) == 0) {
if (t->data_type == &TransConvertType_Cursor3D) {
/* Use a fallback when transforming the cursor.
* In this case the center is _not_ derived from the cursor which is being transformed. */
copy_v3_v3(t->tsnap.snapTargetGrid, TRANS_DATA_CONTAINER_FIRST_SINGLE(t)->data->iloc);
copy_v3_v3(t->tsnap.snap_target_grid, TRANS_DATA_CONTAINER_FIRST_SINGLE(t)->data->iloc);
}
else if (t->around == V3D_AROUND_CURSOR) {
/* Use a fallback for cursor selection,
* this isn't useful as a global center for absolute grid snapping
* since its not based on the position of the selection. */
tranform_snap_target_median_calc(t, t->tsnap.snapTargetGrid);
tranform_snap_target_median_calc(t, t->tsnap.snap_target_grid);
}
else {
copy_v3_v3(t->tsnap.snapTargetGrid, t->center_global);
copy_v3_v3(t->tsnap.snap_target_grid, t->center_global);
}
t->tsnap.status |= TARGET_GRID_INIT;
t->tsnap.status |= SNAP_TARGET_GRID_FOUND;
}
}
@ -378,7 +378,7 @@ static void translate_snap_grid_apply(TransInfo *t,
{
BLI_assert(max_index <= 2);
translate_snap_target_grid_ensure(t);
const float *center_global = t->tsnap.snapTargetGrid;
const float *center_global = t->tsnap.snap_target_grid;
const float *asp = t->aspect;
float in[3];
@ -440,10 +440,10 @@ static void ApplySnapTranslation(TransInfo *t, float vec[3])
if (t->spacetype == SPACE_NODE) {
char border = t->tsnap.snapNodeBorder;
if (border & (NODE_LEFT | NODE_RIGHT)) {
vec[0] = point[0] - t->tsnap.snapTarget[0];
vec[0] = point[0] - t->tsnap.snap_source[0];
}
if (border & (NODE_BOTTOM | NODE_TOP)) {
vec[1] = point[1] - t->tsnap.snapTarget[1];
vec[1] = point[1] - t->tsnap.snap_source[1];
}
}
else if (t->spacetype == SPACE_SEQ) {
@ -459,7 +459,7 @@ static void ApplySnapTranslation(TransInfo *t, float vec[3])
}
}
sub_v3_v3v3(vec, point, t->tsnap.snapTarget);
sub_v3_v3v3(vec, point, t->tsnap.snap_source);
}
}
@ -499,7 +499,7 @@ static void applyTranslationValue(TransInfo *t, const float vec[3])
FOREACH_TRANS_DATA_CONTAINER (t, tc) {
float pivot_local[3];
if (rotate_mode != TRANSLATE_ROTATE_OFF) {
copy_v3_v3(pivot_local, t->tsnap.snapTarget);
copy_v3_v3(pivot_local, t->tsnap.snap_source);
/* The pivot has to be in local-space (see T49494) */
if (tc->use_local_mat) {
mul_m4_v3(tc->imat, pivot_local);
@ -678,8 +678,8 @@ void initTranslation(TransInfo *t)
t->transform = applyTranslation;
t->transform_matrix = applyTranslationMatrix;
t->tsnap.applySnap = ApplySnapTranslation;
t->tsnap.distance = transform_snap_distance_len_squared_fn;
t->tsnap.snap_mode_apply_fn = ApplySnapTranslation;
t->tsnap.snap_mode_distance_fn = transform_snap_distance_len_squared_fn;
initMouseInputMode(t, &t->mouse, INPUT_VECTOR);

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

@ -532,7 +532,7 @@ static void vert_slide_snap_apply(TransInfo *t, float *value)
}
getSnapPoint(t, dvec);
sub_v3_v3(dvec, t->tsnap.snapTarget);
sub_v3_v3(dvec, t->tsnap.snap_source);
if (t->tsnap.snapElem & (SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_FACE_RAYCAST)) {
float co_dir[3];
sub_v3_v3v3(co_dir, co_curr_3d, co_orig_3d);
@ -610,8 +610,8 @@ void initVertSlide_ex(TransInfo *t, bool use_even, bool flipped, bool use_clamp)
t->mode = TFM_VERT_SLIDE;
t->transform = applyVertSlide;
t->handleEvent = handleEventVertSlide;
t->tsnap.applySnap = vert_slide_snap_apply;
t->tsnap.distance = transform_snap_distance_len_squared_fn;
t->tsnap.snap_mode_apply_fn = vert_slide_snap_apply;
t->tsnap.snap_mode_distance_fn = transform_snap_distance_len_squared_fn;
{
VertSlideParams *slp = MEM_callocN(sizeof(*slp), __func__);

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

@ -421,11 +421,11 @@ static int transform_modal(bContext *C, wmOperator *op, const wmEvent *event)
/* XXX, workaround: active needs to be calculated before transforming,
* since we're not reading from 'td->center' in this case. see: T40241 */
if (t->tsnap.source_select == SCE_SNAP_SOURCE_ACTIVE) {
if (t->tsnap.source_operation == SCE_SNAP_SOURCE_ACTIVE) {
/* In camera view, tsnap callback is not set
* (see #initSnappingMode() in transform_snap.c, and T40348). */
if (t->tsnap.targetSnap && ((t->tsnap.status & TARGET_INIT) == 0)) {
t->tsnap.targetSnap(t);
if (t->tsnap.snap_source_fn && ((t->tsnap.status & SNAP_SOURCE_FOUND) == 0)) {
t->tsnap.snap_source_fn(t);
}
}

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

@ -61,16 +61,15 @@ static bool doForceIncrementSnap(const TransInfo *t);
static void setSnappingCallback(TransInfo *t);
/* static void CalcSnapGrid(TransInfo *t, float *vec); */
static void snap_calc_view3d_fn(TransInfo *t, float *vec);
static void snap_calc_uv_fn(TransInfo *t, float *vec);
static void snap_calc_node_fn(TransInfo *t, float *vec);
static void snap_calc_sequencer_fn(TransInfo *t, float *vec);
static void snap_target_view3d_fn(TransInfo *t, float *vec);
static void snap_target_uv_fn(TransInfo *t, float *vec);
static void snap_target_node_fn(TransInfo *t, float *vec);
static void snap_target_sequencer_fn(TransInfo *t, float *vec);
static void TargetSnapMedian(TransInfo *t);
static void TargetSnapCenter(TransInfo *t);
static void TargetSnapClosest(TransInfo *t);
static void TargetSnapActive(TransInfo *t);
static void snap_source_median_fn(TransInfo *t);
static void snap_source_center_fn(TransInfo *t);
static void snap_source_closest_fn(TransInfo *t);
static void snap_source_active_fn(TransInfo *t);
/** \} */
@ -78,7 +77,7 @@ static void TargetSnapActive(TransInfo *t);
/** \name Implementations
* \{ */
static bool snapNodeTest(View2D *v2d, bNode *node, eSnapTargetSelect snap_target_select);
static bool snapNodeTest(View2D *v2d, bNode *node, eSnapTargetOP snap_target_select);
static NodeBorder snapNodeBorder(eSnapMode snap_node_mode);
#if 0
@ -115,8 +114,10 @@ static bool snap_use_backface_culling(const TransInfo *t)
bool validSnap(const TransInfo *t)
{
return (t->tsnap.status & (POINT_INIT | TARGET_INIT)) == (POINT_INIT | TARGET_INIT) ||
(t->tsnap.status & (MULTI_POINTS | TARGET_INIT)) == (MULTI_POINTS | TARGET_INIT);
return (t->tsnap.status & (SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND)) ==
(SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND) ||
(t->tsnap.status & (SNAP_MULTI_POINTS | SNAP_SOURCE_FOUND)) ==
(SNAP_MULTI_POINTS | SNAP_SOURCE_FOUND);
}
bool transform_snap_is_active(const TransInfo *t)
@ -156,10 +157,10 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
return;
}
bool draw_target = (t->spacetype == SPACE_VIEW3D) && (t->tsnap.status & TARGET_INIT) &&
bool draw_source = (t->spacetype == SPACE_VIEW3D) && (t->tsnap.status & SNAP_SOURCE_FOUND) &&
(t->tsnap.mode & SCE_SNAP_MODE_EDGE_PERPENDICULAR);
if (!(draw_target || validSnap(t))) {
if (!(draw_source || validSnap(t))) {
return;
}
@ -216,12 +217,12 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
normal = t->tsnap.snapNormal;
}
if (draw_target) {
loc_prev = t->tsnap.snapTarget;
if (draw_source) {
loc_prev = t->tsnap.snap_source;
}
if (validSnap(t)) {
loc_cur = t->tsnap.snapPoint;
loc_cur = t->tsnap.snap_target;
}
ED_view3d_cursor_snap_draw_util(
@ -234,8 +235,8 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
float x, y;
const float snap_point[2] = {
t->tsnap.snapPoint[0] / t->aspect[0],
t->tsnap.snapPoint[1] / t->aspect[1],
t->tsnap.snap_target[0] / t->aspect[0],
t->tsnap.snap_target[1] / t->aspect[1],
};
UI_view2d_view_to_region_fl(&t->region->v2d, UNPACK2(snap_point), &x, &y);
float radius = 2.5f * UI_GetThemeValuef(TH_VERTEX_SIZE) * U.pixelsize;
@ -274,11 +275,11 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
ED_node_draw_snap(&region->v2d, p->co, size, NodeBorder(0), pos);
}
if (t->tsnap.status & POINT_INIT) {
if (t->tsnap.status & SNAP_TARGET_FOUND) {
immUniformColor4ubv(activeCol);
ED_node_draw_snap(
&region->v2d, t->tsnap.snapPoint, size, NodeBorder(t->tsnap.snapNodeBorder), pos);
&region->v2d, t->tsnap.snap_target, size, NodeBorder(t->tsnap.snapNodeBorder), pos);
}
immUnbindProgram();
@ -293,9 +294,9 @@ void drawSnapping(const struct bContext *C, TransInfo *t)
immUniformColor4ubv(col);
float pixelx = BLI_rctf_size_x(&region->v2d.cur) / BLI_rcti_size_x(&region->v2d.mask);
immRectf(pos,
t->tsnap.snapPoint[0] - pixelx,
t->tsnap.snap_target[0] - pixelx,
region->v2d.cur.ymax,
t->tsnap.snapPoint[0] + pixelx,
t->tsnap.snap_target[0] + pixelx,
region->v2d.cur.ymin);
immUnbindProgram();
GPU_blend(GPU_BLEND_NONE);
@ -346,7 +347,7 @@ static bool applyFaceProject(TransInfo *t, TransDataContainer *tc, TransData *td
}
SnapObjectParams snap_object_params{};
snap_object_params.snap_target_select = t->tsnap.target_select;
snap_object_params.snap_target_select = t->tsnap.target_operation;
snap_object_params.edit_mode_type = (t->flag & T_EDIT) != 0 ? SNAP_GEOM_EDIT : SNAP_GEOM_FINAL;
snap_object_params.use_occlusion_test = false;
snap_object_params.use_backface_culling = t->tsnap.use_backface_culling;
@ -413,7 +414,7 @@ static void applyFaceNearest(TransInfo *t, TransDataContainer *tc, TransData *td
}
SnapObjectParams snap_object_params{};
snap_object_params.snap_target_select = t->tsnap.target_select;
snap_object_params.snap_target_select = t->tsnap.target_operation;
snap_object_params.edit_mode_type = (t->flag & T_EDIT) != 0 ? SNAP_GEOM_EDIT : SNAP_GEOM_FINAL;
snap_object_params.use_occlusion_test = false;
snap_object_params.use_backface_culling = false;
@ -525,9 +526,9 @@ void transform_snap_mixed_apply(TransInfo *t, float *vec)
}
if (t->tsnap.status & SNAP_FORCED) {
t->tsnap.targetSnap(t);
t->tsnap.snap_source_fn(t);
t->tsnap.applySnap(t, vec);
t->tsnap.snap_mode_apply_fn(t, vec);
}
else if (((t->tsnap.mode & ~(SCE_SNAP_MODE_INCREMENT | SCE_SNAP_MODE_GRID)) != 0) &&
transform_snap_is_active(t)) {
@ -536,18 +537,18 @@ void transform_snap_mixed_apply(TransInfo *t, float *vec)
/* Time base quirky code to go around find-nearest slowness. */
/* TODO: add exception for object mode, no need to slow it down then. */
if (current - t->tsnap.last >= 0.01) {
if (t->tsnap.calcSnap) {
t->tsnap.calcSnap(t, vec);
if (t->tsnap.snap_target_fn) {
t->tsnap.snap_target_fn(t, vec);
}
if (t->tsnap.targetSnap) {
t->tsnap.targetSnap(t);
if (t->tsnap.snap_source_fn) {
t->tsnap.snap_source_fn(t);
}
t->tsnap.last = current;
}
if (validSnap(t)) {
t->tsnap.applySnap(t, vec);
t->tsnap.snap_mode_apply_fn(t, vec);
}
}
}
@ -559,8 +560,8 @@ void resetSnapping(TransInfo *t)
t->tsnap.align = false;
t->tsnap.project = false;
t->tsnap.mode = SCE_SNAP_MODE_NONE;
t->tsnap.target_select = SCE_SNAP_TARGET_ALL;
t->tsnap.source_select = SCE_SNAP_SOURCE_CLOSEST;
t->tsnap.target_operation = SCE_SNAP_TARGET_ALL;
t->tsnap.source_operation = SCE_SNAP_SOURCE_CLOSEST;
t->tsnap.last = 0;
t->tsnap.snapNormal[0] = 0;
@ -682,15 +683,15 @@ static eSnapMode snap_mode_from_spacetype(TransInfo *t)
return SCE_SNAP_MODE_INCREMENT;
}
static eSnapTargetSelect snap_target_select_from_spacetype(TransInfo *t)
static eSnapTargetOP snap_target_select_from_spacetype(TransInfo *t)
{
BKE_view_layer_synced_ensure(t->scene, t->view_layer);
Base *base_act = BKE_view_layer_active_base_get(t->view_layer);
eSnapTargetSelect ret = SCE_SNAP_TARGET_ALL;
eSnapTargetOP ret = SCE_SNAP_TARGET_ALL;
/* `t->tsnap.target_select` not initialized yet. */
BLI_assert(t->tsnap.target_select == SCE_SNAP_TARGET_ALL);
/* `t->tsnap.target_operation` not initialized yet. */
BLI_assert(t->tsnap.target_operation == SCE_SNAP_TARGET_ALL);
if (ELEM(t->spacetype, SPACE_VIEW3D, SPACE_IMAGE) && !(t->options & CTX_CAMERA)) {
if (base_act && (base_act->object->mode & OB_MODE_PARTICLE_EDIT)) {
@ -778,12 +779,12 @@ static void initSnappingMode(TransInfo *t)
void initSnapping(TransInfo *t, wmOperator *op)
{
ToolSettings *ts = t->settings;
eSnapSourceSelect snap_source = eSnapSourceSelect(ts->snap_target);
eSnapSourceOP snap_source = eSnapSourceOP(ts->snap_target);
resetSnapping(t);
t->tsnap.mode = snap_mode_from_spacetype(t);
t->tsnap.flag = snap_flag_from_spacetype(t);
t->tsnap.target_select = snap_target_select_from_spacetype(t);
t->tsnap.target_operation = snap_target_select_from_spacetype(t);
t->tsnap.face_nearest_steps = max_ii(ts->snap_face_nearest_steps, 1);
/* if snap property exists */
@ -803,13 +804,13 @@ void initSnapping(TransInfo *t, wmOperator *op)
* geometry is snapped). */
if ((prop = RNA_struct_find_property(op->ptr, "snap_target")) &&
RNA_property_is_set(op->ptr, prop)) {
snap_source = eSnapSourceSelect(RNA_property_enum_get(op->ptr, prop));
snap_source = eSnapSourceOP(RNA_property_enum_get(op->ptr, prop));
}
if ((prop = RNA_struct_find_property(op->ptr, "snap_point")) &&
RNA_property_is_set(op->ptr, prop)) {
RNA_property_float_get_array(op->ptr, prop, t->tsnap.snapPoint);
t->tsnap.status |= SNAP_FORCED | POINT_INIT;
RNA_property_float_get_array(op->ptr, prop, t->tsnap.snap_target);
t->tsnap.status |= SNAP_FORCED | SNAP_TARGET_FOUND;
}
/* snap align only defined in specific cases */
@ -828,28 +829,28 @@ void initSnapping(TransInfo *t, wmOperator *op)
/* use_snap_self is misnamed and should be use_snap_active */
if ((prop = RNA_struct_find_property(op->ptr, "use_snap_self")) &&
RNA_property_is_set(op->ptr, prop)) {
SET_FLAG_FROM_TEST(t->tsnap.target_select,
SET_FLAG_FROM_TEST(t->tsnap.target_operation,
!RNA_property_boolean_get(op->ptr, prop),
SCE_SNAP_TARGET_NOT_ACTIVE);
}
if ((prop = RNA_struct_find_property(op->ptr, "use_snap_edit")) &&
RNA_property_is_set(op->ptr, prop)) {
SET_FLAG_FROM_TEST(t->tsnap.target_select,
SET_FLAG_FROM_TEST(t->tsnap.target_operation,
!RNA_property_boolean_get(op->ptr, prop),
SCE_SNAP_TARGET_NOT_EDITED);
}
if ((prop = RNA_struct_find_property(op->ptr, "use_snap_nonedit")) &&
RNA_property_is_set(op->ptr, prop)) {
SET_FLAG_FROM_TEST(t->tsnap.target_select,
SET_FLAG_FROM_TEST(t->tsnap.target_operation,
!RNA_property_boolean_get(op->ptr, prop),
SCE_SNAP_TARGET_NOT_NONEDITED);
}
if ((prop = RNA_struct_find_property(op->ptr, "use_snap_selectable")) &&
RNA_property_is_set(op->ptr, prop)) {
SET_FLAG_FROM_TEST(t->tsnap.target_select,
SET_FLAG_FROM_TEST(t->tsnap.target_operation,
RNA_property_boolean_get(op->ptr, prop),
SCE_SNAP_TARGET_ONLY_SELECTABLE);
}
@ -864,21 +865,21 @@ void initSnapping(TransInfo *t, wmOperator *op)
t->tsnap.align = ((t->tsnap.flag & SCE_SNAP_ROTATE) != 0);
t->tsnap.project = ((t->tsnap.flag & SCE_SNAP_PROJECT) != 0);
t->tsnap.peel = ((t->tsnap.flag & SCE_SNAP_PROJECT) != 0);
SET_FLAG_FROM_TEST(t->tsnap.target_select,
SET_FLAG_FROM_TEST(t->tsnap.target_operation,
(ts->snap_flag & SCE_SNAP_NOT_TO_ACTIVE),
SCE_SNAP_TARGET_NOT_ACTIVE);
SET_FLAG_FROM_TEST(t->tsnap.target_select,
SET_FLAG_FROM_TEST(t->tsnap.target_operation,
!(ts->snap_flag & SCE_SNAP_TO_INCLUDE_EDITED),
SCE_SNAP_TARGET_NOT_EDITED);
SET_FLAG_FROM_TEST(t->tsnap.target_select,
SET_FLAG_FROM_TEST(t->tsnap.target_operation,
!(ts->snap_flag & SCE_SNAP_TO_INCLUDE_NONEDITED),
SCE_SNAP_TARGET_NOT_NONEDITED);
SET_FLAG_FROM_TEST(t->tsnap.target_select,
SET_FLAG_FROM_TEST(t->tsnap.target_operation,
(ts->snap_flag & SCE_SNAP_TO_ONLY_SELECTABLE),
SCE_SNAP_TARGET_ONLY_SELECTABLE);
}
t->tsnap.source_select = snap_source;
t->tsnap.source_operation = snap_source;
initSnappingMode(t);
}
@ -902,7 +903,7 @@ static void setSnappingCallback(TransInfo *t)
/* Not with camera selected in camera view. */
return;
}
t->tsnap.calcSnap = snap_calc_view3d_fn;
t->tsnap.snap_target_fn = snap_target_view3d_fn;
}
else if (t->spacetype == SPACE_IMAGE) {
SpaceImage *sima = static_cast<SpaceImage *>(t->area->spacedata.first);
@ -912,14 +913,14 @@ static void setSnappingCallback(TransInfo *t)
const bool is_uv_editor = sima->mode == SI_MODE_UV;
const bool has_edit_object = obact && BKE_object_is_in_editmode(obact);
if (is_uv_editor && has_edit_object) {
t->tsnap.calcSnap = snap_calc_uv_fn;
t->tsnap.snap_target_fn = snap_target_uv_fn;
}
}
else if (t->spacetype == SPACE_NODE) {
t->tsnap.calcSnap = snap_calc_node_fn;
t->tsnap.snap_target_fn = snap_target_node_fn;
}
else if (t->spacetype == SPACE_SEQ) {
t->tsnap.calcSnap = snap_calc_sequencer_fn;
t->tsnap.snap_target_fn = snap_target_sequencer_fn;
/* The target is calculated along with the snap point. */
return;
}
@ -927,23 +928,23 @@ static void setSnappingCallback(TransInfo *t)
return;
}
switch (t->tsnap.source_select) {
switch (t->tsnap.source_operation) {
case SCE_SNAP_SOURCE_CLOSEST:
t->tsnap.targetSnap = TargetSnapClosest;
t->tsnap.snap_source_fn = snap_source_closest_fn;
break;
case SCE_SNAP_SOURCE_CENTER:
if (!ELEM(t->mode, TFM_ROTATION, TFM_RESIZE)) {
t->tsnap.targetSnap = TargetSnapCenter;
t->tsnap.snap_source_fn = snap_source_center_fn;
break;
}
/* Can't do TARGET_CENTER with these modes,
* use TARGET_MEDIAN instead. */
ATTR_FALLTHROUGH;
case SCE_SNAP_SOURCE_MEDIAN:
t->tsnap.targetSnap = TargetSnapMedian;
t->tsnap.snap_source_fn = snap_source_median_fn;
break;
case SCE_SNAP_SOURCE_ACTIVE:
t->tsnap.targetSnap = TargetSnapActive;
t->tsnap.snap_source_fn = snap_source_active_fn;
break;
}
}
@ -951,16 +952,16 @@ static void setSnappingCallback(TransInfo *t)
void addSnapPoint(TransInfo *t)
{
/* Currently only 3D viewport works for snapping points. */
if (t->tsnap.status & POINT_INIT && t->spacetype == SPACE_VIEW3D) {
if (t->tsnap.status & SNAP_TARGET_FOUND && t->spacetype == SPACE_VIEW3D) {
TransSnapPoint *p = MEM_cnew<TransSnapPoint>("SnapPoint");
t->tsnap.selectedPoint = p;
copy_v3_v3(p->co, t->tsnap.snapPoint);
copy_v3_v3(p->co, t->tsnap.snap_target);
BLI_addtail(&t->tsnap.points, p);
t->tsnap.status |= MULTI_POINTS;
t->tsnap.status |= SNAP_MULTI_POINTS;
}
}
@ -968,7 +969,7 @@ eRedrawFlag updateSelectedSnapPoint(TransInfo *t)
{
eRedrawFlag status = TREDRAW_NOTHING;
if (t->tsnap.status & MULTI_POINTS) {
if (t->tsnap.status & SNAP_MULTI_POINTS) {
TransSnapPoint *p, *closest_p = nullptr;
float dist_min_sq = TRANSFORM_SNAP_MAX_PX;
const float mval_fl[2] = {float(t->mval[0]), float(t->mval[1])};
@ -1004,14 +1005,14 @@ eRedrawFlag updateSelectedSnapPoint(TransInfo *t)
void removeSnapPoint(TransInfo *t)
{
if (t->tsnap.status & MULTI_POINTS) {
if (t->tsnap.status & SNAP_MULTI_POINTS) {
updateSelectedSnapPoint(t);
if (t->tsnap.selectedPoint) {
BLI_freelinkN(&t->tsnap.points, t->tsnap.selectedPoint);
if (BLI_listbase_is_empty(&t->tsnap.points)) {
t->tsnap.status &= ~MULTI_POINTS;
t->tsnap.status &= ~SNAP_MULTI_POINTS;
}
t->tsnap.selectedPoint = nullptr;
@ -1031,15 +1032,15 @@ void getSnapPoint(const TransInfo *t, float vec[3])
add_v3_v3(vec, p->co);
}
if (t->tsnap.status & POINT_INIT) {
add_v3_v3(vec, t->tsnap.snapPoint);
if (t->tsnap.status & SNAP_TARGET_FOUND) {
add_v3_v3(vec, t->tsnap.snap_target);
total++;
}
mul_v3_fl(vec, 1.0f / total);
}
else {
copy_v3_v3(vec, t->tsnap.snapPoint);
copy_v3_v3(vec, t->tsnap.snap_target);
}
}
@ -1049,7 +1050,7 @@ void getSnapPoint(const TransInfo *t, float vec[3])
/** \name Calc Snap
* \{ */
static void snap_calc_view3d_fn(TransInfo *t, float * /*vec*/)
static void snap_target_view3d_fn(TransInfo *t, float * /*vec*/)
{
BLI_assert(t->spacetype == SPACE_VIEW3D);
float loc[3];
@ -1077,19 +1078,19 @@ static void snap_calc_view3d_fn(TransInfo *t, float * /*vec*/)
}
if (found == true) {
copy_v3_v3(t->tsnap.snapPoint, loc);
copy_v3_v3(t->tsnap.snap_target, loc);
copy_v3_v3(t->tsnap.snapNormal, no);
t->tsnap.status |= POINT_INIT;
t->tsnap.status |= SNAP_TARGET_FOUND;
}
else {
t->tsnap.status &= ~POINT_INIT;
t->tsnap.status &= ~SNAP_TARGET_FOUND;
}
t->tsnap.snapElem = snap_elem;
}
static void snap_calc_uv_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) {
@ -1103,22 +1104,22 @@ static void snap_calc_uv_fn(TransInfo *t, float * /*vec*/)
objects,
objects_len,
t->mval,
t->tsnap.target_select & SCE_SNAP_TARGET_NOT_SELECTED,
t->tsnap.target_operation & SCE_SNAP_TARGET_NOT_SELECTED,
&dist_sq,
t->tsnap.snapPoint)) {
t->tsnap.snapPoint[0] *= t->aspect[0];
t->tsnap.snapPoint[1] *= t->aspect[1];
t->tsnap.snap_target)) {
t->tsnap.snap_target[0] *= t->aspect[0];
t->tsnap.snap_target[1] *= t->aspect[1];
t->tsnap.status |= POINT_INIT;
t->tsnap.status |= SNAP_TARGET_FOUND;
}
else {
t->tsnap.status &= ~POINT_INIT;
t->tsnap.status &= ~SNAP_TARGET_FOUND;
}
MEM_freeN(objects);
}
}
static void snap_calc_node_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)) {
@ -1127,25 +1128,25 @@ static void snap_calc_node_fn(TransInfo *t, float * /*vec*/)
char node_border;
if (snapNodesTransform(t, t->mval, loc, &dist_px, &node_border)) {
copy_v2_v2(t->tsnap.snapPoint, loc);
copy_v2_v2(t->tsnap.snap_target, loc);
t->tsnap.snapNodeBorder = node_border;
t->tsnap.status |= POINT_INIT;
t->tsnap.status |= SNAP_TARGET_FOUND;
}
else {
t->tsnap.status &= ~POINT_INIT;
t->tsnap.status &= ~SNAP_TARGET_FOUND;
}
}
}
static void snap_calc_sequencer_fn(TransInfo *t, float * /*vec*/)
static void snap_target_sequencer_fn(TransInfo *t, float * /*vec*/)
{
BLI_assert(t->spacetype == SPACE_SEQ);
if (transform_snap_sequencer_calc(t)) {
t->tsnap.status |= (POINT_INIT | TARGET_INIT);
t->tsnap.status |= (SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
}
else {
t->tsnap.status &= ~(POINT_INIT | TARGET_INIT);
t->tsnap.status &= ~(SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
}
}
@ -1198,62 +1199,62 @@ static void TargetSnapOffset(TransInfo *t, TransData *td)
char border = t->tsnap.snapNodeBorder;
if (border & NODE_LEFT) {
t->tsnap.snapTarget[0] -= 0.0f;
t->tsnap.snap_source[0] -= 0.0f;
}
if (border & NODE_RIGHT) {
t->tsnap.snapTarget[0] += BLI_rctf_size_x(&node->runtime->totr);
t->tsnap.snap_source[0] += BLI_rctf_size_x(&node->runtime->totr);
}
if (border & NODE_BOTTOM) {
t->tsnap.snapTarget[1] -= BLI_rctf_size_y(&node->runtime->totr);
t->tsnap.snap_source[1] -= BLI_rctf_size_y(&node->runtime->totr);
}
if (border & NODE_TOP) {
t->tsnap.snapTarget[1] += 0.0f;
t->tsnap.snap_source[1] += 0.0f;
}
}
}
static void TargetSnapCenter(TransInfo *t)
static void snap_source_center_fn(TransInfo *t)
{
/* Only need to calculate once */
if ((t->tsnap.status & TARGET_INIT) == 0) {
copy_v3_v3(t->tsnap.snapTarget, t->center_global);
if ((t->tsnap.status & SNAP_SOURCE_FOUND) == 0) {
copy_v3_v3(t->tsnap.snap_source, t->center_global);
TargetSnapOffset(t, nullptr);
t->tsnap.status |= TARGET_INIT;
t->tsnap.status |= SNAP_SOURCE_FOUND;
}
}
static void TargetSnapActive(TransInfo *t)
static void snap_source_active_fn(TransInfo *t)
{
/* Only need to calculate once */
if ((t->tsnap.status & TARGET_INIT) == 0) {
if (calculateCenterActive(t, true, t->tsnap.snapTarget)) {
if ((t->tsnap.status & SNAP_SOURCE_FOUND) == 0) {
if (calculateCenterActive(t, true, t->tsnap.snap_source)) {
TargetSnapOffset(t, nullptr);
t->tsnap.status |= TARGET_INIT;
t->tsnap.status |= SNAP_SOURCE_FOUND;
}
/* No active, default to median */
else {
t->tsnap.source_select = SCE_SNAP_SOURCE_MEDIAN;
t->tsnap.targetSnap = TargetSnapMedian;
TargetSnapMedian(t);
t->tsnap.source_operation = SCE_SNAP_SOURCE_MEDIAN;
t->tsnap.snap_source_fn = snap_source_median_fn;
snap_source_median_fn(t);
}
}
}
static void TargetSnapMedian(TransInfo *t)
static void snap_source_median_fn(TransInfo *t)
{
/* Only need to calculate once. */
if ((t->tsnap.status & TARGET_INIT) == 0) {
tranform_snap_target_median_calc(t, t->tsnap.snapTarget);
t->tsnap.status |= TARGET_INIT;
if ((t->tsnap.status & SNAP_SOURCE_FOUND) == 0) {
tranform_snap_target_median_calc(t, t->tsnap.snap_source);
t->tsnap.status |= SNAP_SOURCE_FOUND;
}
}
static void TargetSnapClosest(TransInfo *t)
static void snap_source_closest_fn(TransInfo *t)
{
/* Only valid if a snap point has been selected. */
if (t->tsnap.status & POINT_INIT) {
if (t->tsnap.status & SNAP_TARGET_FOUND) {
float dist_closest = 0.0f;
TransData *closest = nullptr;
@ -1280,11 +1281,11 @@ static void TargetSnapClosest(TransInfo *t)
copy_v3_v3(loc, bb->vec[j]);
mul_m4_v3(td->ext->obmat, loc);
dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
dist = t->tsnap.snap_mode_distance_fn(t, loc, t->tsnap.snap_target);
if ((dist != TRANSFORM_DIST_INVALID) &&
(closest == nullptr || fabsf(dist) < fabsf(dist_closest))) {
copy_v3_v3(t->tsnap.snapTarget, loc);
copy_v3_v3(t->tsnap.snap_source, loc);
closest = td;
dist_closest = dist;
}
@ -1297,11 +1298,11 @@ static void TargetSnapClosest(TransInfo *t)
copy_v3_v3(loc, td->center);
dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
dist = t->tsnap.snap_mode_distance_fn(t, loc, t->tsnap.snap_target);
if ((dist != TRANSFORM_DIST_INVALID) &&
(closest == nullptr || fabsf(dist) < fabsf(dist_closest))) {
copy_v3_v3(t->tsnap.snapTarget, loc);
copy_v3_v3(t->tsnap.snap_source, loc);
closest = td;
}
}
@ -1322,11 +1323,11 @@ static void TargetSnapClosest(TransInfo *t)
mul_m4_v3(tc->mat, loc);
}
dist = t->tsnap.distance(t, loc, t->tsnap.snapPoint);
dist = t->tsnap.snap_mode_distance_fn(t, loc, t->tsnap.snap_target);
if ((dist != TRANSFORM_DIST_INVALID) &&
(closest == nullptr || fabsf(dist) < fabsf(dist_closest))) {
copy_v3_v3(t->tsnap.snapTarget, loc);
copy_v3_v3(t->tsnap.snap_source, loc);
closest = td;
dist_closest = dist;
}
@ -1336,7 +1337,7 @@ static void TargetSnapClosest(TransInfo *t)
TargetSnapOffset(t, closest);
t->tsnap.status |= TARGET_INIT;
t->tsnap.status |= SNAP_SOURCE_FOUND;
}
}
@ -1350,12 +1351,12 @@ eSnapMode snapObjectsTransform(
TransInfo *t, const float mval[2], float *dist_px, float r_loc[3], float r_no[3])
{
SnapObjectParams snap_object_params{};
snap_object_params.snap_target_select = t->tsnap.target_select;
snap_object_params.snap_target_select = t->tsnap.target_operation;
snap_object_params.edit_mode_type = (t->flag & T_EDIT) != 0 ? SNAP_GEOM_EDIT : SNAP_GEOM_FINAL;
snap_object_params.use_occlusion_test = t->settings->snap_mode != SCE_SNAP_MODE_FACE_RAYCAST;
snap_object_params.use_backface_culling = t->tsnap.use_backface_culling;
float *target = (t->tsnap.status & TARGET_INIT) ? t->tsnap.snapTarget : t->center_global;
float *target = (t->tsnap.status & SNAP_SOURCE_FOUND) ? t->tsnap.snap_source : t->center_global;
return ED_transform_snap_object_project_view3d(t->tsnap.object_context,
t->depsgraph,
t->region,
@ -1385,7 +1386,7 @@ bool peelObjectsTransform(TransInfo *t,
float *r_thickness)
{
SnapObjectParams snap_object_params{};
snap_object_params.snap_target_select = t->tsnap.target_select;
snap_object_params.snap_target_select = t->tsnap.target_operation;
snap_object_params.edit_mode_type = (t->flag & T_EDIT) != 0 ? SNAP_GEOM_EDIT : SNAP_GEOM_FINAL;
ListBase depths_peel = {nullptr};
@ -1461,7 +1462,7 @@ bool peelObjectsTransform(TransInfo *t,
/** \name snap Nodes
* \{ */
static bool snapNodeTest(View2D *v2d, bNode *node, eSnapTargetSelect snap_target_select)
static bool snapNodeTest(View2D *v2d, bNode *node, eSnapTargetOP snap_target_select)
{
/* node is use for snapping only if a) snap mode matches and b) node is inside the view */
return (((snap_target_select & SCE_SNAP_TARGET_NOT_SELECTED) && !(node->flag & NODE_SELECT)) ||
@ -1546,7 +1547,7 @@ static bool snapNodes(ToolSettings *ts,
SpaceNode *snode,
ARegion *region,
const int mval[2],
eSnapTargetSelect snap_target_select,
eSnapTargetOP snap_target_select,
float r_loc[2],
float *r_dist_px,
char *r_node_border)
@ -1573,7 +1574,7 @@ bool snapNodesTransform(
static_cast<SpaceNode *>(t->area->spacedata.first),
t->region,
mval,
t->tsnap.target_select,
t->tsnap.target_operation,
r_loc,
r_dist_px,
r_node_border);

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

@ -404,7 +404,7 @@ using IterSnapObjsCallback = eSnapMode (*)(SnapObjectContext *sctx,
void *data);
static bool snap_object_is_snappable(const SnapObjectContext *sctx,
const eSnapTargetSelect snap_target_select,
const eSnapTargetOP snap_target_select,
const Base *base_act,
const Base *base)
{
@ -471,7 +471,7 @@ static eSnapMode iter_snap_objects(SnapObjectContext *sctx,
Scene *scene = DEG_get_input_scene(sctx->runtime.depsgraph);
ViewLayer *view_layer = DEG_get_input_view_layer(sctx->runtime.depsgraph);
const eSnapTargetSelect snap_target_select = params->snap_target_select;
const eSnapTargetOP snap_target_select = params->snap_target_select;
BKE_view_layer_synced_ensure(scene, view_layer);
Base *base_act = BKE_view_layer_active_base_get(view_layer);

16
source/blender/editors/transform/transform_snap_sequencer.c
View File

@ -319,14 +319,14 @@ bool transform_snap_sequencer_calc(TransInfo *t)
return false;
}
t->tsnap.snapPoint[0] = best_target_frame;
t->tsnap.snapTarget[0] = best_source_frame;
t->tsnap.snap_target[0] = best_target_frame;
t->tsnap.snap_source[0] = best_source_frame;
return true;
}
void transform_snap_sequencer_apply_translate(TransInfo *t, float *vec)
{
*vec += t->tsnap.snapPoint[0] - t->tsnap.snapTarget[0];
*vec += t->tsnap.snap_target[0] - t->tsnap.snap_source[0];
}
static int transform_snap_sequencer_to_closest_strip_ex(TransInfo *t, int frame_1, int frame_2)
@ -357,11 +357,11 @@ static int transform_snap_sequencer_to_closest_strip_ex(TransInfo *t, int frame_
float snap_offset = 0;
if (snap_success) {
t->tsnap.status |= (POINT_INIT | TARGET_INIT);
t->tsnap.status |= (SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
transform_snap_sequencer_apply_translate(t, &snap_offset);
}
else {
t->tsnap.status &= ~(POINT_INIT | TARGET_INIT);
t->tsnap.status &= ~(SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
}
return snap_offset;
@ -382,7 +382,7 @@ bool ED_transform_snap_sequencer_to_closest_strip_calc(Scene *scene,
t.tsnap.mode = SEQ_tool_settings_snap_mode_get(scene);
*r_snap_distance = transform_snap_sequencer_to_closest_strip_ex(&t, frame_1, frame_2);
*r_snap_frame = t.tsnap.snapPoint[0];
*r_snap_frame = t.tsnap.snap_target[0];
return validSnap(&t);
}
@ -393,8 +393,8 @@ void ED_draw_sequencer_snap_point(struct bContext *C, float snap_point)
t.mode = TFM_SEQ_SLIDE;
t.modifiers = MOD_SNAP;
t.spacetype = SPACE_SEQ;
t.tsnap.status = (POINT_INIT | TARGET_INIT);
t.tsnap.snapPoint[0] = snap_point;
t.tsnap.status = (SNAP_TARGET_FOUND | SNAP_SOURCE_FOUND);
t.tsnap.snap_target[0] = snap_point;
drawSnapping(C, &t);
}

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

@ -1618,7 +1618,7 @@ typedef struct ToolSettings {
short snap_flag_node;
short snap_flag_seq;
short snap_uv_flag;
/** Default snap source, #eSnapSourceSelect. */
/** Default snap source, #eSnapSourceOP. */
/**
* TODO(@gfxcoder): Rename `snap_target` to `snap_source` to avoid previous ambiguity of
* "target" (now, "source" is geometry to be moved and "target" is geometry to which moved
@ -2244,7 +2244,7 @@ typedef enum eSnapFlag {
SCE_SNAP_ABS_GRID = (1 << 5),
SCE_SNAP_BACKFACE_CULLING = (1 << 6),
SCE_SNAP_KEEP_ON_SAME_OBJECT = (1 << 7),
/** see #eSnapTargetSelect */
/** see #eSnapTargetOP */
SCE_SNAP_TO_INCLUDE_EDITED = (1 << 8),
SCE_SNAP_TO_INCLUDE_NONEDITED = (1 << 9),
SCE_SNAP_TO_ONLY_SELECTABLE = (1 << 10),
@ -2255,30 +2255,30 @@ typedef enum eSnapFlag {
ENUM_OPERATORS(eSnapFlag, SCE_SNAP_BACKFACE_CULLING)
#endif
/** See #ToolSettings.snap_target (to be renamed `snap_source`) and #TransSnap.source_select */
typedef enum eSnapSourceSelect {
/** See #ToolSettings.snap_target (to be renamed `snap_source`) and #TransSnap.source_operation */
typedef enum eSnapSourceOP {
SCE_SNAP_SOURCE_CLOSEST = 0,
SCE_SNAP_SOURCE_CENTER = 1,
SCE_SNAP_SOURCE_MEDIAN = 2,
SCE_SNAP_SOURCE_ACTIVE = 3,
} eSnapSourceSelect;
} eSnapSourceOP;
ENUM_OPERATORS(eSnapSourceSelect, SCE_SNAP_SOURCE_ACTIVE)
ENUM_OPERATORS(eSnapSourceOP, SCE_SNAP_SOURCE_ACTIVE)
/**
* #TransSnap.target_select and #ToolSettings.snap_flag
* #TransSnap.target_operation and #ToolSettings.snap_flag
* (#SCE_SNAP_NOT_TO_ACTIVE, #SCE_SNAP_TO_INCLUDE_EDITED, #SCE_SNAP_TO_INCLUDE_NONEDITED,
* #SCE_SNAP_TO_ONLY_SELECTABLE).
*/
typedef enum eSnapTargetSelect {
typedef enum eSnapTargetOP {
SCE_SNAP_TARGET_ALL = 0,
SCE_SNAP_TARGET_NOT_SELECTED = (1 << 0),
SCE_SNAP_TARGET_NOT_ACTIVE = (1 << 1),
SCE_SNAP_TARGET_NOT_EDITED = (1 << 2),
SCE_SNAP_TARGET_ONLY_SELECTABLE = (1 << 3),
SCE_SNAP_TARGET_NOT_NONEDITED = (1 << 4),
} eSnapTargetSelect;
ENUM_OPERATORS(eSnapTargetSelect, SCE_SNAP_TARGET_NOT_NONEDITED)
} eSnapTargetOP;
ENUM_OPERATORS(eSnapTargetOP, SCE_SNAP_TARGET_NOT_NONEDITED)
/** #ToolSettings.snap_mode */
typedef enum eSnapMode {