From a6c3a1e9325aae702b30d334acc6a6b8ff2f37f4 Mon Sep 17 00:00:00 2001 From: Frederico Linhares Date: Mon, 10 Mar 2025 15:00:11 -0300 Subject: feat Create BinaryWriter --- src/blu_cat/com/binary_reader.cpp | 156 ++++++++++++++++++++++++++++++++++++ src/blu_cat/com/binary_reader.hpp | 73 +++++++++++++++++ src/blu_cat/com/binary_writer.cpp | 164 ++++++++++++++++++++++++++++++++++++++ src/blu_cat/com/binary_writer.hpp | 65 +++++++++++++++ src/blu_cat/com/numbers.hpp | 63 +++++++++++++++ src/blu_cat/gra/binary_reader.cpp | 156 ------------------------------------ src/blu_cat/gra/binary_reader.hpp | 69 ---------------- src/blu_cat/gra/qoi.cpp | 4 +- src/blu_cat/gra/skeletal_mesh.cpp | 16 ++-- src/blu_cat/gra/static_mesh.cpp | 2 +- src/blu_cat/gra/vulkan.hpp | 14 +--- 11 files changed, 534 insertions(+), 248 deletions(-) create mode 100644 src/blu_cat/com/binary_reader.cpp create mode 100644 src/blu_cat/com/binary_reader.hpp create mode 100644 src/blu_cat/com/binary_writer.cpp create mode 100644 src/blu_cat/com/binary_writer.hpp create mode 100644 src/blu_cat/com/numbers.hpp delete mode 100644 src/blu_cat/gra/binary_reader.cpp delete mode 100644 src/blu_cat/gra/binary_reader.hpp 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 + +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 + +#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 + +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 +#include + +#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 +#include + +// 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 +#include +#include +#include +#include + +// 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/binary_reader.cpp b/src/blu_cat/gra/binary_reader.cpp deleted file mode 100644 index 14fc39c..0000000 --- a/src/blu_cat/gra/binary_reader.cpp +++ /dev/null @@ -1,156 +0,0 @@ -/* - * Copyright 2022-2024 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 - -namespace -{ - -union IntAndFloat32bit{ - uint32_t i; - float f; -}; - -union IntAndFloat64bit{ - uint64_t i; - double f; -}; - -} - -BinaryReader::BinaryReader(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 uint8_t[this->_size]; - file.read((char*)data, this->_size); -} - -BinaryReader::BinaryReader(const char *file_path): - BinaryReader{std::string(file_path)} -{ -} - -BinaryReader::~BinaryReader() -{ - delete[] this->data; -} - -uint8_t -BinaryReader::read_ui8() -{ - return this->data[this->_pointer++]; -} - -uint32_t -BinaryReader::read_ui32() -{ - uint8_t 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 -BinaryReader::read_ui64() -{ - uint8_t 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; -} - -float -BinaryReader::read_float() -{ - IntAndFloat32bit num; - num.i = read_ui32(); - - return num.f; -} - -double -BinaryReader::read_double() -{ - 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/gra/binary_reader.hpp b/src/blu_cat/gra/binary_reader.hpp deleted file mode 100644 index 1995402..0000000 --- a/src/blu_cat/gra/binary_reader.hpp +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright 2022-2024 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 -#include - -#include "vulkan.hpp" - -class BinaryReader -{ - int _pointer; - int _size; - uint8_t *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;}; - - uint8_t - read_ui8(); - - uint32_t - read_ui32(); - - uint64_t - read_ui64(); - - float - read_float(); - - double - read_double(); - - glm::vec2 - read_vec2(); - - glm::vec3 - read_vec3(); - - glm::quat - read_quat(); - - glm::mat4 - read_mat4(); - - void - read_chars(char *str, int size); -}; 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 #include -#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 *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(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(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(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 -#include -#include -#include -#include +#include "../com/numbers.hpp" #include -- cgit v1.2.3