polyscope-rs 0.5.10

A Rust-native 3D visualization library for geometric data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::{GizmoMode, GizmoSpace, Mat4, with_context, with_context_mut};

/// Selects a structure for gizmo manipulation.
///
/// Only one structure can be selected at a time. The gizmo will appear
/// at the selected structure's position when enabled.
pub fn select_structure(type_name: &str, name: &str) {
    with_context_mut(|ctx| {
        ctx.select_structure(type_name, name);
    });
}

/// Deselects the currently selected structure.
pub fn deselect_structure() {
    with_context_mut(|ctx| {
        ctx.deselect_structure();
    });
}

/// Returns the currently selected structure, if any.
#[must_use]
pub fn get_selected_structure() -> Option<(String, String)> {
    with_context(|ctx| {
        ctx.selected_structure()
            .map(|(t, n)| (t.to_string(), n.to_string()))
    })
}

/// Returns whether any structure is currently selected.
#[must_use]
pub fn has_selection() -> bool {
    with_context(polyscope_core::Context::has_selection)
}

/// Sets the gizmo mode (translate, rotate, or scale).
pub fn set_gizmo_mode(mode: GizmoMode) {
    with_context_mut(|ctx| {
        ctx.gizmo_mut().mode = mode;
    });
}

/// Returns the current gizmo mode.
#[must_use]
pub fn get_gizmo_mode() -> GizmoMode {
    with_context(|ctx| ctx.gizmo().mode)
}

/// Sets the gizmo coordinate space (world or local).
pub fn set_gizmo_space(space: GizmoSpace) {
    with_context_mut(|ctx| {
        ctx.gizmo_mut().space = space;
    });
}

/// Returns the current gizmo coordinate space.
#[must_use]
pub fn get_gizmo_space() -> GizmoSpace {
    with_context(|ctx| ctx.gizmo().space)
}

/// Sets whether the gizmo is visible.
pub fn set_gizmo_visible(visible: bool) {
    with_context_mut(|ctx| {
        ctx.gizmo_mut().visible = visible;
    });
}

/// Returns whether the gizmo is visible.
#[must_use]
pub fn is_gizmo_visible() -> bool {
    with_context(|ctx| ctx.gizmo().visible)
}

/// Sets the translation snap value for the gizmo.
///
/// When non-zero, translations will snap to multiples of this value.
pub fn set_gizmo_snap_translate(snap: f32) {
    with_context_mut(|ctx| {
        ctx.gizmo_mut().snap_translate = snap;
    });
}

/// Sets the rotation snap value for the gizmo (in degrees).
///
/// When non-zero, rotations will snap to multiples of this value.
pub fn set_gizmo_snap_rotate(snap_degrees: f32) {
    with_context_mut(|ctx| {
        ctx.gizmo_mut().snap_rotate = snap_degrees;
    });
}

/// Sets the scale snap value for the gizmo.
///
/// When non-zero, scale will snap to multiples of this value.
pub fn set_gizmo_snap_scale(snap: f32) {
    with_context_mut(|ctx| {
        ctx.gizmo_mut().snap_scale = snap;
    });
}

/// Sets the transform of the currently selected structure.
///
/// Does nothing if no structure is selected.
pub fn set_selected_transform(transform: Mat4) {
    with_context_mut(|ctx| {
        if let Some((type_name, name)) = ctx.selected_structure.clone() {
            if let Some(structure) = ctx.registry.get_mut(&type_name, &name) {
                structure.set_transform(transform);
            }
        }
    });
}

/// Gets the transform of the currently selected structure.
///
/// Returns identity matrix if no structure is selected.
#[must_use]
pub fn get_selected_transform() -> Mat4 {
    with_context(|ctx| {
        if let Some((type_name, name)) = ctx.selected_structure() {
            ctx.registry
                .get(type_name, name)
                .map_or(Mat4::IDENTITY, polyscope_core::Structure::transform)
        } else {
            Mat4::IDENTITY
        }
    })
}

/// Resets the transform of the currently selected structure to identity.
///
/// Does nothing if no structure is selected.
pub fn reset_selected_transform() {
    set_selected_transform(Mat4::IDENTITY);
}