lemna 0.4.0

A Reactive UI framework for Rust
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

use bytemuck::{cast_slice, Pod};
use log::info;
use std::sync::{Arc, RwLock};
use wgpu;

use crate::render::next_power_of_2;
use crate::render::renderables::buffer_cache::{BufferCacheId, BufferChunk};

pub struct BufferCache<V, I> {
    pub cache: Arc<RwLock<crate::render::renderables::buffer_cache::BufferCache<V, I>>>,
    pub vertex_buffer: wgpu::Buffer,
    pub index_buffer: wgpu::Buffer,
    vertex_buffer_len: usize,
    index_buffer_len: usize,
}

impl<T: Default + Pod, I: Default + Pod> BufferCache<T, I> {
    pub fn new(device: &wgpu::Device) -> Self {
        let cache = Arc::new(RwLock::new(
            crate::render::renderables::buffer_cache::BufferCache::new(),
        ));
        let initial_buffer_size = 32;
        let vertex_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: None,
            size: (std::mem::size_of::<T>() * initial_buffer_size) as u64,
            usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });
        let index_buffer = device.create_buffer(&wgpu::BufferDescriptor {
            label: None,
            size: (std::mem::size_of::<I>() * initial_buffer_size) as u64,
            usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        Self {
            cache,
            vertex_buffer,
            index_buffer,
            vertex_buffer_len: initial_buffer_size,
            index_buffer_len: initial_buffer_size,
        }
    }

    pub fn sync_buffers(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {
        if self.cache.read().unwrap().vertex_data.len() > self.vertex_buffer_len {
            self.vertex_buffer_len = next_power_of_2(self.cache.read().unwrap().vertex_data.len());
            info!(
                "Resizing BufferCache vertex buffer to {}",
                self.vertex_buffer_len
            );

            self.vertex_buffer = device.create_buffer(&wgpu::BufferDescriptor {
                label: None,
                size: (std::mem::size_of::<T>() * self.vertex_buffer_len) as u64,
                usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            });
        }
        if self.cache.read().unwrap().index_data.len() > self.index_buffer_len {
            self.index_buffer_len = next_power_of_2(self.cache.read().unwrap().index_data.len());
            info!(
                "Resizing BufferCache index buffer to {}",
                self.index_buffer_len
            );
            self.index_buffer = device.create_buffer(&wgpu::BufferDescriptor {
                label: None,
                size: (std::mem::size_of::<I>() * self.index_buffer_len) as u64,
                usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
                mapped_at_creation: false,
            });
        }
        queue.write_buffer(
            &self.vertex_buffer,
            0,
            cast_slice(&self.cache.read().unwrap().vertex_data),
        );
        queue.write_buffer(
            &self.index_buffer,
            0,
            cast_slice(&self.cache.read().unwrap().index_data),
        );
    }

    pub fn unmark(&mut self) {
        self.cache.write().unwrap().unmark();
    }

    pub fn get_chunks(&self, buffer_cache: BufferCacheId) -> (BufferChunk, BufferChunk) {
        self.cache.read().unwrap().get_chunks(buffer_cache)
    }

    // pub fn register(&mut self, chunk: BufferCacheId) {
    //     self.cache.write().unwrap().register(chunk);
    // }

    // pub fn alloc_chunk(&mut self, n_vertex: usize, n_index: usize) -> BufferCacheId {
    //     self.cache.write().unwrap().alloc_chunk(n_vertex, n_index)
    // }

    // pub fn alloc_or_reuse_chunk(
    //     &mut self,
    //     buffer_cache: BufferCacheId,
    //     n_vertex: usize,
    //     n_index: usize,
    // ) -> BufferCacheId {
    //     self.cache
    //         .write()
    //         .unwrap()
    //         .alloc_or_reuse_chunk(buffer_cache, n_vertex, n_index)
    // }

    // pub fn set_n_indices(&mut self, buffer_cache: BufferCacheId, n_index: usize) {
    //     self.cache
    //         .write()
    //         .unwrap()
    //         .set_n_indices(buffer_cache, n_index)
    // }

    // pub fn fill_chunks(&mut self, buffer_cache: BufferCacheId) {
    //     self.cache.write().unwrap().fill_chunks(buffer_cache);
    // }
}