23 template<
typename N = UInt_64>
39 : endianness(
Endianness::
BE), data(nullptr), size(0), offset(0)
44 : endianness(endianness), data(nullptr), size(0), offset(0)
49 : endianness(endianness), data(new
Byte[size]), size(size), offset(0)
54 : endianness(endianness), data(new
Byte[size]), size(size), offset(offset)
56 for (N i = 0; i < size; ++i)
57 this->data[i] = data[i];
61 : endianness(serializer.endianness), data(serializer.data),
62 size(serializer.size), offset(serializer.offset)
64 serializer.data =
nullptr;
66 serializer.offset = 0;
70 : endianness(serializer.endianness), data(new
Byte[serializer.size]),
71 size(serializer.size), offset(serializer.offset)
73 for (N i = 0; i < serializer.size; ++i)
74 data[i] = serializer.data[i];
79 if (
this == &serializer)
82 endianness = serializer.endianness;
84 data = serializer.data;
85 size = serializer.size;
86 offset = serializer.offset;
88 serializer.data =
nullptr;
90 serializer.offset = 0;
97 if (
this == &serializer)
100 endianness = serializer.endianness;
103 data =
new Byte[serializer.size];
104 for (N i = 0; i < serializer.size; ++i)
105 data[i] = serializer.data[i];
107 size = serializer.size;
108 offset = serializer.offset;
171 endianness = newEndianness;
179 template<
typename T,
typename O = UInt_64>
182 if (
sizeof(N) + size *
sizeof(T) > this->size - offset)
184 N remainder =
sizeof(N) + size *
sizeof(T) - (this->size - offset);
186 Byte* r =
new Byte[this->size + remainder];
192 this->size += remainder;
199 *(N*)&data[offset] = (N)size;
203 for (N i = 0; i < size; ++i)
204 *(T*)&data[offset + i *
sizeof(T)] = value[i];
210 for (N i = 0; i <
sizeof(N); ++i)
211 data[offset + i] = ((
Byte*)&tmp)[
sizeof(N) - i - 1];
215 for (N i = 0; i < size; ++i)
216 for (N b = 0; b <
sizeof(T); ++b)
217 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - i - 1];
226 for (N i = 0; i <
sizeof(N); ++i)
227 data[offset + i] = ((
Byte*)&tmp)[
sizeof(N) - i - 1];
231 for (N i = 0; i < size; ++i)
232 for (N b = 0; b <
sizeof(T); ++b)
233 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - i - 1];
237 *(N*)&data[offset] = (N)size;
241 for (N i = 0; i < size; ++i)
242 *(T*)&data[offset + i *
sizeof(T)] = value[i];
246 offset +=
sizeof(T) * size;
249 template<
typename T,
typename O = UInt_64>
252 if (
sizeof(N) + value.
Size() *
sizeof(T) > size - offset)
254 N remainder =
sizeof(N) + value.
Size() *
sizeof(T) - (size - offset);
256 Byte* r =
new Byte[size + remainder];
269 *(N*)&data[offset] = (N)value.
Size();
273 for (N i = 0; i < value.
Size(); ++i)
274 *(T*)&data[offset + i *
sizeof(T)] = value[i];
278 N tmpSize = (N)value.
Size();
280 for (N i = 0; i <
sizeof(N); ++i)
281 data[offset + i] = ((
Byte*)&tmpSize)[
sizeof(N) - i - 1];
285 for (N i = 0; i < value.
Size(); ++i)
286 for (N b = 0; b <
sizeof(T); ++b)
287 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - i - 1];
294 N tmpSize = (N)value.
Size();
296 for (N i = 0; i <
sizeof(N); ++i)
297 data[offset + i] = ((
Byte*)&tmpSize)[
sizeof(N) - i - 1];
301 for (N i = 0; i < value.
Size(); ++i)
302 for (N b = 0; b <
sizeof(T); ++b)
303 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - i - 1];
307 *(N*)&data[offset] = (N)value.
Size();
311 for (N i = 0; i < value.
Size(); ++i)
312 *(T*)&data[offset + i *
sizeof(T)] = value[i];
316 offset +=
sizeof(T) * value.
Size();
319 template<
typename T,
typename O = UInt_64>
322 if (
sizeof(N) + value.
Size() *
sizeof(T) > size - offset)
324 N remainder =
sizeof(N) + value.
Size() *
sizeof(T) - (size - offset);
326 Byte* r =
new Byte[size + remainder];
339 *(N*)&data[offset] = (N)value.
Size();
343 for (N i = 0; i < value.
Size(); ++i)
344 *(T*)&data[offset + i *
sizeof(T)] = value[i];
348 N tmpSize = (N)value.
Size();
350 for (N i = 0; i <
sizeof(N); ++i)
351 data[offset + i] = ((
Byte*)&tmpSize)[
sizeof(N) - i - 1];
355 for (N i = 0; i < value.
Size(); ++i)
356 for (N b = 0; b <
sizeof(T); ++b)
357 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - i - 1];
364 N tmpSize = (N)value.
Size();
366 for (N i = 0; i <
sizeof(N); ++i)
367 data[offset + i] = ((
Byte*)&tmpSize)[
sizeof(N) - i - 1];
371 for (N i = 0; i < value.
Size(); ++i)
372 for (N b = 0; b <
sizeof(T); ++b)
373 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - i - 1];
377 *(N*)&data[offset] = (N)value.
Size();
381 for (N i = 0; i < value.
Size(); ++i)
382 *(T*)&data[offset + i *
sizeof(T)] = value[i];
386 offset +=
sizeof(T) * value.
Size();
389 template<
typename T,
typename O = UInt_64>
392 bool sizeKnown = inSize;
398 N bSize =
sizeof(T) * inSize;
403 if (bSizeN > size - offset)
405 N remainder = bSizeN - (size - offset);
407 Byte* r =
new Byte[size + remainder];
423 *(T*)&data[offset + inSize] = 0;
427 for (N i = 0; i < inSize; ++i)
428 for (N b = 0; b <
sizeof(T); ++b)
429 data[offset +
sizeof(T) * i + b] = ((
Byte*)&str[i])[
sizeof(T) - i - 1];
432 *(T*)&data[offset + bSize] = 0;
439 for (N i = 0; i < inSize; ++i)
440 for (N b = 0; b <
sizeof(T); ++b)
441 data[offset +
sizeof(T) * i + b] = ((
Byte*)&str[i])[
sizeof(T) - i - 1];
444 *(T*)&data[offset + bSize] = 0;
451 *(T*)&data[offset + bSize] = 0;
458 template<
typename T,
typename O = UInt_64>
461 N inSize =
sizeof(T) * (str.
Size() + 1);
463 if (inSize > size - offset)
465 N remainder = inSize - (size - offset);
467 Byte* r =
new Byte[size + remainder];
482 *(T*)&data[offset + str.
Size(
true)] = 0;
486 for (N i = 0; i < str.
Size(); ++i)
487 for (N b = 0; b <
sizeof(T); ++b)
488 data[offset +
sizeof(T) * i + b] = ((
Byte*)&str[i])[
sizeof(T) - i - 1];
490 *(T*)&data[offset + str.
Size(
true)] = 0;
497 for (N i = 0; i < str.
Size(); ++i)
498 for (N b = 0; b <
sizeof(T); ++b)
499 data[offset +
sizeof(T) * i + b] = ((
Byte*)&str[i])[
sizeof(T) - i - 1];
501 *(T*)&data[offset + str.
Size(
true)] = 0;
507 *(T*)&data[offset + str.
Size(
true)] = 0;
516 if (
sizeof(
unsigned int) * 3 > size - offset)
518 N remainder =
sizeof(
unsigned int) * 3 - (size - offset);
520 Byte* r =
new Byte[size + remainder];
532 for (N i = 0; i < 3; ++i)
533 *(
unsigned int*)&data[offset + i *
sizeof(
unsigned int)] = value[i];
535 for (N i = 0; i < 3; ++i)
536 for (N b = 0; b <
sizeof(
unsigned int); ++b)
537 data[offset + i *
sizeof(
unsigned int) + b] = value[
sizeof(
unsigned int) - i - 1];
542 for (N i = 0; i < 3; ++i)
543 for (N b = 0; b <
sizeof(
unsigned int); ++b)
544 data[offset + i *
sizeof(
unsigned int) + b] = value[
sizeof(
unsigned int) - i - 1];
546 for (N i = 0; i < 3; ++i)
547 *(
unsigned int*)&data[offset + i *
sizeof(
unsigned int)] = value[i];
550 offset +=
sizeof(
unsigned int) * 3;
556 if (
sizeof(T) * 2 > size - offset)
558 N remainder =
sizeof(T) * 2 - (size - offset);
560 Byte* r =
new Byte[size + remainder];
572 for (N i = 0; i < 2; ++i)
573 *(T*)&data[offset + i *
sizeof(T)] = value[i];
575 for (N i = 0; i < 2; ++i)
576 for (N b = 0; b <
sizeof(T); ++b)
577 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
582 for (N i = 0; i < 2; ++i)
583 for (N b = 0; b <
sizeof(T); ++b)
584 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
586 for (N i = 0; i < 2; ++i)
587 *(T*)&data[offset + i *
sizeof(T)] = value[i];
590 offset +=
sizeof(T) * 2;
596 if (
sizeof(T) * 3 > size - offset)
598 N remainder =
sizeof(T) * 3 - (size - offset);
600 Byte* r =
new Byte[size + remainder];
612 for (N i = 0; i < 3; ++i)
613 *(T*)&data[offset + i *
sizeof(T)] = value[i];
615 for (N i = 0; i < 3; ++i)
616 for (N b = 0; b <
sizeof(T); ++b)
617 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
622 for (N i = 0; i < 3; ++i)
623 for (N b = 0; b <
sizeof(T); ++b)
624 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
626 for (N i = 0; i < 3; ++i)
627 *(T*)&data[offset + i *
sizeof(T)] = value[i];
630 offset +=
sizeof(T) * 3;
635 if (
sizeof(
float) * 3 > size - offset)
637 N remainder =
sizeof(float) * 3 - (size - offset);
639 Byte* r =
new Byte[size + remainder];
651 for (N i = 0; i < 3; ++i)
652 *(
float*)&data[offset + i *
sizeof(float)] = value[i];
654 for (N i = 0; i < 3; ++i)
655 for (N b = 0; b <
sizeof(float); ++b)
656 data[offset + i *
sizeof(
float) + b] = value[
sizeof(float) - i - 1];
661 for (N i = 0; i < 3; ++i)
662 for (N b = 0; b <
sizeof(float); ++b)
663 data[offset + i *
sizeof(
float) + b] = value[
sizeof(float) - i - 1];
665 for (N i = 0; i < 3; ++i)
666 *(
float*)&data[offset + i *
sizeof(float)] = value[i];
669 offset +=
sizeof(float) * 3;
675 if (
sizeof(T) * 4 > size - offset)
677 N remainder =
sizeof(T) * 4 - (size - offset);
679 Byte* r =
new Byte[size + remainder];
691 for (N i = 0; i < 4; ++i)
692 *(T*)&data[offset + i *
sizeof(T)] = value[i];
694 for (N i = 0; i < 4; ++i)
695 for (N b = 0; b <
sizeof(T); ++b)
696 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
701 for (N i = 0; i < 4; ++i)
702 for (N b = 0; b <
sizeof(T); ++b)
703 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
705 for (N i = 0; i < 4; ++i)
706 *(T*)&data[offset + i *
sizeof(T)] = value[i];
709 offset +=
sizeof(T) * 4;
715 if (
sizeof(T) * 4 > size - offset)
717 N remainder =
sizeof(T) * 4 - (size - offset);
719 Byte* r =
new Byte[size + remainder];
731 for (N i = 0; i < 4; ++i)
732 *(T*)&data[offset + i *
sizeof(T)] = value[i];
734 for (N i = 0; i < 4; ++i)
735 for (N b = 0; b <
sizeof(T); ++b)
736 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
741 for (N i = 0; i < 4; ++i)
742 for (N b = 0; b <
sizeof(T); ++b)
743 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
745 for (N i = 0; i < 4; ++i)
746 *(T*)&data[offset + i *
sizeof(T)] = value[i];
749 offset +=
sizeof(T) * 4;
754 if (
sizeof(
float) * 4 > size - offset)
756 N remainder =
sizeof(float) * 4 - (size - offset);
758 Byte* r =
new Byte[size + remainder];
770 for (N i = 0; i < 4; ++i)
771 *(
float*)&data[offset + i *
sizeof(float)] = value[i];
773 for (N i = 0; i < 4; ++i)
774 for (N b = 0; b <
sizeof(float); ++b)
775 data[offset + i *
sizeof(
float) + b] = value[
sizeof(float) - i - 1];
780 for (N i = 0; i < 4; ++i)
781 for (N b = 0; b <
sizeof(float); ++b)
782 data[offset + i *
sizeof(
float) + b] = value[
sizeof(float) - i - 1];
784 for (N i = 0; i < 4; ++i)
785 *(
float*)&data[offset + i *
sizeof(float)] = value[i];
788 offset +=
sizeof(float) * 4;
794 if (
sizeof(T) * 4 > size - offset)
796 N remainder =
sizeof(T) * 4 - (size - offset);
798 Byte* r =
new Byte[size + remainder];
810 for (N i = 0; i < 4; ++i)
811 *(T*)&data[offset + i *
sizeof(T)] = value[i];
813 for (N i = 0; i < 4; ++i)
814 for (N b = 0; b <
sizeof(T); ++b)
815 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
820 for (N i = 0; i < 4; ++i)
821 for (N b = 0; b <
sizeof(T); ++b)
822 data[offset + i *
sizeof(T) + b] = value[
sizeof(T) - i - 1];
824 for (N i = 0; i < 4; ++i)
825 *(T*)&data[offset + i *
sizeof(T)] = value[i];
828 offset +=
sizeof(T) * 4;
834 if (
sizeof(T) * 4 > size - offset)
836 N remainder =
sizeof(T) * 4 - (size - offset);
838 Byte* r =
new Byte[size + remainder];
850 for (N i = 0; i < 4; ++i)
851 *(T*)&data[offset + i *
sizeof(T)] = value[i];
853 for (N i = 0; i < 4; ++i)
854 for (N b = 0; b <
sizeof(T); ++b)
855 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - b - 1];
860 for (N i = 0; i < 4; ++i)
861 for (N b = 0; b <
sizeof(T); ++b)
862 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - b - 1];
864 for (N i = 0; i < 4; ++i)
865 *(T*)&data[offset + i *
sizeof(T)] = value[i];
868 offset +=
sizeof(T) * 4;
874 if (
sizeof(T) * 9 > size - offset)
876 N remainder =
sizeof(T) * 9 - (size - offset);
878 Byte* r =
new Byte[size + remainder];
890 for (N i = 0; i < 9; ++i)
891 *(T*)&data[offset + i *
sizeof(T)] = value[i];
893 for (N i = 0; i < 9; ++i)
894 for (N b = 0; b <
sizeof(T); ++b)
895 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - b - 1];
900 for (N i = 0; i < 9; ++i)
901 for (N b = 0; b <
sizeof(T); ++b)
902 data[offset + i *
sizeof(T) + b] = ((
Byte*)&value[i])[
sizeof(T) - b - 1];
904 for (N i = 0; i < 9; ++i)
905 *(T*)&data[offset + i *
sizeof(T)] = value[i];
908 offset +=
sizeof(T) * 9;
914 if (
sizeof(T) * 16 > size - offset)
916 N remainder =
sizeof(T) * 16 - (size - offset);
918 Byte* r =
new Byte[size + remainder];
930 for (N y = 0; y < 4; ++y)
931 for (N x = 0; x < 4; ++x)
932 *(T*)&data[offset + y *
sizeof(T) * 4 + x *
sizeof(T)] = value[y][x];
934 for (N y = 0; y < 4; ++y)
935 for (N x = 0; x < 4; ++x)
936 for (N i = 0; i <
sizeof(T); ++i)
937 data[offset + y *
sizeof(T) * 4 + x *
sizeof(T) + i] = ((
Byte*)&value[y][x])[
sizeof(T) - i - 1];
942 for (N y = 0; y < 4; ++y)
943 for (N x = 0; x < 4; ++x)
944 for (N i = 0; i <
sizeof(T); ++i)
945 data[offset + y *
sizeof(T) * 4 + x *
sizeof(T) + i] = ((
Byte*)&value[y][x])[
sizeof(T) - i - 1];
947 for (N y = 0; y < 4; ++y)
948 for (N x = 0; x < 4; ++x)
949 *(T*)&data[offset + y *
sizeof(T) * 4 + x *
sizeof(T)] = value[y][x];
952 offset +=
sizeof(T) * 16;
957 if (ser.endianness != endianness)
960 if (ser.
Size() > size - offset)
962 N remainder = ser.
Size() - (size - offset);
964 Byte* result =
new Byte[size + remainder];
975 offset += ser.
Size();
980 if (size > this->size - offset)
982 N remainder = size - (this->size - offset);
984 Byte* r =
new Byte[this->size + remainder];
990 this->size += remainder;
1001 if (
sizeof(T) > size - offset)
1003 N remainder =
sizeof(T) - (size - offset);
1005 Byte* r =
new Byte[size + remainder];
1017 *(T*)&data[offset] = value;
1019 for (N i = 0; i <
sizeof(T); ++i)
1020 data[offset + i] = ((
Byte*)&value)[
sizeof(T) - i - 1];
1025 for (N i = 0; i <
sizeof(T); ++i)
1026 data[offset + i] = ((
Byte*)&value)[
sizeof(T) - i - 1];
1028 *(T*)&data[offset] = value;
1031 offset +=
sizeof(T);
1034 template<
typename T,
typename O>
1039 *size = (O)Read<N>();
1043 for (N i = 0; i < *size; ++i)
1044 value[i] = Read<T>();
1047 template<
typename T,
typename O>
1052 for (O i = 0; i < result.
Size(); ++i)
1053 result[i] = Read<T>();
1058 template<
typename T,
typename O>
1063 for (O i = 0; i < result.
Size(); ++i)
1064 result[i] = Read<T>();
1069 template<
typename T = Char_8,
typename O = UInt_64>
1072 bool sizeKnown = size;
1075 while (((T*)&data[offset])[size])
1085 for (N i = 0; i < size; ++i)
1086 for (N b = 0; b <
sizeof(T); ++b)
1087 ((
Byte*)&result[i])[b] = data[offset +
sizeof(T) * i + b];
1092 for (N i = 0; i < size; ++i)
1093 for (N b = 0; b <
sizeof(T); ++b)
1094 ((
Byte*)&result[i])[b] = data[offset +
sizeof(T) * i + b];
1099 offset += result.
Size(
true);
1109 return {Read<unsigned int>(), Read<unsigned int>(), Read<unsigned int>()};
1112 template<
typename T>
1115 return {Read<T>(), Read<T>()};
1118 template<
typename T>
1121 return {Read<T>(), Read<T>(), Read<T>()};
1126 return {Read<float>(), Read<float>(), Read<float>()};
1129 template<
typename T>
1132 return {Read<T>(), Read<T>(), Read<T>(), Read<T>()};
1135 template<
typename T>
1138 return {Read<T>(), Read<T>(), Read<T>(), Read<T>()};
1143 return {Read<float>(), Read<float>(), Read<float>(), Read<float>()};
1146 template<
typename T>
1149 return {Read<T>(), Read<T>(), Read<T>(), Read<T>()};
1152 template<
typename T>
1156 for (N i = 0; i < 4; ++i)
1157 result[i] = Read<float>();
1162 template<
typename T>
1166 for (N i = 0; i < 9; ++i)
1167 result[i] = Read<float>();
1172 template<
typename T>
1176 for (N i = 0; i < 16; ++i)
1177 result[i] = Read<float>();
1182 template<
typename T>
1190 value = *(T*)&data[offset];
1192 for (N i = 0; i <
sizeof(T); ++i)
1193 ((
Byte*)&value)[
sizeof(T) - i - 1] = data[offset + i];
1198 for (N i = 0; i <
sizeof(T); ++i)
1199 ((
Byte*)&value)[
sizeof(T) - i - 1] = data[offset + i];
1201 value = *(T*)&data[offset];
1204 offset +=
sizeof(T);
1211 this->offset = offset;
1222 Util::Copy(result, data, newSize >= size ? size : newSize);
N Size() const
Definition: Array.h:413
static Endianness GetEndianness()
Definition: CPU.cpp:93
Definition: Serializer.h:25
Mat4< T > ReadMat4()
Definition: Serializer.h:1173
Mat3< T > ReadMat3()
Definition: Serializer.h:1163
Color4 ReadColor4()
Definition: Serializer.h:1141
Quat< T > ReadQuat()
Definition: Serializer.h:1147
Serializer & operator=(Serializer &&serializer) noexcept
Definition: Serializer.h:77
~Serializer()
Definition: Serializer.h:33
Serializer()
Definition: Serializer.h:38
void WriteStr(const T *str, N inSize=0)
Definition: Serializer.h:390
void WriteMat4(const Mat4< T > &value)
Definition: Serializer.h:912
Serializer(const Serializer &serializer)
Definition: Serializer.h:69
void SetOffset(const N offset)
Definition: Serializer.h:1209
void WriteVersion(const Version &value)
Definition: Serializer.h:514
Serializer(Serializer &&serializer) noexcept
Definition: Serializer.h:60
Vector< T, O > ReadVector(const O size=0)
Definition: Serializer.h:1059
Endianness GetEndianness() const
Definition: Serializer.h:174
Array< T, O > ReadArray(const O size=0)
Definition: Serializer.h:1048
void WriteQuat(const Quat< T > &value)
Definition: Serializer.h:792
Serializer & operator=(const Serializer &serializer)
Definition: Serializer.h:95
void WriteVec4(const Vec4< T > &value)
Definition: Serializer.h:673
Serializer & operator+=(const N size)
Definition: Serializer.h:129
Serializer & operator/=(const N size)
Definition: Serializer.h:147
void WriteColor3(const Color3 &value)
Definition: Serializer.h:633
void WriteSer(const Serializer &ser)
Definition: Serializer.h:955
Vec3< T > ReadVec3()
Definition: Serializer.h:1119
Color3 ReadColor3()
Definition: Serializer.h:1124
Serializer & operator-=(const N size)
Definition: Serializer.h:135
void WriteVec2(const Vec2< T > &value)
Definition: Serializer.h:554
void Resize(const N newSize)
Definition: Serializer.h:1219
void WriteStr(const Str< T, O > &str)
Definition: Serializer.h:459
void Write(const T value)
Definition: Serializer.h:999
void ReadArray(T *const value, O *const size)
Definition: Serializer.h:1035
void WriteRect(const Rect< T > &value)
Definition: Serializer.h:713
void WriteArray(const T *const value, const O size)
Definition: Serializer.h:180
void WriteMat2(const Mat2< T > &value)
Definition: Serializer.h:832
void SetEndianness(const Endianness newEndianness)
Definition: Serializer.h:169
Version ReadVersion()
Definition: Serializer.h:1107
Serializer(const Endianness endianness)
Definition: Serializer.h:43
void WriteVector(const Vector< T, O > &value)
Definition: Serializer.h:320
void WriteColor4(const Color4 &value)
Definition: Serializer.h:752
void WriteArray(const Array< T, O > &value)
Definition: Serializer.h:250
Serializer(const Endianness endianness, const Byte *const data, const N size, const N offset=0)
Definition: Serializer.h:53
Serializer & operator*=(const N size)
Definition: Serializer.h:141
bool operator!=(const Serializer &in) const
Definition: Serializer.h:121
N Size() const
Definition: Serializer.h:1228
Mat2< T > ReadMat2()
Definition: Serializer.h:1153
Serializer(const Endianness endianness, const N size)
Definition: Serializer.h:48
Serializer & operator%=(const N size)
Definition: Serializer.h:153
Vec2< T > ReadVec2()
Definition: Serializer.h:1113
N GetOffset() const
Definition: Serializer.h:1214
bool operator==(const Serializer &in) const
Definition: Serializer.h:113
void WriteVec3(const Vec3< T > &value)
Definition: Serializer.h:594
T Read()
Definition: Serializer.h:1183
Rect< T > ReadRect()
Definition: Serializer.h:1136
Vec4< T > ReadVec4()
Definition: Serializer.h:1130
Str< T, O > ReadStr(O size=0)
Definition: Serializer.h:1070
void WritePadding(const N size)
Definition: Serializer.h:978
void WriteMat3(const Mat3< T > &value)
Definition: Serializer.h:872
N Size(bool inBytes=false) const
Definition: Str.h:526
static void Copy(void *out, const void *in, UInt_64 size)
Definition: Util.cpp:53
static void Zero(void *in, UInt_64 size)
Definition: Util.cpp:95
static bool Compare(const void *a, const void *b, UInt_64 size)
Definition: Util.cpp:9
N Size() const
Definition: Vector.h:240
A helper class for storing version major, minor and patch.
Definition: Version.h:9
Endianness
Definition: CPU.h:21
unsigned char Byte
Definition: Types.h:39