leptos-helios 0.8.1

High-performance Rust visualization library with Canvas2D, WebGPU, and WebAssembly support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

//! Buffer pool management for WebGPU rendering

use super::types::{BufferPoolStats, WebGpuError};
use std::sync::Arc;
use wgpu::util::DeviceExt;

/// Buffer pool for efficient GPU memory management
pub struct BufferPool {
    device: Arc<wgpu::Device>,
    vertex_buffers: Vec<wgpu::Buffer>,
    index_buffers: Vec<wgpu::Buffer>,
    uniform_buffers: Vec<wgpu::Buffer>,
    total_allocations: usize,
    total_deallocations: usize,
    allocated_bytes: u64,
}

impl BufferPool {
    /// Create a new buffer pool
    pub fn new(device: Arc<wgpu::Device>) -> Self {
        Self {
            device,
            vertex_buffers: Vec::new(),
            index_buffers: Vec::new(),
            uniform_buffers: Vec::new(),
            total_allocations: 0,
            total_deallocations: 0,
            allocated_bytes: 0,
        }
    }

    /// Allocate a vertex buffer
    pub fn allocate_vertex_buffer(&mut self, size: u64, data: Option<&[u8]>) -> Result<wgpu::Buffer, WebGpuError> {
        let buffer = if let Some(data) = data {
            self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                label: Some("Vertex Buffer"),
                contents: data,
                usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
            })
        } else {
            self.device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("Vertex Buffer"),
                size,
                usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            })
        };

        self.vertex_buffers.push(buffer.clone());
        self.total_allocations += 1;
        self.allocated_bytes += size;
        
        Ok(buffer)
    }

    /// Allocate an index buffer
    pub fn allocate_index_buffer(&mut self, size: u64, data: Option<&[u8]>) -> Result<wgpu::Buffer, WebGpuError> {
        let buffer = if let Some(data) = data {
            self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                label: Some("Index Buffer"),
                contents: data,
                usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
            })
        } else {
            self.device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("Index Buffer"),
                size,
                usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            })
        };

        self.index_buffers.push(buffer.clone());
        self.total_allocations += 1;
        self.allocated_bytes += size;
        
        Ok(buffer)
    }

    /// Allocate a uniform buffer
    pub fn allocate_uniform_buffer(&mut self, size: u64, data: Option<&[u8]>) -> Result<wgpu::Buffer, WebGpuError> {
        let buffer = if let Some(data) = data {
            self.device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
                label: Some("Uniform Buffer"),
                contents: data,
                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
            })
        } else {
            self.device.create_buffer(&wgpu::BufferDescriptor {
                label: Some("Uniform Buffer"),
                size,
                usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            })
        };

        self.uniform_buffers.push(buffer.clone());
        self.total_allocations += 1;
        self.allocated_bytes += size;
        
        Ok(buffer)
    }

    /// Deallocate a buffer (mark for cleanup)
    pub fn deallocate_buffer(&mut self, _buffer: &wgpu::Buffer) {
        // In a real implementation, we would track buffer IDs and remove them
        // For now, we just update statistics
        self.total_deallocations += 1;
    }

    /// Get buffer pool statistics
    pub fn get_stats(&self) -> BufferPoolStats {
        BufferPoolStats {
            total_allocations: self.total_allocations,
            total_deallocations: self.total_deallocations,
            allocated_bytes: self.allocated_bytes,
            active_buffers: self.vertex_buffers.len() + self.index_buffers.len() + self.uniform_buffers.len(),
            vertex_buffers: self.vertex_buffers.len(),
            index_buffers: self.index_buffers.len(),
            uniform_buffers: self.uniform_buffers.len(),
        }
    }

    /// Clear all buffers (for cleanup)
    pub fn clear(&mut self) {
        self.vertex_buffers.clear();
        self.index_buffers.clear();
        self.uniform_buffers.clear();
        self.total_allocations = 0;
        self.total_deallocations = 0;
        self.allocated_bytes = 0;
    }
}