object names

Author: 4ipset111

src/editor.cpp

@@ -16,6 +16,11 @@ const float icon_size = 64.0f;
 const float padding = 10.0f;
 const float cell_size = icon_size + padding;
 
+static void assign_entity_name(Entity& entity, const char* new_name) {
+    if (!new_name || new_name[0] == '\0') return;
+    entity.name = new_name;
+}
+
 void Editor::handle_input() {
     float speed = 0.1f;
     Entity* e = scene.get_selected();
@@ -113,8 +118,8 @@ void Editor::draw_ui(Shader shader) {
 
             if (ImGui::MenuItem("Dublicate")) {
                 Entity ent_copy = ent;
-                ent_copy.name = ent.name + " copy";
                 ent_copy.id = static_cast<int>(scene.entities.size());
+                ent_copy.name = scene.make_default_name_for(ent_copy);
                 scene.entities.push_back(ent_copy);
             }
 
@@ -130,10 +135,10 @@ void Editor::draw_ui(Shader shader) {
                 if (ImGui::MenuItem(a.name.c_str())) {
                     Entity e;
                     e.id = static_cast<int>(scene.entities.size());
-                    e.name = "Object " + std::to_string(e.id);
                     e.type = a.type;
                     e.asset = &a;
                     e.segments = 16;
+                    e.name = scene.make_default_name_for(e);
 
                     if (a.isProcedural) {
                         e.model = a.generator(e.segments);
@@ -153,14 +158,13 @@ void Editor::draw_ui(Shader shader) {
 
     if (renaming_index != -1) { 
         ImGui::OpenPopup("Rename"); 
-        renaming_index = -2; 
     }
 
     if (ImGui::BeginPopupModal("Rename", nullptr, ImGuiWindowFlags_AlwaysAutoResize)) {
         ImGui::InputText("##rename", rename_buf, IM_ARRAYSIZE(rename_buf));
         if (ImGui::Button("OK")) {
-            if (renaming_index == -2) {
-                scene.entities[scene.selected].name = rename_buf;
+            if (renaming_index >= 0 && renaming_index < static_cast<int>(scene.entities.size())) {
+                assign_entity_name(scene.entities[renaming_index], rename_buf);
             }
             renaming_index = -1;
             ImGui::CloseCurrentPopup();
@@ -187,6 +191,14 @@ void Editor::draw_ui(Shader shader) {
 
     Entity* e = scene.get_selected();
     if (e) {
+        ImGui::Separator();
+        char inspector_name[128] = {};
+        const size_t copied = e->name.copy(inspector_name, sizeof(inspector_name) - 1);
+        inspector_name[copied] = '\0';
+        if (ImGui::InputText("Name", inspector_name, IM_ARRAYSIZE(inspector_name))) {
+            assign_entity_name(*e, inspector_name);
+        }
+
         ImGui::Separator();
         ImGui::Text("Transform");
         float pos[3] = { e->position.x, e->position.y, e->position.z };
@@ -334,13 +346,11 @@ void Editor::draw_ui(Shader shader) {
             ImGui::InputFloat("Intensity", &e->light.intensity, 0.1f, 1.0f, "%.2f");
             ImGui::InputFloat("Range", &e->light.range, 0.1f, 1.0f, "%.2f");
 
-            static int light_counter = 0;
-
             if (!e->light_created)
             {
                 e->light = create_lighting(e->position, e->light.color);
 
-                e->light.id = light_counter++;
+                e->light.id = allocate_light_id();
                 e->light.light = CreateLight(LIGHT_POINT, e->position, Vector3Zero(), e->light.color, shader);
 
                 e->light_created = true;
@@ -520,4 +530,4 @@ void Editor::draw_assets_ui() {
     }
 
     ImGui::End();
-}
+}

src/headers/entity.h

@@ -7,6 +7,18 @@
 
 enum ObjectType { CUBE, SPHERE, CONE, CYLINDER, HEMISPHERE, TORUS };
 
+inline const char* object_type_name(ObjectType type) {
+    switch (type) {
+        case CUBE: return "Cube";
+        case SPHERE: return "Sphere";
+        case CONE: return "Cone";
+        case CYLINDER: return "Cylinder";
+        case HEMISPHERE: return "HemiSphere";
+        case TORUS: return "Torus";
+        default: return "Object";
+    }
+}
+
 struct ModelAsset {
     std::string name;
     std::string filepath;
@@ -84,6 +96,6 @@ struct Entity {
           segments(16),
           type(CUBE)
     {
-        name = "Object " + std::to_string(id);
+        name = object_type_name(type);
     }
 };

src/headers/lighting.h

@@ -18,4 +18,5 @@ struct Lighting {
 };
 
 Lighting create_lighting(Vector3 pos, Color color);
-void update_lighting(Shader shader, Lighting& l);
+void update_lighting(Shader shader, Lighting& l);
+int allocate_light_id();

src/headers/scene.h

@@ -3,6 +3,7 @@
 #include "entity.h"
 #include "lighting.h"
 #include <memory>
+#include <string>
 
 struct Scene {
     std::vector<Entity> entities;
@@ -11,5 +12,7 @@ struct Scene {
     int selected = -1;
 
     Entity* get_selected();
+    std::string make_unique_name(const std::string& base_name) const;
+    std::string make_default_name_for(const Entity& entity) const;
     void release_resources();
 };

src/lighting.cpp

@@ -18,6 +18,12 @@ void update_lighting(Shader shader, Lighting& l) {
     UpdateLightValues(shader, l.light);
 }
 
+int allocate_light_id()
+{
+    static int light_id_counter = 0;
+    return light_id_counter++;
+}
+
 Lighting create_lighting(Vector3 pos, Color color)
 {
     Lighting l = {};
@@ -28,4 +34,4 @@ Lighting create_lighting(Vector3 pos, Color color)
     l.intensity = 1.0f;
     l.range = 5.0f;
     return l;
-}
+}

src/main.cpp

@@ -6,6 +6,25 @@
 #include "headers/editor.h"
 #include "headers/camera.h"
 
+static Entity make_entity_from_asset(Scene& scene, ModelAsset* asset) {
+    Entity entity;
+    entity.id = static_cast<int>(scene.entities.size());
+    entity.type = asset->type;
+    entity.asset = asset;
+    entity.segments = 16;
+    entity.name = scene.make_default_name_for(entity);
+
+    if (asset->isProcedural) {
+        entity.model = asset->generator(entity.segments);
+        store_uv(&entity);
+    } else {
+        entity.model = asset->loadedModel;
+    }
+
+    entity.texture = {0};
+    return entity;
+}
+
 int main() {
     if (!std::filesystem::exists("assets")) std::filesystem::create_directory("assets");
 
@@ -26,6 +45,26 @@ int main() {
     load_models();
     load_textures();
 
+    for (auto& asset : assets) {
+        if (asset.type != SPHERE) continue;
+
+        Entity light_entity = make_entity_from_asset(editor.scene, &asset);
+        light_entity.has_light = true;
+        light_entity.name = editor.scene.make_default_name_for(light_entity);
+        light_entity.position = { 2.0f, 3.0f, 2.0f };
+        light_entity.scale = { 0.2f, 0.2f, 0.2f };
+        light_entity.color = WHITE;
+        light_entity.light = create_lighting(light_entity.position, WHITE);
+        light_entity.light.range = 12.0f;
+        light_entity.light.intensity = 1.5f;
+        light_entity.light.id = allocate_light_id();
+        light_entity.light.light = CreateLight(LIGHT_POINT, light_entity.position, Vector3Zero(), light_entity.light.color, shader);
+        light_entity.light_created = true;
+
+        editor.scene.entities.push_back(light_entity);
+        break;
+    }
+
     while (!WindowShouldClose()) {
         SetWindowTitle(TextFormat("Quark Engine / FPS: %d", GetFPS()));
 

src/scene.cpp

@@ -6,6 +6,27 @@ Entity* Scene::get_selected() {
     return &entities[selected];
 }
 
+std::string Scene::make_unique_name(const std::string& base_name) const {
+    auto is_name_taken = [this](const std::string& candidate) {
+        for (const auto& entity : entities) {
+            if (entity.name == candidate) return true;
+        }
+        return false;
+    };
+
+    if (!is_name_taken(base_name)) return base_name;
+
+    for (int suffix = 1;; ++suffix) {
+        const std::string candidate = base_name + " (" + std::to_string(suffix) + ")";
+        if (!is_name_taken(candidate)) return candidate;
+    }
+}
+
+std::string Scene::make_default_name_for(const Entity& entity) const {
+    const std::string base_name = entity.has_light ? "Light" : object_type_name(entity.type);
+    return make_unique_name(base_name);
+}
+
 void Scene::release_resources() {
     std::unordered_set<void*> released_meshes;