ling-graphics 2030.0.0

3D/4D rendering, geometry, animation, and font tools for the Ling ecosystem
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

use crate::camera::Camera3D;
use crate::color::Color;
use crate::renderer::{Renderer, SoftwareRenderer};
use crate::scene::{Scene, Transform as SceneTransform};
use crate::renderer::FrameBuffer;
use crate::viewport::Viewport;

/// Terminal-based "window" that renders frames via `SoftwareRenderer`.
///
/// Renders a 3-D scene to an RGBA framebuffer then presents it either as
/// coloured ANSI art in the terminal (`present_terminal`) or drives a full
/// animation loop (`run`).
pub struct Window {
    pub viewport: Viewport,
    renderer: SoftwareRenderer,
    term_cols: usize,
    term_rows: usize,
}

impl Window {
    pub fn new(viewport: Viewport) -> Self {
        Self {
            viewport,
            renderer: SoftwareRenderer::new(),
            term_cols: 100,
            term_rows: 40,
        }
    }

    pub fn with_terminal_dimensions(mut self, cols: usize, rows: usize) -> Self {
        self.term_cols = cols.max(10);
        self.term_rows = rows.max(10);
        self
    }

    /// Render the scene into the internal framebuffer and return a clone.
    pub fn render_scene(&mut self, scene: &Scene, camera: &Camera3D) -> FrameBuffer {
        self.renderer.begin_frame(
            self.viewport.width,
            self.viewport.height,
            self.viewport.clear_color,
        );

        for &root in scene.roots() {
            self.render_node_recursive(scene, root, camera, &scene.node(root).transform, 1.0);
        }

        self.renderer.end_frame().clone()
    }

    fn render_node_recursive(
        &mut self,
        scene: &Scene,
        node_id: usize,
        camera: &Camera3D,
        _parent_transform: &SceneTransform,
        _dummy_depth: f32,
    ) {
        let node = scene.node(node_id);
        if node.visible {
            if let (Some(mesh), Some(material)) = (node.mesh.as_ref(), node.material.as_ref()) {
                let global = scene.global_transform(node_id);
                let _ = global;
                self.renderer.draw_mesh(mesh, &node.transform, material, camera);
            }
            // Collect children first to avoid borrow conflict
            let children: Vec<usize> = node.children.clone();
            let transform = node.transform.clone();
            for child in children {
                self.render_node_recursive(scene, child, camera, &transform, _dummy_depth);
            }
        }
    }

    /// Present the last rendered frame to the terminal as ANSI art.
    pub fn present_terminal(&mut self) {
        // Clone the framebuffer to release the mutable borrow on self.renderer
        // before calling present_framebuffer_ascii which needs &self.
        let fb = self.renderer.end_frame().clone();
        self.present_framebuffer_ascii(&fb);
    }

    fn present_framebuffer_ascii(&self, fb: &FrameBuffer) {
        let mut out = String::new();
        out.push_str("\x1b[2J\x1b[H");

        let w = fb.width as usize;
        let h = fb.height as usize;
        let step_x = (w / self.term_cols).max(1);
        let step_y = (h / self.term_rows).max(1);

        // Map luminance to ASCII density ramp
        let chars = b" .:-=+*#%@";

        for y in (0..h).step_by(step_y) {
            for x in (0..w).step_by(step_x) {
                let i = (y * w + x) * 4;
                let r = fb.pixels[i]     as f32 / 255.0;
                let g = fb.pixels[i + 1] as f32 / 255.0;
                let b = fb.pixels[i + 2] as f32 / 255.0;
                let lum = 0.2126 * r + 0.7152 * g + 0.0722 * b;
                let idx = ((lum.clamp(0.0, 1.0)) * ((chars.len() - 1) as f32)) as usize;
                out.push(chars[idx] as char);
            }
            out.push('\n');
        }

        print!("{}", out);
    }

    /// Drive the render / tick / present loop for `max_frames` frames.
    pub fn run(
        &mut self,
        mut scene: Scene,
        mut camera: Camera3D,
        mut tick: impl FnMut(u64, &mut Scene, &mut Camera3D),
        max_frames: u64,
    ) {
        for frame in 0..max_frames {
            tick(frame, &mut scene, &mut camera);

            // Render → clone the framebuffer → present.
            // Cloning releases the mutable borrow of self.renderer so that
            // present_framebuffer_ascii can borrow self immutably.
            let fb = self.render_scene(&scene, &camera);
            self.present_framebuffer_ascii(&fb);
        }
    }
}