graph-explorer-render 0.1.0

use bytemuck::{Pod, Zeroable};
use crate::HaloInstanceData;

// Tightly packed (36 bytes) so `vertex_attr_array!`'s computed offsets
// (0, 8, 12, 28, 32) match the field offsets — see nodes.rs for why no padding.
#[repr(C)]
#[derive(Copy, Clone, Pod, Zeroable)]
struct HaloInstance {
    pos: [f32; 2],
    radius: f32,
    color: [f32; 4],
    softness: f32,
    phase: f32,
}

pub struct HaloPipeline {
    pipeline: wgpu::RenderPipeline,
    instances: wgpu::Buffer,
    count: u32,
    capacity: u64,
}

impl HaloPipeline {
    pub fn new(device: &wgpu::Device, format: wgpu::TextureFormat, camera_bgl: &wgpu::BindGroupLayout) -> Self {
        let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
            label: Some("halo-shader"),
            source: wgpu::ShaderSource::Wgsl(include_str!("shaders/halo.wgsl").into()),
        });
        let layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
            label: Some("halo-layout"),
            bind_group_layouts: &[camera_bgl],
            push_constant_ranges: &[],
        });
        let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
            label: Some("halo-pipeline"),
            layout: Some(&layout),
            vertex: wgpu::VertexState {
                module: &shader,
                entry_point: "vs_main",
                buffers: &[wgpu::VertexBufferLayout {
                    array_stride: std::mem::size_of::<HaloInstance>() as u64,
                    step_mode: wgpu::VertexStepMode::Instance,
                    attributes: &wgpu::vertex_attr_array![0 => Float32x2, 1 => Float32, 2 => Float32x4, 3 => Float32, 4 => Float32],
                }],
                compilation_options: Default::default(),
            },
            fragment: Some(wgpu::FragmentState {
                module: &shader,
                entry_point: "fs_main",
                targets: &[Some(wgpu::ColorTargetState {
                    format, blend: Some(wgpu::BlendState::ALPHA_BLENDING), write_mask: wgpu::ColorWrites::ALL,
                })],
                compilation_options: Default::default(),
            }),
            primitive: wgpu::PrimitiveState { topology: wgpu::PrimitiveTopology::TriangleList, ..Default::default() },
            depth_stencil: None,
            multisample: wgpu::MultisampleState::default(),
            multiview: None,
            cache: None,
        });
        let capacity = 16;
        let instances = device.create_buffer(&wgpu::BufferDescriptor {
            label: Some("halo-instances"),
            size: capacity * std::mem::size_of::<HaloInstance>() as u64,
            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });
        Self { pipeline, instances, count: 0, capacity }
    }

    pub fn upload(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, halos: &[HaloInstanceData]) {
        let data: Vec<HaloInstance> = halos.iter().map(|h| HaloInstance {
            pos: h.pos, radius: h.radius, color: h.color, softness: h.softness, phase: h.phase,
        }).collect();
        let needed = data.len() as u64;
        if needed > self.capacity {
            self.capacity = needed.next_power_of_two();
            self.instances = device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("halo-instances"),
                size: self.capacity * std::mem::size_of::<HaloInstance>() as u64,
                usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            });
        }
        queue.write_buffer(&self.instances, 0, bytemuck::cast_slice(&data));
        self.count = data.len() as u32;
    }

    pub fn draw<'a>(&'a self, rpass: &mut wgpu::RenderPass<'a>, camera_bg: &'a wgpu::BindGroup) {
        if self.count == 0 { return; }
        rpass.set_pipeline(&self.pipeline);
        rpass.set_bind_group(0, camera_bg, &[]);
        rpass.set_vertex_buffer(0, self.instances.slice(..));
        rpass.draw(0..6, 0..self.count);
    }
}