Struct GpuPipelines 

pub struct GpuPipelines {
    pub lines: RenderPipeline,
    pub tris: RenderPipeline,
    pub rects: RenderPipeline,
    pub discs: RenderPipeline,
    pub bind_layout: BindGroupLayout,
    /* private fields */
}

Pipelines cacheadas. Crear uno por proceso (o por surface format).

Para uso típico via GpuBatch los campos no se tocan directo. La API pública existe para callers avanzados que quieran montar su propio buffer persistente (datos que no cambian por frame: starfield Gaia, particles iniciales, viewport estático) y emitir draw calls manualmente reusando estas pipelines.

Layouts:

• Vertex buffer triángulos: [x: f32, y: f32, rgba: u32] (12 B/vert).
• Instance buffer rects: [x, y, w, h, rgba] (20 B/inst).
• Instance buffer líneas: [x0, y0, x1, y1, rgba] (20 B/inst).
• Bind group 0 binding 0: uniform {viewport: vec2<f32>, line_width: f32, _pad: f32} (16 B).

Fields

lines: RenderPipeline

tris: RenderPipeline

rects: RenderPipeline

discs: RenderPipeline

Discos/anillos rellenos con AA por SDF en el fragment. Instance format: [cx, cy, r, stroke, rgba] (20 B/disco). stroke <= 0 → disco lleno; stroke > 0 → anillo de ese grosor (px). Ver GpuBatch::add_disc / GpuBatch::add_ring.

bind_layout: BindGroupLayout

Implementations

impl GpuPipelines

pub fn new(device: &Device, color_format: TextureFormat) -> Self

Compila los 3 pipelines apuntando al color_format del target que recibirán en flush (el de la intermediate de WinitSurface, normalmente Rgba8Unorm).

Examples found in repository

examples/gpu_million_points.rs (line 32)

fn main() {
    let hal = pollster::block_on(Hal::new(None)).expect("hal");
    let pipelines = GpuPipelines::new(&hal.device, FMT);

    let (_tex, view) = make_target(&hal.device);

    println!();
    println!("gpu_million_points — GpuBatch + 3 pipelines · target {W}×{H} Rgba8Unorm");
    println!("warmup {WARMUP}, measured {MEASURED}");
    println!("  {:>10} | {:>14} | {:>14}", "N", "ms / frame", "Mprim/s");
    println!("  {:->10} + {:->14} + {:->14}", "", "", "");

    for &n in SIZES {
        let ms = bench(&hal, &pipelines, &view, n);
        let throughput = (n as f64 / 1_000_000.0) / (ms / 1000.0);
        println!("  {:>10} | {:>14.3} | {:>14.2}", n, ms, throughput);
        let _ = std::io::stdout().flush();
    }
    println!();
    println!("(en llvmpipe estos números son CPU-bound — ver Fase 0 del SDD)");
    println!();
}