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
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
134
135
136
137
138
139
140
141

/// The `Stream` struct provides a borrowed view of one named range in a resource's binary data.
#[derive(Debug)]
pub struct Stream<'a> {
	/// The selected bytes from the resource data.
	buffer: &'a [u8],
	/// The subresource name, such as `Vertex` or `Index`.
	name: &'a str,
	/// The byte offset where this stream starts in the resource data.
	offset: usize,
	/// The maximum number of bytes to read, or the full buffer length when `None`.
	size: Option<usize>,
}

impl<'a> Stream<'a> {
	pub fn new(name: &'a str, buffer: &'a [u8], offset: usize, size: Option<usize>) -> Self {
		Stream {
			buffer,
			name,
			offset,
			size,
		}
	}

	pub fn name(&'a self) -> &'a str {
		self.name
	}

	pub fn buffer(&'a self) -> &'a [u8] {
		self.buffer
	}

	pub fn offset(&self) -> usize {
		self.offset
	}

	pub fn size(&self) -> Option<usize> {
		self.size
	}
}

impl<'a> From<StreamMut<'a>> for Stream<'a> {
	fn from(value: StreamMut<'a>) -> Self {
		Stream::new(value.name, value.buffer, value.offset, value.size)
	}
}

#[derive(Debug)]
/// The `StreamMut` struct provides a writable destination for one named resource-data range.
pub struct StreamMut<'a> {
	/// The buffer that receives the resource data.
	buffer: &'a mut [u8],
	/// The subresource name, such as `Vertex` or `Index`.
	name: &'a str,
	/// The byte offset where this stream starts in the resource data.
	offset: usize,
	/// The maximum number of bytes to read, or the full buffer length when `None`.
	size: Option<usize>,
}

impl<'a> StreamMut<'a> {
	pub fn new<T: Copy>(name: &'a str, buffer: &'a mut [T]) -> Self {
		let buffer = unsafe { std::slice::from_raw_parts_mut(buffer.as_mut_ptr() as *mut u8, std::mem::size_of_val(buffer)) };
		StreamMut {
			buffer,
			name,
			offset: 0,
			size: None,
		}
	}

	/// Sets the maximum number of bytes to read into this stream.
	pub fn with_size(self, size: usize) -> Self {
		StreamMut {
			size: Some(size),
			..self
		}
	}

	pub fn buffer(&self) -> &'_ [u8] {
		self.buffer
	}

	pub fn buffer_mut(&mut self) -> &'_ mut [u8] {
		self.buffer
	}

	pub fn name(&self) -> &'_ str {
		self.name
	}

	pub fn offset(&self) -> usize {
		self.offset
	}

	pub fn size(&self) -> Option<usize> {
		self.size
	}
}

#[cfg(test)]
mod tests {
	use super::{Stream, StreamMut};

	#[test]
	fn immutable_stream_preserves_name_range_and_buffer() {
		let bytes = [1u8, 2, 3, 4];
		let stream = Stream::new("vertices", &bytes, 12, Some(3));

		assert_eq!(stream.name(), "vertices");
		assert_eq!(stream.buffer(), &bytes);
		assert_eq!(stream.offset(), 12);
		assert_eq!(stream.size(), Some(3));
	}

	#[test]
	fn mutable_typed_stream_exposes_the_complete_object_representation() {
		let mut words = [0x1122u16, 0x3344u16];
		let expected = words;
		{
			let mut stream = StreamMut::new("indices", &mut words).with_size(3);

			assert_eq!(stream.name(), "indices");
			assert_eq!(stream.offset(), 0);
			assert_eq!(stream.size(), Some(3));
			assert_eq!(stream.buffer().len(), std::mem::size_of_val(&expected));
			stream.buffer_mut().fill(0);
		}
		assert_eq!(words, [0, 0]);
	}

	#[test]
	fn mutable_to_immutable_conversion_retains_metadata_and_storage() {
		let mut bytes = [1u8, 2, 3];
		let stream = Stream::from(StreamMut::new("payload", &mut bytes).with_size(2));

		assert_eq!(stream.name(), "payload");
		assert_eq!(stream.buffer(), &[1, 2, 3]);
		assert_eq!(stream.offset(), 0);
		assert_eq!(stream.size(), Some(2));
	}
}