cross compile

CMakeLists.txt

@@ -2,6 +2,9 @@ cmake_minimum_required(VERSION 3.14)
 
 include(cmake/prelude.cmake)
 
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
 if (NOT compile-target) 
     #set(compile-target "-target x86_64-linux-gnu")
     set(compile-target "")
@@ -11,14 +14,18 @@ else ()
 endif()
 
 
-set(CMAKE_C_COMPILER "zig" cc ${compile-target})
-set(CMAKE_CXX_COMPILER "zig" c++ ${compile-target})
+#set(CMAKE_C_COMPILER "gcc")
+#set(CMAKE_CXX_COMPILER "g++")
+
+#set(CMAKE_C_COMPILER "zig" cc ${compile-target})
+#set(CMAKE_CXX_COMPILER "zig" c++ ${compile-target})
 
+set(BUILD_SHARED_LIBS OFF)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(OpenGL_GL_PREFERENCE "GLVND")
 
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g ")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g")
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fpermissive -Wno-error ")
 
 
 project(
@@ -56,10 +63,11 @@ target_compile_features(enttge_lib PUBLIC cxx_std_20)
 
 # ---- Add deps
 
+set(ASSIMP_WARNINGS_AS_ERRORS OFF)
 
 CPMAddPackage("gh:assimp/assimp@5.2.5")
 
-CPMAddPackage(NAME stb "gh:nothings/stb#master")
+CPMAddPackage("gh:nothings/stb#master")
 
 CPMAddPackage("gh:ocornut/imgui#v1.89.5")
 
@@ -128,7 +136,7 @@ add_library(imgui STATIC
 )
 target_include_directories(imgui PUBLIC ${imgui_SOURCE_DIR})
 target_compile_definitions(imgui PUBLIC -DIMGUI_DISABLE_OBSOLETE_FUNCTIONS) # optional imgui setting
-target_link_libraries(imgui PRIVATE SDL2)
+target_link_libraries(imgui PUBLIC SDL2::SDL2-static)
 
 
 # ---- Declare executable ----
@@ -138,19 +146,20 @@ add_executable(enttge_exe
     source/mesh.h 
     source/main.cpp 
     source/window.cpp 
+    source/camera.cpp 
+    source/shapes.cpp 
+    source/shaders.cpp 
     source/uniform-buffer.hpp 
     source/camera.hpp 
-    source/camera.cpp 
     source/window.hpp 
     source/glheader.hpp
-    source/shapes.cpp 
-    source/shaders.cpp 
     source/shaders.h
     source/stb_image.cpp
     )
 
 add_executable(enttge::exe ALIAS enttge_exe)
 
+
 set_property(TARGET enttge_exe PROPERTY OUTPUT_NAME enttge)
 
 target_include_directories(enttge_exe PUBLIC ${stb_SOURCE_DIR})
@@ -158,13 +167,15 @@ target_include_directories(enttge_exe PUBLIC ${stb_SOURCE_DIR})
 target_compile_features(enttge_exe PRIVATE cxx_std_20)
 target_compile_features(enttge_lib PRIVATE cxx_std_20)
 
+
 target_link_libraries(enttge_exe PRIVATE enttge_lib 
     fmt::fmt 
     EnTT
     glm::glm
     glad
     refl-cpp
-    SDL2
+    SDL2::SDL2-static
+    SDL2::SDL2main
     spdlog
     imgui
     assimp)

source/main.cpp

@@ -1,3 +1,4 @@
+#include <SDL2/SDL.h>
 #include <SDL2/SDL_events.h>
 #include <cassert>
 #include <glm/gtc/matrix_transform.hpp>
@@ -352,9 +353,9 @@ int main_loop(game_state& g)
 
   glCheckError();
 
-  auto output = fmt::output_file(std::string(g.asset_dir / "shaders" / "write" / fmt::format("{}.gl", g.model_ubo->block_name)));
+  auto output = fmt::output_file((g.asset_dir / "shaders" / "write" / fmt::format("{}.gl", g.model_ubo->block_name)).string());
   output.print("{}", g.model_ubo->fmt_uniform_block());
-  fmt::output_file(std::string(g.asset_dir / "shaders" / "write" / fmt::format("{}.gl", g.material_ubo->block_name))).print("{}", g.model_ubo->fmt_uniform_block());
+  fmt::output_file((g.asset_dir / "shaders" / "write" / fmt::format("{}.gl", g.material_ubo->block_name)).string()).print("{}", g.model_ubo->fmt_uniform_block());
 
   g.model_ubo->gen_ubo(2);
   g.model_ubo->bind_to_shader(g_shader->program);
@@ -722,7 +723,7 @@ void init (game_state &g) {
 }
 
 
-int main()
+int main(int argc, char **argv)
 {
 
   int amount = 0;

source/mesh.h

@@ -3,6 +3,7 @@
 #define MESH_H
 
 #include "uniform-buffer.hpp"
+#include <filesystem>
 #include <glm/glm.hpp>
 #include <memory>
 #include <shaders.h>
@@ -65,6 +66,7 @@ private:
 class Model {
 public:
   Model(std::string path) { load_model(path); }
+  Model(std::filesystem::path path) { load_model(path.string()); }
   void draw(std::shared_ptr<ubo_proxy<material_properties>> ubo_mat,
             std::shared_ptr<ubo_proxy<ubo_info>> ubo_model,
             std::shared_ptr<shader_handle> shader, const glm::mat4 transform);

source/shaders.cpp

@@ -43,12 +43,13 @@ bool shader_handle::handle_error(const std::string &filename) {
   return true;
 }
 
-void shader_handle::add_shader(GLuint type, const std::string &filename) {
+void shader_handle::add_shader(GLuint type,
+                               const std::filesystem::path &filename) {
   add_shader(type, filename, {});
 }
 
 void shader_handle::add_shader(
-    GLuint type, const std::string &filename,
+    GLuint type, const std::filesystem::path &filename,
     std::unordered_map<std::string, std::string> templates) {
   shader = glCreateShader(type);
 
@@ -60,7 +61,8 @@ void shader_handle::add_shader(
   }
 
   if (!source_file.is_open() || source.size() == 0) {
-    throw std::runtime_error("Could not open filepath " + filename);
+    throw std::runtime_error(
+        fmt::format("Could not open filepath {}", filename.string()));
   }
 
   // apply templates
@@ -70,14 +72,14 @@ void shader_handle::add_shader(
       source.replace(position, key.size(), content);
     }
   }
-  spdlog::info("New shader: {}\n{}", filename, source);
+  spdlog::info("New shader: {}\n{}", filename.string(), source);
 
   const char *cstr = source.c_str();
   glShaderSource(shader, 1, &cstr, NULL);
 
   glCompileShader(shader);
 
-  if (handle_error(filename)) {
+  if (handle_error(filename.string())) {
     // compilation failed
     glDeleteShader(shader);
     throw std::runtime_error("Failed to compile shader");
@@ -89,22 +91,23 @@ void shader_handle::add_shader(
 
 shader_handle::shader_handle() : program(glCreateProgram()) {}
 
-shader_handle::shader_handle(std::string filename)
+shader_handle::shader_handle(std::filesystem::path filename)
     : program(glCreateProgram()) {
   add_shader(GL_VERTEX_SHADER, std::move(filename));
 }
 
 shader_handle::shader_handle(
-    std::string filename, std::string filename2,
+    std::filesystem::path filename, std::filesystem::path filename2,
     std::unordered_map<std::string, std::string> templates)
     : program(glCreateProgram()) {
 
-  add_shader(GL_VERTEX_SHADER, std::move(filename), templates);
-  add_shader(GL_FRAGMENT_SHADER, std::move(filename2), templates);
+  add_shader(GL_VERTEX_SHADER, (filename), templates);
+  add_shader(GL_FRAGMENT_SHADER, (filename2), templates);
   link();
 }
 
-shader_handle::shader_handle(std::string filename, std::string filename2)
+shader_handle::shader_handle(std::filesystem::path filename,
+                             std::filesystem::path filename2)
     : program(glCreateProgram()) {
   add_shader(GL_VERTEX_SHADER, std::move(filename));
   add_shader(GL_FRAGMENT_SHADER, std::move(filename2));

source/shaders.h

@@ -1,6 +1,7 @@
 
 
 #pragma once
+#include <filesystem>
 #include <iostream>
 #include <string>
 #include <unordered_map>
@@ -26,10 +27,11 @@ public:
   GLuint shader = 0;
   GLuint type = 0;
 
-  shader_handle(std::string filename, std::string filename2, 
+  shader_handle(std::filesystem::path filename, std::filesystem::path filename2, 
       std::unordered_map<std::string, std::string> templates);
-  shader_handle(std::string filename);
-  shader_handle(std::string filename, std::string filename2);
+
+  shader_handle(std::filesystem::path filename);
+  shader_handle(std::filesystem::path filename, std::filesystem::path filename2);
   ~shader_handle();
 
   shader_handle();
@@ -40,8 +42,8 @@ public:
 
   void use();
   void link();
-  void add_shader(GLuint type, const std::string& filename);
-  void add_shader(GLuint type, const std::string& filename,
+  void add_shader(GLuint type, const std::filesystem::path& filename);
+  void add_shader(GLuint type, const std::filesystem::path& filename,
       std::unordered_map<std::string, std::string> templates);
 
   void set(const std::string& name, float value);

source/uniform-buffer.hpp

@@ -118,27 +118,137 @@ concept reflectable = refl::trait::is_reflectable_v<T>;
 
 // void get_ubo(int size) { glGenBuffers(); }
 
+struct gl_type_hint {
+  size_t alignment;
+  std::string name;
+  bool is_array = false;
+  size_t n_elems;
+  size_t elem_size;
+  size_t elem_alignment;
+};
+
+struct field_info {
+  std::string name;
+  size_t size;
+  size_t offset;
+  gl_type_hint gl_type;
+  void *data;
+};
+
+template <typename V> constexpr gl_type_hint get_alignment() {
+  if constexpr (refl::is_reflectable<V>()) {
+    size_t alignment = 4;
+    auto type_name = refl::descriptor::get_simple_name(
+        refl::reflect<std::remove_all_extents_t<V>>());
+
+    if (std::is_class<V>()) {
+      return {4 * 4, type_name.c_str()};
+    }
+
+    if (std::is_integral<V>()) {
+      static_assert(!(std::is_integral<V>()) || sizeof(V) <= 4,
+                    "Only allow openglable integral types ");
+      return {4, type_name.c_str()};
+    }
+
+    if (sizeof(V) > 2) {
+      // things that are 3 bytes or more get aligned to a vec4
+      alignment *= 4;
+    }
+
+    spdlog::warn("Caution; using default logic for uniform alignment\n");
+    return {alignment, type_name.c_str()};
+  }
+  spdlog::error("Unable to ");
+  return {100, "SCREAMING"};
+}
+
+template <array_type V> static constexpr gl_type_hint get_alignment() {
+  // static_assert(sizeof(std::remove_all_extents_t<V>) <= 4,
+  //              "Don't support sizes > offset.");
+  auto type_hint = get_alignment<std::remove_all_extents_t<V>>();
+  type_hint.alignment = 4 * 4;
+  type_hint.is_array = true;
+  type_hint.elem_size = sizeof(std::remove_all_extents_t<V>);
+  type_hint.elem_alignment = 4 * 4;
+  // number of elements in the array
+  type_hint.n_elems = std::extent<V>::value;
+  return type_hint;
+}
+
+template <> constexpr gl_type_hint get_alignment<GLuint>() {
+  return {4, "uint"};
+}
+
+template <> constexpr gl_type_hint get_alignment<GLint>() { return {4, "int"}; }
+
+template <> constexpr gl_type_hint get_alignment<GLboolean>() {
+  return {4, "bool"};
+}
+
+template <> constexpr gl_type_hint get_alignment<bool>() { return {4, "bool"}; }
+
+template <> constexpr gl_type_hint get_alignment<glm::vec4>() {
+  return {4 * 4, "vec4"};
+}
+
+template <> constexpr gl_type_hint get_alignment<glm::vec2>() {
+  return {4 * 2, "vec2"};
+}
+
+// template <> constexpr gl_type_hint get_alignment<ubo_proxy>() {
+//   gl_type_hint t = {};
+//   // get size
+//   return {4 * 4, "vec3"};
+// }
+
+// template <> constexpr gl_type_hint get_alignment<glm::vec3>() {
+//   return {4 * 4, "vec3"};
+// }
+
+template <> constexpr gl_type_hint get_alignment<glm::mat3>() {
+  gl_type_hint t = {4 * 4, "mat3"};
+  t.is_array = false;
+  t.n_elems = 3;
+  t.elem_alignment = 4 * 4;
+  t.elem_size = sizeof(glm::vec3);
+  return t;
+}
+template <> constexpr gl_type_hint get_alignment<glm::mat4>() {
+  gl_type_hint t = {4 * 4, "mat4"};
+  t.is_array = false;
+  t.n_elems = 3;
+  t.elem_alignment = 4 * 4;
+  t.elem_size = sizeof(glm::vec4);
+  return t;
+}
+
+// template <reflectable V> constexpr gl_type_hint get_alignment() {
+//   // assuming is struct
+//   auto s = refl::reflect<V>();
+//   return {4 * 4, std::string(refl::descriptor::get_name(s))};
+// }
+
+template <> constexpr gl_type_hint get_alignment<float>() {
+  return {4, refl::descriptor::get_name(refl::reflect<float>()).c_str()};
+}
+
+template <> constexpr gl_type_hint get_alignment<double>() {
+  return {4, "double"};
+}
+
+template <typename R, size_t N>
+static constexpr gl_type_hint
+get_alignment_field(refl::descriptor::field_descriptor<R, N> val) {
+  return get_alignment<
+      typename refl::descriptor::field_descriptor<R, N>::value_type>();
+}
+
 template <reflectable T>
 class ubo_proxy : public refl::runtime::proxy<ubo_proxy<T>, T> {
   // UBO proxy MUST have reflection enabled
   // type to store a ubo containing <struct>
 
-  struct gl_type_hint {
-    size_t alignment;
-    const std::string name;
-    bool is_array = false;
-    size_t n_elems;
-    size_t elem_size;
-    size_t elem_alignment;
-  };
-
-  struct field_info {
-    std::string name;
-    size_t size;
-    size_t offset;
-    gl_type_hint gl_type;
-    void *data;
-  };
   GLuint ubo;
   GLuint binding_point;
 
@@ -167,126 +277,6 @@ private:
         typename refl::descriptor::field_descriptor<R, N>::value_type);
   }
 
-  template <typename R, size_t N>
-  static constexpr gl_type_hint
-  get_alignment_field(refl::descriptor::field_descriptor<R, N> val) {
-    return get_alignment<
-        typename refl::descriptor::field_descriptor<R, N>::value_type>();
-  }
-
-  template <reflectable V> static constexpr gl_type_hint get_alignment() {
-    size_t alignment = 4;
-    auto type_name = refl::descriptor::get_simple_name(
-        refl::reflect<std::remove_all_extents_t<V>>());
-
-    if (std::is_class<V>()) {
-      return {4 * 4, type_name.str()};
-    }
-
-    if (std::is_integral<V>()) {
-      static_assert(!(std::is_integral<V>()) || sizeof(V) <= 4,
-                    "Only allow openglable integral types ");
-      return {4, std::string(type_name)};
-    }
-
-    if (sizeof(V) > 2) {
-      // things that are 3 bytes or more get aligned to a vec4
-      alignment *= 4;
-    }
-
-    spdlog::warn("Caution; using default logic for uniform alignment\n");
-    return {alignment, std::string(type_name)};
-  }
-
-  template <typename V> static constexpr gl_type_hint get_alignment() {
-    fmt::print("Default");
-    spdlog::error("Invalid\n");
-    throw std::runtime_error("Invalid uniform data type");
-    return {4 * 4, "ERROR"};
-  }
-
-  template <array_type V> static constexpr gl_type_hint get_alignment() {
-    // static_assert(sizeof(std::remove_all_extents_t<V>) <= 4,
-    //              "Don't support sizes > offset.");
-    auto type_hint = get_alignment<std::remove_all_extents_t<V>>();
-    type_hint.alignment = 4 * 4;
-    type_hint.is_array = true;
-    type_hint.elem_size = sizeof(std::remove_all_extents_t<V>);
-    type_hint.elem_alignment = 4 * 4;
-    // number of elements in the array
-    type_hint.n_elems = std::extent<V>::value;
-    return type_hint;
-  }
-
-  template <> static constexpr gl_type_hint get_alignment<GLuint>() {
-    return {4, "uint"};
-  }
-
-  template <> static constexpr gl_type_hint get_alignment<GLint>() {
-    return {4, "int"};
-  }
-
-  template <> static constexpr gl_type_hint get_alignment<int>() {
-    return {4, "int"};
-  }
-
-  template <> static constexpr gl_type_hint get_alignment<unsigned int>() {
-    return {4, "uint"};
-  }
-
-  template <> static constexpr gl_type_hint get_alignment<GLboolean>() {
-    return {4, "bool"};
-  }
-
-  template <> static constexpr gl_type_hint get_alignment<glm::vec4>() {
-    return {4 * 4, "vec4"};
-  }
-
-  template <> static constexpr gl_type_hint get_alignment<glm::vec2>() {
-    return {4 * 2, "vec2"};
-  }
-
-  // template <> static constexpr gl_type_hint get_alignment<ubo_proxy>() {
-  //   gl_type_hint t = {};
-  //   // get size
-  //   return {4 * 4, "vec3"};
-  // }
-
-  // template <> static constexpr gl_type_hint get_alignment<glm::vec3>() {
-  //   return {4 * 4, "vec3"};
-  // }
-
-  template <> static constexpr gl_type_hint get_alignment<glm::mat3>() {
-    gl_type_hint t = {4 * 4, "mat3"};
-    t.is_array = false;
-    t.n_elems = 3;
-    t.elem_alignment = 4 * 4;
-    t.elem_size = sizeof(glm::vec3);
-    return t;
-  }
-  template <> static constexpr gl_type_hint get_alignment<glm::mat4>() {
-    gl_type_hint t = {4 * 4, "mat4"};
-    t.is_array = false;
-    t.n_elems = 3;
-    t.elem_alignment = 4 * 4;
-    t.elem_size = sizeof(glm::vec4);
-    return t;
-  }
-
-  // template <reflectable V> static constexpr gl_type_hint get_alignment() {
-  //   // assuming is struct
-  //   auto s = refl::reflect<V>();
-  //   return {4 * 4, std::string(refl::descriptor::get_name(s))};
-  // }
-
-  template <> static constexpr gl_type_hint get_alignment<float>() {
-    return {4, std::string(refl::descriptor::get_name(refl::reflect<float>()))};
-  }
-
-  template <> static constexpr gl_type_hint get_alignment<double>() {
-    return {4, "double"};
-  }
-
   static constexpr size_t next_offset(size_t offset, size_t alignment) {
     return offset + (alignment - (offset % alignment)) % alignment;
   }
@@ -324,8 +314,8 @@ private:
 
             unsigned alignment = gl_type.alignment;
             auto n_offset = next_offset(offset, gl_type.alignment);
-            fields.push_back({std::string(refl::descriptor::get_name(member)),
-                              size, n_offset, gl_type,
+            fields.push_back({refl::descriptor::get_name(member).c_str(), size,
+                              n_offset, gl_type,
                               static_cast<void *>(&member(item))});
 
             offset = n_offset + static_cast<GLuint>(size);