rsplot 0.5.0

silx-style scientific plotting for egui, rendered with wgpu
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254

//! Headless render check for the plot3d P1.3 textured-image pipeline
//! (`render::gpu_scene3d` image layers + `scene3d_image.wgsl`): a 2×2 colour
//! checkerboard placed as a quad in the z=0 plane should project, quadrant by
//! quadrant, to the expected screen colours.
//!
//! The image data is row-major (row 0 first); UV `v=0` is at the origin corner
//! (world y=0), so row 0 lands at the *bottom* of the screen and row 1 at the
//! top (screen y is flipped). With the camera centred on the image:
//!
//! - bottom-left  = (row0, col0) = red
//! - bottom-right = (row0, col1) = green
//! - top-left     = (row1, col0) = blue
//! - top-right    = (row1, col1) = white
//!
//! Asserting the four quadrants proves texture upload, UV mapping, the world-rect
//! quad, and the MVP projection are all correct.

use egui_kittest::Harness;
use egui_kittest::wgpu::{WgpuTestRenderer, create_render_state, default_wgpu_setup};
use rsplot::egui::{self, Color32};
use rsplot::egui_wgpu::RenderState;
use rsplot::{
    Camera, ImageInterpolation, Scene3dGeometry, Scene3dImageLayer, Vec3, install_scene3d,
    paint_scene3d, set_scene3d,
};
use std::cell::RefCell;
use std::rc::Rc;

const SCENE_ID: u64 = 0;
const WIN: f32 = 300.0;

/// Premultiplied-linear RGBA8 for an opaque colour (the layer's pixel format).
fn px(c: Color32) -> [u8; 4] {
    let [r, g, b, a] = egui::Rgba::from(c).to_array();
    [
        (r * 255.0).round() as u8,
        (g * 255.0).round() as u8,
        (b * 255.0).round() as u8,
        (a * 255.0).round() as u8,
    ]
}

struct App {
    camera: Camera,
    last_rect: Option<egui::Rect>,
}

impl App {
    fn new(rs: &RenderState) -> Self {
        install_scene3d(rs);

        // 2×2 image: row0 = [red, green], row1 = [blue, white].
        let mut pixels = Vec::new();
        for c in [Color32::RED, Color32::GREEN, Color32::BLUE, Color32::WHITE] {
            pixels.extend_from_slice(&px(c));
        }
        let mut g = Scene3dGeometry::new();
        g.add_image_layer(Scene3dImageLayer {
            pixels,
            width: 2,
            height: 2,
            origin: [0.0, 0.0, 0.0],
            scale: [1.0, 1.0], // spans world [0,2]×[0,2]
            interpolation: ImageInterpolation::Nearest,
        });
        set_scene3d(rs, SCENE_ID, &g);

        // Camera centred on the image centre (1,1,0), looking down −z.
        let camera = Camera::new(
            30.0,
            0.1,
            100.0,
            (1.0, 1.0),
            Vec3::new(1.0, 1.0, 5.0),
            Vec3::new(0.0, 0.0, -1.0),
            Vec3::new(0.0, 1.0, 0.0),
        );
        Self {
            camera,
            last_rect: None,
        }
    }

    fn ui(&mut self, ui: &mut egui::Ui) {
        let (rect, _resp) = ui.allocate_exact_size(ui.available_size(), egui::Sense::hover());
        paint_scene3d(ui, rect, SCENE_ID, &self.camera, Color32::BLACK);
        self.last_rect = Some(rect);
    }
}

#[test]
fn scene3d_image_quad_projects_its_texels() {
    let rs = create_render_state(default_wgpu_setup());
    let app = Rc::new(RefCell::new(App::new(&rs)));
    let renderer = WgpuTestRenderer::from_render_state(rs);

    let app_ui = app.clone();
    let mut harness = Harness::builder()
        .with_size(egui::vec2(WIN, WIN))
        .with_pixels_per_point(1.0)
        .renderer(renderer)
        .build_ui(move |ui| app_ui.borrow_mut().ui(ui));

    harness.step();
    let rect = app.borrow().last_rect.expect("scene rect captured");

    let image = harness.render().expect("headless wgpu render");
    let (iw, ih) = (image.width() as usize, image.height() as usize);
    let raw = image.as_raw();

    let at = |fx: f32, fy: f32| -> (u8, u8, u8) {
        let x = ((rect.min.x + fx * rect.width()).round() as usize).min(iw - 1);
        let y = ((rect.min.y + fy * rect.height()).round() as usize).min(ih - 1);
        let i = (y * iw + x) * 4;
        (raw[i], raw[i + 1], raw[i + 2])
    };

    // Corners (outside the image quad): the black offscreen clear.
    for (fx, fy) in [(0.03, 0.03), (0.97, 0.97)] {
        let (r, g, b) = at(fx, fy);
        assert!(r < 40 && g < 40 && b < 40, "corner should be black clear");
    }

    // Quadrant centres (image spans the central ~75% of the square rect).
    let red = at(0.313, 0.687);
    let green = at(0.687, 0.687);
    let blue = at(0.313, 0.313);
    let white = at(0.687, 0.313);

    let dominant = |(r, g, b): (u8, u8, u8), ch: usize| {
        let v = [r, g, b];
        v[ch] > 200 && v[(ch + 1) % 3] < 70 && v[(ch + 2) % 3] < 70
    };
    assert!(dominant(red, 0), "bottom-left should be red; got {red:?}");
    assert!(
        dominant(green, 1),
        "bottom-right should be green; got {green:?}"
    );
    assert!(dominant(blue, 2), "top-left should be blue; got {blue:?}");
    assert!(
        white.0 > 200 && white.1 > 200 && white.2 > 200,
        "top-right should be white; got {white:?}"
    );
}

/// A front image with one fully transparent texel must let the 3D geometry
/// behind the hole show through — silx `_Image` discards `alpha == 0` texels
/// (`primitives.py:2120-2123`), so they write neither colour nor depth. Before
/// the fix the transparent stand-in for GLSL `discard` still wrote depth and
/// occluded whatever sat behind the hole.
struct DepthHoleApp {
    camera: Camera,
    last_rect: Option<egui::Rect>,
}

impl DepthHoleApp {
    fn new(rs: &RenderState) -> Self {
        install_scene3d(rs);

        let mut g = Scene3dGeometry::new();

        // FRONT quad at z=0 (nearer the camera): 2×2 with the bottom-left texel
        // (row0,col0) fully transparent (a "hole") and the rest opaque red.
        // Inserted FIRST, so it is drawn first — without the discard it stamps
        // depth across the hole and hides the back quad there.
        let transparent = [0u8, 0, 0, 0];
        let mut front = Vec::new();
        front.extend_from_slice(&transparent); // row0,col0 — the hole
        front.extend_from_slice(&px(Color32::RED)); // row0,col1
        front.extend_from_slice(&px(Color32::RED)); // row1,col0
        front.extend_from_slice(&px(Color32::RED)); // row1,col1
        g.add_image_layer(Scene3dImageLayer {
            pixels: front,
            width: 2,
            height: 2,
            origin: [0.0, 0.0, 0.0],
            scale: [1.0, 1.0], // world [0,2]×[0,2] at z=0
            interpolation: ImageInterpolation::Nearest,
        });

        // BACK quad at z=-1 (farther): opaque green, same world rect. Visible at
        // the hole only if the front's transparent texel was discarded.
        g.add_image_layer(Scene3dImageLayer {
            pixels: px(Color32::GREEN).repeat(4),
            width: 2,
            height: 2,
            origin: [0.0, 0.0, -1.0],
            scale: [1.0, 1.0],
            interpolation: ImageInterpolation::Nearest,
        });
        set_scene3d(rs, SCENE_ID, &g);

        let camera = Camera::new(
            30.0,
            0.1,
            100.0,
            (1.0, 1.0),
            Vec3::new(1.0, 1.0, 5.0),
            Vec3::new(0.0, 0.0, -1.0),
            Vec3::new(0.0, 1.0, 0.0),
        );
        Self {
            camera,
            last_rect: None,
        }
    }

    fn ui(&mut self, ui: &mut egui::Ui) {
        let (rect, _resp) = ui.allocate_exact_size(ui.available_size(), egui::Sense::hover());
        paint_scene3d(ui, rect, SCENE_ID, &self.camera, Color32::BLACK);
        self.last_rect = Some(rect);
    }
}

#[test]
fn transparent_front_texel_does_not_occlude_geometry_behind() {
    let rs = create_render_state(default_wgpu_setup());
    let app = Rc::new(RefCell::new(DepthHoleApp::new(&rs)));
    let renderer = WgpuTestRenderer::from_render_state(rs);

    let app_ui = app.clone();
    let mut harness = Harness::builder()
        .with_size(egui::vec2(WIN, WIN))
        .with_pixels_per_point(1.0)
        .renderer(renderer)
        .build_ui(move |ui| app_ui.borrow_mut().ui(ui));

    harness.step();
    let rect = app.borrow().last_rect.expect("scene rect captured");

    let image = harness.render().expect("headless wgpu render");
    let (iw, ih) = (image.width() as usize, image.height() as usize);
    let raw = image.as_raw();

    let at = |fx: f32, fy: f32| -> (u8, u8, u8) {
        let x = ((rect.min.x + fx * rect.width()).round() as usize).min(iw - 1);
        let y = ((rect.min.y + fy * rect.height()).round() as usize).min(ih - 1);
        let i = (y * iw + x) * 4;
        (raw[i], raw[i + 1], raw[i + 2])
    };

    // Bottom-left quadrant = the front hole → the back green must show through.
    let hole = at(0.313, 0.687);
    assert!(
        hole.1 > 150 && hole.0 < 90 && hole.2 < 90,
        "hole should reveal the green quad behind it; got {hole:?}"
    );
    // Bottom-right quadrant = front's opaque red texel, drawn over the back.
    let opaque = at(0.687, 0.687);
    assert!(
        opaque.0 > 150 && opaque.1 < 90 && opaque.2 < 90,
        "opaque front texel should stay red over the back quad; got {opaque:?}"
    );
}