phaz.uk
1use bevy_math::{Quat, Vec3};
2
3#[derive(Clone)]
4pub struct Buffer{
5 dat: Vec<u8>,
6 pointer: usize
7}
8
9impl Buffer{
10 pub fn empty() -> Self{
11 Self { dat: vec![], pointer: 0 }
12 }
13
14 pub fn left(&self) -> usize{
15 self.dat.len() - self.pointer
16 }
17
18 pub fn pointer(&mut self, val: usize){
19 self.pointer = val;
20 }
21
22 pub fn set_u8(&mut self, value: u8){
23 self.dat.push(value);
24 }
25
26 pub fn set_u8s(&mut self, value: &[u8]){
27 self.dat.append(&mut value.to_vec());
28 }
29
30 pub fn set_i16(&mut self, value: i16){
31 let b = value.to_le_bytes();
32 self.set_u8s(&b);
33 }
34
35 pub fn set_i32(&mut self, value: i32){
36 let b = value.to_le_bytes();
37 self.set_u8s(&b);
38 }
39
40 pub fn set_i64(&mut self, value: i64){
41 let b = value.to_le_bytes();
42 self.set_u8s(&b);
43 }
44
45 pub fn set_u16(&mut self, value: u16){
46 let b = value.to_le_bytes();
47 self.set_u8s(&b);
48 }
49
50 pub fn set_u32(&mut self, value: u32){
51 let b = value.to_le_bytes();
52 self.set_u8s(&b);
53 }
54
55 pub fn set_u64(&mut self, value: u64){
56 let b = value.to_le_bytes();
57 self.set_u8s(&b);
58 }
59
60 pub fn set_str(&mut self, value: String){
61 let b = value.as_bytes();
62
63 self.set_u32(b.len() as u32);
64 self.set_u8s(b);
65 }
66
67
68 pub fn set_vec3(&mut self, value: Vec3){
69 self.set_f32(value.x);
70 self.set_f32(value.y);
71 self.set_f32(value.z);
72 }
73
74 pub fn set_quat(&mut self, value: Quat){
75 self.set_f32(value.x);
76 self.set_f32(value.y);
77 self.set_f32(value.z);
78 self.set_f32(value.w);
79 }
80
81
82 pub fn set_f32(&mut self, value: f32){
83 let b = value.to_le_bytes();
84 self.set_u8s(&b);
85 }
86
87 pub fn set_f64(&mut self, value: f64){
88 let b = value.to_le_bytes();
89 self.set_u8s(&b);
90 }
91
92
93 pub fn get_u8(&mut self) -> u8{
94 let b = self.dat[self.pointer];
95 self.pointer += 1;
96
97 b
98 }
99
100 pub fn get_u8s(&mut self, count: usize) -> &[u8]{
101 let b = &self.dat[self.pointer..self.pointer + count];
102 self.pointer += count;
103
104 b
105 }
106
107 pub fn get_i16(&mut self) -> i16{
108 let b = self.get_u8s(2);
109 i16::from_le_bytes([ b[0], b[1] ])
110 }
111
112 pub fn get_i32(&mut self) -> i32{
113 let b = self.get_u8s(4);
114 i32::from_le_bytes([ b[0], b[1], b[2], b[3] ])
115 }
116
117 pub fn get_i64(&mut self) -> i64{
118 let b = self.get_u8s(8);
119 i64::from_le_bytes([ b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7] ])
120 }
121
122 pub fn get_u16(&mut self) -> u16{
123 let b = self.get_u8s(2);
124 u16::from_le_bytes([ b[0], b[1] ])
125 }
126
127 pub fn get_u32(&mut self) -> u32{
128 let b = self.get_u8s(4);
129 u32::from_le_bytes([ b[0], b[1], b[2], b[3] ])
130 }
131
132 pub fn get_u64(&mut self) -> u64{
133 let b = self.get_u8s(8);
134 u64::from_le_bytes([ b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7] ])
135 }
136
137 pub fn get_str(&mut self) -> String{
138 let length = self.get_u32();
139 let b = self.get_u8s(length as usize);
140
141 let string = str::from_utf8(b).unwrap();
142 string.to_owned()
143 }
144
145
146 pub fn get_vec3(&mut self) -> Vec3{
147 Vec3 { x: self.get_f32(), y: self.get_f32(), z: self.get_f32() }
148 }
149
150 pub fn get_quat(&mut self) -> Quat{
151 Quat::from_xyzw(self.get_f32(), self.get_f32(), self.get_f32(), self.get_f32())
152 }
153
154
155 pub fn get_f32(&mut self) -> f32{
156 let b = self.get_u8s(4);
157 f32::from_le_bytes([ b[0], b[1], b[2], b[3] ])
158 }
159
160 pub fn get_f64(&mut self) -> f64{
161 let b = self.get_u8s(8);
162 f64::from_le_bytes([ b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7] ])
163 }
164}
165
166impl From<Vec<u8>> for Buffer{
167 fn from(value: Vec<u8>) -> Self {
168 Self { dat: value, pointer: 0 }
169 }
170}
171
172impl From<&[u8]> for Buffer{
173 fn from(value: &[u8]) -> Self {
174 Self { dat: value.to_vec(), pointer: 0 }
175 }
176}
177
178impl Into<Vec<u8>> for Buffer{
179 fn into(self) -> Vec<u8> {
180 self.dat
181 }
182}