feat Create BinaryWriter

5 files changed, 521 insertions, 0 deletions

diff --git a/src/blu_cat/com/binary_reader.cpp b/src/blu_cat/com/binary_reader.cpp
new file mode 100644
index 0000000..eae422e
--- /dev/null
+++ b/src/blu_cat/com/binary_reader.cpp
@@ -0,0 +1,156 @@
+/*
+ * 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_reader.hpp"
+
+#include <fstream>
+
+namespace
+{
+
+union IntAndFloat32bit{
+  UI32 i;
+  F32 f;
+};
+
+union IntAndFloat64bit{
+  UI64 i;
+  F64 f;
+};
+
+}
+
+BinaryReader::BinaryReader(const std::string &file_path):
+  _pointer{0}
+{
+  std::ifstream file(file_path, std::ios::binary | std::ios::ate);
+	if(!file.is_open())
+	{
+		std::string error{"failed to open file: "};
+		error += file_path;
+		throw std::runtime_error{error};
+	}
+
+  this->_size = file.tellg();
+  file.seekg(0);
+  this->data = new UI8[this->_size];
+  file.read((char*)data, this->_size);
+}
+
+BinaryReader::BinaryReader(const char *file_path):
+  BinaryReader{std::string(file_path)}
+{
+}
+
+BinaryReader::~BinaryReader()
+{
+  delete[] this->data;
+}
+
+UI8
+BinaryReader::read_ui8()
+{
+  return this->data[this->_pointer++];
+}
+
+UI32
+BinaryReader::read_ui32()
+{
+  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;
+}
+
+UI64
+BinaryReader::read_ui64()
+{
+  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 (UI64)b1 << 56 | (UI64)b2 << 48 | (UI64)b3 << 40 |
+    (UI64)b4 << 32 | (UI64)b5 << 24 | (UI64)b6 << 16 |
+    (UI64)b7 << 8 | (UI64)b8;
+}
+
+F32
+BinaryReader::read_f32()
+{
+  IntAndFloat32bit num;
+  num.i = read_ui32();
+
+  return num.f;
+}
+
+F64
+BinaryReader::read_f64()
+{
+  IntAndFloat64bit num;
+  num.i = read_ui64();
+
+  return num.f;
+}
+
+glm::vec2
+BinaryReader::read_vec2()
+{
+  IntAndFloat32bit x{read_ui32()}, y{read_ui32()};
+
+  return glm::vec2{x.f, y.f};
+}
+
+glm::vec3
+BinaryReader::read_vec3()
+{
+  IntAndFloat32bit x{read_ui32()}, y{read_ui32()}, z{read_ui32()};
+
+  return glm::vec3{x.f, y.f, z.f};
+}
+
+glm::quat
+BinaryReader::read_quat()
+{
+  IntAndFloat32bit w{read_ui32()}, x{read_ui32()}, y{read_ui32()},
+    z{read_ui32()};
+
+  return glm::quat{w.f, x.f, y.f, z.f};
+}
+
+glm::mat4
+BinaryReader::read_mat4()
+{
+  glm::mat4 matrix;
+  float *offset_matrix_data{glm::value_ptr(matrix)};
+
+  for(int i{0}; i < 16; i++)
+  {
+    IntAndFloat32bit num;
+    num.i = read_ui32();
+    offset_matrix_data[i] = num.f;
+  }
+
+  return matrix;
+}
+
+void
+BinaryReader::read_chars(char *str, int size)
+{
+  for(int i{0}; i < size; i++)
+    str[i] = (char)data[this->_pointer++];
+}
+
diff --git a/src/blu_cat/com/binary_reader.hpp b/src/blu_cat/com/binary_reader.hpp
new file mode 100644
index 0000000..fa5d495
--- /dev/null
+++ b/src/blu_cat/com/binary_reader.hpp
@@ -0,0 +1,73 @@
+/*
+ * 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_READER_H
+#define BLU_CAT_COM_BINARY_READER_H 1
+
+#include <string>
+
+#include "numbers.hpp"
+
+class BinaryReader
+{
+  I64F _pointer;
+  I64F _size;
+  UI8 *data;
+
+public:
+
+  BinaryReader(const std::string &file_path);
+  BinaryReader(const char *file_path);
+  ~BinaryReader();
+
+  inline int
+  pointer(){return this->_pointer;};
+
+  inline int
+  size(){return this->_size;};
+
+  UI8
+  read_ui8();
+
+  UI32
+  read_ui32();
+
+  UI64
+  read_ui64();
+
+  F32
+  read_f32();
+
+  F64
+  read_f64();
+
+  glm::vec2
+  read_vec2();
+
+  glm::vec3
+  read_vec3();
+
+  glm::quat
+  read_quat();
+
+  glm::mat4
+  read_mat4();
+
+  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 */