feat Create BinaryWriter

9 files changed, 342 insertions, 56 deletions

diff --git a/src/blu_cat/gra/binary_reader.cpp b/src/blu_cat/com/binary_reader.cpp
index 14fc39c..eae422e 100644
--- a/src/blu_cat/gra/binary_reader.cpp
+++ b/src/blu_cat/com/binary_reader.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2024 Frederico de Oliveira Linhares
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,18 +22,18 @@ namespace
 {
 
 union IntAndFloat32bit{
-  uint32_t i;
-  float f;
+  UI32 i;
+  F32 f;
 };
 
 union IntAndFloat64bit{
-  uint64_t i;
-  double f;
+  UI64 i;
+  F64 f;
 };
 
 }
 
-BinaryReader::BinaryReader(std::string file_path):
+BinaryReader::BinaryReader(const std::string &file_path):
   _pointer{0}
 {
   std::ifstream file(file_path, std::ios::binary | std::ios::ate);
@@ -46,7 +46,7 @@ BinaryReader::BinaryReader(std::string file_path):
 
   this->_size = file.tellg();
   file.seekg(0);
-  this->data = new uint8_t[this->_size];
+  this->data = new UI8[this->_size];
   file.read((char*)data, this->_size);
 }
 
@@ -60,36 +60,36 @@ BinaryReader::~BinaryReader()
   delete[] this->data;
 }
 
-uint8_t
+UI8
 BinaryReader::read_ui8()
 {
   return this->data[this->_pointer++];
 }
 
-uint32_t
+UI32
 BinaryReader::read_ui32()
 {
-  uint8_t b1{this->data[_pointer++]}, b2{this->data[_pointer++]},
+  UI8 b1{this->data[_pointer++]}, b2{this->data[_pointer++]},
     b3{this->data[_pointer++]}, b4{this->data[_pointer++]};
 
   return b1 << 24 | b2 << 16 | b3 << 8 | b4;
 }
 
-uint64_t
+UI64
 BinaryReader::read_ui64()
 {
-  uint8_t b1{this->data[_pointer++]}, b2{this->data[_pointer++]},
+  UI8 b1{this->data[_pointer++]}, b2{this->data[_pointer++]},
     b3{this->data[_pointer++]}, b4{this->data[_pointer++]},
     b5{this->data[_pointer++]}, b6{this->data[_pointer++]},
     b7{this->data[_pointer++]}, b8{this->data[_pointer++]};
 
-  return (uint64_t)b1 << 56 | (uint64_t)b2 << 48 | (uint64_t)b3 << 40 |
-    (uint64_t)b4 << 32 | (uint64_t)b5 << 24 | (uint64_t)b6 << 16 |
-    (uint64_t)b7 << 8 | (uint64_t)b8;
+  return (UI64)b1 << 56 | (UI64)b2 << 48 | (UI64)b3 << 40 |
+    (UI64)b4 << 32 | (UI64)b5 << 24 | (UI64)b6 << 16 |
+    (UI64)b7 << 8 | (UI64)b8;
 }
 
-float
-BinaryReader::read_float()
+F32
+BinaryReader::read_f32()
 {
   IntAndFloat32bit num;
   num.i = read_ui32();
@@ -97,8 +97,8 @@ BinaryReader::read_float()
   return num.f;
 }
 
-double
-BinaryReader::read_double()
+F64
+BinaryReader::read_f64()
 {
   IntAndFloat64bit num;
   num.i = read_ui64();
diff --git a/src/blu_cat/gra/binary_reader.hpp b/src/blu_cat/com/binary_reader.hpp
index 1995402..fa5d495 100644
--- a/src/blu_cat/gra/binary_reader.hpp
+++ b/src/blu_cat/com/binary_reader.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2024 Frederico de Oliveira Linhares
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,20 +14,22 @@
  * limitations under the License.
  */
 
-#include <cstdint>
+#ifndef BLU_CAT_COM_BINARY_READER_H
+#define BLU_CAT_COM_BINARY_READER_H 1
+
 #include <string>
 
-#include "vulkan.hpp"
+#include "numbers.hpp"
 
 class BinaryReader
 {
-  int _pointer;
-  int _size;
-  uint8_t *data;
+  I64F _pointer;
+  I64F _size;
+  UI8 *data;
 
 public:
 
-  BinaryReader(const std::string file_path);
+  BinaryReader(const std::string &file_path);
   BinaryReader(const char *file_path);
   ~BinaryReader();
 
@@ -37,20 +39,20 @@ public:
   inline int
   size(){return this->_size;};
 
-  uint8_t
+  UI8
   read_ui8();
 
-  uint32_t
+  UI32
   read_ui32();
 
-  uint64_t
+  UI64
   read_ui64();
 
-  float
-  read_float();
+  F32
+  read_f32();
 
-  double
-  read_double();
+  F64
+  read_f64();
 
   glm::vec2
   read_vec2();
@@ -67,3 +69,5 @@ public:
   void
   read_chars(char *str, int size);
 };
+
+#endif /* BLU_CAT_COM_BINARY_READER_H */
diff --git a/src/blu_cat/com/binary_writer.cpp b/src/blu_cat/com/binary_writer.cpp
new file mode 100644
index 0000000..0c4cace
--- /dev/null
+++ b/src/blu_cat/com/binary_writer.cpp
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "binary_writer.hpp"
+
+#include <iostream>
+
+namespace
+{
+
+union IntAndFloat32bit{
+  UI32 i;
+  F32 f;
+};
+
+union IntAndFloat64bit{
+  UI64 i;
+  F64 f;
+};
+
+}
+
+BinaryWriter::BinaryWriter(const char *file_path):
+  output{file_path, std::ios::binary}
+{
+}
+
+BinaryWriter::BinaryWriter(const std::string &file_path):
+  BinaryWriter{file_path.c_str()}
+{
+}
+
+void
+BinaryWriter::write_ui8(UI8 var)
+{
+	this->output.put(var);
+}
+
+void
+BinaryWriter::write_ui32(UI32 var)
+{
+  using namespace std;
+
+  UI8 b1 = var >> 24;
+  UI8 b2 = var >> 16;
+  UI8 b3 = var >> 8;
+  UI8 b4 = var;
+
+  this->output.put(b1);
+  this->output.put(b2);
+  this->output.put(b3);
+  this->output.put(b4);
+}
+
+void
+BinaryWriter::write_ui64(UI64 var)
+{
+  using namespace std;
+
+  UI8 b1 = var >> 56;
+  UI8 b2 = var >> 48;
+  UI8 b3 = var >> 40;
+  UI8 b4 = var >> 32;
+  UI8 b5 = var >> 24;
+  UI8 b6 = var >> 16;
+  UI8 b7 = var >> 8;
+  UI8 b8 = var;
+
+  this->output.put(b1);
+  this->output.put(b2);
+  this->output.put(b3);
+  this->output.put(b4);
+  this->output.put(b5);
+  this->output.put(b6);
+  this->output.put(b7);
+  this->output.put(b8);
+}
+
+void
+BinaryWriter::write_f32(F32 var)
+{
+  IntAndFloat32bit num;
+  num.f = var;
+  write_ui32(num.i);
+}
+
+void
+BinaryWriter::write_f64(F64 var)
+{
+  IntAndFloat64bit num;
+  num.f = var;
+  write_ui64(num.i);
+}
+
+void
+BinaryWriter::write_vec2(glm::vec2 var)
+{
+  IntAndFloat32bit x, y;
+  x.f = var.x;
+  y.f = var.y;
+
+  this->write_ui32(x.i);
+  this->write_ui32(y.i);
+}
+
+void
+BinaryWriter::write_vec3(glm::vec3 var)
+{
+  IntAndFloat32bit x, y, z;
+  x.f = var.x;
+  y.f = var.y;
+  z.f = var.z;
+
+  this->write_ui32(x.i);
+  this->write_ui32(y.i);
+  this->write_ui32(z.i);
+}
+
+void
+BinaryWriter::write_quat(glm::quat var)
+{
+  IntAndFloat32bit w, x, y, z;
+  w.f = var.w;
+  x.f = var.x;
+  y.f = var.y;
+  z.f = var.z;
+
+  this->write_ui32(w.i);
+  this->write_ui32(x.i);
+  this->write_ui32(y.i);
+  this->write_ui32(z.i);
+}
+
+void
+BinaryWriter::write_mat4(glm::mat4 var)
+{
+  float *offset_matrix_data{glm::value_ptr(var)};
+  IntAndFloat32bit num;
+
+  for(int i{0}; i < 16; i++)
+  {
+    num.f = offset_matrix_data[i];
+    this->write_ui32(num.i);
+  }
+}
+
+void
+BinaryWriter::write_chars(const char *str, int size)
+{
+  for(int i{0}; i < size; i++) this->write_ui8((UI8)str[i]);
+}
diff --git a/src/blu_cat/com/binary_writer.hpp b/src/blu_cat/com/binary_writer.hpp
new file mode 100644
index 0000000..acf92d8
--- /dev/null
+++ b/src/blu_cat/com/binary_writer.hpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BLU_CAT_COM_BINARY_WRITER_H
+#define BLU_CAT_COM_BINARY_WRITER_H 1
+
+#include <fstream>
+#include <string>
+
+#include "numbers.hpp"
+
+class BinaryWriter
+{
+  std::ofstream output;
+
+public:
+
+  BinaryWriter(const std::string &file_path);
+	BinaryWriter(const char *file_path);
+
+  void
+  write_ui8(UI8 var);
+
+  void
+  write_ui32(UI32 var);
+
+  void
+  write_ui64(UI64 var);
+
+  void
+  write_f32(F32 var);
+
+  void
+  write_f64(F64 var);
+
+  void
+  write_vec2(glm::vec2 var);
+
+  void
+  write_vec3(glm::vec3 var);
+
+  void
+  write_quat(glm::quat var);
+
+  void
+  write_mat4(glm::mat4 var);
+
+	void
+	write_chars(const char *str, int size);
+};
+
+#endif /* BLU_CAT_COM_BINARY_WRITER_H */
diff --git a/src/blu_cat/com/numbers.hpp b/src/blu_cat/com/numbers.hpp
new file mode 100644
index 0000000..7fddbe0
--- /dev/null
+++ b/src/blu_cat/com/numbers.hpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef BLU_CAT_COM_NUMBERS_H
+#define BLU_CAT_COM_NUMBERS_H 1
+
+#include <cstdint>
+#include <stdfloat>
+
+// GLM uses some definitions to control their behavior, so you should not
+// include it directly. Instead, use this header.
+#define GLM_ENABLE_EXPERIMENTAL
+#define GLM_FORCE_RADIANS
+#define GLM_FORCE_DEPTH_ZERO_TO_ONE
+
+#include <glm/ext/vector_float3.hpp>
+#include <glm/ext.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtx/quaternion.hpp>
+#include <glm/vec3.hpp>
+
+// Signed int
+typedef int8_t I8;
+typedef int16_t I16;
+typedef int32_t I32;
+typedef int64_t I64;
+
+// Unsigned int
+typedef uint8_t UI8;
+typedef uint16_t UI16;
+typedef uint32_t UI32;
+typedef uint64_t UI64;
+
+// Fast signed int
+typedef int_fast8_t I8F;
+typedef int_fast16_t I16F;
+typedef int_fast32_t I32F;
+typedef int_fast64_t I64F;
+
+// Fast unsigned int
+typedef uint_fast8_t UI8F;
+typedef uint_fast16_t UI16F;
+typedef uint_fast32_t UI32F;
+typedef uint_fast64_t UI64F;
+
+// Floats
+typedef std::float32_t F32;
+typedef std::float64_t F64;
+
+#endif /* BLU_CAT_COM_NUMBERS_H */
diff --git a/src/blu_cat/gra/qoi.cpp b/src/blu_cat/gra/qoi.cpp
index 790516d..40968df 100644
--- a/src/blu_cat/gra/qoi.cpp
+++ b/src/blu_cat/gra/qoi.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2024 Frederico de Oliveira Linhares
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,7 +19,7 @@
 #include <array>
 #include <fstream>
 
-#include "binary_reader.hpp"
+#include "../com/binary_reader.hpp"
 
 namespace
 {
diff --git a/src/blu_cat/gra/skeletal_mesh.cpp b/src/blu_cat/gra/skeletal_mesh.cpp
index 89d701b..1beed1a 100644
--- a/src/blu_cat/gra/skeletal_mesh.cpp
+++ b/src/blu_cat/gra/skeletal_mesh.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2024 Frederico de Oliveira Linhares
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
 
 #include "skeletal_mesh.hpp"
 
-#include "binary_reader.hpp"
+#include "../com/binary_reader.hpp"
 #include "../com/command.hpp"
 #include "../int/core.hpp"
 #include "skeletal_mesh_vertex.hpp"
@@ -72,7 +72,7 @@ load_mesh(void *obj)
 
       for(auto ii{0}; ii < BluCat::GRA::SKELETAL_MESH_MAX_NUM_OF_INFLUENCING_BONES;
 	  ii++)
-	vertexes[i].bone_weights[ii] = input.read_float();
+	vertexes[i].bone_weights[ii] = input.read_f32();
     }
 
     void *vertexes_data{vertexes.data()};
@@ -112,10 +112,10 @@ load_mesh(void *obj)
     self->mesh->animations.resize(num_animations);
     for(uint32_t i{0}; i < num_animations; i++)
     {
-      auto duration{input.read_double()};
+      auto duration{input.read_f64()};
       self->mesh->animations[i].final_time = (float)duration;
 
-      auto ticks_per_second{input.read_double()};
+      auto ticks_per_second{input.read_f64()};
 
       auto num_bone_transforms{input.read_ui32()};
       std::vector<BluCat::GRA::BoneTransform> *bone_transforms =
@@ -133,7 +133,7 @@ load_mesh(void *obj)
 	    position_key_index++)
 	{
 	  auto vec3{input.read_vec3()};
-	  auto timestamp{input.read_double()};
+	  auto timestamp{input.read_f64()};
 	  positions->key_frames.emplace_back(
 	    vec3, static_cast<float>(timestamp));
 	}
@@ -145,7 +145,7 @@ load_mesh(void *obj)
 	    rotation_key_index++)
 	{
 	  auto quat{input.read_quat()};
-	  auto timestamp{input.read_double()};
+	  auto timestamp{input.read_f64()};
 	  rotations->key_frames.emplace_back(
 	    quat, static_cast<float>(timestamp));
 	}
@@ -157,7 +157,7 @@ load_mesh(void *obj)
 	    scaling_key_index++)
 	{
 	  auto vec3{input.read_vec3()};
-	  auto timestamp{input.read_double()};
+	  auto timestamp{input.read_f64()};
 	  scales->key_frames.emplace_back(vec3, static_cast<float>(timestamp));
 	}
       }
diff --git a/src/blu_cat/gra/static_mesh.cpp b/src/blu_cat/gra/static_mesh.cpp
index db3a6ee..0d95590 100644
--- a/src/blu_cat/gra/static_mesh.cpp
+++ b/src/blu_cat/gra/static_mesh.cpp
@@ -16,7 +16,7 @@
 
 #include "static_mesh.hpp"
 
-#include "binary_reader.hpp"
+#include "../com/binary_reader.hpp"
 #include "../com/command.hpp"
 #include "../int/core.hpp"
 #include "static_mesh_vertex.hpp"
diff --git a/src/blu_cat/gra/vulkan.hpp b/src/blu_cat/gra/vulkan.hpp
index fcf6628..73c599f 100644
--- a/src/blu_cat/gra/vulkan.hpp
+++ b/src/blu_cat/gra/vulkan.hpp
@@ -1,5 +1,5 @@
 /*
- * Copyright 2022-2024 Frederico de Oliveira Linhares
+ * Copyright 2022-2025 Frederico de Oliveira Linhares
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,17 +17,7 @@
 #ifndef BLU_CAT_GRA_VULKAN_H
 #define BLU_CAT_GRA_VULKAN_H 1
 
-// GLM uses some definitions to control their behavior, so you should not
-// include it directly. Instead, use this header.
-#define GLM_ENABLE_EXPERIMENTAL
-#define GLM_FORCE_RADIANS
-#define GLM_FORCE_DEPTH_ZERO_TO_ONE
-
-#include <glm/ext/vector_float3.hpp>
-#include <glm/ext.hpp>
-#include <glm/gtc/matrix_transform.hpp>
-#include <glm/gtx/quaternion.hpp>
-#include <glm/vec3.hpp>
+#include "../com/numbers.hpp"
 
 #include <vulkan/vulkan.h>