Plasma Engine  2.0
Loading...
Searching...
No Matches
StreamOperationsMath_inl.h
1#pragma once
2
3#include <Foundation/Math/BoundingBox.h>
4#include <Foundation/Math/BoundingSphere.h>
5#include <Foundation/Math/Color.h>
6#include <Foundation/Math/Color8UNorm.h>
7#include <Foundation/Math/Mat3.h>
8#include <Foundation/Math/Mat4.h>
9#include <Foundation/Math/Plane.h>
10#include <Foundation/Math/Quat.h>
11#include <Foundation/Math/Transform.h>
12#include <Foundation/Math/Vec2.h>
13#include <Foundation/Math/Vec3.h>
14#include <Foundation/Math/Vec4.h>
15
16// plVec2Template
17
18template <typename Type>
19inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plVec2Template<Type>& vValue)
20{
21 inout_stream.WriteBytes(&vValue, sizeof(plVec2Template<Type>)).AssertSuccess();
22 return inout_stream;
23}
24
25template <typename Type>
26inline plStreamReader& operator>>(plStreamReader& inout_stream, plVec2Template<Type>& ref_vValue)
27{
28 PL_VERIFY(inout_stream.ReadBytes(&ref_vValue, sizeof(plVec2Template<Type>)) == sizeof(plVec2Template<Type>), "End of stream reached.");
29 return inout_stream;
30}
31
32template <typename Type>
33plResult SerializeArray(plStreamWriter& inout_stream, const plVec2Template<Type>* pArray, plUInt64 uiCount)
34{
35 return inout_stream.WriteBytes(pArray, sizeof(plVec2Template<Type>) * uiCount);
36}
37
38template <typename Type>
39plResult DeserializeArray(plStreamReader& inout_stream, plVec2Template<Type>* pArray, plUInt64 uiCount)
40{
41 const plUInt64 uiNumBytes = sizeof(plVec2Template<Type>) * uiCount;
42 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
43 return PL_SUCCESS;
44
45 return PL_FAILURE;
46}
47
48
49// plVec3Template
50
51template <typename Type>
52inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plVec3Template<Type>& vValue)
53{
54 inout_stream.WriteBytes(&vValue, sizeof(plVec3Template<Type>)).AssertSuccess();
55 return inout_stream;
56}
57
58template <typename Type>
59inline plStreamReader& operator>>(plStreamReader& inout_stream, plVec3Template<Type>& ref_vValue)
60{
61 PL_VERIFY(inout_stream.ReadBytes(&ref_vValue, sizeof(plVec3Template<Type>)) == sizeof(plVec3Template<Type>), "End of stream reached.");
62 return inout_stream;
63}
64
65template <typename Type>
66plResult SerializeArray(plStreamWriter& inout_stream, const plVec3Template<Type>* pArray, plUInt64 uiCount)
67{
68 return inout_stream.WriteBytes(pArray, sizeof(plVec3Template<Type>) * uiCount);
69}
70
71template <typename Type>
72plResult DeserializeArray(plStreamReader& inout_stream, plVec3Template<Type>* pArray, plUInt64 uiCount)
73{
74 const plUInt64 uiNumBytes = sizeof(plVec3Template<Type>) * uiCount;
75 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
76 return PL_SUCCESS;
77
78 return PL_FAILURE;
79}
80
81
82// plVec4Template
83
84template <typename Type>
85inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plVec4Template<Type>& vValue)
86{
87 inout_stream.WriteBytes(&vValue, sizeof(plVec4Template<Type>)).AssertSuccess();
88 return inout_stream;
89}
90
91template <typename Type>
92inline plStreamReader& operator>>(plStreamReader& inout_stream, plVec4Template<Type>& ref_vValue)
93{
94 PL_VERIFY(inout_stream.ReadBytes(&ref_vValue, sizeof(plVec4Template<Type>)) == sizeof(plVec4Template<Type>), "End of stream reached.");
95 return inout_stream;
96}
97
98template <typename Type>
99plResult SerializeArray(plStreamWriter& inout_stream, const plVec4Template<Type>* pArray, plUInt64 uiCount)
100{
101 return inout_stream.WriteBytes(pArray, sizeof(plVec4Template<Type>) * uiCount);
102}
103
104template <typename Type>
105plResult DeserializeArray(plStreamReader& inout_stream, plVec4Template<Type>* pArray, plUInt64 uiCount)
106{
107 const plUInt64 uiNumBytes = sizeof(plVec4Template<Type>) * uiCount;
108 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
109 return PL_SUCCESS;
110
111 return PL_FAILURE;
112}
113
114
115// plMat3Template
116
117template <typename Type>
118inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plMat3Template<Type>& mValue)
119{
120 inout_stream.WriteBytes(mValue.m_fElementsCM, sizeof(Type) * 9).AssertSuccess();
121 return inout_stream;
122}
123
124template <typename Type>
125inline plStreamReader& operator>>(plStreamReader& inout_stream, plMat3Template<Type>& ref_mValue)
126{
127 PL_VERIFY(inout_stream.ReadBytes(ref_mValue.m_fElementsCM, sizeof(Type) * 9) == sizeof(Type) * 9, "End of stream reached.");
128 return inout_stream;
129}
130
131template <typename Type>
132plResult SerializeArray(plStreamWriter& inout_stream, const plMat3Template<Type>* pArray, plUInt64 uiCount)
133{
134 return inout_stream.WriteBytes(pArray, sizeof(plMat3Template<Type>) * uiCount);
135}
136
137template <typename Type>
138plResult DeserializeArray(plStreamReader& inout_stream, plMat3Template<Type>* pArray, plUInt64 uiCount)
139{
140 const plUInt64 uiNumBytes = sizeof(plMat3Template<Type>) * uiCount;
141 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
142 return PL_SUCCESS;
143
144 return PL_FAILURE;
145}
146
147
148// plMat4Template
149
150template <typename Type>
151inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plMat4Template<Type>& mValue)
152{
153 inout_stream.WriteBytes(mValue.m_fElementsCM, sizeof(Type) * 16).AssertSuccess();
154 return inout_stream;
155}
156
157template <typename Type>
158inline plStreamReader& operator>>(plStreamReader& inout_stream, plMat4Template<Type>& ref_mValue)
159{
160 PL_VERIFY(inout_stream.ReadBytes(ref_mValue.m_fElementsCM, sizeof(Type) * 16) == sizeof(Type) * 16, "End of stream reached.");
161 return inout_stream;
162}
163
164template <typename Type>
165plResult SerializeArray(plStreamWriter& inout_stream, const plMat4Template<Type>* pArray, plUInt64 uiCount)
166{
167 return inout_stream.WriteBytes(pArray, sizeof(plMat4Template<Type>) * uiCount);
168}
169
170template <typename Type>
171plResult DeserializeArray(plStreamReader& inout_stream, plMat4Template<Type>* pArray, plUInt64 uiCount)
172{
173 const plUInt64 uiNumBytes = sizeof(plMat4Template<Type>) * uiCount;
174 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
175 return PL_SUCCESS;
176
177 return PL_FAILURE;
178}
179
180
181// plTransformTemplate
182
183template <typename Type>
184inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plTransformTemplate<Type>& value)
185{
186 inout_stream << value.m_qRotation;
187 inout_stream << value.m_vPosition;
188 inout_stream << value.m_vScale;
189
190 return inout_stream;
191}
192
193template <typename Type>
194inline plStreamReader& operator>>(plStreamReader& inout_stream, plTransformTemplate<Type>& out_value)
195{
196 inout_stream >> out_value.m_qRotation;
197 inout_stream >> out_value.m_vPosition;
198 inout_stream >> out_value.m_vScale;
199
200 return inout_stream;
201}
202
203// plPlaneTemplate
204
205template <typename Type>
206inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plPlaneTemplate<Type>& value)
207{
208 inout_stream.WriteBytes(&value, sizeof(plPlaneTemplate<Type>)).AssertSuccess();
209 return inout_stream;
210}
211
212template <typename Type>
213inline plStreamReader& operator>>(plStreamReader& inout_stream, plPlaneTemplate<Type>& out_value)
214{
215 PL_VERIFY(inout_stream.ReadBytes(&out_value, sizeof(plPlaneTemplate<Type>)) == sizeof(plPlaneTemplate<Type>), "End of stream reached.");
216 return inout_stream;
217}
218
219template <typename Type>
220plResult SerializeArray(plStreamWriter& inout_stream, const plPlaneTemplate<Type>* pArray, plUInt64 uiCount)
221{
222 return inout_stream.WriteBytes(pArray, sizeof(plPlaneTemplate<Type>) * uiCount);
223}
224
225template <typename Type>
226plResult DeserializeArray(plStreamReader& inout_stream, plPlaneTemplate<Type>* pArray, plUInt64 uiCount)
227{
228 const plUInt64 uiNumBytes = sizeof(plPlaneTemplate<Type>) * uiCount;
229 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
230 return PL_SUCCESS;
231
232 return PL_FAILURE;
233}
234
235
236// plQuatTemplate
237
238template <typename Type>
239inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plQuatTemplate<Type>& qValue)
240{
241 inout_stream.WriteBytes(&qValue, sizeof(plQuatTemplate<Type>)).AssertSuccess();
242 return inout_stream;
243}
244
245template <typename Type>
246inline plStreamReader& operator>>(plStreamReader& inout_stream, plQuatTemplate<Type>& ref_qValue)
247{
248 PL_VERIFY(inout_stream.ReadBytes(&ref_qValue, sizeof(plQuatTemplate<Type>)) == sizeof(plQuatTemplate<Type>), "End of stream reached.");
249 return inout_stream;
250}
251
252template <typename Type>
253plResult SerializeArray(plStreamWriter& inout_stream, const plQuatTemplate<Type>* pArray, plUInt64 uiCount)
254{
255 return inout_stream.WriteBytes(pArray, sizeof(plQuatTemplate<Type>) * uiCount);
256}
257
258template <typename Type>
259plResult DeserializeArray(plStreamReader& inout_stream, plQuatTemplate<Type>* pArray, plUInt64 uiCount)
260{
261 const plUInt64 uiNumBytes = sizeof(plQuatTemplate<Type>) * uiCount;
262 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
263 return PL_SUCCESS;
264
265 return PL_FAILURE;
266}
267
268
269// plBoundingBoxTemplate
270
271template <typename Type>
272inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plBoundingBoxTemplate<Type>& value)
273{
274 inout_stream << value.m_vMax;
275 inout_stream << value.m_vMin;
276 return inout_stream;
277}
278
279template <typename Type>
280inline plStreamReader& operator>>(plStreamReader& inout_stream, plBoundingBoxTemplate<Type>& out_value)
281{
282 inout_stream >> out_value.m_vMax;
283 inout_stream >> out_value.m_vMin;
284 return inout_stream;
285}
286
287// plBoundingSphereTemplate
288
289template <typename Type>
290inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plBoundingSphereTemplate<Type>& value)
291{
292 inout_stream << value.m_vCenter;
293 inout_stream << value.m_fRadius;
294 return inout_stream;
295}
296
297template <typename Type>
298inline plStreamReader& operator>>(plStreamReader& inout_stream, plBoundingSphereTemplate<Type>& out_value)
299{
300 inout_stream >> out_value.m_vCenter;
301 inout_stream >> out_value.m_fRadius;
302 return inout_stream;
303}
304
305// plBoundingBoxSphereTemplate
306
307template <typename Type>
308inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plBoundingBoxSphereTemplate<Type>& value)
309{
310 inout_stream << value.m_vCenter;
311 inout_stream << value.m_fSphereRadius;
312 inout_stream << value.m_vBoxHalfExtends;
313 return inout_stream;
314}
315
316template <typename Type>
317inline plStreamReader& operator>>(plStreamReader& inout_stream, plBoundingBoxSphereTemplate<Type>& out_value)
318{
319 inout_stream >> out_value.m_vCenter;
320 inout_stream >> out_value.m_fSphereRadius;
321 inout_stream >> out_value.m_vBoxHalfExtends;
322 return inout_stream;
323}
324
325// plColor
326inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plColor& value)
327{
328 inout_stream.WriteBytes(&value, sizeof(plColor)).AssertSuccess();
329 return inout_stream;
330}
331
332inline plStreamReader& operator>>(plStreamReader& inout_stream, plColor& ref_value)
333{
334 PL_VERIFY(inout_stream.ReadBytes(&ref_value, sizeof(plColor)) == sizeof(plColor), "End of stream reached.");
335 return inout_stream;
336}
337
338inline plResult SerializeArray(plStreamWriter& inout_stream, const plColor* pArray, plUInt64 uiCount)
339{
340 return inout_stream.WriteBytes(pArray, sizeof(plColor) * uiCount);
341}
342
343template <typename Type>
344plResult DeserializeArray(plStreamReader& inout_stream, plColor* pArray, plUInt64 uiCount)
345{
346 const plUInt64 uiNumBytes = sizeof(plColor) * uiCount;
347 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
348 return PL_SUCCESS;
349
350 return PL_FAILURE;
351}
352
353
354// plColorGammaUB
355inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plColorGammaUB& value)
356{
357 inout_stream.WriteBytes(&value, sizeof(plColorGammaUB)).AssertSuccess();
358 return inout_stream;
359}
360
361inline plStreamReader& operator>>(plStreamReader& inout_stream, plColorGammaUB& ref_value)
362{
363 PL_VERIFY(inout_stream.ReadBytes(&ref_value, sizeof(plColorGammaUB)) == sizeof(plColorGammaUB), "End of stream reached.");
364 return inout_stream;
365}
366
367template <typename Type>
368plResult SerializeArray(plStreamWriter& inout_stream, const plColorGammaUB* pArray, plUInt64 uiCount)
369{
370 return inout_stream.WriteBytes(pArray, sizeof(plColorGammaUB) * uiCount);
371}
372
373template <typename Type>
374plResult DeserializeArray(plStreamReader& inout_stream, plColorGammaUB* pArray, plUInt64 uiCount)
375{
376 const plUInt64 uiNumBytes = sizeof(plColorGammaUB) * uiCount;
377 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
378 return PL_SUCCESS;
379
380 return PL_FAILURE;
381}
382
383
384// plAngle
385inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plAngle& value)
386{
387 inout_stream << value.GetRadian();
388 return inout_stream;
389}
390
391inline plStreamReader& operator>>(plStreamReader& inout_stream, plAngle& out_value)
392{
393 float fRadian;
394 inout_stream >> fRadian;
395 out_value.SetRadian(fRadian);
396 return inout_stream;
397}
398
399template <typename Type>
400plResult SerializeArray(plStreamWriter& inout_stream, const plAngle* pArray, plUInt64 uiCount)
401{
402 return inout_stream.WriteBytes(pArray, sizeof(plAngle) * uiCount);
403}
404
405template <typename Type>
406plResult DeserializeArray(plStreamReader& inout_stream, plAngle* pArray, plUInt64 uiCount)
407{
408 const plUInt64 uiNumBytes = sizeof(plAngle) * uiCount;
409 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
410 return PL_SUCCESS;
411
412 return PL_FAILURE;
413}
414
415
416// plColor8Unorm
417inline plStreamWriter& operator<<(plStreamWriter& inout_stream, const plColorLinearUB& value)
418{
419 inout_stream.WriteBytes(&value, sizeof(plColorLinearUB)).AssertSuccess();
420 return inout_stream;
421}
422
423inline plStreamReader& operator>>(plStreamReader& inout_stream, plColorLinearUB& ref_value)
424{
425 PL_VERIFY(inout_stream.ReadBytes(&ref_value, sizeof(plColorLinearUB)) == sizeof(plColorLinearUB), "End of stream reached.");
426 return inout_stream;
427}
428
429template <typename Type>
430plResult SerializeArray(plStreamWriter& inout_stream, const plColorLinearUB* pArray, plUInt64 uiCount)
431{
432 return inout_stream.WriteBytes(pArray, sizeof(plColorLinearUB) * uiCount);
433}
434
435template <typename Type>
436plResult DeserializeArray(plStreamReader& inout_stream, plColorLinearUB* pArray, plUInt64 uiCount)
437{
438 const plUInt64 uiNumBytes = sizeof(plColorLinearUB) * uiCount;
439 if (inout_stream.ReadBytes(pArray, uiNumBytes) == uiNumBytes)
440 return PL_SUCCESS;
441
442 return PL_FAILURE;
443}
plAngle
Float wrapper struct for a safe usage and conversions of angles.
Definition Angle.h:10
plAngle::SetRadian
PL_ALWAYS_INLINE void SetRadian(float fRad)
Sets the radian value. (No need for any conversion)
Definition Angle.h:52
plAngle::GetRadian
constexpr float GetRadian() const
Returns the radian value. (No need for any conversion)
Definition Angle_inl.h:48
plBoundingBoxSphereTemplate
A combination of a bounding box and a bounding sphere with the same center.
Definition BoundingBoxSphere.h:12
plBoundingBoxTemplate
An axis-aligned bounding box implementation.
Definition BoundingBox.h:12
plBoundingSphereTemplate
An implementation of a bounding sphere.
Definition BoundingSphere.h:11
plColorGammaUB
A 8bit per channel unsigned normalized (values interpreted as 0-1) color storage format that represen...
Definition Color8UNorm.h:99
plColor
plColor represents an RGBA color in linear color space. Values are stored as float,...
Definition Color.h:44
plColorLinearUB
A 8bit per channel unsigned normalized (values interpreted as 0-1) color storage format that represen...
Definition Color8UNorm.h:61
plMat3Template
A 3x3 component matrix class.
Definition Mat3.h:9
plMat3Template::m_fElementsCM
Type m_fElementsCM[9]
The matrix as a 9-element Type array (column-major)
Definition Mat3.h:22
plMat4Template
A 4x4 component matrix class.
Definition Mat4.h:11
plMat4Template::m_fElementsCM
Type m_fElementsCM[16]
The matrix as a 16-element Type array (column-major)
Definition Mat4.h:24
plQuatTemplate
Quaternions can be used to represent rotations in 3D space.
Definition Quat.h:19
plStreamReader
Interface for binary in (read) streams.
Definition Stream.h:22
plStreamReader::ReadBytes
virtual plUInt64 ReadBytes(void *pReadBuffer, plUInt64 uiBytesToRead)=0
Reads a raw number of bytes into the read buffer, this is the only method which has to be implemented...
plStreamWriter
Interface for binary out (write) streams.
Definition Stream.h:107
plStreamWriter::WriteBytes
virtual plResult WriteBytes(const void *pWriteBuffer, plUInt64 uiBytesToWrite)=0
Writes a raw number of bytes from the buffer, this is the only method which has to be implemented to ...
plTransformTemplate
A class that represents position, rotation and scaling via a position vector, a quaternion and a scal...
Definition Transform.h:31
plVec2Template
A 2-component vector class.
Definition Vec2.h:14
plVec3Template
A 3-component vector class.
Definition Vec3.h:9
plVec4Template
A 4-component vector class.
Definition Vec4.h:9
plPlaneTemplate
A class that represents a mathematical plane.
Definition Plane.h:21
plResult
Default enum for returning failure or success, instead of using a bool.
Definition Types.h:54
plResult::AssertSuccess
void AssertSuccess(const char *szMsg=nullptr, const char *szDetails=nullptr) const
Asserts that the function succeeded. In case of failure, the program will terminate.
Definition Status.cpp:7