Lua Scripting Support

CMakeLists.txt

@@ -89,6 +89,8 @@ find_package(glslang CONFIG REQUIRED)
 find_package(SPIRV-Tools-opt CONFIG REQUIRED)
 find_package(nlohmann_json CONFIG REQUIRED)
 find_package(unofficial-joltphysics CONFIG REQUIRED)
+find_package(Lua REQUIRED)
+find_package(sol2 CONFIG REQUIRED)
 
 if (ATLAS_TESTS)
 find_package(GTest CONFIG REQUIRED)

src/editor/FileImporter.cpp

@@ -7,6 +7,7 @@
 #include "mesh/Mesh.h"
 #include "scene/Scene.h"
 #include "audio/AudioData.h"
+#include "scripting/Script.h"
 
 #include "loader/ModelLoader.h"
 #include "scene/SceneSerializer.h"
@@ -49,6 +50,12 @@ namespace Atlas::Editor {
                         ResourceOrigin::User, Scene::SceneSerializer::DeserializeScene);
                 }
                 break;
+            case FileType::Script: {
+                    auto handle = ResourceManager<Scripting::Script>::GetOrLoadResourceAsync(
+                        filename, ResourceOrigin::User);
+                    handle.GetResource()->permanent = true;
+                }
+                break;
             default:
                 break;
         }
@@ -63,6 +70,7 @@ namespace Atlas::Editor {
         { "fbx", FileType::Mesh },
         { "aeterrain", FileType::Terrain },
         { "aescene", FileType::Scene },
+        { "lua", FileType::Script },
     };
 
 }

src/editor/FileImporter.h

@@ -18,7 +18,8 @@ namespace Atlas::Editor {
             Audio = 0,
             Mesh,
             Terrain,
-            Scene
+            Scene,
+            Script
         };
 
         static const std::map<const std::string, FileType> fileTypeMapping;

src/editor/ui/panels/EntityPropertiesPanel.cpp

@@ -40,6 +40,11 @@ namespace Atlas::Editor::UI {
                 entity.RemoveComponent<AudioVolumeComponent>();
                 entity.AddComponent<AudioVolumeComponent>(comp);
             }
+
+            if(entity.HasComponent<LuaScriptComponent>()){
+                RenderComponentPanel("Lua script component", entity, luaScriptComponentPanel,
+                    entity.GetComponent<LuaScriptComponent>());
+            }
         }
 
         // Add components
@@ -56,6 +61,8 @@ namespace Atlas::Editor::UI {
                     entity.AddComponent<MeshComponent>();
                 if (!entity.HasComponent<AudioVolumeComponent>() && ImGui::MenuItem("Add audio volume component"))
                     entity.AddComponent<AudioVolumeComponent>();
+                if (!entity.HasComponent<LuaScriptComponent>() && ImGui::MenuItem("Add lua script component"))
+                    entity.AddComponent<LuaScriptComponent>();
 
                 ImGui::EndPopup();
             }

src/editor/ui/panels/EntityPropertiesPanel.h

@@ -8,6 +8,7 @@
 #include "components/MeshComponentPanel.h"
 #include "components/LightComponentPanel.h"
 #include "components/AudioVolumeComponentPanel.h"
+#include "components/LuaScriptComponentPanel.h"
 
 #include <imgui.h>
 
@@ -26,6 +27,7 @@ namespace Atlas::Editor::UI {
         MeshComponentPanel meshComponentPanel;
         LightComponentPanel lightComponentPanel;
         AudioVolumeComponentPanel audioVolumeComponentPanel;
+        LuaScriptComponentPanel luaScriptComponentPanel;
 
         template<class S, class T>
         bool RenderComponentPanel(const std::string& name,

src/editor/ui/panels/components/LuaScriptComponentPanel.cpp

@@ -0,0 +1,56 @@
+#include "LuaScriptComponentPanel.h"
+#include "resource/ResourceManager.h"
+
+#include "imgui_stdlib.h"
+
+namespace Atlas::Editor::UI
+{
+    bool LuaScriptComponentPanel::Render(Scene::Entity entity, LuaScriptComponent &luaScriptComponent)
+    {
+        auto buttonName = luaScriptComponent.script.IsValid() ? luaScriptComponent.script.GetResource()->GetFileName() : "Drop script resource here";
+        ImGui::Button(buttonName.c_str(), {-FLT_MIN, 0});
+
+        if (ImGui::BeginDragDropTarget())
+        {
+            if (auto dropPayload = ImGui::AcceptDragDropPayload(typeid(Scripting::Script).name()))
+            {
+                Resource<Scripting::Script> *resource;
+                std::memcpy(&resource, dropPayload->Data, dropPayload->DataSize);
+                // We know this mesh is loaded, so we can just request a handle without loading
+                luaScriptComponent.script = ResourceManager<Scripting::Script>::GetResource(resource->path);
+                // Usually we need to also keep track of resource in the scene, ignore for now
+                // resourceChanged = true;
+            }
+
+            ImGui::EndDragDropTarget();
+        }
+
+        if (!luaScriptComponent.script.IsLoaded())
+            return false;
+
+        ImGui::InputTextMultiline("Code", &luaScriptComponent.script->code, ImVec2(0, 0), ImGuiInputTextFlags_ReadOnly);
+
+        ImGui::Separator();
+        ImGui::Text("Script defined properties:");
+        for (auto &property : luaScriptComponent.properties)
+        {
+            switch (property.type)
+            {
+            case LuaScriptComponent::PropertyType::Boolean:
+                ImGui::Checkbox(property.name.c_str(), &property.booleanValue);
+                break;
+            case LuaScriptComponent::PropertyType::Integer:
+                ImGui::InputInt(property.name.c_str(), &property.integerValue);
+                break;
+            case LuaScriptComponent::PropertyType::Double:
+                ImGui::InputDouble(property.name.c_str(), &property.doubleValue);
+                break;
+            case LuaScriptComponent::PropertyType::String:
+                ImGui::InputText(property.name.c_str(), &property.stringValue);
+                break;
+            }
+        }
+
+        return false;
+    }
+}

src/editor/ui/panels/components/LuaScriptComponentPanel.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "../Panel.h"
+
+#include "scene/components/LuaScriptComponent.h"
+
+namespace Atlas::Editor::UI
+{
+
+    class LuaScriptComponentPanel : public Panel
+    {
+
+    public:
+        LuaScriptComponentPanel() : Panel("Lua script component") {}
+
+        bool Render(Scene::Entity entity, LuaScriptComponent &luaScriptComponent);
+    };
+
+}

src/editor/ui/windows/ContentBrowserWindow.cpp

@@ -47,7 +47,7 @@ namespace Atlas::Editor::UI {
         ImGui::End();
 
         ImGui::Begin("ResourceTypeSelection", nullptr);
-        const char *items[] = {"Audio", "Mesh", "Terrain", "Scene"};
+        const char *items[] = {"Audio", "Mesh", "Terrain", "Scene", "Script"};
         static int currentSelection = 0;
         ImGui::BeginListBox("##Listbox", ImVec2(-FLT_MIN, 9 * ImGui::GetTextLineHeightWithSpacing()));
         for (int i = 0; i < IM_ARRAYSIZE(items); i++) {
@@ -73,6 +73,9 @@ namespace Atlas::Editor::UI {
                 break;
             case 3:
                 RenderResourceType<Scene::Scene>(IconType::Scene);
+                break;
+            case 4:
+                RenderResourceType<Scripting::Script>(IconType::Document);
             default:
                 break;
         }

src/editor/ui/windows/SceneWindow.cpp

@@ -144,7 +144,7 @@ namespace Atlas::Editor::UI {
             auto offset = region.x / 2.0f - buttonSize.x - 8.0f;
             ImGui::SetCursorPos(ImVec2(offset, 0.0f));
             if (ImGui::ImageButton(set, buttonSize, uvMin, uvMax)) {
-
+                scene->physicsWorld->pauseSimulation = false;
             }
 
             auto& stopIcon = Singletons::icons->Get(IconType::Stop);
@@ -153,7 +153,7 @@ namespace Atlas::Editor::UI {
             offset = region.x / 2.0f + 8.0f;
             ImGui::SetCursorPos(ImVec2(offset, 0.0f));
             if (ImGui::ImageButton(set, buttonSize, uvMin, uvMax)) {
-
+                scene->physicsWorld->pauseSimulation = true;
             }
 
             ImGui::PopStyleColor();

src/engine/CMakeLists.txt

@@ -41,7 +41,8 @@ if(WIN32)
 
     set(ATLAS_ENGINE_LIBS assimp::assimp SDL2::SDL2 SDL2::SDL2main SPIRV-Tools-opt
             volk::volk volk::volk_headers GPUOpen::VulkanMemoryAllocator
-            unofficial::spirv-reflect::spirv-reflect glslang::SPIRV unofficial::joltphysics::Jolt)
+            unofficial::spirv-reflect::spirv-reflect glslang::SPIRV unofficial::joltphysics::Jolt
+            ${LUA_LIBRARIES} sol2)
 endif()
 
 if (MINGW)
@@ -56,13 +57,14 @@ if(APPLE)
     set(ATLAS_ENGINE_LIBS assimp::assimp SDL2::SDL2 SDL2::SDL2main SDL2::SDL2-static
             volk::volk SPIRV-Tools-opt unofficial::joltphysics::Jolt
             GPUOpen::VulkanMemoryAllocator Vulkan::Vulkan Vulkan::Headers
-            unofficial::spirv-reflect::spirv-reflect glslang::SPIRV)
+            unofficial::spirv-reflect::spirv-reflect glslang::SPIRV ${LUA_LIBRARIES} sol2)
 endif()
 
 if(ANDROID)
     set(ATLAS_ENGINE_COMPILE_DEFINITIONS ${ATLAS_ENGINE_COMPILE_DEFINITIONS} AE_OS_ANDROID)
 
-    set(ATLAS_ENGINE_LIBS assimp::assimp SDL2::SDL2 SDL2::SDL2main SDL2::SDL2-static hidapi)
+    set(ATLAS_ENGINE_LIBS assimp::assimp SDL2::SDL2 SDL2::SDL2main SDL2::SDL2-static hidapi
+            ${LUA_LIBRARIES} sol2)
     set(ATLAS_ENGINE_SYSTEM_LIBS android m)
 endif()
 
@@ -79,7 +81,7 @@ if(UNIX AND NOT APPLE AND NOT ANDROID)
 
     set(ATLAS_ENGINE_LIBS assimp::assimp SDL2::SDL2 SDL2::SDL2main SDL2::SDL2-static
             volk::volk volk::volk_headers GPUOpen::VulkanMemoryAllocator unofficial::joltphysics::Jolt
-            unofficial::spirv-reflect::spirv-reflect SPIRV-Tools-opt glslang::SPIRV)
+            unofficial::spirv-reflect::spirv-reflect SPIRV-Tools-opt glslang::SPIRV ${LUA_LIBRARIES} sol2)
 endif()
 
 # Add source files ################################################################################
@@ -151,6 +153,7 @@ target_include_directories(${PROJECT_NAME}
     ${VULKAN_HEADERS_INCLUDE_DIRS}
     ${STB_INCLUDE_DIRS}
     ${GLM_INCLUDE_DIRS}
+    ${LUA_INCLUDE_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/../../libs)
 

src/engine/resource/Resource.h

@@ -4,6 +4,7 @@
 #include "ResourceLoadException.h"
 #include "../common/Hash.h"
 #include "../common/Path.h"
+#include "../loader/AssetLoader.h"
 
 #include <vector>
 #include <mutex>
@@ -86,6 +87,21 @@ namespace Atlas {
 
         }
 
+        bool WasModified() const {
+
+            std::filesystem::file_time_type lastModified = std::filesystem::file_time_type::min();
+            lastModified = Loader::AssetLoader::GetFileLastModifiedTime(path, lastModified);
+
+            return loadModifiedTime < lastModified;
+
+        }
+
+        void UpdateModifiedTime() {
+
+            loadModifiedTime = Loader::AssetLoader::GetFileLastModifiedTime(path, loadModifiedTime);
+
+        }
+
         void Unload() {
             isLoaded = false;
             errorOnLoad = false;
@@ -108,6 +124,8 @@ namespace Atlas {
         bool errorOnLoad = false;
         std::exception exceptionOnLoad;
 
+        std::filesystem::file_time_type loadModifiedTime;        
+
     private:
         Ref<T> data;
 

src/engine/scene/EntitySerializer.h

@@ -52,6 +52,9 @@ namespace Atlas::Scene {
             j["entities"] = entities;
             j["root"] = hierarchyComponent.root;
         }
+        if (p.HasComponent<LuaScriptComponent>()) {
+            j["luaScript"] = p.GetComponent<LuaScriptComponent>();
+        }
     }
 
     void EntityFromJson(const json& j, Entity& p, Ref<Scene>& scene) {
@@ -106,6 +109,10 @@ namespace Atlas::Scene {
                 comp.AddChild(entity);
             }
         }
+        if(j.contains("luaScript")){
+            LuaScriptComponent comp = j["luaScript"];
+            p.AddComponent<LuaScriptComponent>(comp);
+        }
     }
 
 }

src/engine/scene/Scene.cpp

@@ -91,6 +91,13 @@ namespace Atlas {
             // Do cleanup first such that we work with valid data
             CleanupUnusedResources();
 
+            // Update scripting components
+            auto luaScriptComponentSubset = entityManager.GetSubset<LuaScriptComponent>();
+            for(auto entity : luaScriptComponentSubset){
+                auto& luaScriptComponent = luaScriptComponentSubset.Get<LuaScriptComponent>(entity);
+                luaScriptComponent.Update(deltaTime);
+            }
+
             TransformComponent rootTransform = {};
 
             auto hierarchyTransformSubset = entityManager.GetSubset<HierarchyComponent, TransformComponent>();

src/engine/scene/SceneSerializer.cpp

@@ -136,6 +136,7 @@ namespace Atlas {
             if (j.contains("physicsWorld")) {
                 scene->physicsWorld = CreateRef<Physics::PhysicsWorld>();
                 *scene->physicsWorld = j["physicsWorld"];
+                scene->physicsWorld->pauseSimulation = true;
             }
 
             scene->rayTracingWorld = CreateRef<RayTracing::RayTracingWorld>();

src/engine/scene/components/ComponentSerializer.h

@@ -193,5 +193,24 @@ namespace Atlas::Scene::Components {
         j.at("matrix").get_to(p.matrix);
         j.at("isStatic").get_to(p.isStatic);
     }
+
+    void to_json(json& j, const LuaScriptComponent& p) {
+        j = json {};
+
+        if (p.script.IsValid())
+            j["resourcePath"] = p.script.GetResource()->path;
+    }
+
+    void from_json(const json& j, LuaScriptComponent& p) {
+
+        if (j.contains("resourcePath")) {
+            std::string resourcePath;
+            j.at("resourcePath").get_to(resourcePath);
+
+            p.script = ResourceManager<Scripting::Script>::GetOrLoadResourceAsync(
+                        resourcePath, ResourceOrigin::User);
+        }
+
+    }
 
 }

src/engine/scene/components/Components.h

@@ -9,4 +9,5 @@
 #include "NameComponent.h"
 #include "TransformComponent.h"
 #include "ObjectComponent.h"
-#include "RigidBodyComponent.h"
+#include "RigidBodyComponent.h"
+#include "LuaScriptComponent.h"