griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Cleanup: various tweaks to the transform_snap_object code

Browse Source 
This commit implements several changes aimed at enhancing the
readability of the transform snap object code.

The changes are:
- Reduce number of parameters in functions;
- Unify functions;
- Replace enum `eViewProj` with a bool;
- Remove unused members;
- Deduplicate code;

Pull Request: https://projects.blender.org/blender/blender/pulls/109012
This commit is contained in:
Germano Cavalcante
2023-06-15 17:29:50 +02:00
committed by Germano Cavalcante
parent 45b9542e6c
commit 3df2110abd
4 changed files with 719 additions and 851 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -94,13 +94,11 @@ static ID *data_for_snap(Object *ob_eval, eSnapEditType edit_mode_type, bool *r_
* \{ */ * \{ */
using IterSnapObjsCallback = eSnapMode (*)(SnapObjectContext *sctx, using IterSnapObjsCallback = eSnapMode (*)(SnapObjectContext *sctx,
const SnapObjectParams *params,
Object *ob_eval, Object *ob_eval,
ID *ob_data, ID *ob_data,
const float obmat[4][4], const float obmat[4][4],
bool is_object_active, bool is_object_active,
bool use_hide, bool use_hide);
void *data);
static bool snap_object_is_snappable(const SnapObjectContext *sctx, static bool snap_object_is_snappable(const SnapObjectContext *sctx,
const eSnapTargetOP snap_target_select, const eSnapTargetOP snap_target_select,
@@ -161,17 +159,14 @@ static bool snap_object_is_snappable(const SnapObjectContext *sctx,
/** /**
* Walks through all objects in the scene to create the list of objects to snap. * Walks through all objects in the scene to create the list of objects to snap.
*/ */
static eSnapMode iter_snap_objects(SnapObjectContext *sctx, static eSnapMode iter_snap_objects(SnapObjectContext *sctx, IterSnapObjsCallback sob_callback)
const SnapObjectParams *params,
IterSnapObjsCallback sob_callback,
void *data)
{ {
eSnapMode ret = SCE_SNAP_MODE_NONE; eSnapMode ret = SCE_SNAP_MODE_NONE;
eSnapMode tmp; eSnapMode tmp;
Scene *scene = DEG_get_input_scene(sctx->runtime.depsgraph); Scene *scene = DEG_get_input_scene(sctx->runtime.depsgraph);
ViewLayer *view_layer = DEG_get_input_view_layer(sctx->runtime.depsgraph); ViewLayer *view_layer = DEG_get_input_view_layer(sctx->runtime.depsgraph);
const eSnapTargetOP snap_target_select = params->snap_target_select; const eSnapTargetOP snap_target_select = sctx->runtime.params.snap_target_select;
BKE_view_layer_synced_ensure(scene, view_layer); BKE_view_layer_synced_ensure(scene, view_layer);
Base *base_act = BKE_view_layer_active_base_get(view_layer); Base *base_act = BKE_view_layer_active_base_get(view_layer);
@@ -186,14 +181,9 @@ static eSnapMode iter_snap_objects(SnapObjectContext *sctx,
ListBase *lb = object_duplilist(sctx->runtime.depsgraph, sctx->scene, obj_eval); ListBase *lb = object_duplilist(sctx->runtime.depsgraph, sctx->scene, obj_eval);
LISTBASE_FOREACH (DupliObject *, dupli_ob, lb) { LISTBASE_FOREACH (DupliObject *, dupli_ob, lb) {
BLI_assert(DEG_is_evaluated_object(dupli_ob->ob)); BLI_assert(DEG_is_evaluated_object(dupli_ob->ob));
if ((tmp = sob_callback(sctx, if ((tmp = sob_callback(
params, sctx, dupli_ob->ob, dupli_ob->ob_data, dupli_ob->mat, is_object_active, false)) !=
dupli_ob->ob, SCE_SNAP_MODE_NONE)
dupli_ob->ob_data,
dupli_ob->mat,
is_object_active,
false,
data)) != SCE_SNAP_MODE_NONE)
{ {
ret = tmp; ret = tmp;
} }
@@ -202,15 +192,10 @@ static eSnapMode iter_snap_objects(SnapObjectContext *sctx,
} }
bool use_hide = false; bool use_hide = false;
ID *ob_data = data_for_snap(obj_eval, params->edit_mode_type, &use_hide); ID *ob_data = data_for_snap(obj_eval, sctx->runtime.params.edit_mode_type, &use_hide);
if ((tmp = sob_callback(sctx, if ((tmp = sob_callback(
params, sctx, obj_eval, ob_data, obj_eval->object_to_world, is_object_active, use_hide)) !=
obj_eval, SCE_SNAP_MODE_NONE)
ob_data,
obj_eval->object_to_world,
is_object_active,
use_hide,
data)) != SCE_SNAP_MODE_NONE)
{ {
ret = tmp; ret = tmp;
} }
@@ -296,61 +281,26 @@ bool raycast_tri_backface_culling_test(
return dot_v3v3(no, dir) < 0.0f; return dot_v3v3(no, dir) < 0.0f;
} }
struct RaycastObjUserData {
const float *ray_start;
const float *ray_dir;
uint ob_index;
/* read/write args */
float *ray_depth;
uint use_occlusion_test : 1;
uint use_occlusion_test_edit : 1;
};
/** /**
* \note Duplicate args here are documented at #snapObjectsRay * \note Duplicate args here are documented at #snapObjectsRay
*/ */
static eSnapMode raycast_obj_fn(SnapObjectContext *sctx, static eSnapMode raycast_obj_fn(SnapObjectContext *sctx,
const SnapObjectParams *params,
Object *ob_eval, Object *ob_eval,
ID *ob_data, ID *ob_data,
const float obmat[4][4], const float obmat[4][4],
bool is_object_active, bool is_object_active,
bool use_hide, bool use_hide)
void *data)
{ {
RaycastObjUserData *dt = static_cast<RaycastObjUserData *>(data);
const uint ob_index = dt->ob_index++;
/* read/write args */
float *ray_depth = dt->ray_depth;
bool retval = false; bool retval = false;
bool is_edit = false; bool is_edit = false;
if (ob_data == nullptr) { if (ob_data == nullptr) {
if (dt->use_occlusion_test_edit && ELEM(ob_eval->dt, OB_BOUNDBOX, OB_WIRE)) { 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. */ /* Do not hit objects that are in wire or bounding box display mode. */
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
if (ob_eval->type == OB_MESH) { if (ob_eval->type == OB_MESH) {
BMEditMesh *em = BKE_editmesh_from_object(ob_eval); if (snap_object_editmesh(sctx, ob_eval, nullptr, obmat, SCE_SNAP_MODE_FACE, use_hide)) {
if (UNLIKELY(!em)) { /* See #mesh_for_snap doc-string. */
return SCE_SNAP_MODE_NONE;
}
if (raycastEditMesh(sctx,
params,
dt->ray_start,
dt->ray_dir,
ob_eval,
em,
obmat,
ob_index,
ray_depth,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index,
sctx->ret.hit_list))
{
retval = true; retval = true;
is_edit = true; is_edit = true;
} }
@@ -359,7 +309,7 @@ static eSnapMode raycast_obj_fn(SnapObjectContext *sctx,
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
} }
else if (dt->use_occlusion_test && ELEM(ob_eval->dt, OB_BOUNDBOX, OB_WIRE)) { 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. */ /* Do not hit objects that are in wire or bounding box display mode. */
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
@@ -370,20 +320,7 @@ static eSnapMode raycast_obj_fn(SnapObjectContext *sctx,
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
else { else {
const Mesh *me_eval = (const Mesh *)ob_data; retval = snap_object_mesh(sctx, ob_eval, ob_data, obmat, SCE_SNAP_MODE_FACE, use_hide);
retval = raycastMesh(params,
dt->ray_start,
dt->ray_dir,
ob_eval,
me_eval,
obmat,
ob_index,
use_hide,
ray_depth,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index,
sctx->ret.hit_list);
} }
if (retval) { if (retval) {
@@ -410,26 +347,9 @@ static eSnapMode raycast_obj_fn(SnapObjectContext *sctx,
* \param ray_depth: maximum depth allowed for r_co, * \param ray_depth: maximum depth allowed for r_co,
* elements deeper than this value will be ignored. * elements deeper than this value will be ignored.
*/ */
static bool raycastObjects(SnapObjectContext *sctx, static bool raycastObjects(SnapObjectContext *sctx)
const SnapObjectParams *params,
const float ray_start[3],
const float ray_dir[3],
const bool use_occlusion_test,
const bool use_occlusion_test_edit,
/* read/write args */
/* Parameters below cannot be const, because they are assigned to a
* non-const variable (readability-non-const-parameter). */
float *ray_depth /* NOLINT */)
{ {
RaycastObjUserData data = {}; return iter_snap_objects(sctx, raycast_obj_fn) != SCE_SNAP_MODE_NONE;
data.ray_start = ray_start;
data.ray_dir = ray_dir;
data.ob_index = 0;
data.ray_depth = ray_depth;
data.use_occlusion_test = use_occlusion_test;
data.use_occlusion_test_edit = use_occlusion_test_edit;
return iter_snap_objects(sctx, params, raycast_obj_fn, &data) != SCE_SNAP_MODE_NONE;
} }
/** \} */ /** \} */
@@ -475,8 +395,7 @@ static void nearest_world_tree_co(BVHTree *tree,
} }
} }
bool nearest_world_tree(SnapObjectContext * /*sctx*/, bool nearest_world_tree(SnapObjectContext *sctx,
const SnapObjectParams *params,
BVHTree *tree, BVHTree *tree,
BVHTree_NearestPointCallback nearest_cb, BVHTree_NearestPointCallback nearest_cb,
void *treedata, void *treedata,
@@ -507,7 +426,7 @@ bool nearest_world_tree(SnapObjectContext * /*sctx*/,
sub_v3_v3v3(delta_local, curr_co_local, init_co_local); sub_v3_v3v3(delta_local, curr_co_local, init_co_local);
float dist_sq; float dist_sq;
if (params->keep_on_same_target) { if (sctx->runtime.params.keep_on_same_target) {
nearest_world_tree_co( nearest_world_tree_co(
tree, nearest_cb, treedata, init_co_local, nullptr, nullptr, nullptr, &dist_sq); tree, nearest_cb, treedata, init_co_local, nullptr, nullptr, nullptr, &dist_sq);
} }
@@ -524,7 +443,7 @@ bool nearest_world_tree(SnapObjectContext * /*sctx*/,
*r_dist_sq = dist_sq; *r_dist_sq = dist_sq;
/* scale to make `snap_face_nearest_steps` steps */ /* scale to make `snap_face_nearest_steps` steps */
float step_scale_factor = 1.0f / max_ff(1.0f, float(params->face_nearest_steps)); float step_scale_factor = 1.0f / max_ff(1.0f, float(sctx->runtime.params.face_nearest_steps));
mul_v3_fl(delta_local, step_scale_factor); mul_v3_fl(delta_local, step_scale_factor);
float co_local[3]; float co_local[3];
@@ -532,7 +451,7 @@ bool nearest_world_tree(SnapObjectContext * /*sctx*/,
copy_v3_v3(co_local, init_co_local); copy_v3_v3(co_local, init_co_local);
for (int i = 0; i < params->face_nearest_steps; i++) { for (int i = 0; i < sctx->runtime.params.face_nearest_steps; i++) {
add_v3_v3(co_local, delta_local); add_v3_v3(co_local, delta_local);
nearest_world_tree_co( nearest_world_tree_co(
tree, nearest_cb, treedata, co_local, co_local, no_local, r_index, nullptr); tree, nearest_cb, treedata, co_local, co_local, no_local, r_index, nullptr);
@@ -549,37 +468,19 @@ bool nearest_world_tree(SnapObjectContext * /*sctx*/,
} }
static eSnapMode nearest_world_object_fn(SnapObjectContext *sctx, static eSnapMode nearest_world_object_fn(SnapObjectContext *sctx,
const SnapObjectParams *params,
Object *ob_eval, Object *ob_eval,
ID *ob_data, ID *ob_data,
const float obmat[4][4], const float obmat[4][4],
bool is_object_active, bool is_object_active,
bool use_hide, bool use_hide)
void *data)
{ {
NearestWorldObjUserData *dt = static_cast<NearestWorldObjUserData *>(data);
bool retval = false; bool retval = false;
bool is_edit = false; bool is_edit = false;
if (ob_data == nullptr) { if (ob_data == nullptr) {
if (ob_eval->type == OB_MESH) { if (ob_eval->type == OB_MESH) {
BMEditMesh *em = BKE_editmesh_from_object(ob_eval); if (snap_object_editmesh(
if (UNLIKELY(!em)) { /* See #data_for_snap doc-string. */ sctx, ob_eval, nullptr, obmat, SCE_SNAP_MODE_FACE_NEAREST, use_hide)) {
return SCE_SNAP_MODE_NONE;
}
if (nearest_world_editmesh(sctx,
params,
ob_eval,
em,
obmat,
dt->init_co,
dt->curr_co,
&sctx->ret.dist_sq,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index))
{
retval = true; retval = true;
is_edit = true; is_edit = true;
} }
@@ -594,19 +495,8 @@ static eSnapMode nearest_world_object_fn(SnapObjectContext *sctx,
else if (is_object_active && ELEM(ob_eval->type, OB_CURVES_LEGACY, OB_SURF, OB_FONT)) { else if (is_object_active && ELEM(ob_eval->type, OB_CURVES_LEGACY, OB_SURF, OB_FONT)) {
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
else { else if (snap_object_mesh(sctx, ob_eval, ob_data, obmat, SCE_SNAP_MODE_FACE_NEAREST, use_hide)) {
const Mesh *me_eval = (const Mesh *)ob_data; retval = true;
retval = nearest_world_mesh(sctx,
params,
me_eval,
obmat,
use_hide,
dt->init_co,
dt->curr_co,
&sctx->ret.dist_sq,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index);
} }
if (retval) { if (retval) {
@@ -630,16 +520,9 @@ static eSnapMode nearest_world_object_fn(SnapObjectContext *sctx,
* \param init_co: Initial location of source point. * \param init_co: Initial location of source point.
* \param prev_co: Current location of source point after transformation but before snapping. * \param prev_co: Current location of source point after transformation but before snapping.
*/ */
static bool nearestWorldObjects(SnapObjectContext *sctx, static bool nearestWorldObjects(SnapObjectContext *sctx)
const SnapObjectParams *params,
const float init_co[3],
const float curr_co[3])
{ {
NearestWorldObjUserData data = {}; return iter_snap_objects(sctx, nearest_world_object_fn) != SCE_SNAP_MODE_NONE;
data.init_co = init_co;
data.curr_co = curr_co;
return iter_snap_objects(sctx, params, nearest_world_object_fn, &data) != SCE_SNAP_MODE_NONE;
} }
/** \} */ /** \} */
@@ -793,10 +676,7 @@ void cb_snap_edge(void *userdata,
/** \name Internal Object Snapping API /** \name Internal Object Snapping API
* \{ */ * \{ */
static eSnapMode snap_polygon(SnapObjectContext *sctx, static eSnapMode snap_polygon(SnapObjectContext *sctx, eSnapMode snap_to_flag)
const SnapObjectParams *params,
/* read/write args */
float *dist_px)
{ {
float lpmat[4][4]; float lpmat[4][4];
mul_m4_m4m4(lpmat, sctx->runtime.pmat, sctx->ret.obmat); mul_m4_m4m4(lpmat, sctx->runtime.pmat, sctx->ret.obmat);
@@ -812,36 +692,27 @@ static eSnapMode snap_polygon(SnapObjectContext *sctx,
nullptr; nullptr;
if (mesh) { if (mesh) {
return snap_polygon_mesh(sctx, return snap_polygon_mesh(sctx,
params, sctx->ret.ob,
mesh, sctx->ret.data,
sctx->ret.obmat, sctx->ret.obmat,
clip_planes_local, snap_to_flag,
dist_px, sctx->ret.index,
sctx->ret.loc, clip_planes_local);
sctx->ret.no,
&sctx->ret.index);
} }
else if (sctx->ret.is_edit) { else if (sctx->ret.is_edit) {
return snap_polygon_editmesh(sctx, return snap_polygon_editmesh(sctx,
params, sctx->ret.ob,
BKE_editmesh_from_object(sctx->ret.ob), sctx->ret.data,
sctx->ret.obmat, sctx->ret.obmat,
clip_planes_local, snap_to_flag,
dist_px, sctx->ret.index,
sctx->ret.loc, clip_planes_local);
sctx->ret.no,
&sctx->ret.index);
} }
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
static eSnapMode snap_mesh_edge_verts_mixed(SnapObjectContext *sctx, static eSnapMode snap_mesh_edge_verts_mixed(SnapObjectContext *sctx, float original_dist_px)
const SnapObjectParams *params,
float original_dist_px,
const float prev_co[3],
/* read/write args */
float *dist_px)
{ {
eSnapMode elem = SCE_SNAP_MODE_EDGE; eSnapMode elem = SCE_SNAP_MODE_EDGE;
@@ -855,16 +726,14 @@ static eSnapMode snap_mesh_edge_verts_mixed(SnapObjectContext *sctx,
(const Mesh *)sctx->ret.data : (const Mesh *)sctx->ret.data :
nullptr; nullptr;
if (mesh) { if (mesh) {
nearest2d_data_init_mesh(mesh, nearest2d_data_init_mesh(
sctx->runtime.view_proj == VIEW_PROJ_PERSP, mesh, sctx->runtime.is_persp, sctx->runtime.params.use_backface_culling, &nearest2d);
params->use_backface_culling,
&nearest2d);
} }
else if (sctx->ret.is_edit) { else if (sctx->ret.is_edit) {
/* The object's #BMEditMesh was used to snap instead. */ /* The object's #BMEditMesh was used to snap instead. */
nearest2d_data_init_editmesh(BKE_editmesh_from_object(sctx->ret.ob), nearest2d_data_init_editmesh(BKE_editmesh_from_object(sctx->ret.ob),
sctx->runtime.view_proj == VIEW_PROJ_PERSP, sctx->runtime.is_persp,
params->use_backface_culling, sctx->runtime.params.use_backface_culling,
&nearest2d); &nearest2d);
} }
else { else {
@@ -953,17 +822,17 @@ static eSnapMode snap_mesh_edge_verts_mixed(SnapObjectContext *sctx,
} }
} }
if (prev_co && (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_EDGE_PERPENDICULAR)) { if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_EDGE_PERPENDICULAR) {
float v_near[3], va_g[3], vb_g[3]; float v_near[3], va_g[3], vb_g[3];
mul_v3_m4v3(va_g, sctx->ret.obmat, v_pair[0]); mul_v3_m4v3(va_g, sctx->ret.obmat, v_pair[0]);
mul_v3_m4v3(vb_g, sctx->ret.obmat, v_pair[1]); mul_v3_m4v3(vb_g, sctx->ret.obmat, v_pair[1]);
lambda = line_point_factor_v3(prev_co, va_g, vb_g); lambda = line_point_factor_v3(sctx->runtime.curr_co, va_g, vb_g);
if (IN_RANGE(lambda, 0.0f, 1.0f)) { if (IN_RANGE(lambda, 0.0f, 1.0f)) {
interp_v3_v3v3(v_near, va_g, vb_g, lambda); interp_v3_v3v3(v_near, va_g, vb_g, lambda);
if (len_squared_v3v3(prev_co, v_near) > FLT_EPSILON) { if (len_squared_v3v3(sctx->runtime.curr_co, v_near) > FLT_EPSILON) {
dist_squared_to_projected_aabb_precalc( dist_squared_to_projected_aabb_precalc(
&neasrest_precalc, sctx->runtime.pmat, sctx->runtime.win_size, sctx->runtime.mval); &neasrest_precalc, sctx->runtime.pmat, sctx->runtime.win_size, sctx->runtime.mval);
@@ -984,7 +853,7 @@ static eSnapMode snap_mesh_edge_verts_mixed(SnapObjectContext *sctx,
} }
if (nearest.index != -1) { if (nearest.index != -1) {
*dist_px = sqrtf(nearest.dist_sq); sctx->ret.dist_px_sq = nearest.dist_sq;
copy_v3_v3(sctx->ret.loc, nearest.co); copy_v3_v3(sctx->ret.loc, nearest.co);
if (elem != SCE_SNAP_MODE_EDGE_PERPENDICULAR) { if (elem != SCE_SNAP_MODE_EDGE_PERPENDICULAR) {
@@ -998,16 +867,9 @@ static eSnapMode snap_mesh_edge_verts_mixed(SnapObjectContext *sctx,
} }
static eSnapMode snapArmature(SnapObjectContext *sctx, static eSnapMode snapArmature(SnapObjectContext *sctx,
const SnapObjectParams *params,
Object *ob_eval, Object *ob_eval,
const float obmat[4][4], const float obmat[4][4],
bool is_object_active, bool is_object_active)
/* read/write args */
float *dist_px,
/* return args */
float r_loc[3],
float * /*r_no*/,
int *r_index)
{ {
eSnapMode retval = SCE_SNAP_MODE_NONE; eSnapMode retval = SCE_SNAP_MODE_NONE;
@@ -1016,7 +878,7 @@ static eSnapMode snapArmature(SnapObjectContext *sctx,
return retval; return retval;
} }
float lpmat[4][4], dist_px_sq = square_f(*dist_px); float lpmat[4][4];
mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat); mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat);
DistProjectedAABBPrecalc neasrest_precalc; DistProjectedAABBPrecalc neasrest_precalc;
@@ -1029,9 +891,12 @@ static eSnapMode snapArmature(SnapObjectContext *sctx,
if (is_editmode == false) { if (is_editmode == false) {
/* Test BoundBox. */ /* Test BoundBox. */
const BoundBox *bb = BKE_armature_boundbox_get(ob_eval); const BoundBox *bb = BKE_armature_boundbox_get(ob_eval);
if (bb && if (bb && !snap_bound_box_check_dist(bb->vec[0],
!snap_bound_box_check_dist( bb->vec[6],
bb->vec[0], bb->vec[6], lpmat, sctx->runtime.win_size, sctx->runtime.mval, dist_px_sq)) lpmat,
sctx->runtime.win_size,
sctx->runtime.mval,
sctx->ret.dist_px_sq))
{ {
return retval; return retval;
} }
@@ -1045,8 +910,9 @@ static eSnapMode snapArmature(SnapObjectContext *sctx,
const bool is_posemode = is_object_active && (ob_eval->mode & OB_MODE_POSE); const bool is_posemode = is_object_active && (ob_eval->mode & OB_MODE_POSE);
const bool skip_selected = (is_editmode || is_posemode) && const bool skip_selected = (is_editmode || is_posemode) &&
(params->snap_target_select & SCE_SNAP_TARGET_NOT_SELECTED); (sctx->runtime.params.snap_target_select &
const bool is_persp = sctx->runtime.view_proj == VIEW_PROJ_PERSP; SCE_SNAP_TARGET_NOT_SELECTED);
const bool is_persp = sctx->runtime.is_persp;
if (arm->edbo) { if (arm->edbo) {
LISTBASE_FOREACH (EditBone *, eBone, arm->edbo) { LISTBASE_FOREACH (EditBone *, eBone, arm->edbo) {
@@ -1068,16 +934,16 @@ static eSnapMode snapArmature(SnapObjectContext *sctx,
sctx->runtime.clip_plane_len, sctx->runtime.clip_plane_len,
is_persp, is_persp,
eBone->head, eBone->head,
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
has_vert_snap |= test_projected_vert_dist(&neasrest_precalc, has_vert_snap |= test_projected_vert_dist(&neasrest_precalc,
clip_planes_local, clip_planes_local,
sctx->runtime.clip_plane_len, sctx->runtime.clip_plane_len,
is_persp, is_persp,
eBone->tail, eBone->tail,
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
if (has_vert_snap) { if (has_vert_snap) {
retval = SCE_SNAP_MODE_VERTEX; retval = SCE_SNAP_MODE_VERTEX;
@@ -1090,8 +956,8 @@ static eSnapMode snapArmature(SnapObjectContext *sctx,
is_persp, is_persp,
eBone->head, eBone->head,
eBone->tail, eBone->tail,
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc)) sctx->ret.loc))
{ {
retval = SCE_SNAP_MODE_EDGE; retval = SCE_SNAP_MODE_EDGE;
} }
@@ -1122,15 +988,15 @@ static eSnapMode snapArmature(SnapObjectContext *sctx,
sctx->runtime.clip_plane_len, sctx->runtime.clip_plane_len,
is_persp, is_persp,
head_vec, head_vec,
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
has_vert_snap |= test_projected_vert_dist(&neasrest_precalc, has_vert_snap |= test_projected_vert_dist(&neasrest_precalc,
clip_planes_local, clip_planes_local,
sctx->runtime.clip_plane_len, sctx->runtime.clip_plane_len,
is_persp, is_persp,
tail_vec, tail_vec,
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
if (has_vert_snap) { if (has_vert_snap) {
retval = SCE_SNAP_MODE_VERTEX; retval = SCE_SNAP_MODE_VERTEX;
@@ -1143,8 +1009,8 @@ static eSnapMode snapArmature(SnapObjectContext *sctx,
is_persp, is_persp,
head_vec, head_vec,
tail_vec, tail_vec,
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc)) sctx->ret.loc))
{ {
retval = SCE_SNAP_MODE_EDGE; retval = SCE_SNAP_MODE_EDGE;
} }
@@ -1153,28 +1019,16 @@ static eSnapMode snapArmature(SnapObjectContext *sctx,
} }
if (retval) { if (retval) {
*dist_px = sqrtf(dist_px_sq); mul_m4_v3(obmat, sctx->ret.loc);
mul_m4_v3(obmat, r_loc); /* Does not support index. */
if (r_index) { sctx->ret.index = -1;
/* Does not support index. */
*r_index = -1;
}
return retval; return retval;
} }
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
static eSnapMode snapCurve(SnapObjectContext *sctx, static eSnapMode snapCurve(SnapObjectContext *sctx, Object *ob_eval, const float obmat[4][4])
const SnapObjectParams *params,
Object *ob_eval,
const float obmat[4][4],
/* read/write args */
float *dist_px,
/* return args */
float r_loc[3],
float * /*r_no*/,
int *r_index)
{ {
bool has_snap = false; bool has_snap = false;
@@ -1184,7 +1038,6 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
} }
Curve *cu = static_cast<Curve *>(ob_eval->data); Curve *cu = static_cast<Curve *>(ob_eval->data);
float dist_px_sq = square_f(*dist_px);
float lpmat[4][4]; float lpmat[4][4];
mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat); mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat);
@@ -1198,9 +1051,12 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
if (use_obedit == false) { if (use_obedit == false) {
/* Test BoundBox */ /* Test BoundBox */
BoundBox *bb = BKE_curve_boundbox_get(ob_eval); BoundBox *bb = BKE_curve_boundbox_get(ob_eval);
if (bb && if (bb && !snap_bound_box_check_dist(bb->vec[0],
!snap_bound_box_check_dist( bb->vec[6],
bb->vec[0], bb->vec[6], lpmat, sctx->runtime.win_size, sctx->runtime.mval, dist_px_sq)) lpmat,
sctx->runtime.win_size,
sctx->runtime.mval,
sctx->ret.dist_px_sq))
{ {
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
@@ -1223,8 +1079,9 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
mul_v4_m4v4(clip_planes_local[i], tobmat, clip_planes[i]); mul_v4_m4v4(clip_planes_local[i], tobmat, clip_planes[i]);
} }
bool is_persp = sctx->runtime.view_proj == VIEW_PROJ_PERSP; bool is_persp = sctx->runtime.is_persp;
bool skip_selected = params->snap_target_select & SCE_SNAP_TARGET_NOT_SELECTED; bool skip_selected = (sctx->runtime.params.snap_target_select & SCE_SNAP_TARGET_NOT_SELECTED) !=
0;
LISTBASE_FOREACH (Nurb *, nu, (use_obedit ? &cu->editnurb->nurbs : &cu->nurb)) { LISTBASE_FOREACH (Nurb *, nu, (use_obedit ? &cu->editnurb->nurbs : &cu->nurb)) {
for (int u = 0; u < nu->pntsu; u++) { for (int u = 0; u < nu->pntsu; u++) {
@@ -1245,8 +1102,8 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
clip_plane_len, clip_plane_len,
is_persp, is_persp,
nu->bezt[u].vec[1], nu->bezt[u].vec[1],
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
/* Don't snap if handle is selected (moving), /* Don't snap if handle is selected (moving),
* or if it is aligning to a moving handle. */ * or if it is aligning to a moving handle. */
@@ -1260,8 +1117,8 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
clip_plane_len, clip_plane_len,
is_persp, is_persp,
nu->bezt[u].vec[0], nu->bezt[u].vec[0],
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
} }
if (!skip_selected || !(is_selected_h2 || (is_autoalign_h2 && is_selected_h1))) { if (!skip_selected || !(is_selected_h2 || (is_autoalign_h2 && is_selected_h1))) {
@@ -1270,8 +1127,8 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
clip_plane_len, clip_plane_len,
is_persp, is_persp,
nu->bezt[u].vec[2], nu->bezt[u].vec[2],
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
} }
} }
else { else {
@@ -1290,8 +1147,8 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
clip_plane_len, clip_plane_len,
is_persp, is_persp,
nu->bp[u].vec, nu->bp[u].vec,
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
} }
} }
else { else {
@@ -1303,8 +1160,8 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
clip_plane_len, clip_plane_len,
is_persp, is_persp,
nu->bezt[u].vec[1], nu->bezt[u].vec[1],
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
} }
else { else {
has_snap |= test_projected_vert_dist(&neasrest_precalc, has_snap |= test_projected_vert_dist(&neasrest_precalc,
@@ -1312,8 +1169,8 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
clip_plane_len, clip_plane_len,
is_persp, is_persp,
nu->bp[u].vec, nu->bp[u].vec,
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc); sctx->ret.loc);
} }
} }
} }
@@ -1321,12 +1178,9 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
} }
} }
if (has_snap) { if (has_snap) {
*dist_px = sqrtf(dist_px_sq); mul_m4_v3(obmat, sctx->ret.loc);
mul_m4_v3(obmat, r_loc); /* Does not support index yet. */
if (r_index) { sctx->ret.index = -1;
/* Does not support index yet. */
*r_index = -1;
}
return SCE_SNAP_MODE_VERTEX; return SCE_SNAP_MODE_VERTEX;
} }
@@ -1334,15 +1188,10 @@ static eSnapMode snapCurve(SnapObjectContext *sctx,
} }
/* may extend later (for now just snaps to empty center) */ /* may extend later (for now just snaps to empty center) */
static eSnapMode snap_object_center(const SnapObjectContext *sctx, static eSnapMode snap_object_center(SnapObjectContext *sctx,
Object *ob_eval, Object *ob_eval,
const float obmat[4][4], const float obmat[4][4],
/* read/write args */ eSnapMode snap_to_flag)
float *dist_px,
/* return args */
float r_loc[3],
float * /*r_no*/,
int *r_index)
{ {
eSnapMode retval = SCE_SNAP_MODE_NONE; eSnapMode retval = SCE_SNAP_MODE_NONE;
@@ -1351,7 +1200,7 @@ static eSnapMode snap_object_center(const SnapObjectContext *sctx,
} }
/* For now only vertex supported. */ /* For now only vertex supported. */
if ((sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX) == 0) { if ((snap_to_flag & SCE_SNAP_MODE_VERTEX) == 0) {
return retval; return retval;
} }
@@ -1359,55 +1208,44 @@ static eSnapMode snap_object_center(const SnapObjectContext *sctx,
dist_squared_to_projected_aabb_precalc( dist_squared_to_projected_aabb_precalc(
&neasrest_precalc, sctx->runtime.pmat, sctx->runtime.win_size, sctx->runtime.mval); &neasrest_precalc, sctx->runtime.pmat, sctx->runtime.win_size, sctx->runtime.mval);
bool is_persp = sctx->runtime.view_proj == VIEW_PROJ_PERSP; bool is_persp = sctx->runtime.is_persp;
float dist_px_sq = square_f(*dist_px);
if (test_projected_vert_dist(&neasrest_precalc, if (test_projected_vert_dist(&neasrest_precalc,
sctx->runtime.clip_plane, sctx->runtime.clip_plane,
sctx->runtime.clip_plane_len, sctx->runtime.clip_plane_len,
is_persp, is_persp,
obmat[3], obmat[3],
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc)) sctx->ret.loc))
{ {
*dist_px = sqrtf(dist_px_sq);
retval = SCE_SNAP_MODE_VERTEX; retval = SCE_SNAP_MODE_VERTEX;
} }
if (retval) { if (retval) {
if (r_index) { sctx->ret.index = -1;
/* Does not support index. */
*r_index = -1;
}
return retval; return retval;
} }
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
static eSnapMode snapCamera(const SnapObjectContext *sctx, static eSnapMode snapCamera(SnapObjectContext *sctx,
Object *object, Object *object,
const float obmat[4][4], const float obmat[4][4],
/* read/write args */ eSnapMode snap_to_flag)
float *dist_px,
/* return args */
float r_loc[3],
float *r_no,
int *r_index)
{ {
eSnapMode retval = SCE_SNAP_MODE_NONE; eSnapMode retval = SCE_SNAP_MODE_NONE;
Scene *scene = sctx->scene; Scene *scene = sctx->scene;
bool is_persp = sctx->runtime.view_proj == VIEW_PROJ_PERSP; bool is_persp = sctx->runtime.is_persp;
float dist_px_sq = square_f(*dist_px);
float orig_camera_mat[4][4], orig_camera_imat[4][4], imat[4][4]; float orig_camera_mat[4][4], orig_camera_imat[4][4], imat[4][4];
MovieClip *clip = BKE_object_movieclip_get(scene, object, false); MovieClip *clip = BKE_object_movieclip_get(scene, object, false);
MovieTracking *tracking; MovieTracking *tracking;
if (clip == nullptr) { if (clip == nullptr) {
return snap_object_center(sctx, object, obmat, dist_px, r_loc, r_no, r_index); return snap_object_center(sctx, object, obmat, snap_to_flag);
} }
if (object->transflag & OB_DUPLI) { if (object->transflag & OB_DUPLI) {
return retval; return retval;
@@ -1458,8 +1296,8 @@ static eSnapMode snapCamera(const SnapObjectContext *sctx,
sctx->runtime.clip_plane_len, sctx->runtime.clip_plane_len,
is_persp, is_persp,
bundle_pos, bundle_pos,
&dist_px_sq, &sctx->ret.dist_px_sq,
r_loc)) sctx->ret.loc))
{ {
retval = SCE_SNAP_MODE_VERTEX; retval = SCE_SNAP_MODE_VERTEX;
} }
@@ -1468,59 +1306,36 @@ static eSnapMode snapCamera(const SnapObjectContext *sctx,
} }
if (retval) { if (retval) {
*dist_px = sqrtf(dist_px_sq); /* Does not support index. */
if (r_index) { sctx->ret.index = -1;
/* Does not support index. */
*r_index = -1;
}
return retval; return retval;
} }
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
struct SnapObjUserData {
/* read/write args */
float *dist_px;
};
/** /**
* \note Duplicate args here are documented at #snapObjectsRay * \note Duplicate args here are documented at #snapObjectsRay
*/ */
static eSnapMode snap_obj_fn(SnapObjectContext *sctx, static eSnapMode snap_obj_fn(SnapObjectContext *sctx,
const SnapObjectParams *params,
Object *ob_eval, Object *ob_eval,
ID *ob_data, ID *ob_data,
const float obmat[4][4], const float obmat[4][4],
bool is_object_active, bool is_object_active,
bool use_hide, bool use_hide)
void *data)
{ {
SnapObjUserData *dt = static_cast<SnapObjUserData *>(data);
eSnapMode retval = SCE_SNAP_MODE_NONE; eSnapMode retval = SCE_SNAP_MODE_NONE;
bool is_edit = false; bool is_edit = false;
if (ob_data == nullptr && (ob_eval->type == OB_MESH)) { if (ob_data == nullptr && (ob_eval->type == OB_MESH)) {
BMEditMesh *em = BKE_editmesh_from_object(ob_eval); retval = snap_object_editmesh(
if (UNLIKELY(!em)) { /* See #data_for_snap doc-string. */ sctx, ob_eval, nullptr, obmat, sctx->runtime.snap_to_flag, use_hide);
return SCE_SNAP_MODE_NONE;
}
retval = snapEditMesh(sctx,
params,
ob_eval,
em,
obmat,
dt->dist_px,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index);
if (retval) { if (retval) {
is_edit = true; is_edit = true;
} }
} }
else if (ob_data == nullptr) { else if (ob_data == nullptr) {
retval = snap_object_center( retval = snap_object_center(sctx, ob_eval, obmat, sctx->runtime.snap_to_flag);
sctx, ob_eval, obmat, dt->dist_px, sctx->ret.loc, sctx->ret.no, &sctx->ret.index);
} }
else { else {
switch (ob_eval->type) { switch (ob_eval->type) {
@@ -1530,42 +1345,19 @@ static eSnapMode snap_obj_fn(SnapObjectContext *sctx,
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
if (GS(ob_data->name) == ID_ME) { if (GS(ob_data->name) == ID_ME) {
retval = snapMesh(sctx, retval = snap_object_mesh(
params, sctx, ob_eval, ob_data, obmat, sctx->runtime.snap_to_flag, use_hide);
ob_eval,
(const Mesh *)ob_data,
obmat,
use_hide,
dt->dist_px,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index);
} }
break; break;
} }
case OB_ARMATURE: case OB_ARMATURE:
retval = snapArmature(sctx, retval = snapArmature(sctx, ob_eval, obmat, is_object_active);
params,
ob_eval,
obmat,
is_object_active,
dt->dist_px,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index);
break; break;
case OB_CURVES_LEGACY: case OB_CURVES_LEGACY:
case OB_SURF: case OB_SURF:
if (ob_eval->type == OB_CURVES_LEGACY || BKE_object_is_in_editmode(ob_eval)) { if (ob_eval->type == OB_CURVES_LEGACY || BKE_object_is_in_editmode(ob_eval)) {
retval = snapCurve(sctx, retval = snapCurve(sctx, ob_eval, obmat);
params, if (sctx->runtime.params.edit_mode_type != SNAP_GEOM_FINAL) {
ob_eval,
obmat,
dt->dist_px,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index);
if (params->edit_mode_type != SNAP_GEOM_FINAL) {
break; break;
} }
} }
@@ -1573,28 +1365,18 @@ static eSnapMode snap_obj_fn(SnapObjectContext *sctx,
case OB_FONT: { case OB_FONT: {
const Mesh *mesh_eval = BKE_object_get_evaluated_mesh(ob_eval); const Mesh *mesh_eval = BKE_object_get_evaluated_mesh(ob_eval);
if (mesh_eval) { if (mesh_eval) {
retval |= snapMesh(sctx, retval |= snap_object_mesh(
params, sctx, ob_eval, (ID *)mesh_eval, obmat, sctx->runtime.snap_to_flag, use_hide);
ob_eval,
mesh_eval,
obmat,
false,
dt->dist_px,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index);
} }
break; break;
} }
case OB_EMPTY: case OB_EMPTY:
case OB_GPENCIL_LEGACY: case OB_GPENCIL_LEGACY:
case OB_LAMP: case OB_LAMP:
retval = snap_object_center( retval = snap_object_center(sctx, ob_eval, obmat, sctx->runtime.snap_to_flag);
sctx, ob_eval, obmat, dt->dist_px, sctx->ret.loc, sctx->ret.no, &sctx->ret.index);
break; break;
case OB_CAMERA: case OB_CAMERA:
retval = snapCamera( retval = snapCamera(sctx, ob_eval, obmat, sctx->runtime.snap_to_flag);
sctx, ob_eval, obmat, dt->dist_px, sctx->ret.loc, sctx->ret.no, &sctx->ret.index);
break; break;
} }
} }
@@ -1621,17 +1403,9 @@ static eSnapMode snap_obj_fn(SnapObjectContext *sctx,
* *
* \param dist_px: Maximum threshold distance (in pixels). * \param dist_px: Maximum threshold distance (in pixels).
*/ */
static eSnapMode snapObjectsRay(SnapObjectContext *sctx, static eSnapMode snapObjectsRay(SnapObjectContext *sctx)
const SnapObjectParams *params,
/* read/write args */
/* Parameters below cannot be const, because they are assigned to a
* non-const variable (readability-non-const-parameter). */
float *dist_px /* NOLINT */)
{ {
SnapObjUserData data = {}; return iter_snap_objects(sctx, snap_obj_fn);
data.dist_px = dist_px;
return iter_snap_objects(sctx, params, snap_obj_fn, &data);
} }
/** \} */ /** \} */
@@ -1640,12 +1414,10 @@ static eSnapMode snapObjectsRay(SnapObjectContext *sctx,
/** \name Public Object Snapping API /** \name Public Object Snapping API
* \{ */ * \{ */
SnapObjectContext *ED_transform_snap_object_context_create(Scene *scene, int flag) SnapObjectContext *ED_transform_snap_object_context_create(Scene *scene, int /*flag*/)
{ {
SnapObjectContext *sctx = MEM_new<SnapObjectContext>(__func__); SnapObjectContext *sctx = MEM_new<SnapObjectContext>(__func__);
sctx->flag = flag;
sctx->scene = scene; sctx->scene = scene;
return sctx; return sctx;
@@ -1686,6 +1458,99 @@ void ED_transform_snap_object_context_set_editmesh_callbacks(
} }
} }
static bool snap_object_context_runtime_init(SnapObjectContext *sctx,
Depsgraph *depsgraph,
const ARegion *region,
const View3D *v3d,
eSnapMode snap_to_flag,
const SnapObjectParams *params,
const float ray_start[3],
const float ray_dir[3],
const float ray_depth,
const float mval[2],
const float init_co[3],
const float prev_co[3],
const float dist_px_sq,
ListBase *hit_list,
bool use_occlusion_test)
{
if (use_occlusion_test && XRAY_ENABLED(v3d) && (snap_to_flag & SCE_SNAP_MODE_FACE)) {
if (snap_to_flag != SCE_SNAP_MODE_FACE) {
/* In theory everything is visible in X-Ray except faces. */
snap_to_flag &= ~SCE_SNAP_MODE_FACE;
use_occlusion_test = false;
}
}
if (snap_to_flag & (SCE_SNAP_MODE_EDGE_PERPENDICULAR | SCE_SNAP_MODE_FACE_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;
}
}
else {
snap_to_flag &= ~(SCE_SNAP_MODE_EDGE_PERPENDICULAR | SCE_SNAP_MODE_FACE_NEAREST);
}
}
if (snap_to_flag == SCE_SNAP_MODE_NONE) {
return false;
}
sctx->runtime.depsgraph = depsgraph;
sctx->runtime.region = region;
sctx->runtime.v3d = v3d;
sctx->runtime.snap_to_flag = snap_to_flag;
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;
sctx->runtime.has_occlusion_plane = false;
sctx->runtime.object_index = 0;
copy_v3_v3(sctx->runtime.ray_start, ray_start);
copy_v3_v3(sctx->runtime.ray_dir, ray_dir);
if (mval) {
copy_v2_v2(sctx->runtime.mval, mval);
}
if (region) {
const RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
copy_m4_m4(sctx->runtime.pmat, rv3d->persmat);
sctx->runtime.win_size[0] = region->winx;
sctx->runtime.win_size[1] = region->winy;
planes_from_projmat(sctx->runtime.pmat,
nullptr,
nullptr,
nullptr,
nullptr,
sctx->runtime.clip_plane[0],
sctx->runtime.clip_plane[1]);
sctx->runtime.clip_plane_len = 2;
sctx->runtime.is_persp = rv3d->is_persp;
}
sctx->ret.ray_depth_max = ray_depth;
zero_v3(sctx->ret.loc);
zero_v3(sctx->ret.no);
sctx->ret.index = -1;
zero_m4(sctx->ret.obmat);
sctx->ret.hit_list = hit_list;
sctx->ret.ob = nullptr;
sctx->ret.data = nullptr;
sctx->ret.dist_px_sq = dist_px_sq;
sctx->ret.is_edit = false;
return true;
}
bool ED_transform_snap_object_project_ray_ex(SnapObjectContext *sctx, bool ED_transform_snap_object_project_ray_ex(SnapObjectContext *sctx,
Depsgraph *depsgraph, Depsgraph *depsgraph,
const View3D *v3d, const View3D *v3d,
@@ -1699,27 +1564,27 @@ bool ED_transform_snap_object_project_ray_ex(SnapObjectContext *sctx,
Object **r_ob, Object **r_ob,
float r_obmat[4][4]) float r_obmat[4][4])
{ {
sctx->runtime.depsgraph = depsgraph; if (!snap_object_context_runtime_init(sctx,
sctx->runtime.v3d = v3d; depsgraph,
nullptr,
zero_v3(sctx->ret.loc); v3d,
zero_v3(sctx->ret.no); SCE_SNAP_MODE_FACE,
sctx->ret.index = -1; params,
zero_m4(sctx->ret.obmat); ray_start,
sctx->ret.hit_list = nullptr; ray_normal,
sctx->ret.ob = nullptr; !ray_depth || *ray_depth == -1.0f ? BVH_RAYCAST_DIST_MAX :
sctx->ret.data = nullptr; *ray_depth,
sctx->ret.dist_sq = FLT_MAX; nullptr,
sctx->ret.is_edit = false; nullptr,
nullptr,
if (raycastObjects(sctx, 0,
params, nullptr,
ray_start, params->use_occlusion_test))
ray_normal,
params->use_occlusion_test,
params->use_occlusion_test,
ray_depth))
{ {
return false;
}
if (raycastObjects(sctx)) {
copy_v3_v3(r_loc, sctx->ret.loc); copy_v3_v3(r_loc, sctx->ret.loc);
if (r_no) { if (r_no) {
copy_v3_v3(r_no, sctx->ret.no); copy_v3_v3(r_no, sctx->ret.no);
@@ -1733,6 +1598,9 @@ bool ED_transform_snap_object_project_ray_ex(SnapObjectContext *sctx,
if (r_obmat) { if (r_obmat) {
copy_m4_m4(r_obmat, sctx->ret.obmat); copy_m4_m4(r_obmat, sctx->ret.obmat);
} }
if (ray_depth) {
*ray_depth = sctx->ret.ray_depth_max;
}
return true; return true;
} }
return false; return false;
@@ -1748,41 +1616,35 @@ bool ED_transform_snap_object_project_ray_all(SnapObjectContext *sctx,
bool sort, bool sort,
ListBase *r_hit_list) ListBase *r_hit_list)
{ {
sctx->runtime.depsgraph = depsgraph; if (!snap_object_context_runtime_init(sctx,
sctx->runtime.v3d = v3d; depsgraph,
nullptr,
zero_v3(sctx->ret.loc); v3d,
zero_v3(sctx->ret.no); SCE_SNAP_MODE_FACE,
sctx->ret.index = -1; params,
zero_m4(sctx->ret.obmat); ray_start,
sctx->ret.hit_list = r_hit_list; ray_normal,
sctx->ret.ob = nullptr; ray_depth == -1.0f ? BVH_RAYCAST_DIST_MAX : ray_depth,
sctx->ret.data = nullptr; nullptr,
sctx->ret.dist_sq = FLT_MAX; nullptr,
sctx->ret.is_edit = false; nullptr,
0,
if (ray_depth == -1.0f) { r_hit_list,
ray_depth = BVH_RAYCAST_DIST_MAX; params->use_occlusion_test))
{
return false;
} }
#ifdef DEBUG #ifdef DEBUG
float ray_depth_prev = ray_depth; float ray_depth_prev = sctx->ret.ray_depth_max;
#endif #endif
if (raycastObjects(sctx)) {
if (raycastObjects(sctx,
params,
ray_start,
ray_normal,
params->use_occlusion_test,
params->use_occlusion_test,
&ray_depth))
{
if (sort) { if (sort) {
BLI_listbase_sort(r_hit_list, hit_depth_cmp); BLI_listbase_sort(r_hit_list, hit_depth_cmp);
} }
/* meant to be readonly for 'all' hits, ensure it is */ /* meant to be readonly for 'all' hits, ensure it is */
#ifdef DEBUG #ifdef DEBUG
BLI_assert(ray_depth_prev == ray_depth); BLI_assert(ray_depth_prev == sctx->ret.ray_depth_max);
#endif #endif
return true; return true;
} }
@@ -1796,115 +1658,94 @@ bool ED_transform_snap_object_project_ray_all(SnapObjectContext *sctx,
* *
* \return Snap success * \return Snap success
*/ */
static bool transform_snap_context_project_ray_impl(SnapObjectContext *sctx,
Depsgraph *depsgraph,
const View3D *v3d,
const SnapObjectParams *params,
const float ray_start[3],
const float ray_normal[3],
float *ray_depth,
float r_co[3],
float r_no[3])
{
bool ret;
/* try snap edge, then face if it fails */
ret = ED_transform_snap_object_project_ray_ex(sctx,
depsgraph,
v3d,
params,
ray_start,
ray_normal,
ray_depth,
r_co,
r_no,
nullptr,
nullptr,
nullptr);
return ret;
}
bool ED_transform_snap_object_project_ray(SnapObjectContext *sctx, bool ED_transform_snap_object_project_ray(SnapObjectContext *sctx,
Depsgraph *depsgraph, Depsgraph *depsgraph,
const View3D *v3d, const View3D *v3d,
const SnapObjectParams *params, const SnapObjectParams *params,
const float ray_origin[3], const float ray_start[3],
const float ray_direction[3], const float ray_normal[3],
float *ray_depth, float *ray_depth,
float r_co[3], float r_co[3],
float r_no[3]) float r_no[3])
{ {
float ray_depth_fallback; return ED_transform_snap_object_project_ray_ex(sctx,
if (ray_depth == nullptr) { depsgraph,
ray_depth_fallback = BVH_RAYCAST_DIST_MAX; v3d,
ray_depth = &ray_depth_fallback; params,
} ray_start,
ray_normal,
return transform_snap_context_project_ray_impl( ray_depth,
sctx, depsgraph, v3d, params, ray_origin, ray_direction, ray_depth, r_co, r_no); r_co,
r_no,
nullptr,
nullptr,
nullptr);
} }
static eSnapMode transform_snap_context_project_view3d_mixed_impl(SnapObjectContext *sctx, eSnapMode ED_transform_snap_object_project_view3d_ex(SnapObjectContext *sctx,
Depsgraph *depsgraph, Depsgraph *depsgraph,
const ARegion *region, const ARegion *region,
const View3D *v3d, const View3D *v3d,
eSnapMode snap_to_flag, eSnapMode snap_to_flag,
const SnapObjectParams *params, const SnapObjectParams *params,
const float init_co[3], const float init_co[3],
const float mval[2], const float mval[2],
const float prev_co[3], const float prev_co[3],
float *dist_px, float *dist_px,
float r_loc[3], float r_loc[3],
float r_no[3], float r_no[3],
int *r_index, int *r_index,
Object **r_ob, Object **r_ob,
float r_obmat[4][4], float r_obmat[4][4],
float r_face_nor[3]) float r_face_nor[3])
{ {
sctx->runtime.depsgraph = depsgraph;
sctx->runtime.region = region;
sctx->runtime.v3d = v3d;
zero_v3(sctx->ret.loc);
zero_v3(sctx->ret.no);
sctx->ret.index = -1;
zero_m4(sctx->ret.obmat);
sctx->ret.hit_list = nullptr;
sctx->ret.ob = nullptr;
sctx->ret.data = nullptr;
sctx->ret.dist_sq = FLT_MAX;
sctx->ret.is_edit = false;
BLI_assert(snap_to_flag & (SCE_SNAP_MODE_GEOM | SCE_SNAP_MODE_FACE_NEAREST));
eSnapMode retval = SCE_SNAP_MODE_NONE; eSnapMode retval = SCE_SNAP_MODE_NONE;
bool has_hit = false;
const RegionView3D *rv3d = static_cast<RegionView3D *>(region->regiondata);
bool use_occlusion_test = params->use_occlusion_test; bool use_occlusion_test = params->use_occlusion_test;
if (use_occlusion_test || (snap_to_flag & SCE_SNAP_MODE_FACE)) {
if (use_occlusion_test && XRAY_ENABLED(v3d) && (snap_to_flag & SCE_SNAP_MODE_FACE)) { if (!ED_view3d_win_to_ray_clipped_ex(depsgraph,
if (snap_to_flag != SCE_SNAP_MODE_FACE) { region,
/* In theory everything is visible in X-Ray except faces. */ v3d,
mval,
nullptr,
sctx->runtime.ray_dir,
sctx->runtime.ray_start,
true))
{
snap_to_flag &= ~SCE_SNAP_MODE_FACE; snap_to_flag &= ~SCE_SNAP_MODE_FACE;
use_occlusion_test = false; use_occlusion_test = false;
} }
} }
if (prev_co == nullptr) { if (!snap_object_context_runtime_init(sctx,
snap_to_flag &= ~(SCE_SNAP_MODE_EDGE_PERPENDICULAR | SCE_SNAP_MODE_FACE_NEAREST); depsgraph,
} region,
else if (init_co == nullptr) { v3d,
snap_to_flag &= ~SCE_SNAP_MODE_FACE_NEAREST; snap_to_flag,
params,
sctx->runtime.ray_start,
sctx->runtime.ray_dir,
BVH_RAYCAST_DIST_MAX,
mval,
init_co,
prev_co,
square_f(*dist_px),
nullptr,
use_occlusion_test))
{
return retval;
} }
snap_to_flag = sctx->runtime.snap_to_flag;
BLI_assert(snap_to_flag & (SCE_SNAP_MODE_GEOM | SCE_SNAP_MODE_FACE_NEAREST));
bool has_hit = false;
/* NOTE: if both face ray-cast and face nearest are enabled, first find result of nearest, then /* NOTE: if both face ray-cast and face nearest are enabled, first find result of nearest, then
* override with ray-cast. */ * override with ray-cast. */
if ((snap_to_flag & SCE_SNAP_MODE_FACE_NEAREST) && !has_hit) { if ((snap_to_flag & SCE_SNAP_MODE_FACE_NEAREST) && !has_hit) {
has_hit = nearestWorldObjects(sctx, params, init_co, prev_co); has_hit = nearestWorldObjects(sctx);
if (has_hit) { if (has_hit) {
retval = SCE_SNAP_MODE_FACE_NEAREST; retval = SCE_SNAP_MODE_FACE_NEAREST;
@@ -1925,23 +1766,8 @@ static eSnapMode transform_snap_context_project_view3d_mixed_impl(SnapObjectCont
} }
} }
if ((snap_to_flag & SCE_SNAP_MODE_FACE) || use_occlusion_test) { if ((snap_to_flag & SCE_SNAP_MODE_FACE) || sctx->runtime.params.use_occlusion_test) {
float ray_start[3], ray_normal[3]; has_hit = raycastObjects(sctx);
if (!ED_view3d_win_to_ray_clipped_ex(
depsgraph, region, v3d, mval, nullptr, ray_normal, ray_start, true))
{
return retval;
}
float dummy_ray_depth = BVH_RAYCAST_DIST_MAX;
has_hit = raycastObjects(sctx,
params,
ray_start,
ray_normal,
use_occlusion_test,
use_occlusion_test && (snap_to_flag & SCE_SNAP_MODE_FACE) == 0,
&dummy_ray_depth);
if (has_hit) { if (has_hit) {
if (r_face_nor) { if (r_face_nor) {
@@ -1972,33 +1798,13 @@ static eSnapMode transform_snap_context_project_view3d_mixed_impl(SnapObjectCont
SCE_SNAP_MODE_EDGE_PERPENDICULAR)) SCE_SNAP_MODE_EDGE_PERPENDICULAR))
{ {
eSnapMode elem_test, elem = SCE_SNAP_MODE_NONE; eSnapMode elem_test, elem = SCE_SNAP_MODE_NONE;
float dist_px_tmp = *dist_px;
copy_m4_m4(sctx->runtime.pmat, rv3d->persmat);
sctx->runtime.win_size[0] = region->winx;
sctx->runtime.win_size[1] = region->winy;
copy_v2_v2(sctx->runtime.mval, mval);
sctx->runtime.view_proj = rv3d->is_persp ? VIEW_PROJ_PERSP : VIEW_PROJ_ORTHO;
/* First snap to edge instead of middle or perpendicular. */ /* First snap to edge instead of middle or perpendicular. */
sctx->runtime.snap_to_flag = static_cast<eSnapMode>( sctx->runtime.snap_to_flag &= (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE);
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)) { if (snap_to_flag & (SCE_SNAP_MODE_EDGE_MIDPOINT | SCE_SNAP_MODE_EDGE_PERPENDICULAR)) {
sctx->runtime.snap_to_flag = static_cast<eSnapMode>(sctx->runtime.snap_to_flag | sctx->runtime.snap_to_flag |= SCE_SNAP_MODE_EDGE;
SCE_SNAP_MODE_EDGE);
} }
planes_from_projmat(sctx->runtime.pmat,
nullptr,
nullptr,
nullptr,
nullptr,
sctx->runtime.clip_plane[0],
sctx->runtime.clip_plane[1]);
sctx->runtime.clip_plane_len = 2;
sctx->runtime.has_occlusion_plane = false;
/* By convention we only snap to the original elements of a curve. */ /* By convention we only snap to the original elements of a curve. */
if (has_hit && sctx->ret.ob->type != OB_CURVES_LEGACY) { if (has_hit && sctx->ret.ob->type != OB_CURVES_LEGACY) {
/* Compute the new clip_pane but do not add it yet. */ /* Compute the new clip_pane but do not add it yet. */
@@ -2014,7 +1820,7 @@ static eSnapMode transform_snap_context_project_view3d_mixed_impl(SnapObjectCont
new_clipplane[3] += 0.01f; new_clipplane[3] += 0.01f;
/* Try to snap only to the polygon. */ /* Try to snap only to the polygon. */
elem_test = snap_polygon(sctx, params, &dist_px_tmp); elem_test = snap_polygon(sctx, sctx->runtime.snap_to_flag);
if (elem_test) { if (elem_test) {
elem = elem_test; elem = elem_test;
} }
@@ -2028,7 +1834,7 @@ static eSnapMode transform_snap_context_project_view3d_mixed_impl(SnapObjectCont
sctx->runtime.has_occlusion_plane = true; sctx->runtime.has_occlusion_plane = true;
} }
elem_test = snapObjectsRay(sctx, params, &dist_px_tmp); elem_test = snapObjectsRay(sctx);
if (elem_test) { if (elem_test) {
elem = elem_test; elem = elem_test;
} }
@@ -2038,7 +1844,7 @@ static eSnapMode transform_snap_context_project_view3d_mixed_impl(SnapObjectCont
(SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE_MIDPOINT | SCE_SNAP_MODE_EDGE_PERPENDICULAR))) (SCE_SNAP_MODE_VERTEX | SCE_SNAP_MODE_EDGE_MIDPOINT | SCE_SNAP_MODE_EDGE_PERPENDICULAR)))
{ {
sctx->runtime.snap_to_flag = snap_to_flag; sctx->runtime.snap_to_flag = snap_to_flag;
elem = snap_mesh_edge_verts_mixed(sctx, params, *dist_px, prev_co, &dist_px_tmp); elem = snap_mesh_edge_verts_mixed(sctx, *dist_px);
} }
if (elem & snap_to_flag) { if (elem & snap_to_flag) {
@@ -2058,48 +1864,13 @@ static eSnapMode transform_snap_context_project_view3d_mixed_impl(SnapObjectCont
*r_index = sctx->ret.index; *r_index = sctx->ret.index;
} }
*dist_px = dist_px_tmp; *dist_px = blender::math::sqrt(sctx->ret.dist_px_sq);
} }
} }
return retval; return retval;
} }
eSnapMode ED_transform_snap_object_project_view3d_ex(SnapObjectContext *sctx,
Depsgraph *depsgraph,
const ARegion *region,
const View3D *v3d,
const eSnapMode snap_to,
const SnapObjectParams *params,
const float init_co[3],
const float mval[2],
const float prev_co[3],
float *dist_px,
float r_loc[3],
float r_no[3],
int *r_index,
Object **r_ob,
float r_obmat[4][4],
float r_face_nor[3])
{
return transform_snap_context_project_view3d_mixed_impl(sctx,
depsgraph,
region,
v3d,
snap_to,
params,
init_co,
mval,
prev_co,
dist_px,
r_loc,
r_no,
r_index,
r_ob,
r_obmat,
r_face_nor);
}
eSnapMode ED_transform_snap_object_project_view3d(SnapObjectContext *sctx, eSnapMode ED_transform_snap_object_project_view3d(SnapObjectContext *sctx,
Depsgraph *depsgraph, Depsgraph *depsgraph,
const ARegion *region, const ARegion *region,

154
source/blender/editors/transform/transform_snap_object.hh
View File

@@ -10,12 +10,6 @@
#define MAX_CLIPPLANE_LEN 3 #define MAX_CLIPPLANE_LEN 3
enum eViewProj {
VIEW_PROJ_NONE = -1,
VIEW_PROJ_ORTHO = 0,
VIEW_PROJ_PERSP = -1,
};
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
/** \name Internal Data Types /** \name Internal Data Types
* \{ */ * \{ */
@@ -58,8 +52,6 @@ struct SnapData_EditMesh {
struct SnapObjectContext { struct SnapObjectContext {
struct Scene *scene; struct Scene *scene;
int flag;
blender::Map<const BMEditMesh *, std::unique_ptr<SnapData_EditMesh>> editmesh_caches; blender::Map<const BMEditMesh *, std::unique_ptr<SnapData_EditMesh>> editmesh_caches;
/* Filter data, returns true to check this value */ /* Filter data, returns true to check this value */
@@ -77,14 +69,27 @@ struct SnapObjectContext {
const ARegion *region; const ARegion *region;
const View3D *v3d; const View3D *v3d;
eSnapMode snap_to_flag;
SnapObjectParams params;
float ray_start[3];
float ray_dir[3];
float mval[2]; float mval[2];
float init_co[3];
float curr_co[3];
float pmat[4][4]; /* perspective matrix */ float pmat[4][4]; /* perspective matrix */
float win_size[2]; /* win x and y */ float win_size[2]; /* win x and y */
enum eViewProj view_proj;
float clip_plane[MAX_CLIPPLANE_LEN][4]; float clip_plane[MAX_CLIPPLANE_LEN][4];
short clip_plane_len; int clip_plane_len;
eSnapMode snap_to_flag;
/* read/write */
uint object_index;
bool is_persp;
bool has_occlusion_plane; /* Ignore plane of occlusion in curves. */ bool has_occlusion_plane; /* Ignore plane of occlusion in curves. */
bool use_occlusion_test_edit;
} runtime; } runtime;
/* Output. */ /* Output. */
@@ -104,7 +109,8 @@ struct SnapObjectContext {
/* Snapped data. */ /* Snapped data. */
ID *data; ID *data;
float dist_sq; float ray_depth_max;
float dist_px_sq;
bool is_edit; bool is_edit;
} ret; } ret;
@@ -203,7 +209,6 @@ void cb_snap_edge(void *userdata,
BVHTreeNearest *nearest); BVHTreeNearest *nearest);
bool nearest_world_tree(SnapObjectContext *sctx, bool nearest_world_tree(SnapObjectContext *sctx,
const struct SnapObjectParams *params,
BVHTree *tree, BVHTree *tree,
BVHTree_NearestPointCallback nearest_cb, BVHTree_NearestPointCallback nearest_cb,
void *treedata, void *treedata,
@@ -217,57 +222,20 @@ bool nearest_world_tree(SnapObjectContext *sctx,
/* transform_snap_object_editmesh.cc */ /* transform_snap_object_editmesh.cc */
bool raycastEditMesh(SnapObjectContext *sctx, eSnapMode snap_object_editmesh(SnapObjectContext *sctx,
const struct SnapObjectParams *params, Object *ob_eval,
const float ray_start[3], ID *id,
const float ray_dir[3], const float obmat[4][4],
Object *ob_eval, eSnapMode snap_to_flag,
BMEditMesh *em, bool use_hide);
const float obmat[4][4],
const uint ob_index,
/* read/write args */
float *ray_depth,
/* return args */
float r_loc[3],
float r_no[3],
int *r_index,
ListBase *r_hit_list);
eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx, eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx,
const SnapObjectParams *params, Object *ob_eval,
BMEditMesh *em, ID *id,
const float obmat[4][4], const float obmat[4][4],
float clip_planes_local[MAX_CLIPPLANE_LEN][4], eSnapMode snap_to_flag,
/* read/write args */ int polygon,
float *dist_px, const float clip_planes_local[MAX_CLIPPLANE_LEN][4]);
/* return args */
float r_loc[3],
float r_no[3],
int *r_index);
eSnapMode snapEditMesh(struct SnapObjectContext *sctx,
const struct SnapObjectParams *params,
struct Object *ob_eval,
struct BMEditMesh *em,
const float obmat[4][4],
/* read/write args */
float *dist_px,
/* return args */
float r_loc[3],
float r_no[3],
int *r_index);
bool nearest_world_editmesh(struct SnapObjectContext *sctx,
const struct SnapObjectParams *params,
struct Object *ob_eval,
struct BMEditMesh *em,
const float (*obmat)[4],
const float init_co[3],
const float curr_co[3],
float *r_dist_sq,
float *r_loc,
float *r_no,
int *r_index);
void nearest2d_data_init_editmesh(struct BMEditMesh *em, void nearest2d_data_init_editmesh(struct BMEditMesh *em,
bool is_persp, bool is_persp,
@@ -276,60 +244,22 @@ void nearest2d_data_init_editmesh(struct BMEditMesh *em,
/* transform_snap_object_mesh.cc */ /* transform_snap_object_mesh.cc */
bool raycastMesh(const struct SnapObjectParams *params, eSnapMode snap_object_mesh(SnapObjectContext *sctx,
const float ray_start[3], Object *ob_eval,
const float ray_dir[3], ID *id,
struct Object *ob_eval, const float obmat[4][4],
const struct Mesh *me_eval, eSnapMode snap_to_flag,
const float obmat[4][4], bool use_hide);
const uint ob_index,
bool use_hide,
/* read/write args */
float *ray_depth,
/* return args */
float r_loc[3],
float r_no[3],
int *r_index,
struct ListBase *r_hit_list);
bool nearest_world_mesh(SnapObjectContext *sctx, eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
const SnapObjectParams *params, Object *ob_eval,
const Mesh *me_eval, ID *id,
const float (*obmat)[4], const float obmat[4][4],
bool use_hide, eSnapMode snap_to_flag,
const float init_co[3], int polygon,
const float curr_co[3], const float clip_planes_local[MAX_CLIPPLANE_LEN][4]);
float *r_dist_sq,
float *r_loc,
float *r_no,
int *r_index);
void nearest2d_data_init_mesh(const Mesh *mesh, void nearest2d_data_init_mesh(const Mesh *mesh,
bool is_persp, bool is_persp,
bool use_backface_culling, bool use_backface_culling,
Nearest2dUserData *r_nearest2d); Nearest2dUserData *r_nearest2d);
eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
const SnapObjectParams *params,
const Mesh *mesh,
const float obmat[4][4],
float clip_planes_local[MAX_CLIPPLANE_LEN][4],
/* read/write args */
float *dist_px,
/* return args */
float r_loc[3],
float r_no[3],
int *r_index);
eSnapMode snapMesh(SnapObjectContext *sctx,
const SnapObjectParams *params,
Object *ob_eval,
const Mesh *me_eval,
const float obmat[4][4],
bool use_hide,
/* read/write args */
float *dist_px,
/* return args */
float r_loc[3],
float r_no[3],
int *r_index);

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

@@ -66,9 +66,10 @@ static blender::bke::MeshRuntime *snap_object_data_editmesh_runtime_get(Object *
static SnapData_EditMesh *snap_object_data_editmesh_get(SnapObjectContext *sctx, static SnapData_EditMesh *snap_object_data_editmesh_get(SnapObjectContext *sctx,
Object *ob_eval, Object *ob_eval,
BMEditMesh *em) BMEditMesh *em,
const bool create)
{ {
SnapData_EditMesh *sod; SnapData_EditMesh *sod = nullptr;
bool init = false; bool init = false;
if (std::unique_ptr<SnapData_EditMesh> *sod_p = sctx->editmesh_caches.lookup_ptr(em)) { if (std::unique_ptr<SnapData_EditMesh> *sod_p = sctx->editmesh_caches.lookup_ptr(em)) {
@@ -114,7 +115,7 @@ static SnapData_EditMesh *snap_object_data_editmesh_get(SnapObjectContext *sctx,
init = true; init = true;
} }
} }
else { else if (create) {
std::unique_ptr<SnapData_EditMesh> sod_ptr = std::make_unique<SnapData_EditMesh>(); std::unique_ptr<SnapData_EditMesh> sod_ptr = std::make_unique<SnapData_EditMesh>();
sod = sod_ptr.get(); sod = sod_ptr.get();
sctx->editmesh_caches.add_new(em, std::move(sod_ptr)); sctx->editmesh_caches.add_new(em, std::move(sod_ptr));
@@ -122,6 +123,9 @@ static SnapData_EditMesh *snap_object_data_editmesh_get(SnapObjectContext *sctx,
} }
if (init) { if (init) {
/* Operators only update the editmesh looptris of the original mesh. */
BLI_assert(em == BKE_editmesh_from_object(DEG_get_original_object(ob_eval)));
sod->treedata_editmesh.em = em; sod->treedata_editmesh.em = em;
sod->mesh_runtime = snap_object_data_editmesh_runtime_get(ob_eval); sod->mesh_runtime = snap_object_data_editmesh_runtime_get(ob_eval);
snap_editmesh_minmax(sctx, em->bm, sod->min, sod->max); snap_editmesh_minmax(sctx, em->bm, sod->min, sod->max);
@@ -130,18 +134,13 @@ static SnapData_EditMesh *snap_object_data_editmesh_get(SnapObjectContext *sctx,
return sod; return sod;
} }
static BVHTreeFromEditMesh *snap_object_data_editmesh_treedata_get(SnapObjectContext *sctx, static BVHTreeFromEditMesh *snap_object_data_editmesh_treedata_get(SnapData_EditMesh *sod,
Object *ob_eval, SnapObjectContext *sctx,
BMEditMesh *em) BMEditMesh *em)
{ {
SnapData_EditMesh *sod = snap_object_data_editmesh_get(sctx, ob_eval, em);
BVHTreeFromEditMesh *treedata = &sod->treedata_editmesh; BVHTreeFromEditMesh *treedata = &sod->treedata_editmesh;
if (treedata->tree == nullptr) { if (treedata->tree == nullptr) {
/* Operators only update the editmesh looptris of the original mesh. */
BLI_assert(sod->treedata_editmesh.em ==
BKE_editmesh_from_object(DEG_get_original_object(ob_eval)));
em = sod->treedata_editmesh.em; em = sod->treedata_editmesh.em;
if (sctx->callbacks.edit_mesh.test_face_fn) { if (sctx->callbacks.edit_mesh.test_face_fn) {
@@ -178,6 +177,50 @@ static BVHTreeFromEditMesh *snap_object_data_editmesh_treedata_get(SnapObjectCon
/** \} */ /** \} */
/* -------------------------------------------------------------------- */
/** \name Snap Object Data
* \{ */
static eSnapMode editmesh_snap_mode_supported(BMEditMesh *em)
{
eSnapMode snap_mode_supported = SCE_SNAP_MODE_NONE;
if (em->bm->totface) {
snap_mode_supported |= SCE_SNAP_MODE_FACE | SCE_SNAP_MODE_FACE_NEAREST;
}
if (em->bm->totedge) {
snap_mode_supported |= SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_EDGE_MIDPOINT |
SCE_SNAP_MODE_EDGE_PERPENDICULAR;
}
if (em->bm->totvert) {
snap_mode_supported |= SCE_SNAP_MODE_VERTEX;
}
return snap_mode_supported;
}
static SnapData_EditMesh *editmesh_snapdata_init(SnapObjectContext *sctx,
Object *ob_eval,
eSnapMode snap_to_flag)
{
BMEditMesh *em = BKE_editmesh_from_object(ob_eval);
if (em == nullptr) {
return nullptr;
}
SnapData_EditMesh *sod = snap_object_data_editmesh_get(sctx, ob_eval, em, false);
if (sod != nullptr) {
return sod;
}
eSnapMode snap_mode_used = snap_to_flag & editmesh_snap_mode_supported(em);
if (snap_mode_used == SCE_SNAP_MODE_NONE) {
return nullptr;
}
return snap_object_data_editmesh_get(sctx, ob_eval, em, true);
}
/** \} */
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
/** \name Ray Cast Functions /** \name Ray Cast Functions
* \{ */ * \{ */
@@ -212,26 +255,21 @@ static void editmesh_looptri_raycast_backface_culling_cb(void *userdata,
} }
} }
bool raycastEditMesh(SnapObjectContext *sctx, static bool raycastEditMesh(SnapData_EditMesh *sod,
const SnapObjectParams *params, SnapObjectContext *sctx,
const float ray_start[3], Object *ob_eval,
const float ray_dir[3], BMEditMesh *em,
Object *ob_eval, const float obmat[4][4],
BMEditMesh *em, const uint ob_index,
const float obmat[4][4], /* read/write args */
const uint ob_index, float *ray_depth,
/* read/write args */ /* return args */
float *ray_depth, float r_loc[3],
/* return args */ float r_no[3],
float r_loc[3], int *r_index,
float r_no[3], ListBase *r_hit_list)
int *r_index,
ListBase *r_hit_list)
{ {
bool retval = false; bool retval = false;
if (em->bm->totface == 0) {
return retval;
}
float imat[4][4]; float imat[4][4];
float ray_start_local[3], ray_normal_local[3]; float ray_start_local[3], ray_normal_local[3];
@@ -239,8 +277,8 @@ bool raycastEditMesh(SnapObjectContext *sctx,
invert_m4_m4(imat, obmat); invert_m4_m4(imat, obmat);
copy_v3_v3(ray_start_local, ray_start); copy_v3_v3(ray_start_local, sctx->runtime.ray_start);
copy_v3_v3(ray_normal_local, ray_dir); copy_v3_v3(ray_normal_local, sctx->runtime.ray_dir);
mul_m4_v3(imat, ray_start_local); mul_m4_v3(imat, ray_start_local);
mul_mat3_m4_v3(imat, ray_normal_local); mul_mat3_m4_v3(imat, ray_normal_local);
@@ -252,8 +290,6 @@ bool raycastEditMesh(SnapObjectContext *sctx,
local_depth *= local_scale; local_depth *= local_scale;
} }
SnapData_EditMesh *sod = snap_object_data_editmesh_get(sctx, ob_eval, em);
/* Test BoundBox */ /* Test BoundBox */
/* was BKE_boundbox_ray_hit_check, see: cf6ca226fa58 */ /* was BKE_boundbox_ray_hit_check, see: cf6ca226fa58 */
@@ -275,7 +311,7 @@ bool raycastEditMesh(SnapObjectContext *sctx,
len_diff = 0.0f; len_diff = 0.0f;
} }
BVHTreeFromEditMesh *treedata = snap_object_data_editmesh_treedata_get(sctx, ob_eval, em); BVHTreeFromEditMesh *treedata = snap_object_data_editmesh_treedata_get(sod, sctx, em);
if (treedata == nullptr) { if (treedata == nullptr) {
return retval; return retval;
} }
@@ -317,7 +353,7 @@ bool raycastEditMesh(SnapObjectContext *sctx,
ray_normal_local, ray_normal_local,
0.0f, 0.0f,
&hit, &hit,
params->use_backface_culling ? sctx->runtime.params.use_backface_culling ?
editmesh_looptri_raycast_backface_culling_cb : editmesh_looptri_raycast_backface_culling_cb :
treedata->raycast_callback, treedata->raycast_callback,
treedata) != -1) treedata) != -1)
@@ -355,25 +391,23 @@ bool raycastEditMesh(SnapObjectContext *sctx,
/** \name Surface Snap Functions /** \name Surface Snap Functions
* \{ */ * \{ */
bool nearest_world_editmesh(SnapObjectContext *sctx, static bool nearest_world_editmesh(SnapData_EditMesh *sod,
const SnapObjectParams *params, SnapObjectContext *sctx,
Object *ob_eval, BMEditMesh *em,
BMEditMesh *em, const float (*obmat)[4],
const float (*obmat)[4], const float init_co[3],
const float init_co[3], const float curr_co[3],
const float curr_co[3], float *r_dist_sq,
float *r_dist_sq, float *r_loc,
float *r_loc, float *r_no,
float *r_no, int *r_index)
int *r_index)
{ {
BVHTreeFromEditMesh *treedata = snap_object_data_editmesh_treedata_get(sctx, ob_eval, em); BVHTreeFromEditMesh *treedata = snap_object_data_editmesh_treedata_get(sod, sctx, em);
if (treedata == nullptr) { if (treedata == nullptr) {
return false; return false;
} }
return nearest_world_tree(sctx, return nearest_world_tree(sctx,
params,
treedata->tree, treedata->tree,
treedata->nearest_callback, treedata->nearest_callback,
treedata, treedata,
@@ -437,21 +471,22 @@ void nearest2d_data_init_editmesh(BMEditMesh *em,
* \{ */ * \{ */
eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx, eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx,
const SnapObjectParams *params, Object *ob_eval,
BMEditMesh *em, ID * /*id*/,
const float obmat[4][4], const float obmat[4][4],
float clip_planes_local[MAX_CLIPPLANE_LEN][4], eSnapMode snap_to_flag,
/* read/write args */ int polygon,
float *dist_px, const float clip_planes_local[MAX_CLIPPLANE_LEN][4])
/* return args */
float r_loc[3],
float r_no[3],
int *r_index)
{ {
BLI_assert(sctx->editmesh_caches.lookup(em).get()->treedata_editmesh.em == em);
eSnapMode elem = SCE_SNAP_MODE_NONE; eSnapMode elem = SCE_SNAP_MODE_NONE;
SnapData_EditMesh *sod = editmesh_snapdata_init(sctx, ob_eval, snap_to_flag);
if (sod == nullptr) {
return elem;
}
BMEditMesh *em = sod->treedata_editmesh.em;
float lpmat[4][4]; float lpmat[4][4];
mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat); mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat);
@@ -461,18 +496,18 @@ eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx,
BVHTreeNearest nearest{}; BVHTreeNearest nearest{};
nearest.index = -1; nearest.index = -1;
nearest.dist_sq = square_f(*dist_px); nearest.dist_sq = sctx->ret.dist_px_sq;
Nearest2dUserData nearest2d; Nearest2dUserData nearest2d;
nearest2d_data_init_editmesh( nearest2d_data_init_editmesh(
em, sctx->runtime.view_proj == VIEW_PROJ_PERSP, params->use_backface_culling, &nearest2d); em, sctx->runtime.is_persp, sctx->runtime.params.use_backface_culling, &nearest2d);
BM_mesh_elem_table_ensure(em->bm, BM_FACE); BM_mesh_elem_table_ensure(em->bm, BM_FACE);
BMFace *f = BM_face_at_index(em->bm, sctx->ret.index); BMFace *f = BM_face_at_index(em->bm, polygon);
BMLoop *l_iter, *l_first; BMLoop *l_iter, *l_first;
l_iter = l_first = BM_FACE_FIRST_LOOP(f); l_iter = l_first = BM_FACE_FIRST_LOOP(f);
if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_EDGE) { if (snap_to_flag & SCE_SNAP_MODE_EDGE) {
elem = SCE_SNAP_MODE_EDGE; elem = SCE_SNAP_MODE_EDGE;
BM_mesh_elem_index_ensure(em->bm, BM_VERT | BM_EDGE); BM_mesh_elem_index_ensure(em->bm, BM_VERT | BM_EDGE);
BM_mesh_elem_table_ensure(em->bm, BM_VERT | BM_EDGE); BM_mesh_elem_table_ensure(em->bm, BM_VERT | BM_EDGE);
@@ -500,10 +535,10 @@ eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx,
} }
if (nearest.index != -1) { if (nearest.index != -1) {
*dist_px = sqrtf(nearest.dist_sq); sctx->ret.dist_px_sq = nearest.dist_sq;
mul_m4_v3(obmat, nearest.co); mul_m4_v3(obmat, nearest.co);
copy_v3_v3(r_loc, nearest.co); copy_v3_v3(sctx->ret.loc, nearest.co);
{ {
float imat[4][4]; float imat[4][4];
@@ -511,58 +546,42 @@ eSnapMode snap_polygon_editmesh(SnapObjectContext *sctx,
mul_transposed_mat3_m4_v3(imat, nearest.no); mul_transposed_mat3_m4_v3(imat, nearest.no);
normalize_v3(nearest.no); normalize_v3(nearest.no);
copy_v3_v3(r_no, nearest.no); copy_v3_v3(sctx->ret.no, nearest.no);
} }
*r_index = nearest.index; sctx->ret.index = nearest.index;
return elem; return elem;
} }
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
eSnapMode snapEditMesh(SnapObjectContext *sctx, static eSnapMode snapEditMesh(SnapData_EditMesh *sod,
const SnapObjectParams *params, SnapObjectContext *sctx,
Object *ob_eval, BMEditMesh *em,
BMEditMesh *em, const float obmat[4][4],
const float obmat[4][4], eSnapMode snap_to_flag,
/* read/write args */ /* read/write args */
float *dist_px, float *dist_px_sq,
/* return args */ /* return args */
float r_loc[3], float r_loc[3],
float r_no[3], float r_no[3],
int *r_index) int *r_index)
{ {
BLI_assert(sctx->runtime.snap_to_flag != SCE_SNAP_MODE_FACE); BLI_assert(snap_to_flag != SCE_SNAP_MODE_FACE);
if ((sctx->runtime.snap_to_flag & ~SCE_SNAP_MODE_FACE) == SCE_SNAP_MODE_VERTEX) {
if (em->bm->totvert == 0) {
return SCE_SNAP_MODE_NONE;
}
}
else {
if (em->bm->totedge == 0) {
return SCE_SNAP_MODE_NONE;
}
}
float lpmat[4][4]; float lpmat[4][4];
mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat); mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat);
float dist_px_sq = square_f(*dist_px);
SnapData_EditMesh *sod = snap_object_data_editmesh_get(sctx, ob_eval, em);
/* Test BoundBox */ /* Test BoundBox */
/* Was BKE_boundbox_ray_hit_check, see: cf6ca226fa58. */ /* Was BKE_boundbox_ray_hit_check, see: cf6ca226fa58. */
if (!snap_bound_box_check_dist( if (!snap_bound_box_check_dist(
sod->min, sod->max, lpmat, sctx->runtime.win_size, sctx->runtime.mval, dist_px_sq)) sod->min, sod->max, lpmat, sctx->runtime.win_size, sctx->runtime.mval, *dist_px_sq))
{ {
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX) { if (snap_to_flag & SCE_SNAP_MODE_VERTEX) {
BVHTreeFromEditMesh treedata{}; BVHTreeFromEditMesh treedata{};
treedata.tree = sod->bvhtree[0]; treedata.tree = sod->bvhtree[0];
@@ -592,7 +611,7 @@ eSnapMode snapEditMesh(SnapObjectContext *sctx,
} }
} }
if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_EDGE) { if (snap_to_flag & SCE_SNAP_MODE_EDGE) {
BVHTreeFromEditMesh treedata{}; BVHTreeFromEditMesh treedata{};
treedata.tree = sod->bvhtree[1]; treedata.tree = sod->bvhtree[1];
@@ -624,13 +643,13 @@ eSnapMode snapEditMesh(SnapObjectContext *sctx,
Nearest2dUserData nearest2d; Nearest2dUserData nearest2d;
nearest2d_data_init_editmesh(sod->treedata_editmesh.em, nearest2d_data_init_editmesh(sod->treedata_editmesh.em,
sctx->runtime.view_proj == VIEW_PROJ_PERSP, sctx->runtime.is_persp,
params->use_backface_culling, sctx->runtime.params.use_backface_culling,
&nearest2d); &nearest2d);
BVHTreeNearest nearest{}; BVHTreeNearest nearest{};
nearest.index = -1; nearest.index = -1;
nearest.dist_sq = dist_px_sq; nearest.dist_sq = *dist_px_sq;
eSnapMode elem = SCE_SNAP_MODE_VERTEX; eSnapMode elem = SCE_SNAP_MODE_VERTEX;
@@ -641,7 +660,7 @@ eSnapMode snapEditMesh(SnapObjectContext *sctx,
mul_v4_m4v4(clip_planes_local[i], tobmat, sctx->runtime.clip_plane[i]); mul_v4_m4v4(clip_planes_local[i], tobmat, sctx->runtime.clip_plane[i]);
} }
if (sod->bvhtree[0] && (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_VERTEX)) { if (sod->bvhtree[0] && (snap_to_flag & SCE_SNAP_MODE_VERTEX)) {
BM_mesh_elem_table_ensure(em->bm, BM_VERT); BM_mesh_elem_table_ensure(em->bm, BM_VERT);
BM_mesh_elem_index_ensure(em->bm, BM_VERT); BM_mesh_elem_index_ensure(em->bm, BM_VERT);
BLI_bvhtree_find_nearest_projected(sod->bvhtree[0], BLI_bvhtree_find_nearest_projected(sod->bvhtree[0],
@@ -655,7 +674,7 @@ eSnapMode snapEditMesh(SnapObjectContext *sctx,
&nearest2d); &nearest2d);
} }
if (sod->bvhtree[1] && (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_EDGE)) { if (sod->bvhtree[1] && (snap_to_flag & SCE_SNAP_MODE_EDGE)) {
int last_index = nearest.index; int last_index = nearest.index;
nearest.index = -1; nearest.index = -1;
BM_mesh_elem_table_ensure(em->bm, BM_EDGE | BM_VERT); BM_mesh_elem_table_ensure(em->bm, BM_EDGE | BM_VERT);
@@ -679,7 +698,7 @@ eSnapMode snapEditMesh(SnapObjectContext *sctx,
} }
if (nearest.index != -1) { if (nearest.index != -1) {
*dist_px = sqrtf(nearest.dist_sq); *dist_px_sq = nearest.dist_sq;
copy_v3_v3(r_loc, nearest.co); copy_v3_v3(r_loc, nearest.co);
mul_m4_v3(obmat, r_loc); mul_m4_v3(obmat, r_loc);
@@ -702,3 +721,75 @@ eSnapMode snapEditMesh(SnapObjectContext *sctx,
} }
/** \} */ /** \} */
eSnapMode snap_object_editmesh(SnapObjectContext *sctx,
Object *ob_eval,
ID * /*id*/,
const float obmat[4][4],
eSnapMode snap_to_flag,
bool /*use_hide*/)
{
eSnapMode elem = SCE_SNAP_MODE_NONE;
SnapData_EditMesh *sod = editmesh_snapdata_init(sctx, ob_eval, snap_to_flag);
if (sod == nullptr) {
return elem;
}
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))
{
elem = snapEditMesh(sod,
sctx,
em,
obmat,
snap_to_flag,
&sctx->ret.dist_px_sq,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index);
if (elem) {
return elem;
}
}
if (snap_mode_used & SCE_SNAP_MODE_FACE) {
if (raycastEditMesh(sod,
sctx,
ob_eval,
em,
obmat,
sctx->runtime.object_index++,
/* read/write args */
&sctx->ret.ray_depth_max,
/* return args */
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index,
sctx->ret.hit_list))
{
return SCE_SNAP_MODE_FACE;
}
}
if (snap_mode_used & SCE_SNAP_MODE_FACE_NEAREST) {
if (nearest_world_editmesh(sod,
sctx,
em,
obmat,
sctx->runtime.init_co,
sctx->runtime.curr_co,
&sctx->ret.dist_px_sq,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index))
{
return SCE_SNAP_MODE_FACE_NEAREST;
}
}
return SCE_SNAP_MODE_NONE;
}

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

@@ -82,21 +82,19 @@ static void mesh_looptri_raycast_backface_culling_cb(void *userdata,
} }
} }
bool raycastMesh(const SnapObjectParams *params, static bool raycastMesh(SnapObjectContext *sctx,
const float ray_start[3], Object *ob_eval,
const float ray_dir[3], const Mesh *me_eval,
Object *ob_eval, const float obmat[4][4],
const Mesh *me_eval, const uint ob_index,
const float obmat[4][4], bool use_hide,
const uint ob_index, /* read/write args */
bool use_hide, float *ray_depth,
/* read/write args */ /* return args */
float *ray_depth, float r_loc[3],
/* return args */ float r_no[3],
float r_loc[3], int *r_index,
float r_no[3], ListBase *r_hit_list)
int *r_index,
ListBase *r_hit_list)
{ {
bool retval = false; bool retval = false;
@@ -110,8 +108,8 @@ bool raycastMesh(const SnapObjectParams *params,
invert_m4_m4(imat, obmat); invert_m4_m4(imat, obmat);
copy_v3_v3(ray_start_local, ray_start); copy_v3_v3(ray_start_local, sctx->runtime.ray_start);
copy_v3_v3(ray_normal_local, ray_dir); copy_v3_v3(ray_normal_local, sctx->runtime.ray_dir);
mul_m4_v3(imat, ray_start_local); mul_m4_v3(imat, ray_start_local);
mul_mat3_m4_v3(imat, ray_normal_local); mul_mat3_m4_v3(imat, ray_normal_local);
@@ -191,7 +189,7 @@ bool raycastMesh(const SnapObjectParams *params,
ray_normal_local, ray_normal_local,
0.0f, 0.0f,
&hit, &hit,
params->use_backface_culling ? sctx->runtime.params.use_backface_culling ?
mesh_looptri_raycast_backface_culling_cb : mesh_looptri_raycast_backface_culling_cb :
treedata.raycast_callback, treedata.raycast_callback,
&treedata) != -1) &treedata) != -1)
@@ -229,17 +227,16 @@ bool raycastMesh(const SnapObjectParams *params,
/** \name Surface Snap Functions /** \name Surface Snap Functions
* \{ */ * \{ */
bool nearest_world_mesh(SnapObjectContext *sctx, static bool nearest_world_mesh(SnapObjectContext *sctx,
const SnapObjectParams *params, const Mesh *me_eval,
const Mesh *me_eval, const float (*obmat)[4],
const float (*obmat)[4], bool use_hide,
bool use_hide, const float init_co[3],
const float init_co[3], const float curr_co[3],
const float curr_co[3], float *r_dist_sq,
float *r_dist_sq, float *r_loc,
float *r_loc, float *r_no,
float *r_no, int *r_index)
int *r_index)
{ {
BVHTreeFromMesh treedata; BVHTreeFromMesh treedata;
snap_object_data_mesh_get(me_eval, use_hide, &treedata); snap_object_data_mesh_get(me_eval, use_hide, &treedata);
@@ -248,7 +245,6 @@ bool nearest_world_mesh(SnapObjectContext *sctx,
} }
return nearest_world_tree(sctx, return nearest_world_tree(sctx,
params,
treedata.tree, treedata.tree,
treedata.nearest_callback, treedata.nearest_callback,
&treedata, &treedata,
@@ -429,19 +425,17 @@ void nearest2d_data_init_mesh(const Mesh *mesh,
* \{ */ * \{ */
eSnapMode snap_polygon_mesh(SnapObjectContext *sctx, eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
const SnapObjectParams *params, Object * /*ob_eval*/,
const Mesh *mesh, ID *id,
const float obmat[4][4], const float obmat[4][4],
float clip_planes_local[MAX_CLIPPLANE_LEN][4], eSnapMode snap_to_flag,
/* read/write args */ int polygon,
float *dist_px, const float clip_planes_local[MAX_CLIPPLANE_LEN][4])
/* return args */
float r_loc[3],
float r_no[3],
int *r_index)
{ {
eSnapMode elem = SCE_SNAP_MODE_NONE; eSnapMode elem = SCE_SNAP_MODE_NONE;
Mesh *mesh_eval = reinterpret_cast<Mesh *>(id);
float lpmat[4][4]; float lpmat[4][4];
mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat); mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat);
@@ -451,15 +445,15 @@ eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
BVHTreeNearest nearest{}; BVHTreeNearest nearest{};
nearest.index = -1; nearest.index = -1;
nearest.dist_sq = square_f(*dist_px); nearest.dist_sq = sctx->ret.dist_px_sq;
Nearest2dUserData nearest2d; Nearest2dUserData nearest2d;
nearest2d_data_init_mesh( nearest2d_data_init_mesh(
mesh, sctx->runtime.view_proj == VIEW_PROJ_PERSP, params->use_backface_culling, &nearest2d); mesh_eval, sctx->runtime.is_persp, sctx->runtime.params.use_backface_culling, &nearest2d);
const blender::IndexRange poly = mesh->polys()[sctx->ret.index]; const blender::IndexRange poly = mesh_eval->polys()[polygon];
if (sctx->runtime.snap_to_flag & SCE_SNAP_MODE_EDGE) { if (snap_to_flag & SCE_SNAP_MODE_EDGE) {
elem = SCE_SNAP_MODE_EDGE; elem = SCE_SNAP_MODE_EDGE;
BLI_assert(nearest2d.edges != nullptr); BLI_assert(nearest2d.edges != nullptr);
const int *poly_edges = &nearest2d.corner_edges[poly.start()]; const int *poly_edges = &nearest2d.corner_edges[poly.start()];
@@ -486,10 +480,10 @@ eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
} }
if (nearest.index != -1) { if (nearest.index != -1) {
*dist_px = sqrtf(nearest.dist_sq); sctx->ret.dist_px_sq = sqrtf(nearest.dist_sq);
mul_m4_v3(obmat, nearest.co); mul_m4_v3(obmat, nearest.co);
copy_v3_v3(r_loc, nearest.co); copy_v3_v3(sctx->ret.loc, nearest.co);
{ {
float imat[4][4]; float imat[4][4];
@@ -497,28 +491,27 @@ eSnapMode snap_polygon_mesh(SnapObjectContext *sctx,
mul_transposed_mat3_m4_v3(imat, nearest.no); mul_transposed_mat3_m4_v3(imat, nearest.no);
normalize_v3(nearest.no); normalize_v3(nearest.no);
copy_v3_v3(r_no, nearest.no); copy_v3_v3(sctx->ret.no, nearest.no);
} }
*r_index = nearest.index; sctx->ret.index = nearest.index;
return elem; return elem;
} }
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
eSnapMode snapMesh(SnapObjectContext *sctx, static eSnapMode snapMesh(SnapObjectContext *sctx,
const SnapObjectParams *params, Object *ob_eval,
Object *ob_eval, const Mesh *me_eval,
const Mesh *me_eval, const float obmat[4][4],
const float obmat[4][4], bool use_hide,
bool use_hide, /* read/write args */
/* read/write args */ float *dist_px_sq,
float *dist_px, /* return args */
/* return args */ float r_loc[3],
float r_loc[3], float r_no[3],
float r_no[3], int *r_index)
int *r_index)
{ {
BLI_assert(sctx->runtime.snap_to_flag != SCE_SNAP_MODE_FACE); BLI_assert(sctx->runtime.snap_to_flag != SCE_SNAP_MODE_FACE);
if (me_eval->totvert == 0) { if (me_eval->totvert == 0) {
@@ -531,13 +524,15 @@ eSnapMode snapMesh(SnapObjectContext *sctx,
float lpmat[4][4]; float lpmat[4][4];
mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat); mul_m4_m4m4(lpmat, sctx->runtime.pmat, obmat);
float dist_px_sq = square_f(*dist_px);
/* Test BoundBox */ /* Test BoundBox */
if (ob_eval->data == me_eval) { if (ob_eval->data == me_eval) {
const BoundBox *bb = BKE_object_boundbox_get(ob_eval); const BoundBox *bb = BKE_object_boundbox_get(ob_eval);
if (!snap_bound_box_check_dist( if (!snap_bound_box_check_dist(bb->vec[0],
bb->vec[0], bb->vec[6], lpmat, sctx->runtime.win_size, sctx->runtime.mval, dist_px_sq)) bb->vec[6],
lpmat,
sctx->runtime.win_size,
sctx->runtime.mval,
*dist_px_sq))
{ {
return SCE_SNAP_MODE_NONE; return SCE_SNAP_MODE_NONE;
} }
@@ -555,14 +550,12 @@ eSnapMode snapMesh(SnapObjectContext *sctx,
} }
Nearest2dUserData nearest2d; Nearest2dUserData nearest2d;
nearest2d_data_init_mesh(me_eval, nearest2d_data_init_mesh(
sctx->runtime.view_proj == VIEW_PROJ_PERSP, me_eval, sctx->runtime.is_persp, sctx->runtime.params.use_backface_culling, &nearest2d);
params->use_backface_culling,
&nearest2d);
BVHTreeNearest nearest{}; BVHTreeNearest nearest{};
nearest.index = -1; nearest.index = -1;
nearest.dist_sq = dist_px_sq; nearest.dist_sq = *dist_px_sq;
int last_index = nearest.index; int last_index = nearest.index;
eSnapMode elem = SCE_SNAP_MODE_VERTEX; eSnapMode elem = SCE_SNAP_MODE_VERTEX;
@@ -650,7 +643,7 @@ eSnapMode snapMesh(SnapObjectContext *sctx,
} }
if (nearest.index != -1) { if (nearest.index != -1) {
*dist_px = sqrtf(nearest.dist_sq); *dist_px_sq = nearest.dist_sq;
copy_v3_v3(r_loc, nearest.co); copy_v3_v3(r_loc, nearest.co);
mul_m4_v3(obmat, r_loc); mul_m4_v3(obmat, r_loc);
@@ -674,3 +667,86 @@ eSnapMode snapMesh(SnapObjectContext *sctx,
} }
/** \} */ /** \} */
static eSnapMode mesh_snap_mode_supported(Mesh *mesh)
{
eSnapMode snap_mode_supported = SCE_SNAP_MODE_NONE;
if (mesh->totpoly) {
snap_mode_supported |= SCE_SNAP_MODE_FACE | SCE_SNAP_MODE_FACE_NEAREST;
}
if (mesh->totedge) {
snap_mode_supported |= SCE_SNAP_MODE_EDGE | SCE_SNAP_MODE_EDGE_MIDPOINT |
SCE_SNAP_MODE_EDGE_PERPENDICULAR;
}
if (mesh->totvert) {
snap_mode_supported |= SCE_SNAP_MODE_VERTEX;
}
return snap_mode_supported;
}
eSnapMode snap_object_mesh(SnapObjectContext *sctx,
Object *ob_eval,
ID *id,
const float obmat[4][4],
eSnapMode snap_to_flag,
bool use_hide)
{
eSnapMode elem = SCE_SNAP_MODE_NONE;
Mesh *mesh_eval = reinterpret_cast<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))
{
elem = snapMesh(sctx,
ob_eval,
mesh_eval,
obmat,
use_hide,
&sctx->ret.dist_px_sq,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index);
if (elem) {
return elem;
}
}
if (snap_mode_used & SCE_SNAP_MODE_FACE) {
if (raycastMesh(sctx,
ob_eval,
mesh_eval,
obmat,
sctx->runtime.object_index++,
use_hide,
/* read/write args */
&sctx->ret.ray_depth_max,
/* return args */
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index,
sctx->ret.hit_list))
{
return SCE_SNAP_MODE_FACE;
}
}
if (snap_mode_used & SCE_SNAP_MODE_FACE_NEAREST) {
if (nearest_world_mesh(sctx,
mesh_eval,
obmat,
use_hide,
sctx->runtime.init_co,
sctx->runtime.curr_co,
&sctx->ret.dist_px_sq,
sctx->ret.loc,
sctx->ret.no,
&sctx->ret.index))
{
return SCE_SNAP_MODE_FACE_NEAREST;
}
}
return SCE_SNAP_MODE_NONE;
}