mittens-engine 0.7.0

A Vulkan and OpenXR scene engine with ECS, reactive signals, and Meow Meow scripting
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::engine::ecs::ComponentId;
use crate::engine::ecs::component::Component;
use crate::engine::ecs::{IntentValue, SignalEmitter};

#[derive(Debug, Clone)]
pub struct TextInputComponent {
    pub text: String,
    pub caret: usize,
    pub focused: bool,
    pub read_only: bool,
    component: Option<ComponentId>,
}

impl TextInputComponent {
    pub fn new(text: impl Into<String>) -> Self {
        let text = text.into();
        let caret = text.chars().count();
        Self {
            text,
            caret,
            focused: false,
            read_only: false,
            component: None,
        }
    }

    pub fn set_text(&mut self, text: impl Into<String>) {
        self.text = text.into();
        self.clamp_caret();
    }

    pub fn clamp_caret(&mut self) {
        self.caret = self.caret.min(self.text.chars().count());
    }
}

impl Default for TextInputComponent {
    fn default() -> Self {
        Self::new("")
    }
}

impl Component for TextInputComponent {
    fn name(&self) -> &'static str {
        "text_input"
    }

    fn set_id(&mut self, id: ComponentId) {
        self.component = Some(id);
    }

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
        self
    }

    fn init(&mut self, emit: &mut dyn SignalEmitter, component: ComponentId) {
        let _ = self.component;
        emit.push_intent_now(
            component,
            IntentValue::RegisterTextInput {
                component_id: component,
            },
        );
    }

    fn encode(&self) -> std::collections::HashMap<String, serde_json::Value> {
        let mut out = std::collections::HashMap::new();
        out.insert(
            "text".to_string(),
            serde_json::Value::String(self.text.clone()),
        );
        if self.read_only {
            out.insert("read_only".to_string(), serde_json::Value::Bool(true));
        }
        out
    }

    fn decode(
        &mut self,
        data: &std::collections::HashMap<String, serde_json::Value>,
    ) -> Result<(), String> {
        if let Some(serde_json::Value::String(text)) = data.get("text") {
            self.text = text.clone();
        }
        if let Some(serde_json::Value::Bool(read_only)) = data.get("read_only") {
            self.read_only = *read_only;
        }
        self.clamp_caret();
        Ok(())
    }

    fn to_mms_ast(
        &self,
        _world: &crate::engine::ecs::World,
    ) -> crate::scripting::ast::ComponentExpression {
        use crate::engine::ecs::component::ce_helpers::*;
        use crate::scripting::ast::{Expression, Statement};

        let mut node = ce("TextInput");
        if !self.text.is_empty() {
            node.body
                .statements
                .push(Statement::Expression(Expression::String(self.text.clone())));
        }
        if self.read_only {
            node = node.with_call("read_only", vec![b(true)]);
        }
        node
    }
}

#[derive(Debug, Clone, Copy)]
pub struct TextInputGlyphHitComponent {
    pub text_input_root: ComponentId,
    pub text_target: ComponentId,
    pub char_index: usize,
}

impl Component for TextInputGlyphHitComponent {
    fn name(&self) -> &'static str {
        "text_input_glyph_hit"
    }

    fn set_id(&mut self, _id: ComponentId) {}

    fn as_any(&self) -> &dyn std::any::Any {
        self
    }

    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
        self
    }
}