Struct Renderer 

pub struct Renderer { /* private fields */ }

Rasterizador vectorial. Una instancia por surface (porque vello cachea resources contra un surface_format específico).

Implementations

impl Renderer

pub fn new(hal: &Hal) -> Result<Self, RasterError>

Inicializa el rasterizador. Vello acepta cualquier textura compatible (Rgba8Unorm / Bgra8Unorm) en render, así que no se fija un formato en construcción.

antialiasing_support: pedimos area solamente, no all(). area es el único método que render() usa (AaConfig::Area fijo). Pedir all() haría a vello compilar también pipelines para msaa8 y msaa16 que nunca se invocan — en Mali-G57 eso triplica el cold-start (medido: 3.7s vs ~1.2s). Si alguna app futura necesita MSAA, agregamos un constructor explícito.

num_init_threads: None: vello paraleliza la compilación de shaders en None → todos los CPU cores. Mali-G57 viene en SoCs octa-core ARM; con 1 thread tardamos 2.0s, con 8 esperamos ~400-600ms. La compilación de shaders es 100% CPU (Rust → SPIR-V), el GPU no participa, así que multi-thread escala casi linealmente hasta saturar el queue del Naga compiler.

Examples found in repository

examples/render_node.rs (line 47)

    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
        if self.state.is_some() {
            return;
        }
        let window = event_loop
            .create_window(
                WindowAttributes::default()
                    .with_title("llimphi · render_node")
                    .with_inner_size(LogicalSize::new(960u32, 540u32)),
            )
            .expect("create window");
        let window = Arc::new(window);
        let hal = pollster::block_on(Hal::new(None)).expect("hal");
        let surface = WinitSurface::new(&hal, window.clone()).expect("surface");
        let renderer = Renderer::new(&hal).expect("renderer");
        window.request_redraw();
        self.state = Some(State {
            window,
            hal,
            surface,
            renderer,
            scene: vello::Scene::new(),
        });
    }

pub fn render( &mut self, hal: &Hal, scene: &Scene, frame: &Frame, base_color: Color, ) -> Result<(), RasterError>

Renderiza scene sobre frame limpiando con base_color. AA fija en area-sampling (precisión Δ < 10⁻⁹ rad del SDD).

Examples found in repository

examples/render_node.rs (lines 86-91)

    fn window_event(
        &mut self,
        event_loop: &ActiveEventLoop,
        _id: WindowId,
        event: WindowEvent,
    ) {
        let Some(state) = self.state.as_mut() else {
            return;
        };
        match event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::Resized(size) => {
                state.surface.resize(size.width, size.height);
                state.window.request_redraw();
            }
            WindowEvent::RedrawRequested => {
                let frame = match state.surface.acquire() {
                    Ok(f) => f,
                    Err(_) => {
                        let (w, h) = state.surface.size();
                        state.surface.resize(w, h);
                        state.window.request_redraw();
                        return;
                    }
                };
                let (w, h) = frame.size();
                state.scene.reset();
                build_node(&mut state.scene, w as f64, h as f64, self.started.elapsed().as_secs_f64());
                if let Err(e) = state.renderer.render(
                    &state.hal,
                    &state.scene,
                    &frame,
                    palette::css::BLACK,
                ) {
                    eprintln!("render error: {e}");
                }
                state.surface.present(frame, &state.hal);
                state.window.request_redraw();
            }
            _ => {}
        }
    }

pub fn render_to_view( &mut self, hal: &Hal, scene: &Scene, view: &TextureView, width: u32, height: u32, base_color: Color, ) -> Result<(), RasterError>

Como render pero contra una vista de textura explícita (mismo formato/tamaño que la intermedia). Lo usa el compositor de overlay de llimphi-ui para rasterizar la capa de overlay sobre fondo transparente en su propia textura. Ojo: render_to_texture limpia el target con base_color y escribe todos los píxeles — no compone sobre contenido previo.