nightshade 0.8.0

A cross-platform data-oriented game engine.
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

use super::{ComponentInspector, InspectorContext};
use crate::prelude::*;

pub struct MeshInspector;

const MESH_TYPES: &[&str] = &["Cube", "Sphere", "Plane", "Cylinder", "Cone", "Torus"];

impl ComponentInspector for MeshInspector {
    fn name(&self) -> &str {
        "Mesh"
    }

    fn has_component(&self, world: &World, entity: Entity) -> bool {
        world.entity_has_render_mesh(entity)
    }

    fn add_component(&self, world: &mut World, entity: Entity) {
        world.set_render_mesh(entity, RenderMesh::default());
        world.resources.mesh_render_state.mark_entity_added(entity);
    }

    fn remove_component(&self, world: &mut World, entity: Entity) {
        if let Some(render_mesh) = world.get_render_mesh(entity) {
            let mesh_name = render_mesh.name.clone();
            if let Some(&index) = world
                .resources
                .mesh_cache
                .registry
                .name_to_index
                .get(&mesh_name)
            {
                world.resources.mesh_cache.registry.remove_reference(index);
            }
        }
        world
            .resources
            .mesh_render_state
            .mark_entity_removed(entity);
        world.remove_render_mesh(entity);
    }

    fn ui(
        &mut self,
        world: &mut World,
        entity: Entity,
        ui: &mut egui::Ui,
        _context: &mut InspectorContext,
    ) {
        let previous_name = world
            .get_render_mesh(entity)
            .map(|mesh| mesh.name.clone())
            .unwrap_or_default();

        if let Some(mesh) = world.get_render_mesh_mut(entity) {
            ui.label("Mesh Type:");
            let display_name = truncate_mesh_name(&mesh.name, 30);
            egui::ComboBox::from_id_salt("mesh_type")
                .selected_text(&display_name)
                .show_ui(ui, |ui| {
                    for mesh_type in MESH_TYPES {
                        ui.selectable_value(&mut mesh.name, mesh_type.to_string(), *mesh_type);
                    }
                });
        }

        let current_name = world
            .get_render_mesh(entity)
            .map(|mesh| mesh.name.clone())
            .unwrap_or_default();

        if current_name != previous_name {
            if let Some(&index) = world
                .resources
                .mesh_cache
                .registry
                .name_to_index
                .get(&previous_name)
            {
                world.resources.mesh_cache.registry.remove_reference(index);
            }
            if let Some(&index) = world
                .resources
                .mesh_cache
                .registry
                .name_to_index
                .get(&current_name)
            {
                world.resources.mesh_cache.registry.add_reference(index);
            }
            world
                .resources
                .mesh_render_state
                .mark_entity_removed(entity);
            world.resources.mesh_render_state.mark_entity_added(entity);
        }
    }
}

fn truncate_mesh_name(name: &str, max_len: usize) -> String {
    if let Some(filename) = std::path::Path::new(name).file_name() {
        let filename_str = filename.to_string_lossy();
        if filename_str.len() <= max_len {
            return filename_str.to_string();
        }
        return format!("{}...", &filename_str[..max_len.saturating_sub(3)]);
    }
    if name.len() <= max_len {
        return name.to_string();
    }
    format!("{}...", &name[..max_len.saturating_sub(3)])
}