cranpose-render-common 0.1.32

Common rendering contracts for Cranpose
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

//! Renderer-drawn dev overlay (fps counter): one shared graph builder so
//! every backend draws the identical overlay without composition impact.

use crate::graph::{
    CachePolicy, DrawPrimitiveNode, IsolationReasons, LayerNode, PrimitiveEntry, PrimitiveNode,
    PrimitivePhase, ProjectiveTransform, RenderGraph, RenderNode, TextPrimitiveNode,
};
use crate::raster_cache::LayerRasterCacheHashes;
use cranpose_ui_graphics::{
    Brush, Color, CornerRadii, DrawPrimitive, GraphicsLayer, Point, Rect, Size,
};

/// Cache key for the last-built overlay; rebuilding only on change keeps the
/// overlay free when the text is stable.
#[derive(Clone, PartialEq, Eq)]
pub struct DevOverlayKey {
    pub text: String,
    pub viewport_width_bits: u32,
    pub viewport_height_bits: u32,
}

impl DevOverlayKey {
    pub fn new(text: &str, viewport: Size) -> Self {
        Self {
            text: text.to_string(),
            viewport_width_bits: viewport.width.to_bits(),
            viewport_height_bits: viewport.height.to_bits(),
        }
    }
}

/// Build the dev-overlay graph: a translucent pill with the stats text in
/// the top-right corner, sized with fixed monospace-ish metrics so the
/// overlay never depends on renderer text measurement.
pub fn build_dev_overlay_graph(
    text: &str,
    viewport: Size,
    node_id: cranpose_core::NodeId,
) -> RenderGraph {
    let padding = 8.0;
    let font_size = 14.0;
    let char_width = 7.0;
    let text_width = text.len() as f32 * char_width;
    let text_height = font_size * 1.4;
    let x = (viewport.width - text_width - padding * 2.0).max(padding);
    let y = padding;

    let mut overlay_layer = LayerNode {
        node_id: Some(node_id),
        local_bounds: Rect {
            x: 0.0,
            y: 0.0,
            width: text_width + padding,
            height: text_height + padding / 2.0,
        },
        transform_to_parent: ProjectiveTransform::translation(x, y),
        content_offset: Point::default(),
        motion_context_animated: false,
        translated_content_context: false,
        translated_content_offset: Point::default(),
        graphics_layer: GraphicsLayer::default(),
        clip_to_bounds: false,
        shadow_clip: None,
        hit_test: None,
        has_hit_targets: false,
        isolation: IsolationReasons::default(),
        cache_policy: CachePolicy::None,
        cache_hashes: LayerRasterCacheHashes::default(),
        cache_hashes_valid: false,
        children: vec![
            RenderNode::Primitive(PrimitiveEntry {
                phase: PrimitivePhase::BeforeChildren,
                node: PrimitiveNode::Draw(DrawPrimitiveNode {
                    primitive: DrawPrimitive::RoundRect {
                        rect: Rect {
                            x: 0.0,
                            y: 0.0,
                            width: text_width + padding,
                            height: text_height + padding / 2.0,
                        },
                        brush: Brush::Solid(Color(0.0, 0.0, 0.0, 0.7)),
                        radii: CornerRadii::uniform(4.0),
                    },
                    clip: None,
                }),
            }),
            RenderNode::Primitive(PrimitiveEntry {
                phase: PrimitivePhase::AfterChildren,
                node: PrimitiveNode::Text(Box::new(TextPrimitiveNode {
                    node_id,
                    rect: Rect {
                        x: padding / 2.0,
                        y: padding / 4.0,
                        width: text_width,
                        height: text_height,
                    },
                    text: cranpose_ui::text::AnnotatedString::from(text),
                    text_style: cranpose_ui::TextStyle::default(),
                    font_size,
                    layout_options: cranpose_ui::TextLayoutOptions::default(),
                    clip: None,
                })),
            }),
        ],
    };
    overlay_layer.recompute_raster_cache_hashes();

    let mut graph = RenderGraph::new(LayerNode {
        node_id: None,
        local_bounds: Rect::from_size(viewport),
        transform_to_parent: ProjectiveTransform::identity(),
        content_offset: Point::default(),
        motion_context_animated: false,
        translated_content_context: false,
        translated_content_offset: Point::default(),
        graphics_layer: GraphicsLayer::default(),
        clip_to_bounds: false,
        shadow_clip: None,
        hit_test: None,
        has_hit_targets: false,
        isolation: IsolationReasons::default(),
        cache_policy: CachePolicy::None,
        cache_hashes: LayerRasterCacheHashes::default(),
        cache_hashes_valid: false,
        children: vec![RenderNode::Layer(Box::new(overlay_layer))],
    });
    graph.root.recompute_raster_cache_hashes();
    graph
}