Method update

src/grid.rs:96–184

(&mut self, device: &Device, state: &PlotState)

    }

    pub(crate) fn update(&mut self, device: &Device, state: &PlotState) {
        let camera = &state.camera;

        if camera.position == self.last_center
            && camera.half_extents == self.last_extents
            && state.grid_style == self.last_style
        {
            return;
        }

        self.last_center = camera.position;
        self.last_extents = camera.half_extents;
        self.last_style = state.grid_style;

        // Calculate bounds in render space (world - offset) for line endpoints
        let render_center = camera.effective_position();
        let min_x = render_center.x - camera.half_extents.x;
        let max_x = render_center.x + camera.half_extents.x;
        let min_y = render_center.y - camera.half_extents.y;
        let max_y = render_center.y + camera.half_extents.y;

        let mut verts = Vec::new();
        let mut count = 0u32;

        // Build vertical lines from precomputed x ticks
        let width = state.bounds.width.max(1.0);
        let height = state.bounds.height.max(1.0);
        for positioned_tick in &state.x_ticks {
            let ndc_x = (positioned_tick.screen_pos / width) as f64 * 2.0 - 1.0;
            let render_x = render_center.x + ndc_x * camera.half_extents.x;
            let color = match positioned_tick.tick.line_type {
                TickWeight::Major => state.grid_style.major,
                TickWeight::Minor => state.grid_style.minor,
                TickWeight::SubMinor => state.grid_style.sub_minor,
            };
            verts.extend_from_slice(&[
                render_x as f32,
                min_y as f32,
                color.r,
                color.g,
                color.b,
                color.a,
            ]);
            verts.extend_from_slice(&[
                render_x as f32,
                max_y as f32,
                color.r,
                color.g,
                color.b,
                color.a,
            ]);
            count += 2;
        }

        // Build horizontal lines from precomputed y ticks
        for positioned_tick in &state.y_ticks {
            let ndc_y = 1.0 - (positioned_tick.screen_pos / height) as f64 * 2.0;
            let render_y = render_center.y + ndc_y * camera.half_extents.y;