byte-engine-resource-management 0.1.0

Asset, resource, shader, and storage management for Byte-Engine.
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

use super::reader::ResourceReader;

pub type MultiResourceReader = Box<dyn ResourceReader>;

#[cfg(test)]
pub mod tests {
	use crate::{
		resource::{
			reader::{ResourceReader, ResourceReaderBacking},
			ReadTargets, ReadTargetsMut,
		},
		StreamDescription,
	};

	#[derive(Debug)]
	pub struct MemoryResourceReader {
		data: Box<[u8]>,
	}

	impl MemoryResourceReader {
		pub fn new(data: Box<[u8]>) -> Self {
			Self { data }
		}
	}

	impl ResourceReader for MemoryResourceReader {
		fn read_into<'b, 'c: 'b, 'a: 'b>(
			&mut self,
			stream_descriptions: Option<&'c [StreamDescription]>,
			read_target: ReadTargetsMut<'a>,
		) -> Result<ReadTargets<'a>, ()> {
			match read_target {
				ReadTargetsMut::Buffer { buffer, offset, size } => {
					let read_len = size
						.unwrap_or(buffer.len())
						.min(buffer.len())
						.min(self.data.len().saturating_sub(offset));
					buffer[..read_len].copy_from_slice(&self.data[offset..][..read_len]);
					Ok(ReadTargets::Buffer(&buffer[..read_len]))
				}
				ReadTargetsMut::Box {
					mut buffer,
					offset,
					size,
				} => {
					let read_len = size
						.unwrap_or(buffer.len())
						.min(buffer.len())
						.min(self.data.len().saturating_sub(offset));
					buffer[..read_len].copy_from_slice(&self.data[offset..][..read_len]);
					if read_len < buffer.len() {
						let mut v = buffer.into_vec();
						v.truncate(read_len);
						Ok(ReadTargets::Box(v.into_boxed_slice()))
					} else {
						Ok(ReadTargets::Box(buffer))
					}
				}
				ReadTargetsMut::Streams(mut streams) => {
					if let Some(stream_descriptions) = stream_descriptions {
						for sd in stream_descriptions {
							let stream_offset = sd.offset;
							if let Some(s) = streams.iter_mut().find(|s| s.name() == sd.name) {
								let offset = s.offset();
								let read_len = s
									.size()
									.unwrap_or(s.buffer().len())
									.min(s.buffer().len())
									.min(self.data.len().saturating_sub(stream_offset + offset));
								s.buffer_mut()[..read_len].copy_from_slice(&self.data[(stream_offset + offset)..][..read_len]);
							}
						}

						Ok(ReadTargets::Streams(
							streams.into_iter().map(|stream| stream.into()).collect(),
						))
					} else {
						Err(())
					}
				}
				ReadTargetsMut::BackingStorage => Ok(ReadTargets::Backing(ResourceReaderBacking::Buffer(self.data.clone()))),
			}
		}

		fn into_backing_storage(self: Box<Self>) -> Result<ResourceReaderBacking, Box<dyn ResourceReader>> {
			Ok(ResourceReaderBacking::Buffer(self.data))
		}
	}
}