Struct GpuBatch 

pub struct GpuBatch<'a> { /* private fields */ }

Acumulador de primitivas por frame. Construir → add_* → flush.

Implementations

impl<'a> GpuBatch<'a>

pub fn new(pipelines: &'a GpuPipelines) -> Self

Examples found in repository

examples/gpu_million_points.rs (line 76)

fn bench(hal: &Hal, pipelines: &GpuPipelines, view: &wgpu::TextureView, n: u32) -> f64 {
    let mut samples: Vec<f64> = Vec::with_capacity(MEASURED);
    for frame in 0..(WARMUP + MEASURED) {
        let t0 = Instant::now();
        let mut batch = GpuBatch::new(pipelines);
        let mut state: u32 = 0x1234_5678;
        for _ in 0..n {
            state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let x = (state % W) as f32;
            state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let y = (state % H) as f32;
            state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let r = ((state >>  0) & 0xFF) as f32 / 255.0;
            let g = ((state >>  8) & 0xFF) as f32 / 255.0;
            let b = ((state >> 16) & 0xFF) as f32 / 255.0;
            batch.add_rect(x, y, 1.2, 1.2, Color::new([r, g, b, 1.0]));
        }
        let mut encoder = hal.device.create_command_encoder(
            &wgpu::CommandEncoderDescriptor {
                label: Some("gpu_million_points-enc"),
            },
        );
        batch.flush(
            &hal.device,
            &hal.queue,
            &mut encoder,
            view,
            (W as f32, H as f32),
            wgpu::LoadOp::Clear(wgpu::Color::BLACK),
        );
        hal.queue.submit(std::iter::once(encoder.finish()));
        hal.device.poll(wgpu::PollType::wait_indefinitely());
        let dt = t0.elapsed().as_secs_f64() * 1000.0;
        if frame >= WARMUP {
            samples.push(dt);
        }
    }
    samples.sort_by(|a, b| a.partial_cmp(b).unwrap());
    samples[samples.len() / 2]
}

pub fn line_width(&mut self, w: f32)

Grosor de las próximas líneas (en pixels del frame, sin AA). Se aplica a todas las líneas del batch — el lado bueno de una sola draw call es que sólo hay un grosor “vivo” por flush.

pub fn add_line(&mut self, p0: (f32, f32), p1: (f32, f32), color: Color)

Añade un segmento de línea como instancia.

pub fn add_polyline(&mut self, points: &[(f32, f32)], color: Color)

Añade una polilínea como secuencia de segmentos individuales (line-list). Para N puntos emite N-1 instancias.

pub fn add_tri( &mut self, a: (f32, f32), b: (f32, f32), c: (f32, f32), ca: Color, cb: Color, cc: Color, )

Añade un triángulo con color por vértice.

pub fn add_tri_list(&mut self, verts: &[(f32, f32)], color: Color)

Añade un triangle list crudo [(x, y); 3*N] con un mismo color uniforme por vértice. Útil para teselaciones precomputadas (contornos, polígonos rellenos).

pub fn add_rect(&mut self, x: f32, y: f32, w: f32, h: f32, color: Color)

Añade un rectángulo lleno como instancia (sin radio — para rounded rects sigue por vello).

Examples found in repository

examples/gpu_million_points.rs (line 87)

fn bench(hal: &Hal, pipelines: &GpuPipelines, view: &wgpu::TextureView, n: u32) -> f64 {
    let mut samples: Vec<f64> = Vec::with_capacity(MEASURED);
    for frame in 0..(WARMUP + MEASURED) {
        let t0 = Instant::now();
        let mut batch = GpuBatch::new(pipelines);
        let mut state: u32 = 0x1234_5678;
        for _ in 0..n {
            state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let x = (state % W) as f32;
            state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let y = (state % H) as f32;
            state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let r = ((state >>  0) & 0xFF) as f32 / 255.0;
            let g = ((state >>  8) & 0xFF) as f32 / 255.0;
            let b = ((state >> 16) & 0xFF) as f32 / 255.0;
            batch.add_rect(x, y, 1.2, 1.2, Color::new([r, g, b, 1.0]));
        }
        let mut encoder = hal.device.create_command_encoder(
            &wgpu::CommandEncoderDescriptor {
                label: Some("gpu_million_points-enc"),
            },
        );
        batch.flush(
            &hal.device,
            &hal.queue,
            &mut encoder,
            view,
            (W as f32, H as f32),
            wgpu::LoadOp::Clear(wgpu::Color::BLACK),
        );
        hal.queue.submit(std::iter::once(encoder.finish()));
        hal.device.poll(wgpu::PollType::wait_indefinitely());
        let dt = t0.elapsed().as_secs_f64() * 1000.0;
        if frame >= WARMUP {
            samples.push(dt);
        }
    }
    samples.sort_by(|a, b| a.partial_cmp(b).unwrap());
    samples[samples.len() / 2]
}

pub fn add_disc(&mut self, cx: f32, cy: f32, r: f32, color: Color)

Añade un disco (círculo relleno) con AA por shader como instancia. (cx, cy) es el centro y r el radio, ambos en pixels del frame. El borde queda antialiased vía un SDF + smoothstep de ~1 px en el fragment — no escalonado, sin MSAA. El alpha del color se respeta (blending alfa activo).

pub fn add_ring(&mut self, cx: f32, cy: f32, r: f32, stroke: f32, color: Color)

Añade un anillo (círculo hueco / stroke circular) con AA por shader. r es el radio exterior; stroke el grosor del trazo en px (el agujero interior tiene radio r - stroke). stroke <= 0 degenera en un disco lleno. Ambos bordes (externo e interno) quedan antialiased.

pub fn primitive_count(&self) -> u32

Cuenta total de primitivas pendientes (útil para benches).

pub fn flush( self, device: &Device, queue: &Queue, encoder: &mut CommandEncoder, view: &TextureView, viewport: (f32, f32), load_op: LoadOp<Color>, )

Despacha las primitivas acumuladas como 1 draw call por tipo no vacío contra view. viewport es el tamaño en pixels del target (lo usa el VS para mapear pixel → NDC).

load_op decide si la pasada conserva el contenido previo (Load, lo normal cuando vello ya pintó algo) o limpia (Clear(color)). Apps que llamen a GpuBatch desde gpu_paint_with quieren Load.

Examples found in repository

examples/gpu_million_points.rs (lines 94-101)

fn bench(hal: &Hal, pipelines: &GpuPipelines, view: &wgpu::TextureView, n: u32) -> f64 {
    let mut samples: Vec<f64> = Vec::with_capacity(MEASURED);
    for frame in 0..(WARMUP + MEASURED) {
        let t0 = Instant::now();
        let mut batch = GpuBatch::new(pipelines);
        let mut state: u32 = 0x1234_5678;
        for _ in 0..n {
            state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let x = (state % W) as f32;
            state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let y = (state % H) as f32;
            state = state.wrapping_mul(1_664_525).wrapping_add(1_013_904_223);
            let r = ((state >>  0) & 0xFF) as f32 / 255.0;
            let g = ((state >>  8) & 0xFF) as f32 / 255.0;
            let b = ((state >> 16) & 0xFF) as f32 / 255.0;
            batch.add_rect(x, y, 1.2, 1.2, Color::new([r, g, b, 1.0]));
        }
        let mut encoder = hal.device.create_command_encoder(
            &wgpu::CommandEncoderDescriptor {
                label: Some("gpu_million_points-enc"),
            },
        );
        batch.flush(
            &hal.device,
            &hal.queue,
            &mut encoder,
            view,
            (W as f32, H as f32),
            wgpu::LoadOp::Clear(wgpu::Color::BLACK),
        );
        hal.queue.submit(std::iter::once(encoder.finish()));
        hal.device.poll(wgpu::PollType::wait_indefinitely());
        let dt = t0.elapsed().as_secs_f64() * 1000.0;
        if frame >= WARMUP {
            samples.push(dt);
        }
    }
    samples.sort_by(|a, b| a.partial_cmp(b).unwrap());
    samples[samples.len() / 2]
}