globject_rs/
buffervec.rs

1
2use crate::prelude::*;
3use bitvec::vec::BitVec;
4use std::{
5	cell::UnsafeCell,
6	fmt::Debug,
7	mem::{ManuallyDrop, size_of, size_of_val},
8	ops::{Index, IndexMut, Range, RangeFrom, RangeTo, RangeFull, RangeInclusive, RangeToInclusive},
9	rc::Rc,
10};
11
12/// The type that could be the item of the `BufferVec`
13pub trait BufferVecItem: Copy + Sized + Default + Debug {}
14impl<T> BufferVecItem for T where T: Copy + Sized + Default + Debug {}
15
16/// The `BufferVec` trait
17pub trait BufferVec<T: BufferVecItem>: Debug + Clone + From<Buffer> +
18	Index<usize> + IndexMut<usize> +
19	Index<Range<usize>> + IndexMut<Range<usize>> +
20	Index<RangeTo<usize>> + IndexMut<RangeTo<usize>> +
21	Index<RangeFull> + IndexMut<RangeFull> +
22	Index<RangeInclusive<usize>> + IndexMut<RangeInclusive<usize>> +
23	Index<RangeToInclusive<usize>> + IndexMut<RangeToInclusive<usize>>
24{
25	/// Get the underlying `Buffer`
26	fn get_buffer(&self) -> &Buffer;
27
28	/// Get the underlying `Buffer` as mut
29	fn get_buffer_mut(&mut self) -> &mut Buffer;
30
31	/// Get the default binding target of the buffer
32	fn get_target(&self) -> BufferTarget;
33
34	/// Set the binding target of the buffer
35	fn set_target(&mut self, target: BufferTarget);
36
37	/// Get the size of the buffer
38	fn len(&self) -> usize;
39
40	/// Get the capacity of the buffer
41	fn capacity(&self) -> usize;
42
43	/// Resizes to the new size, reallocate the buffer if the new size is larger
44	fn resize(&mut self, new_len: usize, value: T) -> Result<(), GLCoreError>;
45
46	/// Shrink to the exact number of items
47	fn shrink_to_fit(&mut self) -> Result<(), GLCoreError>;
48
49	/// Retrieve a single item from the buffer in the GPU
50	fn get(&self, index: usize) -> Result<T, GLCoreError>;
51
52	/// Update a single item from the buffer in the GPU
53	fn set(&mut self, index: usize, data: &T) -> Result<(), GLCoreError>;
54
55	/// Retrieve a slice of items from the buffer in the GPU
56	fn get_slice_of_data(&self, start_index: usize, len: usize) -> Result<Vec<T>, GLCoreError>;
57
58	/// Update a slice of itrems to the buffer in the GPU
59	fn set_slice_of_data(&mut self, start_index: usize, data: &[T]) -> Result<(), GLCoreError>;
60
61	/// Flush the buffer to the GPU if it has a cache in the system memory
62	fn flush(&mut self) -> Result<(), GLCoreError> {Ok(())}
63
64	/// Check if the content of the buffer is empty
65	fn is_empty(&self) -> bool {
66		self.len() == 0
67	}
68
69	/// Create a `BufferBind` to use the RAII system to manage the binding state.
70	fn bind<'a>(&'a self) -> Result<BufferBind<'a>, GLCoreError> {
71		self.get_buffer().bind()
72	}
73
74	/// Bind to a specific target. WILL NOT change the default target of the buffer. Create a `BufferBind` to use the RAII system to manage the binding state, while change the binding target.
75	fn bind_to<'a>(&'a self, target: BufferTarget) -> Result<BufferBind<'a>, GLCoreError> {
76		self.get_buffer().bind_to(target)
77	}
78}
79
80/// The `BufferVecStatic` struct, although it doesn't supports
81#[derive(Debug)]
82pub struct BufferVecStatic<T: BufferVecItem> {
83	pub glcore: Rc<GLCore>,
84	buffer: ManuallyDrop<Buffer>,
85	num_items: usize,
86	capacity: usize,
87	cache: UnsafeCell<BufferVecStaticCache<T>>,
88}
89
90impl<T: BufferVecItem> Clone for BufferVecStatic<T> {
91	fn clone(&self) -> Self {
92		let buffer = self.buffer.clone();
93		let cache = UnsafeCell::new(unsafe {&mut *self.cache.get()}.clone_cache(&buffer).unwrap());
94		Self {
95			glcore: self.glcore.clone(),
96			buffer,
97			num_items: self.num_items,
98			capacity: self.capacity,
99			cache,
100		}
101	}
102}
103
104/// A vectorized buffer that allows you to modify its content via providing your struct.
105impl<T: BufferVecItem> BufferVecStatic<T> {
106	/// Get the internal name
107	pub fn get_name(&self) -> u32 {
108		self.buffer.get_name()
109	}
110
111	/// Convert `Buffer` to an `BufferVecStatic`
112	pub fn new(buffer: Buffer) -> Self {
113		let glcore = buffer.glcore.clone();
114		let capacity = buffer.size() / size_of::<T>();
115		Self {
116			glcore,
117			buffer: ManuallyDrop::new(buffer),
118			num_items: 0,
119			capacity,
120			cache: UnsafeCell::new(BufferVecStaticCache::None),
121		}
122	}
123}
124
125impl<T: BufferVecItem> BufferVec<T> for BufferVecStatic<T> {
126	fn get_buffer(&self) -> &Buffer {
127		&self.buffer
128	}
129
130	fn get_buffer_mut(&mut self) -> &mut Buffer {
131		&mut self.buffer
132	}
133
134	fn get_target(&self) -> BufferTarget {
135		self.buffer.get_target()
136	}
137
138	fn set_target(&mut self, target: BufferTarget) {
139		self.buffer.set_target(target)
140	}
141
142	fn capacity(&self) -> usize {
143		self.capacity
144	}
145
146	fn len(&self) -> usize {
147		self.num_items
148	}
149
150	fn resize(&mut self, new_len: usize, value: T) -> Result<(), GLCoreError> {
151		let new_size = new_len * size_of::<T>();
152		if new_size > self.capacity {
153			self.buffer.resize(new_len * size_of::<T>(), value)?;
154		}
155		self.num_items = new_len;
156		Ok(())
157	}
158
159	fn shrink_to_fit(&mut self) -> Result<(), GLCoreError> {
160		self.capacity = self.num_items;
161		self.buffer.resize(self.capacity * size_of::<T>(), T::default())?;
162		Ok(())
163	}
164
165	fn get(&self, index: usize) -> Result<T, GLCoreError> {
166		let offset = index * size_of::<T>();
167		let bind = self.buffer.bind()?;
168		let (map, addr) = bind.map_ranged(offset, size_of::<T>(), MapAccess::WriteOnly)?;
169		let addr = addr as *mut T;
170		let ret = unsafe { *addr };
171		map.unmap();
172		Ok(ret)
173	}
174
175	fn set(&mut self, index: usize, data: &T) -> Result<(), GLCoreError> {
176		let offset = index * size_of::<T>();
177		let bind = self.buffer.bind()?;
178		let (map, addr) = bind.map_ranged(offset, size_of::<T>(), MapAccess::WriteOnly)?;
179		let addr = addr as *mut T;
180		unsafe {
181			*addr = *data;
182		}
183		map.unmap();
184		Ok(())
185	}
186
187	fn get_slice_of_data(&self, start_index: usize, len: usize) -> Result<Vec<T>, GLCoreError> {
188		let offset = start_index * size_of::<T>();
189		let end_index = start_index + len;
190		let bind = self.buffer.bind()?;
191		let (map, addr) = bind.map_ranged(offset, len * size_of::<T>(), MapAccess::WriteOnly)?;
192		let addr = addr as *mut T;
193		let mut ret: Vec<T> = Vec::with_capacity(len);
194		for i in start_index..end_index {
195			ret.push(unsafe {*addr.wrapping_add(i)});
196		}
197		map.unmap();
198		Ok(ret)
199	}
200
201	fn set_slice_of_data(&mut self, index: usize, data: &[T]) -> Result<(), GLCoreError> {
202		let offset = index * size_of::<T>();
203		let bind = self.buffer.bind()?;
204		let (map, addr) = bind.map_ranged(offset, size_of_val(data), MapAccess::WriteOnly)?;
205		let addr = addr as *mut T;
206		for (i, item) in data.iter().enumerate() {
207			unsafe { *addr.wrapping_add(i) = *item; };
208		}
209		map.unmap();
210		Ok(())
211	}
212
213	fn flush(&mut self) -> Result<(), GLCoreError> {
214		*self.cache.get_mut() = BufferVecStaticCache::None;
215		Ok(())
216	}
217}
218
219/// The `&item` for `BufferVecStatic`
220#[derive(Debug)]
221pub struct BufferVecItemRef<T>
222where
223	T: BufferVecItem {
224	item: T,
225	index: usize,
226	buffer: Box<BufferVecStatic<T>>,
227}
228
229/// The `&mut item` for `BufferVecStatic`
230#[derive(Debug)]
231pub struct BufferVecItemRefMut<T>
232where
233	T: BufferVecItem {
234	item: T,
235	index: usize,
236	buffer: Box<BufferVecStatic<T>>,
237}
238
239/// The `&slice[]` for `BufferVecStatic`
240#[derive(Debug)]
241pub struct BufferVecSliceRef<T>
242where
243	T: BufferVecItem {
244	slice: Vec<T>,
245	start_index: usize,
246	buffer: Box<BufferVecStatic<T>>,
247}
248
249/// The `&mut slice[]` for `BufferVecStatic`
250#[derive(Debug)]
251pub struct BufferVecSliceRefMut<T>
252where
253	T: BufferVecItem {
254	slice: Vec<T>,
255	start_index: usize,
256	buffer: Box<BufferVecStatic<T>>,
257}
258
259/// The caching system of `BufferVecStatic`
260#[derive(Debug)]
261enum BufferVecStaticCache<T: BufferVecItem> {
262	None,
263	Item(BufferVecItemRef<T>),
264	ItemMut(BufferVecItemRefMut<T>),
265	Slice(BufferVecSliceRef<T>),
266	SliceMut(BufferVecSliceRefMut<T>),
267}
268
269impl<T: BufferVecItem> BufferVecStaticCache<T> {
270	/// Get as reference to an item
271	fn get_item(&self) -> &T {
272		if let Self::Item(item) = self {
273			item.as_ref()
274		} else {
275			panic!("The current cache isn't an item")
276		}
277	}
278
279	/// Get as reference to a mutable item
280	fn get_item_mut(&mut self) -> &mut T {
281		if let Self::ItemMut(item_mut) = self {
282			item_mut.as_mut()
283		} else {
284			panic!("The current cache isn't an item")
285		}
286	}
287
288	/// Get as reference to a slice
289	fn get_slice(&self) -> &[T] {
290		if let Self::Slice(slice) = self {
291			slice.as_ref()
292		} else {
293			panic!("The current cache isn't an item")
294		}
295	}
296
297	/// Get as reference to a mutable slice
298	fn get_slice_mut(&mut self) -> &mut [T] {
299		if let Self::SliceMut(slice_mut) = self {
300			slice_mut.as_mut()
301		} else {
302			panic!("The current cache isn't an item")
303		}
304	}
305
306	/// Clone this cache
307	fn clone_cache(&self, new_buffer: &Buffer) -> Result<Self, GLCoreError> {
308		let ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(new_buffer.glcore.clone(), new_buffer.get_name(), new_buffer.get_target())}?));
309		Ok(match self {
310			Self::None => Self::None,
311			Self::Item(data) => Self::Item(BufferVecItemRef{
312				item: data.item,
313				index: data.index,
314				buffer: ref_buffer,
315			}),
316			Self::ItemMut(data) => Self::ItemMut(BufferVecItemRefMut{
317				item: data.item,
318				index: data.index,
319				buffer: ref_buffer,
320			}),
321			Self::Slice(data) => Self::Slice(BufferVecSliceRef{
322				slice: data.slice.clone(),
323				start_index: data.start_index,
324				buffer: ref_buffer,
325			}),
326			Self::SliceMut(data) => Self::SliceMut(BufferVecSliceRefMut{
327				slice: data.slice.clone(),
328				start_index: data.start_index,
329				buffer: ref_buffer,
330			}),
331		})
332	}
333}
334
335impl<T: BufferVecItem> From<Buffer> for BufferVecStatic<T> {
336	fn from(val: Buffer) -> Self {
337		let capacity = val.size() / size_of::<T>();
338		BufferVecStatic {
339			glcore: val.glcore.clone(),
340			buffer: ManuallyDrop::new(val),
341			num_items: 0,
342			capacity,
343			cache: UnsafeCell::new(BufferVecStaticCache::None),
344		}
345	}
346}
347
348/// A high-level vectorized buffer that allows you to modify its content via index accessing/slicing
349#[derive(Debug, Clone)]
350pub struct BufferVecDynamic<T: BufferVecItem> {
351	pub glcore: Rc<GLCore>,
352	buffer: BufferVecStatic<T>,
353	num_items: usize,
354	capacity: usize,
355	cache: Vec<T>,
356	cache_modified_bitmap: BitVec,
357	cache_modified: bool,
358}
359
360impl<T: BufferVecItem> BufferVecDynamic<T> {
361	/// Get the internal name
362	pub fn get_name(&self) -> u32 {
363		self.buffer.get_name()
364	}
365
366	/// Convert an `BufferVecStatic` to the `BufferVecDynamic`
367	pub fn new(mut buffer: BufferVecStatic<T>) -> Result<Self, GLCoreError> {
368		buffer.flush()?;
369		let capacity = buffer.capacity();
370		let mut cache_modified_bitmap = BitVec::new();
371		let cache = buffer.get_slice_of_data(0, capacity)?;
372		cache_modified_bitmap.resize(capacity, false);
373		let num_items = buffer.len();
374		Ok(Self {
375			glcore: buffer.glcore.clone(),
376			buffer,
377			cache,
378			cache_modified_bitmap,
379			cache_modified: false,
380			num_items,
381			capacity
382		})
383	}
384}
385
386impl<T: BufferVecItem> BufferVec<T> for BufferVecDynamic<T> {
387	fn get_buffer(&self) -> &Buffer {
388		self.buffer.get_buffer()
389	}
390
391	fn get_buffer_mut(&mut self) -> &mut Buffer {
392		self.buffer.get_buffer_mut()
393	}
394
395	fn get_target(&self) -> BufferTarget {
396		self.buffer.get_target()
397	}
398
399	fn set_target(&mut self, target: BufferTarget) {
400		self.buffer.set_target(target)
401	}
402
403	fn len(&self) -> usize {
404		self.num_items
405	}
406
407	fn capacity(&self) -> usize {
408		self.capacity
409	}
410
411	fn resize(&mut self, new_len: usize, value: T) -> Result<(), GLCoreError> {
412		self.cache.resize(new_len, value);
413		self.num_items = new_len;
414		if new_len > self.capacity {
415			self.cache_modified_bitmap.clear(); // set all false
416			self.cache_modified_bitmap.resize(new_len, false);
417			self.buffer.resize(new_len, value)?;
418			self.capacity = new_len;
419			self.cache_modified = false;
420		} else {
421			self.cache_modified_bitmap.resize(new_len, false);
422		}
423		Ok(())
424	}
425
426	fn shrink_to_fit(&mut self) -> Result<(), GLCoreError> {
427		if self.capacity > self.num_items {
428			self.cache.shrink_to_fit();
429			self.cache_modified_bitmap.clear(); // set all false
430			self.cache_modified_bitmap.resize(self.num_items, false);
431			self.buffer.resize(self.num_items, T::default())?;
432			self.capacity = self.num_items;
433			self.cache_modified = false;
434		}
435		Ok(())
436	}
437
438	fn get(&self, index: usize) -> Result<T, GLCoreError> {
439		Ok(self.cache[index])
440	}
441
442	fn set(&mut self, index: usize, data: &T) -> Result<(), GLCoreError> {
443		self.cache[index] = *data;
444		self.cache_modified = true;
445		self.cache_modified_bitmap.set(index, true);
446		Ok(())
447	}
448
449	fn get_slice_of_data(&self, start_index: usize, len: usize) -> Result<Vec<T>, GLCoreError> {
450		let end_index = start_index + len;
451		Ok(self.cache[start_index..end_index].to_vec())
452	}
453
454	fn set_slice_of_data(&mut self, start_index: usize, data: &[T]) -> Result<(), GLCoreError> {
455		let end_index = start_index + data.len();
456		self.cache_modified = true;
457		for i in start_index..end_index {
458			self.cache[i] = data[i - start_index];
459			self.cache_modified_bitmap.set(i, true);
460		}
461		Ok(())
462	}
463
464	fn flush(&mut self) -> Result<(), GLCoreError> {
465		if !self.cache_modified {
466			return Ok(());
467		}
468
469		const MAXIMUM_GAP: usize = 16;
470
471		let mut is_in: bool = false;
472		let mut start_index: usize = 0;
473		let mut end_index: usize = 0;
474		let mut gap_length: usize = 0;
475		for i in 0..self.num_items {
476			if self.cache_modified_bitmap[i] {
477				if !is_in {
478					is_in = true;
479					start_index = i;
480				}
481				gap_length = 0;
482				end_index = i;
483				self.cache_modified_bitmap.set(i, false);
484			} else if is_in {
485				if gap_length < MAXIMUM_GAP {
486					gap_length += 1;
487				} else {
488					self.buffer.set_slice_of_data(0, &self.cache[start_index..=end_index])?;
489					is_in = false;
490				}
491			}
492		}
493		if is_in {
494			self.buffer.set_slice_of_data(0, &self.cache[start_index..=end_index])?;
495		}
496
497		self.cache_modified = false;
498		Ok(())
499	}
500}
501
502impl<T> BufferVecItemRef<T>
503where
504	T: BufferVecItem {
505	fn new(buffer: &BufferVecStatic<T>, index: usize) -> Result<Self, GLCoreError> {
506		let item = buffer.get(index)?;
507		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
508		ref_buffer.resize(buffer.len(), T::default())?;
509		Ok(Self {
510			item,
511			index,
512			buffer: ref_buffer,
513		})
514	}
515
516	fn as_ref(&self) -> &T {
517		&self.item
518	}
519}
520
521impl<T> BufferVecItemRefMut<T>
522where
523	T: BufferVecItem {
524	fn new(buffer: &mut BufferVecStatic<T>, index: usize) -> Result<Self, GLCoreError> {
525		let item = buffer.get(index)?;
526		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
527		ref_buffer.resize(buffer.len(), T::default())?;
528		Ok(Self {
529			item,
530			index,
531			buffer: ref_buffer,
532		})
533	}
534
535	fn as_mut(&mut self) -> &mut T {
536		&mut self.item
537	}
538}
539
540impl<T> BufferVecSliceRef<T>
541where
542	T: BufferVecItem {
543	fn as_ref(&self) -> &[T] {
544		self.slice.as_ref()
545	}
546
547	fn new_range(buffer: &BufferVecStatic<T>, range: Range<usize>) -> Result<Self, GLCoreError> {
548		let slice = buffer.get_slice_of_data(range.start, range.end - range.start)?;
549		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
550		ref_buffer.resize(buffer.len(), T::default())?;
551		Ok(Self {
552			slice,
553			start_index: range.start,
554			buffer: ref_buffer,
555		})
556	}
557
558	fn new_range_from(buffer: &BufferVecStatic<T>, range: RangeFrom<usize>) -> Result<Self, GLCoreError> {
559		let slice = buffer.get_slice_of_data(range.start, buffer.len() - range.start)?;
560		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
561		ref_buffer.resize(buffer.len(), T::default())?;
562		Ok(Self {
563			slice,
564			start_index: range.start,
565			buffer: ref_buffer,
566		})
567	}
568
569	fn new_range_to(buffer: &BufferVecStatic<T>, range: RangeTo<usize>) -> Result<Self, GLCoreError> {
570		let slice = buffer.get_slice_of_data(0, range.end)?;
571		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
572		ref_buffer.resize(buffer.len(), T::default())?;
573		Ok(Self {
574			slice,
575			start_index: 0,
576			buffer: ref_buffer,
577		})
578	}
579
580	fn new_range_full(buffer: &BufferVecStatic<T>) -> Result<Self, GLCoreError> {
581		let slice = buffer.get_slice_of_data(0, buffer.len())?;
582		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
583		ref_buffer.resize(buffer.len(), T::default())?;
584		Ok(Self {
585			slice,
586			start_index: 0,
587			buffer: ref_buffer,
588		})
589	}
590
591	fn new_range_inclusive(buffer: &BufferVecStatic<T>, range: RangeInclusive<usize>) -> Result<Self, GLCoreError> {
592		let slice = buffer.get_slice_of_data(*range.start(), *range.end() + 1 - *range.start())?;
593		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
594		ref_buffer.resize(buffer.len(), T::default())?;
595		Ok(Self {
596			slice,
597			start_index: *range.start(),
598			buffer: ref_buffer,
599		})
600	}
601
602	fn new_range_to_inclusive(buffer: &BufferVecStatic<T>, range: RangeToInclusive<usize>) -> Result<Self, GLCoreError> {
603		let slice = buffer.get_slice_of_data(0, range.end + 1)?;
604		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
605		ref_buffer.resize(buffer.len(), T::default())?;
606		Ok(Self {
607			slice,
608			start_index: 0,
609			buffer: ref_buffer,
610		})
611	}
612}
613
614impl<T> BufferVecSliceRefMut<T>
615where
616	T: BufferVecItem {
617	fn as_mut(&mut self) -> &mut [T] {
618		self.slice.as_mut()
619	}
620
621	fn new_range(buffer: &mut BufferVecStatic<T>, range: Range<usize>) -> Result<Self, GLCoreError> {
622		let slice = buffer.get_slice_of_data(range.start, range.end - range.start)?;
623		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
624		ref_buffer.resize(buffer.len(), T::default())?;
625		Ok(Self {
626			slice,
627			start_index: range.start,
628			buffer: ref_buffer,
629		})
630	}
631
632	fn new_range_from(buffer: &mut BufferVecStatic<T>, range: RangeFrom<usize>) -> Result<Self, GLCoreError> {
633		let slice = buffer.get_slice_of_data(range.start, buffer.len() - range.start)?;
634		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
635		ref_buffer.resize(buffer.len(), T::default())?;
636		Ok(Self {
637			slice,
638			start_index: range.start,
639			buffer: ref_buffer,
640		})
641	}
642
643	fn new_range_to(buffer: &mut BufferVecStatic<T>, range: RangeTo<usize>) -> Result<Self, GLCoreError> {
644		let slice = buffer.get_slice_of_data(0, range.end)?;
645		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
646		ref_buffer.resize(buffer.len(), T::default())?;
647		Ok(Self {
648			slice,
649			start_index: 0,
650			buffer: ref_buffer,
651		})
652	}
653
654	fn new_range_full(buffer: &mut BufferVecStatic<T>) -> Result<Self, GLCoreError> {
655		let slice = buffer.get_slice_of_data(0, buffer.len())?;
656		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
657		ref_buffer.resize(buffer.len(), T::default())?;
658		Ok(Self {
659			slice,
660			start_index: 0,
661			buffer: ref_buffer,
662		})
663	}
664
665	fn new_range_inclusive(buffer: &mut BufferVecStatic<T>, range: RangeInclusive<usize>) -> Result<Self, GLCoreError> {
666		let slice = buffer.get_slice_of_data(*range.start(), *range.end() + 1 - *range.start())?;
667		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
668		ref_buffer.resize(buffer.len(), T::default())?;
669		Ok(Self {
670			slice,
671			start_index: *range.start(),
672			buffer: ref_buffer,
673		})
674	}
675
676	fn new_range_to_inclusive(buffer: &mut BufferVecStatic<T>, range: RangeToInclusive<usize>) -> Result<Self, GLCoreError> {
677		let slice = buffer.get_slice_of_data(0, range.end + 1)?;
678		let mut ref_buffer = Box::new(BufferVecStatic::new(unsafe {Buffer::from_raw(buffer.glcore.clone(), buffer.get_name(), buffer.get_target())}?));
679		ref_buffer.resize(buffer.len(), T::default())?;
680		Ok(Self {
681			slice,
682			start_index: 0,
683			buffer: ref_buffer,
684		})
685	}
686}
687
688impl<T> Drop for BufferVecItemRefMut<T>
689where
690	T: BufferVecItem {
691	fn drop(&mut self) {
692		self.buffer.set(self.index, &self.item).unwrap();
693		unsafe {
694			let buffer = ManuallyDrop::take(&mut self.buffer.buffer);
695			buffer.to_raw();
696		}
697	}
698}
699
700impl<T> Drop for BufferVecSliceRefMut<T>
701where
702	T: BufferVecItem {
703	fn drop(&mut self) {
704		self.buffer.set_slice_of_data(self.start_index, self.slice.as_ref()).unwrap();
705		unsafe {
706			let buffer = ManuallyDrop::take(&mut self.buffer.buffer);
707			buffer.to_raw();
708		}
709	}
710}
711
712impl<T: BufferVecItem> From<BufferVecStatic<T>> for BufferVecDynamic<T> {
713	fn from(mut val: BufferVecStatic<T>) -> Self {
714		val.flush().unwrap();
715		BufferVecDynamic::new(val).unwrap()
716	}
717}
718
719impl<T: BufferVecItem> From<BufferVecDynamic<T>> for BufferVecStatic<T> {
720	fn from(mut val: BufferVecDynamic<T>) -> Self {
721		val.flush().unwrap();
722		val.buffer
723	}
724}
725
726impl<T: BufferVecItem> From<BufferVecDynamic<T>> for Buffer {
727	fn from(mut val: BufferVecDynamic<T>) -> Self {
728		unsafe {ManuallyDrop::take(&mut val.buffer.buffer)}
729	}
730}
731
732impl<T: BufferVecItem> From<Buffer> for BufferVecDynamic<T> {
733	fn from(val: Buffer) -> Self {
734		let ab: BufferVecStatic<T> = val.into();
735		ab.into()
736	}
737}
738
739impl<T: BufferVecItem> Index<usize> for BufferVecStatic<T> {
740	type Output = T;
741	fn index(&self, i: usize) -> &T {
742		let cache = unsafe{&mut *self.cache.get()};
743		*cache = BufferVecStaticCache::Item(BufferVecItemRef::new(self, i).unwrap());
744		cache.get_item()
745	}
746}
747
748impl<T: BufferVecItem> IndexMut<usize> for BufferVecStatic<T> {
749	fn index_mut(&mut self, i: usize) -> &mut T {
750		let cache = unsafe{&mut *self.cache.get()};
751		*cache = BufferVecStaticCache::ItemMut(BufferVecItemRefMut::new(self, i).unwrap());
752		cache.get_item_mut()
753	}
754}
755
756impl<T: BufferVecItem> Index<Range<usize>> for BufferVecStatic<T> {
757	type Output = [T];
758	fn index(&self, r: Range<usize>) -> &[T] {
759		let cache = unsafe{&mut *self.cache.get()};
760		*cache = BufferVecStaticCache::Slice(BufferVecSliceRef::new_range(self, r).unwrap());
761		cache.get_slice()
762	}
763}
764
765impl<T: BufferVecItem> IndexMut<Range<usize>> for BufferVecStatic<T> {
766	fn index_mut(&mut self, r: Range<usize>) -> &mut [T] {
767		let cache = unsafe{&mut *self.cache.get()};
768		*cache = BufferVecStaticCache::SliceMut(BufferVecSliceRefMut::new_range(self, r).unwrap());
769		cache.get_slice_mut()
770	}
771}
772
773impl<T: BufferVecItem> Index<RangeFrom<usize>> for BufferVecStatic<T> {
774	type Output = [T];
775	fn index(&self, r: RangeFrom<usize>) -> &[T] {
776		let cache = unsafe{&mut *self.cache.get()};
777		*cache = BufferVecStaticCache::Slice(BufferVecSliceRef::new_range_from(self, r).unwrap());
778		cache.get_slice()
779	}
780}
781
782impl<T: BufferVecItem> IndexMut<RangeFrom<usize>> for BufferVecStatic<T> {
783	fn index_mut(&mut self, r: RangeFrom<usize>) -> &mut [T] {
784		let cache = unsafe{&mut *self.cache.get()};
785		*cache = BufferVecStaticCache::SliceMut(BufferVecSliceRefMut::new_range_from(self, r).unwrap());
786		cache.get_slice_mut()
787	}
788}
789
790impl<T: BufferVecItem> Index<RangeTo<usize>> for BufferVecStatic<T> {
791	type Output = [T];
792	fn index(&self, r: RangeTo<usize>) -> &[T] {
793		let cache = unsafe{&mut *self.cache.get()};
794		*cache = BufferVecStaticCache::Slice(BufferVecSliceRef::new_range_to(self, r).unwrap());
795		cache.get_slice()
796	}
797}
798
799impl<T: BufferVecItem> IndexMut<RangeTo<usize>> for BufferVecStatic<T> {
800	fn index_mut(&mut self, r: RangeTo<usize>) -> &mut [T] {
801		let cache = unsafe{&mut *self.cache.get()};
802		*cache = BufferVecStaticCache::SliceMut(BufferVecSliceRefMut::new_range_to(self, r).unwrap());
803		cache.get_slice_mut()
804	}
805}
806
807impl<T: BufferVecItem> Index<RangeFull> for BufferVecStatic<T> {
808	type Output = [T];
809	fn index(&self, _: RangeFull) -> &[T] {
810		let cache = unsafe{&mut *self.cache.get()};
811		*cache = BufferVecStaticCache::Slice(BufferVecSliceRef::new_range_full(self).unwrap());
812		cache.get_slice()
813	}
814}
815
816impl<T: BufferVecItem> IndexMut<RangeFull> for BufferVecStatic<T> {
817	fn index_mut(&mut self, _: RangeFull) -> &mut [T] {
818		let cache = unsafe{&mut *self.cache.get()};
819		*cache = BufferVecStaticCache::SliceMut(BufferVecSliceRefMut::new_range_full(self).unwrap());
820		cache.get_slice_mut()
821	}
822}
823
824impl<T: BufferVecItem> Index<RangeInclusive<usize>> for BufferVecStatic<T> {
825	type Output = [T];
826	fn index(&self, r: RangeInclusive<usize>) -> &[T] {
827		let cache = unsafe{&mut *self.cache.get()};
828		*cache = BufferVecStaticCache::Slice(BufferVecSliceRef::new_range_inclusive(self, r).unwrap());
829		cache.get_slice()
830	}
831}
832
833impl<T: BufferVecItem> IndexMut<RangeInclusive<usize>> for BufferVecStatic<T> {
834	fn index_mut(&mut self, r: RangeInclusive<usize>) -> &mut [T] {
835		let cache = unsafe{&mut *self.cache.get()};
836		*cache = BufferVecStaticCache::SliceMut(BufferVecSliceRefMut::new_range_inclusive(self, r).unwrap());
837		cache.get_slice_mut()
838	}
839}
840
841impl<T: BufferVecItem> Index<RangeToInclusive<usize>> for BufferVecStatic<T> {
842	type Output = [T];
843	fn index(&self, r: RangeToInclusive<usize>) -> &[T] {
844		let cache = unsafe{&mut *self.cache.get()};
845		*cache = BufferVecStaticCache::Slice(BufferVecSliceRef::new_range_to_inclusive(self, r).unwrap());
846		cache.get_slice()
847	}
848}
849
850impl<T: BufferVecItem> IndexMut<RangeToInclusive<usize>> for BufferVecStatic<T> {
851	fn index_mut(&mut self, r: RangeToInclusive<usize>) -> &mut [T] {
852		let cache = unsafe{&mut *self.cache.get()};
853		*cache = BufferVecStaticCache::SliceMut(BufferVecSliceRefMut::new_range_to_inclusive(self, r).unwrap());
854		cache.get_slice_mut()
855	}
856}
857
858impl<T: BufferVecItem> Index<usize> for BufferVecDynamic<T> {
859	type Output = T;
860	fn index(&self, i: usize) -> &T {
861		&self.cache[i]
862	}
863}
864
865impl<T: BufferVecItem> IndexMut<usize> for BufferVecDynamic<T> {
866	fn index_mut(&mut self, i: usize) -> &mut T {
867		self.cache_modified = true;
868		self.cache_modified_bitmap.set(i, true);
869		&mut self.cache[i]
870	}
871}
872
873impl<T: BufferVecItem> Index<Range<usize>> for BufferVecDynamic<T> {
874	type Output = [T];
875	fn index(&self, r: Range<usize>) -> &[T] {
876		&self.cache[r]
877	}
878}
879
880impl<T: BufferVecItem> IndexMut<Range<usize>> for BufferVecDynamic<T> {
881	fn index_mut(&mut self, r: Range<usize>) -> &mut [T] {
882		self.cache_modified = true;
883		for i in r.clone() {
884			self.cache_modified_bitmap.set(i, true);
885		}
886		&mut self.cache[r]
887	}
888}
889
890impl<T: BufferVecItem> Index<RangeFrom<usize>> for BufferVecDynamic<T> {
891	type Output = [T];
892	fn index(&self, r: RangeFrom<usize>) -> &[T] {
893		&self.cache[r]
894	}
895}
896
897impl<T: BufferVecItem> IndexMut<RangeFrom<usize>> for BufferVecDynamic<T> {
898	fn index_mut(&mut self, r: RangeFrom<usize>) -> &mut [T] {
899		self.cache_modified = true;
900		for i in r.clone() {
901			self.cache_modified_bitmap.set(i, true);
902		}
903		&mut self.cache[r]
904	}
905}
906
907impl<T: BufferVecItem> Index<RangeTo<usize>> for BufferVecDynamic<T> {
908	type Output = [T];
909	fn index(&self, r: RangeTo<usize>) -> &[T] {
910		&self.cache[r]
911	}
912}
913
914impl<T: BufferVecItem> IndexMut<RangeTo<usize>> for BufferVecDynamic<T> {
915	fn index_mut(&mut self, r: RangeTo<usize>) -> &mut [T] {
916		self.cache_modified = true;
917		for i in 0..r.end {
918			self.cache_modified_bitmap.set(i, true);
919		}
920		&mut self.cache[r]
921	}
922}
923
924impl<T: BufferVecItem> Index<RangeFull> for BufferVecDynamic<T> {
925	type Output = [T];
926	fn index(&self, _: RangeFull) -> &[T] {
927		&self.cache[..]
928	}
929}
930
931impl<T: BufferVecItem> IndexMut<RangeFull> for BufferVecDynamic<T> {
932	fn index_mut(&mut self, _: RangeFull) -> &mut [T] {
933		self.cache_modified = true;
934		for i in 0..self.num_items {
935			self.cache_modified_bitmap.set(i, true);
936		}
937		&mut self.cache[..]
938	}
939}
940
941impl<T: BufferVecItem> Index<RangeInclusive<usize>> for BufferVecDynamic<T> {
942	type Output = [T];
943	fn index(&self, r: RangeInclusive<usize>) -> &[T] {
944		&self.cache[r]
945	}
946}
947
948impl<T: BufferVecItem> IndexMut<RangeInclusive<usize>> for BufferVecDynamic<T> {
949	fn index_mut(&mut self, r: RangeInclusive<usize>) -> &mut [T] {
950		self.cache_modified = true;
951		for i in r.clone() {
952			self.cache_modified_bitmap.set(i, true);
953		}
954		&mut self.cache[r]
955	}
956}
957
958impl<T: BufferVecItem> Index<RangeToInclusive<usize>> for BufferVecDynamic<T> {
959	type Output = [T];
960	fn index(&self, r: RangeToInclusive<usize>) -> &[T] {
961		&self.cache[r]
962	}
963}
964
965impl<T: BufferVecItem> IndexMut<RangeToInclusive<usize>> for BufferVecDynamic<T> {
966	fn index_mut(&mut self, r: RangeToInclusive<usize>) -> &mut [T] {
967		self.cache_modified = true;
968		for i in 0..=r.end {
969			self.cache_modified_bitmap.set(i, true);
970		}
971		&mut self.cache[r]
972	}
973}
globject_rs/buffervec.rs

globject_rs/
buffervec.rs
