dotspace 0.4.0

Explore your Graphviz dot files in interactive 3D space
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
136
137

use crate::types::{GraphNode, LabelSettings, LabelVisibilityIndicator, NodeLabel, SearchState};
use bevy::prelude::*;

pub fn setup_ui(commands: &mut Commands) {
    // Add control instructions
    commands.spawn((
        Text::new("Controls:\nArrows: Pan camera\nShift+Arrows: Orbit view\n+/- or Scroll: Zoom\nLeft drag: Orbit\nRight drag: Pan\nL: Show all labels\n/: Search nodes\nESC: Close search\nQ: Exit"),
        TextFont {
            font_size: 16.0,
            ..default()
        },
        TextColor(Color::WHITE),
        Node {
            position_type: PositionType::Absolute,
            top: Val::Px(10.0),
            left: Val::Px(10.0),
            ..default()
        },
    ));

    // Add label visibility indicator
    commands.spawn((
        Text::new(""),
        TextFont {
            font_size: 20.0,
            ..default()
        },
        TextColor(Color::srgba(1.0, 1.0, 0.0, 0.8)),
        Node {
            position_type: PositionType::Absolute,
            bottom: Val::Px(10.0),
            left: Val::Px(10.0),
            ..default()
        },
        LabelVisibilityIndicator,
    ));
}

pub fn create_node_labels(
    mut commands: Commands,
    node_query: Query<(Entity, &GraphNode), Added<GraphNode>>,
) {
    for (node_entity, graph_node) in &node_query {
        // Create a UI text element for this node
        commands.spawn((
            Text::new(graph_node.name.clone()),
            TextFont {
                font_size: 20.0,
                ..default()
            },
            TextColor(Color::WHITE),
            Node {
                position_type: PositionType::Absolute,
                ..default()
            },
            NodeLabel { node_entity },
            Visibility::Hidden, // Start hidden, will be shown by update system if in range
        ));
    }
}

pub fn toggle_label_visibility(
    keyboard_input: Res<ButtonInput<KeyCode>>,
    mut label_settings: ResMut<LabelSettings>,
    mut indicator_query: Query<&mut Text, With<LabelVisibilityIndicator>>,
    search_state: Res<SearchState>,
) {
    // Don't toggle labels when searching
    if search_state.active {
        return;
    }
    // Toggle show all labels with 'L' key
    if keyboard_input.just_pressed(KeyCode::KeyL) {
        label_settings.show_all_labels = !label_settings.show_all_labels;
        if let Ok(mut text) = indicator_query.single_mut() {
            text.0 = if label_settings.show_all_labels {
                "Showing all labels".to_string()
            } else {
                String::new()
            };
        }
    }
}

pub fn update_node_label_positions(
    camera_query: Query<(&Camera, &GlobalTransform)>,
    node_query: Query<&GlobalTransform, With<GraphNode>>,
    mut label_query: Query<(&mut Node, &mut Visibility, &mut TextColor, &NodeLabel)>,
    label_settings: Res<LabelSettings>,
) {
    let Ok((camera, camera_transform)) = camera_query.single() else {
        return;
    };

    for (mut node_style, mut visibility, mut text_color, label) in &mut label_query {
        let Ok(node_transform) = node_query.get(label.node_entity) else {
            continue;
        };

        // Calculate distance from camera to node
        let distance = camera_transform
            .translation()
            .distance(node_transform.translation());

        // Show label if within distance threshold or if show_all_labels is true
        if label_settings.show_all_labels || distance <= label_settings.visibility_distance {
            *visibility = Visibility::Visible;

            // Fade labels based on distance (closer = more opaque)
            let alpha = if label_settings.show_all_labels {
                // When forcing all labels visible, make them fully opaque
                1.0
            } else {
                // Normal distance-based fading
                let fade_start = label_settings.visibility_distance * 0.7;
                if distance < fade_start {
                    1.0
                } else {
                    1.0 - ((distance - fade_start)
                        / (label_settings.visibility_distance - fade_start))
                }
            };

            text_color.0 = Color::srgba(1.0, 1.0, 1.0, alpha.clamp(0.0, 1.0));
        } else {
            *visibility = Visibility::Hidden;
        }

        // Project 3D position to screen coordinates
        if let Ok(viewport_position) =
            camera.world_to_viewport(camera_transform, node_transform.translation())
        {
            node_style.left = Val::Px(viewport_position.x);
            node_style.top = Val::Px(viewport_position.y);
        }
    }
}