1#![allow(non_camel_case_types)]
2
3use std::ops::{Deref, DerefMut};
4
5use serde::ser::SerializeTupleStruct;
6use serde::{Serialize, Serializer};
7
8use crate::f16;
9
10#[derive(Copy, Clone, Debug, Default)]
11pub struct vec2<T>(pub [T; 2]);
12
13impl<T> From<[T; 2]> for vec2<T> {
14 fn from(value: [T; 2]) -> Self {
15 Self(value)
16 }
17}
18
19impl<T> Deref for vec2<T> {
20 type Target = [T; 2];
21
22 fn deref(&self) -> &Self::Target {
23 &self.0
24 }
25}
26
27impl<T> DerefMut for vec2<T> {
28 fn deref_mut(&mut self) -> &mut Self::Target {
29 &mut self.0
30 }
31}
32
33impl Serialize for vec2<f16> {
34 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
35 where
36 S: Serializer,
37 {
38 let mut s = serializer.serialize_tuple_struct("vec2@f16", 2)?;
39 s.serialize_field(&self[0])?;
40 s.serialize_field(&self[1])?;
41 s.end()
42 }
43}
44
45impl Serialize for vec2<i32> {
46 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
47 where
48 S: Serializer,
49 {
50 let mut s = serializer.serialize_tuple_struct("vec2@i32", 2)?;
51 s.serialize_field(&self[0])?;
52 s.serialize_field(&self[1])?;
53 s.end()
54 }
55}
56
57impl Serialize for vec2<u32> {
58 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
59 where
60 S: Serializer,
61 {
62 let mut s = serializer.serialize_tuple_struct("vec2@u32", 2)?;
63 s.serialize_field(&self[0])?;
64 s.serialize_field(&self[1])?;
65 s.end()
66 }
67}
68
69impl Serialize for vec2<f32> {
70 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
71 where
72 S: Serializer,
73 {
74 let mut s = serializer.serialize_tuple_struct("vec2@f32", 2)?;
75 s.serialize_field(&self[0])?;
76 s.serialize_field(&self[1])?;
77 s.end()
78 }
79}
80
81#[derive(Copy, Clone, Debug, Default)]
82pub struct vec3<T>(pub [T; 3]);
83
84impl<T> From<[T; 3]> for vec3<T> {
85 fn from(value: [T; 3]) -> Self {
86 Self(value)
87 }
88}
89
90impl<T> Deref for vec3<T> {
91 type Target = [T; 3];
92
93 fn deref(&self) -> &Self::Target {
94 &self.0
95 }
96}
97
98impl<T> DerefMut for vec3<T> {
99 fn deref_mut(&mut self) -> &mut Self::Target {
100 &mut self.0
101 }
102}
103
104impl Serialize for vec3<f16> {
105 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
106 where
107 S: Serializer,
108 {
109 let mut s = serializer.serialize_tuple_struct("vec3@f16", 3)?;
110 s.serialize_field(&self[0])?;
111 s.serialize_field(&self[1])?;
112 s.serialize_field(&self[2])?;
113 s.end()
114 }
115}
116
117impl Serialize for vec3<i32> {
118 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
119 where
120 S: Serializer,
121 {
122 let mut s = serializer.serialize_tuple_struct("vec3@i32", 3)?;
123 s.serialize_field(&self[0])?;
124 s.serialize_field(&self[1])?;
125 s.serialize_field(&self[2])?;
126 s.end()
127 }
128}
129
130impl Serialize for vec3<u32> {
131 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
132 where
133 S: Serializer,
134 {
135 let mut s = serializer.serialize_tuple_struct("vec3@u32", 3)?;
136 s.serialize_field(&self[0])?;
137 s.serialize_field(&self[1])?;
138 s.serialize_field(&self[2])?;
139 s.end()
140 }
141}
142
143impl Serialize for vec3<f32> {
144 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
145 where
146 S: Serializer,
147 {
148 let mut s = serializer.serialize_tuple_struct("vec3@f32", 3)?;
149 s.serialize_field(&self[0])?;
150 s.serialize_field(&self[1])?;
151 s.serialize_field(&self[2])?;
152 s.end()
153 }
154}
155
156#[derive(Copy, Clone, Debug, Default)]
157pub struct vec4<T>(pub [T; 4]);
158
159impl<T> From<[T; 4]> for vec4<T> {
160 fn from(value: [T; 4]) -> Self {
161 Self(value)
162 }
163}
164
165impl<T> Deref for vec4<T> {
166 type Target = [T; 4];
167
168 fn deref(&self) -> &Self::Target {
169 &self.0
170 }
171}
172
173impl<T> DerefMut for vec4<T> {
174 fn deref_mut(&mut self) -> &mut Self::Target {
175 &mut self.0
176 }
177}
178
179impl Serialize for vec4<f16> {
180 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
181 where
182 S: Serializer,
183 {
184 let mut s = serializer.serialize_tuple_struct("vec4@f16", 4)?;
185 s.serialize_field(&self[0])?;
186 s.serialize_field(&self[1])?;
187 s.serialize_field(&self[2])?;
188 s.serialize_field(&self[3])?;
189 s.end()
190 }
191}
192
193impl Serialize for vec4<i32> {
194 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
195 where
196 S: Serializer,
197 {
198 let mut s = serializer.serialize_tuple_struct("vec4@i32", 4)?;
199 s.serialize_field(&self[0])?;
200 s.serialize_field(&self[1])?;
201 s.serialize_field(&self[2])?;
202 s.serialize_field(&self[3])?;
203 s.end()
204 }
205}
206
207impl Serialize for vec4<u32> {
208 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
209 where
210 S: Serializer,
211 {
212 let mut s = serializer.serialize_tuple_struct("vec4@u32", 4)?;
213 s.serialize_field(&self[0])?;
214 s.serialize_field(&self[1])?;
215 s.serialize_field(&self[2])?;
216 s.serialize_field(&self[3])?;
217 s.end()
218 }
219}
220
221impl Serialize for vec4<f32> {
222 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
223 where
224 S: Serializer,
225 {
226 let mut s = serializer.serialize_tuple_struct("vec4@f32", 4)?;
227 s.serialize_field(&self[0])?;
228 s.serialize_field(&self[1])?;
229 s.serialize_field(&self[2])?;
230 s.serialize_field(&self[3])?;
231 s.end()
232 }
233}