feat: switch to only quads for renderring

README.md

@@ -18,7 +18,8 @@ Come back later, sorry! Jenjin is not ready for real usage.
 - [x] Code editor in the editor
 - [x] Dynamic data attached to game objects at runtime
 - [x] Console window in the editor showing output from the engine
-- [ ] Improved meshing algorithm that gives same input meshes all one mesh reference instead of making multiple mesh references and data for them.
+- [x] Switch to only quads for rendering
+- [ ] * -> & (less pointers! more references!)
 - [ ] Hierarchy and `.Parent` in Lua along with `workspace` (e.g. `Workspace.MyGameObject.Parent` == `Workspace`)
 - [ ] Autocompletion in the editor
 - [ ] Allow user to create UI from Lua

engine/include/jenjin/editor/editor.h

@@ -33,7 +33,12 @@ class Manager {
   int renderTexture = -1;
 
 private:
-  Jenjin::GameObject *selectedObject = nullptr;
+  struct selectedObject_t {
+    std::shared_ptr<Jenjin::GameObject> ptr = nullptr;
+    std::string name = "";
+    bool valid = false;
+  } selectedObject;
+
   bool selectedCamera = false;
 
   char renameGameObjectBuffer[256] = {0};

engine/include/jenjin/gameobject.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "jenjin/datastore.h"
-#include "jenjin/mesh.h"
 
 #include <glm/glm.hpp>
 #include <spdlog/spdlog.h>
@@ -13,56 +12,35 @@
 namespace Jenjin {
 class GameObject {
 public:
-  GameObject(std::string name, Mesh mesh) : mesh(mesh), name(name) {}
-  ~GameObject() { spdlog::trace("GameObject::~GameObject(\"{}\")", name); }
-
-  std::string name;
+  GameObject() {}
+  ~GameObject() {}
 
   // Transform
   struct Transform {
-    glm::vec2 position;
-    glm::vec2 scale;
-    float rotation;
-  } transform = {glm::vec2(0.0f), glm::vec2(1.0f), 0.0f};
+    glm::vec2 position = glm::vec2(0.0f);
+    glm::vec2 scale = glm::vec2(1.0f);
+    float rotation = 0.0f;
+  } transform;
 
   // Appearance
   glm::vec3 color = glm::vec3(1.0f);
 
-  Mesh mesh;
   std::string texturePath = "";
 
-  int meshReferenceID = -1;
-
-  bool mixColor = false;
-
   DataStore dataStore;
 
-  // TODO: hierarchy
-#ifdef false
-  GameObject *parent = nullptr;
-  std::vector<GameObject *> children = {};
-#endif
-
   // Getters
-  std::string GetName() { return name; }
   glm::vec2 GetPosition() { return transform.position; }
   glm::vec2 GetScale() { return transform.scale; }
   float GetRotation() { return transform.rotation; }
   glm::vec3 GetColor() { return color; }
 
   // Setters
-  void SetName(std::string name) { this->name = name; }
   void SetPosition(glm::vec2 position) { transform.position = position; }
   void SetScale(glm::vec2 scale) { transform.scale = scale; }
   void SetRotation(float rotation) { transform.rotation = rotation; }
   void SetColor(glm::vec3 color) { this->color = color; }
 
-  // Pointer getters
-  std::string *GetNamePointer() { return &name; }
-  glm::vec2 *GetPositionPointer() { return &transform.position; }
-  glm::vec2 *GetScalePointer() { return &transform.scale; }
-  float *GetRotationPointer() { return &transform.rotation; }
-
   // Modifiers
   void Translate(glm::vec2 translation) { transform.position += translation; }
   void Scale(glm::vec2 scale) { transform.scale *= scale; }

engine/include/jenjin/helpers.h

@@ -1,7 +1,6 @@
 #pragma once
 
-#include "jenjin/mesh.h"
-
+#define GLFW_INCLUDE_NONE
 #include <GLFW/glfw3.h>
 #include <glad/glad.h>
 
@@ -10,7 +9,5 @@ namespace Helpers {
 GLFWwindow *CreateWindow(int width, int height, const char *title);
 void CheckWindow(GLFWwindow *window);
 void InitiateImGui(GLFWwindow *window);
-
-Mesh CreateQuad(int width, int height);
 } // namespace Helpers
 } // namespace Jenjin

engine/include/jenjin/scene.h

@@ -13,7 +13,6 @@
 
 #include <fstream>
 #include <memory>
-#include <vector>
 
 namespace Jenjin {
 class Scene {
@@ -23,12 +22,21 @@ class Scene {
 
   void SetTarget(Target *target);
 
-  void AddGameObject(std::shared_ptr<GameObject> gameObject);
-  void RemoveGameObject(GameObject *gameObject);
-  void RemoveGameObject(std::shared_ptr<GameObject> gameObject);
+  /*void AddGameObject(std::shared_ptr<GameObject> gameObject);*/
+  /*void RemoveGameObject(GameObject *gameObject);*/
+  /*void RemoveGameObject(std::shared_ptr<GameObject> gameObject);*/
+
+  /*void SetGameObjectTexture(GameObject *gameObject,*/
+  /*                          const std::string &texturePath);*/
+
+  void AddGameObject(const std::string &name,
+                     std::shared_ptr<GameObject> gameObject);
+  void RemoveGameObject(std::string name);
+
+  void RenameGameObject(std::string oldName, std::string newName);
+  void RenameGameObject(std::shared_ptr<GameObject> gameObject,
+                        std::string newName);
 
-  void SetGameObjectTexture(GameObject *gameObject,
-                            const std::string &texturePath);
   void SetGameObjectTexture(std::shared_ptr<GameObject> gameObject,
                             const std::string &texturePath);
 
@@ -40,9 +48,12 @@ class Scene {
   std::shared_ptr<GameObject> GetGameObject(const std::string &name);
 
   Camera *GetCamera() { return &camera; }
-  std::vector<std::shared_ptr<GameObject>> *GetGameObjects() {
-    return &gameObjects;
+
+  std::unordered_map<std::string, std::shared_ptr<GameObject>> &
+  GetGameObjects() {
+    return gameObjects;
   }
+
   Target *GetTarget() { return target; }
   LuaManager *GetLuaManager() { return &luaManager; }
 
@@ -54,13 +65,12 @@ class Scene {
 private:
   GLuint vao, vbo, ebo = 0;
 
-  std::vector<std::shared_ptr<GameObject>> gameObjects = {};
-
-  std::vector<MeshReference> meshReferences = {};
+  std::unordered_map<std::string, std::shared_ptr<GameObject>> gameObjects;
   std::unordered_map<std::string, std::shared_ptr<Texture>> textures;
 
   Shader shader = Shader("resources/shaders/default_vert.glsl",
                          "resources/shaders/default_frag.glsl");
+
   Target *target = nullptr;
 
   Camera camera = Camera(&shader, glm::vec2(800, 600));

engine/src/editor/editor.cpp

@@ -1,3 +1,4 @@
+#include <cstring>
 #define GLFW_INCLUDE_NONE
 
 #include "jenjin/editor/editor.h"
@@ -20,7 +21,6 @@
 #include <filesystem>
 #include <memory>
 #include <string>
-#include <vector>
 
 static char codeBuffer[1024 * 16] = {0};
 
@@ -218,8 +218,8 @@ void Manager::hierarchy(Jenjin::Scene *scene) {
     return;
   }
 
-  std::vector<std::shared_ptr<Jenjin::GameObject>> *gameObjects =
-      Jenjin::EngineRef->GetCurrentScene()->GetGameObjects();
+  std::unordered_map<std::string, std::shared_ptr<Jenjin::GameObject>>
+      &gameObjects = Jenjin::EngineRef->GetCurrentScene()->GetGameObjects();
 
   static auto title = ICON_FA_SITEMAP " Hierarchy";
   ImGui::Begin(title);
@@ -243,18 +243,18 @@ void Manager::hierarchy(Jenjin::Scene *scene) {
 
     if (ImGui::Button("Create##Add") ||
         ImGui::IsKeyPressed(ImGui::GetKeyIndex(ImGuiKey_Enter))) {
-      auto gameObject = std::make_shared<Jenjin::GameObject>(
-          name, Jenjin::Helpers::CreateQuad(2.0f, 2.0f));
-      scene->AddGameObject(gameObject);
-      scene->Build();
+      auto gameObject = std::make_shared<Jenjin::GameObject>();
+      scene->AddGameObject(name, gameObject);
 
       selectedCamera = false;
-      selectedObject = gameObjects->back().get();
+      selectedObject.ptr = gameObjects[name];
+      selectedObject.name = name;
+      selectedObject.valid = true;
 
       memset(this->renameGameObjectBuffer, 0,
              sizeof(this->renameGameObjectBuffer));
-      memcpy(this->renameGameObjectBuffer, selectedObject->name.c_str(),
-             selectedObject->name.size());
+
+      memcpy(this->renameGameObjectBuffer, name, sizeof(name));
 
       ImGui::CloseCurrentPopup();
     }
@@ -272,24 +272,29 @@ void Manager::hierarchy(Jenjin::Scene *scene) {
   static auto cameraText = ICON_FA_VIDEO " Camera";
   if (ImGui::Selectable(cameraText, selectedCamera)) {
     selectedCamera = !selectedCamera;
+
     if (selectedCamera)
-      selectedObject = nullptr;
+      selectedObject.valid = false;
   }
 
-  for (std::shared_ptr<Jenjin::GameObject> gameObject : *gameObjects) {
-    bool isSelected = selectedObject == gameObject.get();
+  for (auto &[name, gameObject] : gameObjects) {
+    bool isSelected =
+        selectedObject.ptr.get() == gameObject.get() && selectedObject.valid;
 
-    const auto text = fmt::format("{} {}", ICON_FA_CUBE, gameObject->name);
+    const auto text = fmt::format("{} {}", ICON_FA_CUBE, name);
     if (ImGui::Selectable(text.c_str(), isSelected)) {
       if (isSelected) {
-        selectedObject = nullptr;
+        selectedObject.valid = false;
       } else {
         selectedCamera = false;
-        selectedObject = gameObject.get();
+        selectedObject.ptr = gameObject;
+        selectedObject.name = name;
+        selectedObject.valid = true;
+
         memset(this->renameGameObjectBuffer, 0,
                sizeof(this->renameGameObjectBuffer));
-        memcpy(this->renameGameObjectBuffer, selectedObject->name.c_str(),
-               selectedObject->name.size());
+
+        memcpy(this->renameGameObjectBuffer, name.c_str(), name.size());
       }
     }
   }
@@ -303,7 +308,7 @@ void Manager::hierarchy(Jenjin::Scene *scene) {
 }
 
 void Manager::inspector(Jenjin::Scene *scene) {
-  if (!selectedObject && !selectedCamera) {
+  if (!selectedObject.valid && !selectedCamera) {
     return;
   }
 
@@ -332,21 +337,21 @@ void Manager::inspector(Jenjin::Scene *scene) {
     }
   }
 
-  if (selectedObject) {
+  if (selectedObject.valid) {
     static auto transform_title =
         ICON_FA_ARROWS_UP_DOWN_LEFT_RIGHT " Transform";
     if (ImGui::CollapsingHeader(transform_title,
                                 ImGuiTreeNodeFlags_DefaultOpen)) {
       ImGui::Indent();
-      Jenjin::Editor::Widgets::transformWidget(&selectedObject->transform);
+      Jenjin::Editor::Widgets::transformWidget(&selectedObject.ptr->transform);
       ImGui::Unindent();
     }
 
     ImGui::ItemSize(ImVec2(0, 10));
 
     if (ImGui::CollapsingHeader(appearance_title)) {
       ImGui::Indent();
-      ImGui::ColorPicker3("Color", glm::value_ptr(selectedObject->color));
+      ImGui::ColorPicker3("Color", glm::value_ptr(selectedObject.ptr->color));
       ImGui::Unindent();
     }
 
@@ -364,13 +369,14 @@ void Manager::inspector(Jenjin::Scene *scene) {
 
       static auto text = ICON_FA_PEN " Rename";
       if (ImGui::Button(text, ImVec2(itemWidth, 0))) {
-        selectedObject->SetName(renameGameObjectBuffer);
+        /*selectedObject->SetName(renameGameObjectBuffer);*/
+        scene->RenameGameObject(selectedObject.name, renameGameObjectBuffer);
       }
 
       static auto delete_text = ICON_FA_TRASH " Delete";
       if (ImGui::Button(delete_text, ImVec2(itemWidth, 0))) {
-        scene->RemoveGameObject(selectedObject);
-        selectedObject = nullptr;
+        scene->RemoveGameObject(selectedObject.name);
+        selectedObject.valid = false;
       }
 
       ImGui::Unindent();
@@ -425,8 +431,8 @@ void Manager::explorer(Jenjin::Scene *scene) {
               auto texture_text = fmt::format(
                   "{} {}", ICON_FA_IMAGE, subfile.path().filename().string());
               if (ImGui::Selectable(texture_text.c_str())) {
-                if (selectedObject) {
-                  scene->SetGameObjectTexture(selectedObject,
+                if (selectedObject.valid) {
+                  scene->SetGameObjectTexture(selectedObject.ptr,
                                               subfile.path().string());
                 } else {
                   spdlog::warn("No object selected");
@@ -604,7 +610,6 @@ void Manager::console(Jenjin::Scene *scene) {
     }
   }
 
-
   ImGui::End();
 }
 
@@ -758,7 +763,7 @@ void Manager::welcome() {
       spdlog::info("Changed cwd to {}",
                    std::filesystem::current_path().string());
 
-      Jenjin::EngineRef->GetCurrentScene()->GetGameObjects()->clear();
+      Jenjin::EngineRef->GetCurrentScene()->GetGameObjects().clear();
       Jenjin::EngineRef->GetCurrentScene()->Save("main.jenscene");
       ImGui::CloseCurrentPopup();
     }