scenevm 0.9.7

A GPU-based layer renderer with configurable compute shaders for Eldiron.
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

use uuid::Uuid;
use vek::Vec4;

use crate::ui::{
    drawable::Drawable,
    text::TextCache,
    workspace::{UiView, ViewContext},
};

use super::align::{HAlign, VAlign};

#[derive(Debug, Clone)]
pub struct LabelRect {
    pub id: Uuid,
    pub text: String,
    pub rect: [f32; 4], // x, y, w, h
    pub px_size: f32,
    pub color: Vec4<f32>,
    pub halign: HAlign,
    pub valign: VAlign,
    pub layer: i32,
}

impl LabelRect {
    pub fn new<T: Into<String>>(text: T, rect: [f32; 4], px_size: f32, color: Vec4<f32>) -> Self {
        Self {
            id: Uuid::new_v4(),
            text: text.into(),
            rect,
            px_size,
            color,
            halign: HAlign::Center,
            valign: VAlign::Center,
            layer: 0,
        }
    }

    pub fn with_align(mut self, halign: HAlign, valign: VAlign) -> Self {
        self.halign = halign;
        self.valign = valign;
        self
    }

    pub fn with_layer(mut self, layer: i32) -> Self {
        self.layer = layer;
        self
    }

    fn calculate_origin(&self, text_cache: &TextCache) -> [f32; 2] {
        let [rect_x, rect_y, rect_w, rect_h] = self.rect;

        // Get text dimensions
        let glyphs = text_cache.layout_positions(&self.text, self.px_size);
        let text_width = if glyphs.is_empty() {
            0.0
        } else {
            glyphs
                .iter()
                .map(|g| g.x + g.width as f32)
                .fold(0.0f32, f32::max)
        };

        // Simple height estimation: use px_size as approximate line height
        let text_height = self.px_size;

        // Calculate horizontal position
        let x = match self.halign {
            HAlign::Left => rect_x,
            HAlign::Center => rect_x + (rect_w - text_width) * 0.5,
            HAlign::Right => rect_x + rect_w - text_width,
        };

        // Calculate vertical position
        let y = match self.valign {
            VAlign::Top => rect_y,
            VAlign::Center => rect_y + (rect_h - text_height) * 0.5,
            VAlign::Bottom => rect_y + rect_h - text_height,
        };

        [x, y]
    }
}

impl UiView for LabelRect {
    fn build(&mut self, ctx: &mut ViewContext) {
        let origin = self.calculate_origin(ctx.text_cache());
        ctx.push(Drawable::Text {
            id: self.id,
            text: self.text.clone(),
            origin,
            px_size: self.px_size,
            color: self.color,
            layer: self.layer,
        });
    }

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

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