anonymous_namespace{SurfaceDrag.cpp} Namespace Reference

Functions
Vec2d	mouse_position (const wxMouseEvent &mouse_event)
	Extract position of mouse from mouse event.
bool	start_dragging (const Vec2d &mouse_pos, const Camera &camera, std::optional< SurfaceDrag > &surface_drag, GLCanvas3D &canvas, RaycastManager &raycast_manager, const std::optional< double > &up_limit)
bool	dragging (const Vec2d &mouse_pos, const Camera &camera, SurfaceDrag &surface_drag, GLCanvas3D &canvas, const RaycastManager &raycast_manager, const std::optional< double > &up_limit)
Transform3d	get_volume_transformation (Transform3d world, const Vec3d &world_dir, const Vec3d &world_position, const std::optional< Transform3d > &fix, const Transform3d &instance_inv, std::optional< float > current_angle={}, const std::optional< double > &up_limit={})
bool	is_embossed_object (const Selection &selection)
const Transform3d *	get_fix_transformation (const Selection &selection)
	Get fix transformation for selected volume Fix after store to 3mf.

Variables
constexpr Slic3r::MinMax< double >	surface_distance_sq {1e-4, 10.}

Function Documentation

dragging()

bool anonymous_namespace{SurfaceDrag.cpp}::dragging	(	const Vec2d &	mouse_pos,
		const Camera &	camera,
		SurfaceDrag &	surface_drag,
		GLCanvas3D &	canvas,
		const RaycastManager &	raycast_manager,
		const std::optional< double > &	up_limit )

{
    Vec2d offseted_mouse = mouse_pos + surface_drag.mouse_offset_without_sla_shift;
    std::optional<RaycastManager::Hit> hit = ray_from_camera(
        raycast_manager, offseted_mouse, camera, &surface_drag.condition);
 
    surface_drag.exist_hit = hit.has_value();
    if (!hit.has_value()) {
        // cross hair need redraw
        canvas.set_as_dirty();
        return true;
    }
 
    const ModelVolume *volume = get_model_volume(*surface_drag.gl_volume, canvas.get_model()->objects);
    std::optional<Transform3d> fix;
    if (volume !=nullptr && 
        volume->emboss_shape.has_value() && 
        volume->emboss_shape->fix_3mf_tr.has_value())
        fix = volume->emboss_shape->fix_3mf_tr;
    Transform3d volume_new = get_volume_transformation(surface_drag.world, hit->normal, hit->position,
        fix, surface_drag.instance_inv, surface_drag.start_angle, up_limit);
 
    // Update transformation for all instances
    for (GLVolume *vol : canvas.get_volumes().volumes) {
        if (vol->object_idx() != surface_drag.gl_volume->object_idx() || 
            vol->volume_idx() != surface_drag.gl_volume->volume_idx())
            continue;
        vol->set_volume_transformation(volume_new);
    }
 
    canvas.set_as_dirty();
    // Show current position in manipulation panel
    wxGetApp().obj_manipul()->set_dirty();
    return true;
}

References Slic3r::GUI::SurfaceDrag::condition, Slic3r::ModelVolume::emboss_shape, Slic3r::GUI::SurfaceDrag::exist_hit, Slic3r::GUI::GLCanvas3D::get_model(), Slic3r::GUI::get_model_volume(), get_volume_transformation(), Slic3r::GUI::GLCanvas3D::get_volumes(), Slic3r::GUI::SurfaceDrag::gl_volume, Slic3r::GUI::SurfaceDrag::instance_inv, Slic3r::GUI::SurfaceDrag::mouse_offset_without_sla_shift, Slic3r::GLVolume::object_idx(), Slic3r::Model::objects, Slic3r::GUI::ray_from_camera(), Slic3r::GUI::GLCanvas3D::set_as_dirty(), Slic3r::GUI::SurfaceDrag::start_angle, Slic3r::GLVolume::volume_idx(), Slic3r::GLVolumeCollection::volumes, and Slic3r::GUI::SurfaceDrag::world.

Here is the call graph for this function:

get_fix_transformation()

const Transform3d * anonymous_namespace{SurfaceDrag.cpp}::get_fix_transformation

(

const Selection &

selection

)

Get fix transformation for selected volume Fix after store to 3mf.

Parameters

selection

Select only wanted volume

Returns

Pointer on fix transformation from ModelVolume when exists otherwise nullptr

                                                                      {
    const GLVolume *gl_volume = get_selected_gl_volume(selection);
    assert(gl_volume != nullptr);
    if (gl_volume == nullptr)
        return nullptr;
 
    const ModelVolume *volume = get_model_volume(*gl_volume, selection.get_model()->objects);
    assert(volume != nullptr);
    if (volume == nullptr)
        return nullptr;
 
    const std::optional<EmbossShape> &es = volume->emboss_shape;
    if (!volume->emboss_shape.has_value())
        return nullptr;
    if (!es->fix_3mf_tr.has_value())
        return nullptr;
    return &(*es->fix_3mf_tr);
}

References Slic3r::ModelVolume::emboss_shape, Slic3r::GUI::Selection::get_model(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::get_selected_gl_volume(), and Slic3r::Model::objects.

Here is the call graph for this function:

get_volume_transformation()

Transform3d anonymous_namespace{SurfaceDrag.cpp}::get_volume_transformation	(	Transform3d	world,
		const Vec3d &	world_dir,
		const Vec3d &	world_position,
		const std::optional< Transform3d > &	fix,
		const Transform3d &	instance_inv,
		std::optional< float >	current_angle = {},
		const std::optional< double > &	up_limit = {} )

{
    auto world_linear = world.linear().eval();
    // Calculate offset: transformation to wanted position
    {
        // Reset skew of the text Z axis:
        // Project the old Z axis into a new Z axis, which is perpendicular to the old XY plane.
        Vec3d old_z         = world_linear.col(2);
        Vec3d new_z         = world_linear.col(0).cross(world_linear.col(1));
        world_linear.col(2) = new_z * (old_z.dot(new_z) / new_z.squaredNorm());
    }
 
    Vec3d       text_z_world     = world_linear.col(2); // world_linear * Vec3d::UnitZ()
    auto        z_rotation       = Eigen::Quaternion<double, Eigen::DontAlign>::FromTwoVectors(text_z_world, world_dir);
    Transform3d world_new        = z_rotation * world;
    auto        world_new_linear = world_new.linear().eval();
 
    // Fix direction of up vector to zero initial rotation
    if(up_limit.has_value()){
        Vec3d z_world = world_new_linear.col(2);
        z_world.normalize();
        Vec3d wanted_up = Emboss::suggest_up(z_world, *up_limit);
 
        Vec3d y_world    = world_new_linear.col(1);
        auto  y_rotation = Eigen::Quaternion<double, Eigen::DontAlign>::FromTwoVectors(y_world, wanted_up);
 
        world_new        = y_rotation * world_new;
        world_new_linear = world_new.linear();
    }
    
    // Edit position from right
    Transform3d volume_new{Eigen::Translation<double, 3>(instance_inv * world_position)};
    volume_new.linear() = instance_inv.linear() * world_new_linear;
 
    // Check that transformation matrix is valid transformation
    assert(volume_new.matrix()(0, 0) == volume_new.matrix()(0, 0)); // Check valid transformation not a NAN
    if (volume_new.matrix()(0, 0) != volume_new.matrix()(0, 0))
        return Transform3d::Identity();
 
    // Check that scale in world did not changed
    assert(!calc_scale(world_linear, world_new_linear, Vec3d::UnitY()).has_value());
    assert(!calc_scale(world_linear, world_new_linear, Vec3d::UnitZ()).has_value());
 
    // fix baked transformation from .3mf store process
    if (fix.has_value())
        volume_new = volume_new * (*fix);
 
    // apply move in Z direction and rotation by up vector
    Emboss::apply_transformation(current_angle, {}, volume_new);
 
    return volume_new;    
}

References Slic3r::Emboss::apply_transformation(), Slic3r::GUI::calc_scale(), and Slic3r::Emboss::suggest_up().

Referenced by dragging().

Here is the call graph for this function:

Here is the caller graph for this function:

is_embossed_object()

bool anonymous_namespace{SurfaceDrag.cpp}::is_embossed_object

(

const Selection &

selection

)

{
    assert(selection.volumes_count() == 1);
    return selection.is_single_full_object() || selection.is_single_full_instance();
}

References Slic3r::GUI::Selection::is_single_full_instance(), Slic3r::GUI::Selection::is_single_full_object(), and Slic3r::GUI::Selection::volumes_count().

Here is the call graph for this function:

mouse_position()

Vec2d anonymous_namespace{SurfaceDrag.cpp}::mouse_position

(

const wxMouseEvent &

mouse_event

)

Extract position of mouse from mouse event.

Parameters

mouse_event

Event

Returns

Position

                                                     {
    // wxCoord == int --> wx/types.h
    Vec2i32 mouse_coord(mouse_event.GetX(), mouse_event.GetY());
    return mouse_coord.cast<double>();
}

References Slic3r::GUI::wxMouseEvent.

start_dragging()

bool anonymous_namespace{SurfaceDrag.cpp}::start_dragging	(	const Vec2d &	mouse_pos,
		const Camera &	camera,
		std::optional< SurfaceDrag > &	surface_drag,
		GLCanvas3D &	canvas,
		RaycastManager &	raycast_manager,
		const std::optional< double > &	up_limit )

{
    // selected volume
    GLVolume *gl_volume_ptr = get_selected_gl_volume(canvas);
    if (gl_volume_ptr == nullptr)
        return false;
    const GLVolume &gl_volume = *gl_volume_ptr;
 
    // is selected volume closest hovered?
    const GLVolumePtrs &gl_volumes = canvas.get_volumes().volumes;
    if (int hovered_idx = canvas.get_first_hover_volume_idx(); hovered_idx < 0)
        return false;
    else if (auto hovered_idx_ = static_cast<size_t>(hovered_idx);
             hovered_idx_ >= gl_volumes.size() || gl_volumes[hovered_idx_] != gl_volume_ptr)
        return false;
 
    const ModelObjectPtrs &objects = canvas.get_model()->objects;
    const ModelObject     *object  = get_model_object(gl_volume, objects);
    assert(object != nullptr);
    if (object == nullptr)
        return false;
 
    const ModelInstance *instance = get_model_instance(gl_volume, *object);
    const ModelVolume   *volume   = get_model_volume(gl_volume, *object);
    assert(instance != nullptr && volume != nullptr);
    if (object == nullptr || instance == nullptr || volume == nullptr)
        return false;
 
    // allowed drag&drop by canvas for object
    if (volume->is_the_only_one_part())
        return false;
 
    RaycastManager::AllowVolumes condition = create_condition(object->volumes, volume->id());
    RaycastManager::Meshes meshes = create_meshes(canvas, condition);
    // initialize raycasters
    // INFO: It could slows down for big objects
    // (may be move to thread and do not show drag until it finish)
    raycast_manager.actualize(*instance, &condition, &meshes);
 
    // world_matrix_fixed() without sla shift
    Transform3d to_world = world_matrix_fixed(gl_volume, objects);
 
    // zero point of volume in world coordinate system
    Vec3d volume_center = to_world.translation();
    // screen coordinate of volume center
    auto coor                           = CameraUtils::project(camera, volume_center);
    Vec2d mouse_offset                   = coor.cast<double>() - mouse_pos;
    Vec2d mouse_offset_without_sla_shift = mouse_offset;
    if (double sla_shift = gl_volume.get_sla_shift_z(); !is_approx(sla_shift, 0.)) {
        Transform3d to_world_without_sla_move = instance->get_matrix() * volume->get_matrix();
        if (volume->emboss_shape.has_value() && volume->emboss_shape->fix_3mf_tr.has_value())
            to_world_without_sla_move = to_world_without_sla_move * (*volume->emboss_shape->fix_3mf_tr);
        // zero point of volume in world coordinate system
        volume_center = to_world_without_sla_move.translation();
        // screen coordinate of volume center
        coor                           = CameraUtils::project(camera, volume_center);
        mouse_offset_without_sla_shift = coor.cast<double>() - mouse_pos;
    }
 
    Transform3d volume_tr = gl_volume.get_volume_transformation().get_matrix();
 
    // fix baked transformation from .3mf store process
    if (const std::optional<EmbossShape> &es_opt = volume->emboss_shape; es_opt.has_value()) {
        const std::optional<Slic3r::Transform3d> &fix = es_opt->fix_3mf_tr;
        if (fix.has_value())
            volume_tr = volume_tr * fix->inverse();
    }
 
    Transform3d instance_tr     = instance->get_matrix();
    Transform3d instance_tr_inv = instance_tr.inverse();
    Transform3d world_tr        = instance_tr * volume_tr;
    std::optional<float> start_angle;
    if (up_limit.has_value()) {
        start_angle = Emboss::calc_up(world_tr, *up_limit);
        if (start_angle.has_value() && has_reflection(world_tr))
            start_angle = -(*start_angle);
    }
 
    std::optional<float> start_distance;
    if (!volume->emboss_shape->projection.use_surface)
        start_distance = calc_distance(gl_volume, raycast_manager, &condition, volume->emboss_shape->fix_3mf_tr);
    surface_drag = SurfaceDrag{mouse_offset,   world_tr,  instance_tr_inv,
                               gl_volume_ptr,  condition, start_angle,
                               start_distance, true,      mouse_offset_without_sla_shift};
 
    // disable moving with object by mouse
    canvas.enable_moving(false);
    canvas.enable_picking(false);
    return true;
}

References Slic3r::GUI::RaycastManager::actualize(), Slic3r::GUI::calc_distance(), Slic3r::Emboss::calc_up(), Slic3r::GUI::create_condition(), Slic3r::GUI::create_meshes(), Slic3r::ModelVolume::emboss_shape, Slic3r::GUI::GLCanvas3D::enable_moving(), Slic3r::GUI::GLCanvas3D::enable_picking(), Slic3r::GUI::GLCanvas3D::get_first_hover_volume_idx(), Slic3r::Geometry::Transformation::get_matrix(), Slic3r::ModelInstance::get_matrix(), Slic3r::ModelVolume::get_matrix(), Slic3r::GUI::GLCanvas3D::get_model(), Slic3r::GUI::get_model_instance(), Slic3r::GUI::get_model_object(), Slic3r::GUI::get_model_volume(), Slic3r::GUI::get_selected_gl_volume(), Slic3r::GLVolume::get_sla_shift_z(), Slic3r::GLVolume::get_volume_transformation(), Slic3r::GUI::GLCanvas3D::get_volumes(), Slic3r::has_reflection(), Slic3r::ObjectBase::id(), Slic3r::is_approx(), Slic3r::ModelVolume::is_the_only_one_part(), Slic3r::Model::objects, Slic3r::GUI::CameraUtils::project(), Slic3r::GLVolumeCollection::volumes, Slic3r::ModelObject::volumes, and Slic3r::GUI::world_matrix_fixed().

Here is the call graph for this function:

Variable Documentation

surface_distance_sq

Slic3r::MinMax<double> anonymous_namespace{SurfaceDrag.cpp}::surface_distance_sq {1e-4, 10.}

constexpr

{1e-4, 10.}; // [in mm]