diff --git a/Makefile b/Makefile index c88b63f..a9f981a 100644 --- a/Makefile +++ b/Makefile @@ -11,8 +11,7 @@ BUILD_DIR := build # Include Directories GLFW_INCLUDE := C:/libraries/glfw/include -INCLUDE_DIRS := $(SRC_DIR) $(VENDOR_DIRS) $(GLFW_INCLUDE) vendor/stb/include C:\msys64\mingw64\include -INCLUDE_DIRS := $(SRC_DIR) $(VENDOR_DIRS) $(GLFW_INCLUDE) vendor/gcml +INCLUDE_DIRS := $(SRC_DIR) $(VENDOR_DIRS) $(GLFW_INCLUDE) vendor/stb/include C:\msys64\mingw64\include vendor/lua vendor/gcml INCLUDES := $(addprefix -I, $(INCLUDE_DIRS)) # Update compiler flags with include paths @@ -43,7 +42,7 @@ OBJ_FILES := $(patsubst %.cpp, $(BUILD_DIR)/%.o, $(ALL_SRC)) TARGET := TesseractEngine.exe # Libraries -LIBS := -LC:/libraries/glfw/lib -lglfw3 -lopengl32 -lgdi32 -limm32 -lole32 -loleaut32 -luuid -lwinmm -lglew32 -lglu32 -lyaml-cpp +LIBS := -LC:/libraries/glfw/lib -Llib -lglfw3 -lopengl32 -lgdi32 -limm32 -lole32 -loleaut32 -luuid -lwinmm -lglew32 -lglu32 -lyaml-cpp -llua54 # Phony Targets .PHONY: all clean copy_assets diff --git a/assets/scripts/script.lua b/assets/scripts/script.lua new file mode 100644 index 0000000..dba0510 --- /dev/null +++ b/assets/scripts/script.lua @@ -0,0 +1,31 @@ +-- script.lua +local itterator = 0 +local ticks = 0 +function OnInit() + -- Log a message with a custom red color + Engine.Log("This is a red message.", {1.0, 0.0, 0.0, 1.0}) + + -- Log a message with a custom green color + Engine.Log("This is a green message.", {0.0, 1.0, 0.0, 1.0}) + + -- Log a message with a custom blue color + Engine.Log("This is a blue message.", {0.0, 0.0, 1.0, 1.0}) + + +end + + +function OnUpdate(deltaTime) + + ticks = ticks + 1 + + + if itterator >= 1 then + Engine.Log("TPS: ".. ticks) + ticks = 0 + itterator = 0 + end + itterator = itterator + deltaTime +end + + diff --git a/imgui.ini b/imgui.ini index 51d5c8c..1a67cc3 100644 --- a/imgui.ini +++ b/imgui.ini @@ -1,6 +1,6 @@ [Window][DockSpace] Pos=0,0 -Size=1920,1177 +Size=1280,720 Collapsed=0 [Window][Debug##Default] @@ -9,8 +9,8 @@ Size=400,400 Collapsed=0 [Window][Inspector] -Pos=1543,27 -Size=369,1142 +Pos=903,27 +Size=369,685 Collapsed=0 DockId=0x00000002,0 @@ -21,14 +21,14 @@ Collapsed=0 DockId=0x00000003,0 [Window][Performance] -Pos=8,777 -Size=364,392 +Pos=8,477 +Size=364,235 Collapsed=0 DockId=0x00000006,0 [Window][Logger] -Pos=374,799 -Size=1167,370 +Pos=374,342 +Size=527,370 Collapsed=0 DockId=0x00000004,0 @@ -40,18 +40,18 @@ DockId=0x00000007,0 [Window][Scene Window] Pos=8,27 -Size=364,748 +Size=364,448 Collapsed=0 DockId=0x00000005,0 [Window][Editor] Pos=374,27 -Size=1167,770 +Size=527,313 Collapsed=0 DockId=0x00000003,0 [Docking][Data] -DockSpace ID=0x14621557 Window=0x3DA2F1DE Pos=8,27 Size=1904,1142 Split=X Selected=0xF7365A5A +DockSpace ID=0x14621557 Window=0x3DA2F1DE Pos=8,27 Size=1264,685 Split=X Selected=0xF7365A5A DockNode ID=0x00000009 Parent=0x14621557 SizeRef=364,1142 Split=Y Selected=0x3DC5AC3F DockNode ID=0x00000005 Parent=0x00000009 SizeRef=364,748 HiddenTabBar=1 Selected=0x3DC5AC3F DockNode ID=0x00000006 Parent=0x00000009 SizeRef=364,392 HiddenTabBar=1 Selected=0x726D8899 diff --git a/lib/lua54.dll b/lib/lua54.dll new file mode 100644 index 0000000..0dab789 Binary files /dev/null and b/lib/lua54.dll differ diff --git a/lib/lua54.lib b/lib/lua54.lib new file mode 100644 index 0000000..21bdd6e Binary files /dev/null and b/lib/lua54.lib differ diff --git a/lua54.dll b/lua54.dll new file mode 100644 index 0000000..0dab789 Binary files /dev/null and b/lua54.dll differ diff --git a/lua54.lib b/lua54.lib new file mode 100644 index 0000000..21bdd6e Binary files /dev/null and b/lua54.lib differ diff --git a/scenes/Default.scene b/scenes/Default.scene index 098806b..46f71e8 100644 --- a/scenes/Default.scene +++ b/scenes/Default.scene @@ -2,120 +2,125 @@ Entities: - ID: 0 Name: Car Components: + Transform: + Position: [0, 2.79999995, -12.6000004] + Rotation: [149.699997, -137.899994, -39.2999992] + Scale: [1, 1, 1] Mesh: vao: 2 indexCount: 15810 textureID: 1 MeshPath: assets/models/LowPolyFiatUNO.obj - Transform: - Position: [0, 2.79999995, -12.6000004] - Rotation: [149.699997, -137.899994, -39.2999992] - Scale: [1, 1, 1] - ID: 1 Name: Plant Components: - Mesh: - vao: 7 - indexCount: 589632 - textureID: 7 - MeshPath: assets/models/OutSidePlant.obj Transform: Position: [-8.60000038, 6.5, -15.6000004] Rotation: [-180, 0, 0] Scale: [1, 1, 1] + Mesh: + vao: 5 + indexCount: 589632 + textureID: 7 + MeshPath: assets/models/OutSidePlant.obj - ID: 2 Name: Cube Yay 2 Components: + Transform: + Position: [7.80000019, -8.10000038, -20.6000004] + Rotation: [-86.3000031, 0, -66] + Scale: [1, 1, 1] Mesh: vao: 6 indexCount: 36 textureID: 3 MeshPath: assets/models/DefaultMesh.obj - Transform: - Position: [7.80000019, -8.10000038, -20.6000004] - Rotation: [-86.3000031, 0, -66] - Scale: [1, 1, 1] - ID: 3 Name: Cube Yay 3 Components: + Transform: + Position: [-1.20000005, -3.4000001, -17.7000008] + Rotation: [-23.5, 15.8999996, -59.9000015] + Scale: [1, 1, 1] Mesh: vao: 6 indexCount: 36 textureID: 4 MeshPath: assets/models/DefaultMesh.obj - Transform: - Position: [-1.20000005, -3.4000001, -17.7000008] - Rotation: [-23.5, 15.8999996, -59.9000015] - Scale: [1, 1, 1] - ID: 4 Name: Cube Yay 4 Components: + Transform: + Position: [8.10000038, 0.800000012, -12] + Rotation: [-17.2999992, -16.1000004, -19.2999992] + Scale: [1, 1, 1] Mesh: vao: 6 indexCount: 36 textureID: 5 MeshPath: assets/models/DefaultMesh.obj - Transform: - Position: [8.10000038, 0.800000012, -12] - Rotation: [-17.2999992, -16.1000004, -19.2999992] - Scale: [1, 1, 1] - ID: 5 - Name: Colormap + Name: Sky Components: - Transform: - Position: [0, 0, 43.2000008] - Rotation: [0, 0, 0] - Scale: [100, 100, 100] Mesh: vao: 6 indexCount: 36 textureID: 6 MeshPath: assets/models/DefaultMesh.obj + Transform: + Position: [0, 0, 43.2000008] + Rotation: [0, 0, 0] + Scale: [100, 100, 100] - ID: 6 Name: Cube Yay 6 Components: + Transform: + Position: [-6.5, -6, -18] + Rotation: [15.8000002, -18.2000008, -11.1000004] + Scale: [1, 1, 1] Mesh: vao: 6 indexCount: 36 textureID: 3 MeshPath: assets/models/DefaultMesh.obj - Transform: - Position: [-6.5, -6, -18] - Rotation: [15.8000002, -18.2000008, -11.1000004] - Scale: [1, 1, 1] - ID: 7 Name: Cube Yay 7 Components: + Transform: + Position: [6.5, 1.79999995, -23.8999996] + Rotation: [-16.1000004, -15.8999996, -35] + Scale: [1, 1, 1] Mesh: vao: 6 indexCount: 36 textureID: 4 MeshPath: assets/models/DefaultMesh.obj - Transform: - Position: [6.5, 1.79999995, -23.8999996] - Rotation: [-16.1000004, -15.8999996, -35] - Scale: [1, 1, 1] - ID: 8 Name: Cube Yay 8 Components: + Transform: + Position: [-7.80000019, 0.200000003, -29.7999992] + Rotation: [22.2999992, -32.7999992, 0] + Scale: [1, 1, 1] Mesh: vao: 6 indexCount: 36 textureID: 1 MeshPath: assets/models/DefaultMesh.obj - Transform: - Position: [-7.80000019, 0.200000003, -29.7999992] - Rotation: [22.2999992, -32.7999992, 0] - Scale: [1, 1, 1] - ID: 9 Name: Cube Yay 9 Components: + Transform: + Position: [5.5, -2.9000001, -19.5] + Rotation: [-41.4000015, -22.6000004, -52.2999992] + Scale: [1, 1, 1] Mesh: vao: 6 indexCount: 36 textureID: 2 MeshPath: assets/models/DefaultMesh.obj - Transform: - Position: [5.5, -2.9000001, -19.5] - Rotation: [-41.4000015, -22.6000004, -52.2999992] - Scale: [1, 1, 1] \ No newline at end of file + - ID: 10 + Name: Script + Components: + ScriptComponent: + ScriptPath: assets/scripts/script.lua \ No newline at end of file diff --git a/src/Componenets/GameObject.cpp b/src/Componenets/GameObject.cpp index 2dc9a25..39a4c7a 100644 --- a/src/Componenets/GameObject.cpp +++ b/src/Componenets/GameObject.cpp @@ -2,6 +2,7 @@ #include "GameObject.h" #include "Transform.h" #include +#include "gcml.h" #include "../Windows/LoggerWindow.h" @@ -89,9 +90,16 @@ void GameObject::Deserialize(const YAML::Node &node) mesh->Deserialize(compNode); AddComponent(mesh); } + else if (compName == ScriptComponent::GetStaticName()) + { + auto ScriptComp = std::make_shared(); + ScriptComp->Deserialize(compNode); + AddComponent(ScriptComp); + } else { g_LoggerWindow->AddLog("[SceneManager] Failed to load Component: %s", compName.c_str()); + DEBUG_PRINT("[SceneManager] Failed to load Component: %s", compName.c_str()); } // Add deserialization for other components as needed diff --git a/src/Componenets/GameObject.h b/src/Componenets/GameObject.h index 558bcf8..cafc703 100644 --- a/src/Componenets/GameObject.h +++ b/src/Componenets/GameObject.h @@ -7,6 +7,7 @@ #include "Component.h" #include "Transform.h" +#include "ScriptComponent.h" #include "Mesh.h" #include diff --git a/src/Componenets/Mesh.cpp b/src/Componenets/Mesh.cpp index d432b31..39adaaa 100644 --- a/src/Componenets/Mesh.cpp +++ b/src/Componenets/Mesh.cpp @@ -7,10 +7,6 @@ extern AssetManager g_AssetManager; -// TODO: Make this have a OBJ path, make indexCount derive from AssetManager -// TODO: and make texture id also get from AssetManager -//? Procastinate - const std::string MeshComponent::name = "Mesh"; MeshComponent::MeshComponent() diff --git a/src/Componenets/ScriptComponent.cpp b/src/Componenets/ScriptComponent.cpp new file mode 100644 index 0000000..67d8cca --- /dev/null +++ b/src/Componenets/ScriptComponent.cpp @@ -0,0 +1,91 @@ +// ScriptComponent.cpp + +#include "ScriptComponent.h" +#include + +// External pointer to LoggerWindow (Assuming it's defined globally) +extern LoggerWindow* g_LoggerWindow; + + + +const std::string ScriptComponent::name = "ScriptComponent"; + + +ScriptComponent::ScriptComponent() + : ScriptPath(""), m_LastErrorMessage("") +{ + Initialize(); +} + +ScriptComponent::~ScriptComponent() +{ + // LuaManager destructor will handle Lua state cleanup +} + +const std::string &ScriptComponent::GetName() const +{ + return name; +} + +const std::string &ScriptComponent::GetStaticName() +{ + return name; +} + +YAML::Node ScriptComponent::Serialize() +{ + YAML::Node node; + + // ScriptPath + node["ScriptPath"] = ScriptPath; + + return node; +} + +void ScriptComponent::Deserialize(const YAML::Node& node) +{ + if (node["ScriptPath"]) + { + ScriptPath = node["ScriptPath"].as(); + } + Initialize(); + +} + +bool ScriptComponent::Initialize() +{ + if (ScriptPath.empty()) + { + if (g_LoggerWindow) + { + g_LoggerWindow->AddLog("ScriptComponent: Script path is empty.", ImVec4(1.0f, 0.0f, 0.0f, 1.0f)); + } + else + { + std::cerr << "ScriptComponent: Script path is empty." << std::endl; + } + return false; + } + + // Initialize LuaManager with the script path + if (!m_LuaManager.init(ScriptPath)) + { + if (g_LoggerWindow) + { + g_LoggerWindow->AddLog("ScriptComponent: Failed to initialize LuaManager.", ImVec4(1.0f, 0.0f, 0.0f, 1.0f)); + } + else + { + std::cerr << "ScriptComponent: Failed to initialize LuaManager." << std::endl; + } + return false; + } + + return true; +} + +void ScriptComponent::Update(float deltaTime) +{ + // Call the Update method of LuaManager + m_LuaManager.onUpdate(deltaTime); +} diff --git a/src/Componenets/ScriptComponent.h b/src/Componenets/ScriptComponent.h new file mode 100644 index 0000000..e80fb27 --- /dev/null +++ b/src/Componenets/ScriptComponent.h @@ -0,0 +1,42 @@ +// ScriptComponent.hpp + +#pragma once + +#include "Component.h" +#include +#include +#include "Windows/LoggerWindow.h" +#include "Engine/LuaAPI.h" // Include the LuaManager class + +class ScriptComponent : public Component +{ +public: + ScriptComponent(); + virtual ~ScriptComponent(); + + std::string ScriptPath; // Path to the Lua script + + + // Component interface implementation + virtual const std::string& GetName() const override; + static const std::string& GetStaticName(); + + virtual YAML::Node Serialize() override; + virtual void Deserialize(const YAML::Node& node) override; + + // Script management methods + bool Initialize(); + void Update(float deltaTime); + + +private: + LuaManager m_LuaManager; // Instance of LuaManager + std::string m_LastErrorMessage; // To prevent duplicate error logs + + // Disallow copying + ScriptComponent(const ScriptComponent&) = delete; + ScriptComponent& operator=(const ScriptComponent&) = delete; + + static const std::string name; + +}; diff --git a/src/Engine.cpp b/src/Engine.cpp index fdac944..8ff7669 100644 --- a/src/Engine.cpp +++ b/src/Engine.cpp @@ -11,8 +11,6 @@ #include #include - - // Dear ImGui #include "imgui.h" #include "imgui_impl_glfw.h" @@ -26,7 +24,7 @@ #include "Engine/ThemeManager.h" #include "Engine/SceneManager.h" - +#include "Engine/LuaAPI.h" // #define YAML_CPP_STATIC_DEFINE #include @@ -108,16 +106,20 @@ bool MyEngine::Init(int width, int height, const std::string &title) m_InspectorWindow = std::make_unique(); m_SceneWindow = std::make_unique(); + g_LoggerWindow = m_LoggerWindow.get(); + + + // Optionally, call 'onInit' Lua function + // Some initial logs m_LoggerWindow->AddLog("Engine initialized."); m_LoggerWindow->AddLog("Welcome to Tesseract Engine!"); - g_LoggerWindow = m_LoggerWindow.get(); - m_Running = true; m_LastTime = glfwGetTime(); DEBUG_PRINT("[OK] Engine Init "); + return true; } @@ -178,27 +180,23 @@ void MyEngine::Run() g_AssetManager.loadAsset(AssetType::TEXTURE, "assets/textures/sky.png"); - - // Load a model - Model* modelPtr = g_AssetManager.loadAsset(AssetType::MODEL, "assets/models/LowPolyFiatUNO.obj"); + Model *modelPtr = g_AssetManager.loadAsset(AssetType::MODEL, "assets/models/LowPolyFiatUNO.obj"); if (modelPtr == nullptr) { DEBUG_PRINT("Failed to load model."); } else { - Model* model = reinterpret_cast(modelPtr); - DEBUG_PRINT("Model loaded successfully with %lld vertices and %lld indices.", model->vertices.size(), model->indices.size()); + Model *model = reinterpret_cast(modelPtr); + DEBUG_PRINT("Model loaded successfully with %lld vertices and %lld indices.", model->vertices.size(), model->indices.size()); } + Model *modelPtr4 = g_AssetManager.loadAsset(AssetType::MODEL, "assets/models/shopping-cart.obj"); - Model* modelPtr4 = g_AssetManager.loadAsset(AssetType::MODEL, "assets/models/shopping-cart.obj"); - - Model* model4 = reinterpret_cast(modelPtr4); - - DEBUG_PRINT("Model loaded successfully with %lld vertices and %lld indices.", model4->vertices.size(), model4->indices.size()); + Model *model4 = reinterpret_cast(modelPtr4); + DEBUG_PRINT("Model loaded successfully with %lld vertices and %lld indices.", model4->vertices.size(), model4->indices.size()); g_GameObjects.push_back(newGameObject); DEBUG_PRINT("Put componenent into Global Componenets Subsystem"); @@ -212,19 +210,29 @@ void MyEngine::Run() while (!glfwWindowShouldClose(m_Window) && m_Running) { - // Poll + // Poll events glfwPollEvents(); - // Calculate FPS + // Calculate current time double current_time = glfwGetTime(); - double delta = current_time - m_LastTime; + + // Calculate per-frame delta time + double frame_delta = current_time - m_LastFrameTime; + m_LastFrameTime = current_time; + + // Accumulate time for FPS calculation + m_TimeAccumulator += frame_delta; m_FrameCount++; - if (delta >= 0.1) + + // Update FPS every 0.1 seconds + if (m_TimeAccumulator >= 0.1) { - m_Fps = (float)(m_FrameCount / delta); - m_Ms = 100.0f / m_Fps; + m_Fps = static_cast(m_FrameCount / m_TimeAccumulator); + m_Ms = 100.0f / m_Fps; // Assuming m_Ms represents milliseconds per frame + + // Reset counters m_FrameCount = 0; - m_LastTime = current_time; + m_TimeAccumulator = 0.0; } // Start new frame @@ -235,7 +243,23 @@ void MyEngine::Run() m_InspectorWindow->Show(); - // Show our windows + + if (1) { + for (auto& Gameobject : g_GameObjects) { + + // Handle Componenets That require Updates + + std::shared_ptr script = Gameobject->GetComponent(); + if (script){ // Stupid Null Checks + script->Update(frame_delta); + } + + + } + } + + // Pass per-frame delta time to Lua + m_RenderWindow->Show(); // The spinning triangle as ImGui::Image m_PerformanceWindow->Show(m_Fps, m_Ms); // FPS & ms @@ -245,12 +269,12 @@ void MyEngine::Run() m_SceneWindow->Show(); // After rendering - m_PerformanceWindow->UpdatePerformanceStats(-1, g_GPU_Triangles_drawn_to_screen); // End frame EndFrame(); } + DEBUG_PRINT("[OK] Engine Run "); } @@ -350,15 +374,12 @@ void MyEngine::ShowDockSpace() { m_LoggerWindow->AddLog("Saveing Scene", ImVec4(0.3f, 1.0f, 0.3f, 1.0f)); g_SceneManager.SaveScene(g_GameObjects, "./scenes/Default.scene"); - } if (ImGui::MenuItem("Load")) { m_LoggerWindow->AddLog("Loading Scene", ImVec4(0.3f, 1.0f, 0.3f, 1.0f)); g_SceneManager.LoadScene(g_GameObjects, "./scenes/Default.scene"); - - } ImGui::EndMenu(); } diff --git a/src/Engine.h b/src/Engine.h index 02956b4..11b4504 100644 --- a/src/Engine.h +++ b/src/Engine.h @@ -10,14 +10,12 @@ #include "Windows/InspectorWindow.h" #include "Windows/SceneWindow.h" - #include "Componenets/GameObject.h" #include "Componenets/Mesh.h" #include "Componenets/Transform.h" #include "TestModel.h" - - +#include "Engine/LuaAPI.h" #include "gcml.h" @@ -28,9 +26,7 @@ struct GLFWwindow; class MyEngine { public: - - - bool Init(int width, int height, const std::string& title); + bool Init(int width, int height, const std::string &title); void Run(); void Cleanup(); @@ -42,23 +38,22 @@ private: private: - - - GLFWwindow* m_Window = nullptr; + GLFWwindow *m_Window = nullptr; bool m_Running = false; // Windows - std::unique_ptr m_RenderWindow; - std::unique_ptr m_PerformanceWindow; - std::unique_ptr m_LoggerWindow; - std::unique_ptr m_InspectorWindow; - std::unique_ptr m_SceneWindow; - + std::unique_ptr m_RenderWindow; + std::unique_ptr m_PerformanceWindow; + std::unique_ptr m_LoggerWindow; + std::unique_ptr m_InspectorWindow; + std::unique_ptr m_SceneWindow; + double m_LastFrameTime = 0.0; // Initialize with the current time + double m_TimeAccumulator = 0.0; // For FPS calculation float m_Fps = 0.0f; - float m_Ms = 0.0f; + float m_Ms = 0.0f; double m_LastTime = 0.0; - int m_FrameCount = 0; + int m_FrameCount = 0; }; diff --git a/src/Engine/AssetManager.cpp b/src/Engine/AssetManager.cpp index da95b31..49cd2e6 100644 --- a/src/Engine/AssetManager.cpp +++ b/src/Engine/AssetManager.cpp @@ -53,6 +53,7 @@ void AssetManager::DebugAssetMap() AssetManager::AssetVariant AssetManager::loadAssetFromDisk(AssetType type, const std::string &path) { //DebugAssetMap(); + LoadedAssets = m_AssetMap.size(); switch (type) { case AssetType::TEXTURE: diff --git a/src/Engine/LuaAPI.cpp b/src/Engine/LuaAPI.cpp new file mode 100644 index 0000000..56ec5db --- /dev/null +++ b/src/Engine/LuaAPI.cpp @@ -0,0 +1,232 @@ +// LuaManager.cpp + +#include "LuaAPI.h" +#include "LuaMacros.h" +#include "imgui.h" +#include + +#include "gcml.h" + +#include "Windows/LoggerWindow.h" + + +extern LoggerWindow *g_LoggerWindow; + + +int lua_log_message(lua_State *L); + + + + +LuaManager::LuaManager() : L(nullptr) {} + +LuaManager::~LuaManager() +{ + if (L) + { + lua_close(L); + } +} + +bool LuaManager::init(const std::string &scriptPath) +{ + // Create a new Lua state + L = luaL_newstate(); + if (L == nullptr) + { + std::cerr << "Failed to create Lua state.\n"; + return false; + } + + // Open Lua standard libraries + luaL_openlibs(L); + + // Create the Engine table + CREATE_LUA_TABLE(L, Engine); + + // Bind the Log function to the Engine table + BIND_LUA_FUNCTION(L, Engine, "Log", lua_log_message); + + // Load and execute the Lua script + if (luaL_dofile(L, scriptPath.c_str()) != LUA_OK) + { + std::cerr << "Error running " << scriptPath << ": " << lua_tostring(L, -1) << "\n"; + lua_close(L); + L = nullptr; + return false; + } + + + return true; +} + +bool LuaManager::callLuaFunction(const std::string &funcName) +{ + lua_getglobal(L, funcName.c_str()); + if (!lua_isfunction(L, -1)) + { + std::cerr << "'" << funcName << "' is not a function.\n"; + lua_pop(L, 1); // Remove non-function value + return false; + } + + // Call the function with 0 arguments and 0 return values + if (lua_pcall(L, 0, 0, 0) != LUA_OK) + { + std::cerr << "Error calling '" << funcName << "': " << lua_tostring(L, -1) << "\n"; + lua_pop(L, 1); // Remove error message + return false; + } + + return true; +} + +bool LuaManager::onUpdate(float deltaTime) +{ + + // Push the 'OnUpdate' function onto the stack + lua_getglobal(L, "OnUpdate"); // Ensure correct case + if (!lua_isfunction(L, -1)) + { + std::cerr << "'OnUpdate' is not a function.\n"; + lua_pop(L, 1); // Remove non-function value + return false; + } + + // Push the deltaTime argument + lua_pushnumber(L, deltaTime); + + // Call the function with 1 argument and 0 return values + if (lua_pcall(L, 1, 0, 0) != LUA_OK) + { + // Retrieve the error message from Lua + const char* luaError = lua_tostring(L, -1); + if (luaError) + { + std::string errorMsg(luaError); + + // Check if this error message has already been logged + if (errorMsg != m_LastErrorMessage) + { + // Log the error to the in-game terminal in red + if (g_LoggerWindow) + { + g_LoggerWindow->AddLog(errorMsg.c_str(), ImVec4(1.0f, 0.0f, 0.0f, 1.0f)); + } + else + { + std::cerr << "LoggerWindow is not initialized.\n"; + } + + // Update the last error message + m_LastErrorMessage = errorMsg; + } + + // Optionally, print to std::cerr once if LoggerWindow is unavailable + if (!g_LoggerWindow) + { + std::cerr << "Error calling 'OnUpdate': " << luaError << "\n"; + } + } + else + { + std::cerr << "Unknown error calling 'OnUpdate'.\n"; + } + + + lua_pop(L, 1); // Remove error message + return false; + } + else + { + // Reset the last error message if the call was successful + m_LastErrorMessage.clear(); + } + return true; +} + +bool LuaManager::onDrawGui() +{ + return callLuaFunction("onDrawGui"); +} + +bool LuaManager::callFunction(const std::string &funcName, int args, int returns) +{ + lua_getglobal(L, funcName.c_str()); + if (!lua_isfunction(L, -1)) + { + std::cerr << "'" << funcName << "' is not a function.\n"; + lua_pop(L, 1); // Remove non-function value + return false; + } + + // For simplicity, this example doesn't handle arguments and return values. + // You can extend this method to push arguments and retrieve returns as needed. + + if (lua_pcall(L, args, returns, 0) != LUA_OK) + { + std::cerr << "Error calling '" << funcName << "': " << lua_tostring(L, -1) << "\n"; + lua_pop(L, 1); // Remove error message + return false; + } + + return true; +} + +// Binding function to log messages from Lua +int lua_log_message(lua_State *L) +{ + // Check and retrieve the message string + if (!lua_isstring(L, 1)) + { + lua_pushstring(L, "Incorrect argument to 'log_message'. Expected string as first argument."); + lua_error(L); + return 0; // Never reached, lua_error long jumps + } + const char *message = lua_tostring(L, 1); + + // Initialize default color + ImVec4 color(1.0f, 1.0f, 1.0f, 1.0f); // Default white color + + // Check if a second argument (color) is provided + if (lua_gettop(L) >= 2) + { + if (lua_istable(L, 2)) + { + // Retrieve color components from the table + lua_pushnumber(L, 1); // Push key 1 (r) + lua_gettable(L, 2); + float r = lua_isnumber(L, -1) ? lua_tonumber(L, -1) : 1.0f; + lua_pop(L, 1); + + lua_pushnumber(L, 2); // Push key 2 (g) + lua_gettable(L, 2); + float g = lua_isnumber(L, -1) ? lua_tonumber(L, -1) : 1.0f; + lua_pop(L, 1); + + lua_pushnumber(L, 3); // Push key 3 (b) + lua_gettable(L, 2); + float b = lua_isnumber(L, -1) ? lua_tonumber(L, -1) : 1.0f; + lua_pop(L, 1); + + lua_pushnumber(L, 4); // Push key 4 (a) + lua_gettable(L, 2); + float a = lua_isnumber(L, -1) ? lua_tonumber(L, -1) : 1.0f; + lua_pop(L, 1); + + color = ImVec4(r, g, b, a); + } + else + { + lua_pushstring(L, "Incorrect argument to 'log_message'. Expected table for color."); + lua_error(L); + return 0; + } + } + + // Ensure LoggerWindow is valid + + g_LoggerWindow->AddLog(message, color); + + return 0; // Number of return values +} diff --git a/src/Engine/LuaAPI.h b/src/Engine/LuaAPI.h new file mode 100644 index 0000000..f332b3e --- /dev/null +++ b/src/Engine/LuaAPI.h @@ -0,0 +1,32 @@ +#pragma once + +#include "lua.hpp" +#include + +class LuaManager { +public: + LuaManager(); + ~LuaManager(); + + // Initialize the Lua state and load the script + bool init(const std::string& scriptPath); + + // Call the 'onUpdate' function in Lua + bool onUpdate(float deltaTime); + + // Call the 'onDrawGui' function in Lua + bool onDrawGui(); + + // Optionally, call other Lua functions as needed + bool callFunction(const std::string& funcName, int args = 0, int returns = 0); + +private: + lua_State* L; + std::string m_LastErrorMessage; // Stores the last error message + + + // Helper function to call a Lua function with no arguments and no return values + + bool callLuaFunction(const std::string& funcName); +}; + diff --git a/src/Engine/LuaMacros.h b/src/Engine/LuaMacros.h new file mode 100644 index 0000000..8c6a720 --- /dev/null +++ b/src/Engine/LuaMacros.h @@ -0,0 +1,95 @@ +// LuaMacros.h + +#pragma once + +#include "lua.hpp" + +// Macro to create a Lua table with a specified name +#define CREATE_LUA_TABLE(L, tableName) \ + lua_newtable(L); \ + int tableName##_index = lua_gettop(L); \ + lua_setglobal(L, #tableName); \ + lua_getglobal(L, #tableName); \ + tableName##_index = lua_gettop(L); + +// Macro to bind a C++ function to a Lua table +#define BIND_LUA_FUNCTION(L, tableName, funcName, cFunc) \ + lua_pushcfunction(L, cFunc); \ + lua_setfield(L, tableName##_index, funcName); + +// Macro to define and bind a Lua function within a table +#define DEFINE_AND_BIND_LUA_FUNCTION(L, tableName, funcName, cFunc) \ + lua_pushcfunction(L, cFunc); \ + lua_setfield(L, tableName##_index, funcName); + +// Macro to register multiple functions to a Lua table +#define REGISTER_LUA_FUNCTIONS(L, tableName, ...) \ + do { \ + const char* funcs[] = {__VA_ARGS__}; \ + for (const char* func : funcs) { \ + /* Assume corresponding C function has prefix lua_ and tableName_ */ \ + std::string cFuncName = std::string("lua_") + tableName + "_" + func; \ + lua_pushcfunction(L, (lua_CFunction)(&cFuncName[0])); /* Needs appropriate mapping */ \ + lua_setfield(L, tableName##_index, func); \ + } \ + } while(0) + + +// Macro to get an integer from Lua +#define GET_LUA_INT(L, index, varName) \ + int varName = 0; \ + if (lua_isinteger(L, index)) { \ + varName = static_cast(lua_tointeger(L, index)); \ + } else { \ + std::cerr << "Expected integer at argument " << index << "\n"; \ + } + +// Macro to get a float from Lua +#define GET_LUA_FLOAT(L, index, varName) \ + float varName = 0.0f; \ + if (lua_isnumber(L, index)) { \ + varName = static_cast(lua_tonumber(L, index)); \ + } else { \ + std::cerr << "Expected number at argument " << index << "\n"; \ + } + +// Macro to get a string from Lua +#define GET_LUA_STRING(L, index, varName) \ + std::string varName; \ + if (lua_isstring(L, index)) { \ + varName = lua_tostring(L, index); \ + } else { \ + std::cerr << "Expected string at argument " << index << "\n"; \ + } + +// Macro to get a boolean from Lua +#define GET_LUA_BOOL(L, index, varName) \ + bool varName = false; \ + if (lua_isboolean(L, index)) { \ + varName = lua_toboolean(L, index); \ + } else { \ + std::cerr << "Expected boolean at argument " << index << "\n"; \ + } + +// Macro to return a value to Lua +#define RETURN_LUA_VALUE(L, value) \ + lua_push##value(L, value); \ + return 1; + +// Examples for returning integer, float, string, boolean +#define RETURN_LUA_INT(L, value) RETURN_LUA_VALUE(L, integer) +#define RETURN_LUA_FLOAT(L, value) RETURN_LUA_VALUE(L, number) +#define RETURN_LUA_STRING(L, value) RETURN_LUA_VALUE(L, string) +#define RETURN_LUA_BOOL(L, value) RETURN_LUA_VALUE(L, boolean) + + + +#define RETURN_LUA_VALUE(L, value) \ + lua_push##value(L, value); \ + return 1; + +// Specific return macros +#define RETURN_LUA_INT(L, value) RETURN_LUA_VALUE(L, integer) +#define RETURN_LUA_FLOAT(L, value) RETURN_LUA_VALUE(L, number) +#define RETURN_LUA_STRING(L, value) RETURN_LUA_VALUE(L, string) +#define RETURN_LUA_BOOL(L, value) RETURN_LUA_VALUE(L, boolean) \ No newline at end of file diff --git a/src/Windows/InspectorWindow.cpp b/src/Windows/InspectorWindow.cpp index 398912b..4bf3b5c 100644 --- a/src/Windows/InspectorWindow.cpp +++ b/src/Windows/InspectorWindow.cpp @@ -74,13 +74,15 @@ void InspectorWindow::Show() // =========================== // 1) TRANSFORM // =========================== - + std::shared_ptr transform = g_SelectedObject->GetComponent(); std::shared_ptr mesh = g_SelectedObject->GetComponent(); + std::shared_ptr script = g_SelectedObject->GetComponent(); + // Color the Transform header - if (transform && g_SelectedObject) //! Funny: I did not put a null check here and it broke everything. + if (transform && g_SelectedObject) // Funny: I did not put a null check here and it broke everything. { ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 1.0f, 1.0f)); @@ -291,7 +293,7 @@ void InspectorWindow::Show() } } - if (mesh && g_SelectedObject) //! Funny: I did not put a null check here and it broke everything. + if (mesh && g_SelectedObject) { // Transform* transform = &g_SelectedObject->transform; @@ -339,6 +341,35 @@ void InspectorWindow::Show() } ImGui::Spacing(); + if (script && g_SelectedObject) + { + + // Transform* transform = &g_SelectedObject->transform; + + ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0f, 1.0f, 1.0f, 1.0f)); + bool scriptOpen = ImGui::CollapsingHeader("Script##Main", ImGuiTreeNodeFlags_DefaultOpen); + ImGui::PopStyleColor(); + + + // printf("%p\n", &transform); + if (scriptOpen) + { + // Define a maximum buffer size + const size_t BUFFER_SIZE = 256; + // Allocate a buffer and initialize it with the current string + char buffer[BUFFER_SIZE]; + strncpy(buffer, script->ScriptPath.c_str(), BUFFER_SIZE - 1); + buffer[BUFFER_SIZE - 1] = '\0'; // Ensure null-termination + // Render the InputText widget + if (ImGui::InputText(script->ScriptPath.c_str(), buffer, BUFFER_SIZE)) + { + // Update the string if user made changes + script->ScriptPath = buffer; + } + + } + } + // =========================== // 2) SCRIPT // =========================== diff --git a/src/Windows/InspectorWindow.h b/src/Windows/InspectorWindow.h index 5212c47..fc5b1e9 100644 --- a/src/Windows/InspectorWindow.h +++ b/src/Windows/InspectorWindow.h @@ -7,6 +7,8 @@ #include "Componenets/GameObject.h" #include "Componenets/Mesh.h" #include "Componenets/Transform.h" +#include "Componenets/ScriptComponent.h" + // Example struct for a Script component diff --git a/src/Windows/RenderWindow.cpp b/src/Windows/RenderWindow.cpp index 54b22b6..d9fa448 100644 --- a/src/Windows/RenderWindow.cpp +++ b/src/Windows/RenderWindow.cpp @@ -335,9 +335,6 @@ void RenderWindow::RenderSceneToFBO() std::shared_ptr mesh = obj->GetComponent(); - if (!transform) { - DEBUG_PRINT("Could not find Transform Component"); - } if (transform && mesh) @@ -345,7 +342,7 @@ void RenderWindow::RenderSceneToFBO() // Translate - g_GPU_Triangles_drawn_to_screen = static_cast(mesh->indexCount); + g_GPU_Triangles_drawn_to_screen += static_cast(mesh->indexCount); model = glm::translate(model, transform->position); diff --git a/vendor/lua/lauxlib.h b/vendor/lua/lauxlib.h new file mode 100644 index 0000000..59fef6a --- /dev/null +++ b/vendor/lua/lauxlib.h @@ -0,0 +1,276 @@ +/* +** $Id: lauxlib.h $ +** Auxiliary functions for building Lua libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lauxlib_h +#define lauxlib_h + + +#include +#include + +#include "lua.h" + + +/* global table */ +#define LUA_GNAME "_G" + + +typedef struct luaL_Buffer luaL_Buffer; + + +/* extra error code for 'luaL_loadfilex' */ +#define LUA_ERRFILE (LUA_ERRERR+1) + + +/* key, in the registry, for table of loaded modules */ +#define LUA_LOADED_TABLE "_LOADED" + + +/* key, in the registry, for table of preloaded loaders */ +#define LUA_PRELOAD_TABLE "_PRELOAD" + + +typedef struct luaL_Reg { + const char *name; + lua_CFunction func; +} luaL_Reg; + + +#define LUAL_NUMSIZES (sizeof(lua_Integer)*16 + sizeof(lua_Number)) + +LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver, size_t sz); +#define luaL_checkversion(L) \ + luaL_checkversion_(L, LUA_VERSION_NUM, LUAL_NUMSIZES) + +LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e); +LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e); +LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len); +LUALIB_API int (luaL_argerror) (lua_State *L, int arg, const char *extramsg); +LUALIB_API int (luaL_typeerror) (lua_State *L, int arg, const char *tname); +LUALIB_API const char *(luaL_checklstring) (lua_State *L, int arg, + size_t *l); +LUALIB_API const char *(luaL_optlstring) (lua_State *L, int arg, + const char *def, size_t *l); +LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int arg); +LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int arg, lua_Number def); + +LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int arg); +LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int arg, + lua_Integer def); + +LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg); +LUALIB_API void (luaL_checktype) (lua_State *L, int arg, int t); +LUALIB_API void (luaL_checkany) (lua_State *L, int arg); + +LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname); +LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname); +LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname); +LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname); + +LUALIB_API void (luaL_where) (lua_State *L, int lvl); +LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...); + +LUALIB_API int (luaL_checkoption) (lua_State *L, int arg, const char *def, + const char *const lst[]); + +LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname); +LUALIB_API int (luaL_execresult) (lua_State *L, int stat); + + +/* predefined references */ +#define LUA_NOREF (-2) +#define LUA_REFNIL (-1) + +LUALIB_API int (luaL_ref) (lua_State *L, int t); +LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref); + +LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename, + const char *mode); + +#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL) + +LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz, + const char *name, const char *mode); +LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); + +LUALIB_API lua_State *(luaL_newstate) (void); + +LUALIB_API lua_Integer (luaL_len) (lua_State *L, int idx); + +LUALIB_API void luaL_addgsub (luaL_Buffer *b, const char *s, + const char *p, const char *r); +LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, + const char *p, const char *r); + +LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup); + +LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname); + +LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1, + const char *msg, int level); + +LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname, + lua_CFunction openf, int glb); + +/* +** =============================================================== +** some useful macros +** =============================================================== +*/ + + +#define luaL_newlibtable(L,l) \ + lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1) + +#define luaL_newlib(L,l) \ + (luaL_checkversion(L), luaL_newlibtable(L,l), luaL_setfuncs(L,l,0)) + +#define luaL_argcheck(L, cond,arg,extramsg) \ + ((void)((cond) || luaL_argerror(L, (arg), (extramsg)))) + +#define luaL_argexpected(L,cond,arg,tname) \ + ((void)((cond) || luaL_typeerror(L, (arg), (tname)))) + +#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) +#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) + +#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i))) + +#define luaL_dofile(L, fn) \ + (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0)) + +#define luaL_dostring(L, s) \ + (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0)) + +#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n))) + +#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n))) + +#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL) + + +/* push the value used to represent failure/error */ +#define luaL_pushfail(L) lua_pushnil(L) + + +/* +** {====================================================== +** Generic Buffer manipulation +** ======================================================= +*/ + +struct luaL_Buffer { + char *b; /* buffer address */ + size_t size; /* buffer size */ + size_t n; /* number of characters in buffer */ + lua_State *L; + union { + LUAI_MAXALIGN; /* ensure maximum alignment for buffer */ + char b[LUAL_BUFFERSIZE]; /* initial buffer */ + } init; +}; + + +#define luaL_bufflen(bf) ((bf)->n) +#define luaL_buffaddr(bf) ((bf)->b) + + +#define luaL_addchar(B,c) \ + ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \ + ((B)->b[(B)->n++] = (c))) + +#define luaL_addsize(B,s) ((B)->n += (s)) + +#define luaL_buffsub(B,s) ((B)->n -= (s)) + +LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); +LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz); +LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l); +LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s); +LUALIB_API void (luaL_addvalue) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresult) (luaL_Buffer *B); +LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz); +LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz); + +#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE) + +/* }====================================================== */ + + + +/* +** {====================================================== +** File handles for IO library +** ======================================================= +*/ + +/* +** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and +** initial structure 'luaL_Stream' (it may contain other fields +** after that initial structure). +*/ + +#define LUA_FILEHANDLE "FILE*" + + +typedef struct luaL_Stream { + FILE *f; /* stream (NULL for incompletely created streams) */ + lua_CFunction closef; /* to close stream (NULL for closed streams) */ +} luaL_Stream; + +/* }====================================================== */ + +/* +** {================================================================== +** "Abstraction Layer" for basic report of messages and errors +** =================================================================== +*/ + +/* print a string */ +#if !defined(lua_writestring) +#define lua_writestring(s,l) fwrite((s), sizeof(char), (l), stdout) +#endif + +/* print a newline and flush the output */ +#if !defined(lua_writeline) +#define lua_writeline() (lua_writestring("\n", 1), fflush(stdout)) +#endif + +/* print an error message */ +#if !defined(lua_writestringerror) +#define lua_writestringerror(s,p) \ + (fprintf(stderr, (s), (p)), fflush(stderr)) +#endif + +/* }================================================================== */ + + +/* +** {============================================================ +** Compatibility with deprecated conversions +** ============================================================= +*/ +#if defined(LUA_COMPAT_APIINTCASTS) + +#define luaL_checkunsigned(L,a) ((lua_Unsigned)luaL_checkinteger(L,a)) +#define luaL_optunsigned(L,a,d) \ + ((lua_Unsigned)luaL_optinteger(L,a,(lua_Integer)(d))) + +#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n))) +#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d))) + +#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n))) +#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d))) + +#endif +/* }============================================================ */ + + + +#endif + + diff --git a/vendor/lua/lua.h b/vendor/lua/lua.h new file mode 100644 index 0000000..c9d64d7 --- /dev/null +++ b/vendor/lua/lua.h @@ -0,0 +1,517 @@ +/* +** $Id: lua.h $ +** Lua - A Scripting Language +** Lua.org, PUC-Rio, Brazil (http://www.lua.org) +** See Copyright Notice at the end of this file +*/ + + +#ifndef lua_h +#define lua_h + +#include +#include + + +#include "luaconf.h" + + +#define LUA_VERSION_MAJOR "5" +#define LUA_VERSION_MINOR "4" +#define LUA_VERSION_RELEASE "2" + +#define LUA_VERSION_NUM 504 +#define LUA_VERSION_RELEASE_NUM (LUA_VERSION_NUM * 100 + 0) + +#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE +#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2020 Lua.org, PUC-Rio" +#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes" + + +/* mark for precompiled code ('Lua') */ +#define LUA_SIGNATURE "\x1bLua" + +/* option for multiple returns in 'lua_pcall' and 'lua_call' */ +#define LUA_MULTRET (-1) + + +/* +** Pseudo-indices +** (-LUAI_MAXSTACK is the minimum valid index; we keep some free empty +** space after that to help overflow detection) +*/ +#define LUA_REGISTRYINDEX (-LUAI_MAXSTACK - 1000) +#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i)) + + +/* thread status */ +#define LUA_OK 0 +#define LUA_YIELD 1 +#define LUA_ERRRUN 2 +#define LUA_ERRSYNTAX 3 +#define LUA_ERRMEM 4 +#define LUA_ERRERR 5 + + +typedef struct lua_State lua_State; + + +/* +** basic types +*/ +#define LUA_TNONE (-1) + +#define LUA_TNIL 0 +#define LUA_TBOOLEAN 1 +#define LUA_TLIGHTUSERDATA 2 +#define LUA_TNUMBER 3 +#define LUA_TSTRING 4 +#define LUA_TTABLE 5 +#define LUA_TFUNCTION 6 +#define LUA_TUSERDATA 7 +#define LUA_TTHREAD 8 + +#define LUA_NUMTYPES 9 + + + +/* minimum Lua stack available to a C function */ +#define LUA_MINSTACK 20 + + +/* predefined values in the registry */ +#define LUA_RIDX_MAINTHREAD 1 +#define LUA_RIDX_GLOBALS 2 +#define LUA_RIDX_LAST LUA_RIDX_GLOBALS + + +/* type of numbers in Lua */ +typedef LUA_NUMBER lua_Number; + + +/* type for integer functions */ +typedef LUA_INTEGER lua_Integer; + +/* unsigned integer type */ +typedef LUA_UNSIGNED lua_Unsigned; + +/* type for continuation-function contexts */ +typedef LUA_KCONTEXT lua_KContext; + + +/* +** Type for C functions registered with Lua +*/ +typedef int (*lua_CFunction) (lua_State *L); + +/* +** Type for continuation functions +*/ +typedef int (*lua_KFunction) (lua_State *L, int status, lua_KContext ctx); + + +/* +** Type for functions that read/write blocks when loading/dumping Lua chunks +*/ +typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz); + +typedef int (*lua_Writer) (lua_State *L, const void *p, size_t sz, void *ud); + + +/* +** Type for memory-allocation functions +*/ +typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); + + +/* +** Type for warning functions +*/ +typedef void (*lua_WarnFunction) (void *ud, const char *msg, int tocont); + + + + +/* +** generic extra include file +*/ +#if defined(LUA_USER_H) +#include LUA_USER_H +#endif + + +/* +** RCS ident string +*/ +extern const char lua_ident[]; + + +/* +** state manipulation +*/ +LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud); +LUA_API void (lua_close) (lua_State *L); +LUA_API lua_State *(lua_newthread) (lua_State *L); +LUA_API int (lua_resetthread) (lua_State *L); + +LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf); + + +LUA_API lua_Number (lua_version) (lua_State *L); + + +/* +** basic stack manipulation +*/ +LUA_API int (lua_absindex) (lua_State *L, int idx); +LUA_API int (lua_gettop) (lua_State *L); +LUA_API void (lua_settop) (lua_State *L, int idx); +LUA_API void (lua_pushvalue) (lua_State *L, int idx); +LUA_API void (lua_rotate) (lua_State *L, int idx, int n); +LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx); +LUA_API int (lua_checkstack) (lua_State *L, int n); + +LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n); + + +/* +** access functions (stack -> C) +*/ + +LUA_API int (lua_isnumber) (lua_State *L, int idx); +LUA_API int (lua_isstring) (lua_State *L, int idx); +LUA_API int (lua_iscfunction) (lua_State *L, int idx); +LUA_API int (lua_isinteger) (lua_State *L, int idx); +LUA_API int (lua_isuserdata) (lua_State *L, int idx); +LUA_API int (lua_type) (lua_State *L, int idx); +LUA_API const char *(lua_typename) (lua_State *L, int tp); + +LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum); +LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum); +LUA_API int (lua_toboolean) (lua_State *L, int idx); +LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len); +LUA_API lua_Unsigned (lua_rawlen) (lua_State *L, int idx); +LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx); +LUA_API void *(lua_touserdata) (lua_State *L, int idx); +LUA_API lua_State *(lua_tothread) (lua_State *L, int idx); +LUA_API const void *(lua_topointer) (lua_State *L, int idx); + + +/* +** Comparison and arithmetic functions +*/ + +#define LUA_OPADD 0 /* ORDER TM, ORDER OP */ +#define LUA_OPSUB 1 +#define LUA_OPMUL 2 +#define LUA_OPMOD 3 +#define LUA_OPPOW 4 +#define LUA_OPDIV 5 +#define LUA_OPIDIV 6 +#define LUA_OPBAND 7 +#define LUA_OPBOR 8 +#define LUA_OPBXOR 9 +#define LUA_OPSHL 10 +#define LUA_OPSHR 11 +#define LUA_OPUNM 12 +#define LUA_OPBNOT 13 + +LUA_API void (lua_arith) (lua_State *L, int op); + +#define LUA_OPEQ 0 +#define LUA_OPLT 1 +#define LUA_OPLE 2 + +LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); +LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op); + + +/* +** push functions (C -> stack) +*/ +LUA_API void (lua_pushnil) (lua_State *L); +LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n); +LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n); +LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t len); +LUA_API const char *(lua_pushstring) (lua_State *L, const char *s); +LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt, + va_list argp); +LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...); +LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n); +LUA_API void (lua_pushboolean) (lua_State *L, int b); +LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p); +LUA_API int (lua_pushthread) (lua_State *L); + + +/* +** get functions (Lua -> stack) +*/ +LUA_API int (lua_getglobal) (lua_State *L, const char *name); +LUA_API int (lua_gettable) (lua_State *L, int idx); +LUA_API int (lua_getfield) (lua_State *L, int idx, const char *k); +LUA_API int (lua_geti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawget) (lua_State *L, int idx); +LUA_API int (lua_rawgeti) (lua_State *L, int idx, lua_Integer n); +LUA_API int (lua_rawgetp) (lua_State *L, int idx, const void *p); + +LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec); +LUA_API void *(lua_newuserdatauv) (lua_State *L, size_t sz, int nuvalue); +LUA_API int (lua_getmetatable) (lua_State *L, int objindex); +LUA_API int (lua_getiuservalue) (lua_State *L, int idx, int n); + + +/* +** set functions (stack -> Lua) +*/ +LUA_API void (lua_setglobal) (lua_State *L, const char *name); +LUA_API void (lua_settable) (lua_State *L, int idx); +LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k); +LUA_API void (lua_seti) (lua_State *L, int idx, lua_Integer n); +LUA_API void (lua_rawset) (lua_State *L, int idx); +LUA_API void (lua_rawseti) (lua_State *L, int idx, lua_Integer n); +LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p); +LUA_API int (lua_setmetatable) (lua_State *L, int objindex); +LUA_API int (lua_setiuservalue) (lua_State *L, int idx, int n); + + +/* +** 'load' and 'call' functions (load and run Lua code) +*/ +LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, + lua_KContext ctx, lua_KFunction k); +#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL) + +LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc, + lua_KContext ctx, lua_KFunction k); +#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL) + +LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, + const char *chunkname, const char *mode); + +LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data, int strip); + + +/* +** coroutine functions +*/ +LUA_API int (lua_yieldk) (lua_State *L, int nresults, lua_KContext ctx, + lua_KFunction k); +LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg, + int *nres); +LUA_API int (lua_status) (lua_State *L); +LUA_API int (lua_isyieldable) (lua_State *L); + +#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL) + + +/* +** Warning-related functions +*/ +LUA_API void (lua_setwarnf) (lua_State *L, lua_WarnFunction f, void *ud); +LUA_API void (lua_warning) (lua_State *L, const char *msg, int tocont); + + +/* +** garbage-collection function and options +*/ + +#define LUA_GCSTOP 0 +#define LUA_GCRESTART 1 +#define LUA_GCCOLLECT 2 +#define LUA_GCCOUNT 3 +#define LUA_GCCOUNTB 4 +#define LUA_GCSTEP 5 +#define LUA_GCSETPAUSE 6 +#define LUA_GCSETSTEPMUL 7 +#define LUA_GCISRUNNING 9 +#define LUA_GCGEN 10 +#define LUA_GCINC 11 + +LUA_API int (lua_gc) (lua_State *L, int what, ...); + + +/* +** miscellaneous functions +*/ + +LUA_API int (lua_error) (lua_State *L); + +LUA_API int (lua_next) (lua_State *L, int idx); + +LUA_API void (lua_concat) (lua_State *L, int n); +LUA_API void (lua_len) (lua_State *L, int idx); + +LUA_API size_t (lua_stringtonumber) (lua_State *L, const char *s); + +LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud); +LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud); + +LUA_API void (lua_toclose) (lua_State *L, int idx); + + +/* +** {============================================================== +** some useful macros +** =============================================================== +*/ + +#define lua_getextraspace(L) ((void *)((char *)(L) - LUA_EXTRASPACE)) + +#define lua_tonumber(L,i) lua_tonumberx(L,(i),NULL) +#define lua_tointeger(L,i) lua_tointegerx(L,(i),NULL) + +#define lua_pop(L,n) lua_settop(L, -(n)-1) + +#define lua_newtable(L) lua_createtable(L, 0, 0) + +#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n))) + +#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0) + +#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION) +#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE) +#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA) +#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL) +#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN) +#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD) +#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE) +#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0) + +#define lua_pushliteral(L, s) lua_pushstring(L, "" s) + +#define lua_pushglobaltable(L) \ + ((void)lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)) + +#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) + + +#define lua_insert(L,idx) lua_rotate(L, (idx), 1) + +#define lua_remove(L,idx) (lua_rotate(L, (idx), -1), lua_pop(L, 1)) + +#define lua_replace(L,idx) (lua_copy(L, -1, (idx)), lua_pop(L, 1)) + +/* }============================================================== */ + + +/* +** {============================================================== +** compatibility macros +** =============================================================== +*/ +#if defined(LUA_COMPAT_APIINTCASTS) + +#define lua_pushunsigned(L,n) lua_pushinteger(L, (lua_Integer)(n)) +#define lua_tounsignedx(L,i,is) ((lua_Unsigned)lua_tointegerx(L,i,is)) +#define lua_tounsigned(L,i) lua_tounsignedx(L,(i),NULL) + +#endif + +#define lua_newuserdata(L,s) lua_newuserdatauv(L,s,1) +#define lua_getuservalue(L,idx) lua_getiuservalue(L,idx,1) +#define lua_setuservalue(L,idx) lua_setiuservalue(L,idx,1) + +#define LUA_NUMTAGS LUA_NUMTYPES + +/* }============================================================== */ + +/* +** {====================================================================== +** Debug API +** ======================================================================= +*/ + + +/* +** Event codes +*/ +#define LUA_HOOKCALL 0 +#define LUA_HOOKRET 1 +#define LUA_HOOKLINE 2 +#define LUA_HOOKCOUNT 3 +#define LUA_HOOKTAILCALL 4 + + +/* +** Event masks +*/ +#define LUA_MASKCALL (1 << LUA_HOOKCALL) +#define LUA_MASKRET (1 << LUA_HOOKRET) +#define LUA_MASKLINE (1 << LUA_HOOKLINE) +#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT) + +typedef struct lua_Debug lua_Debug; /* activation record */ + + +/* Functions to be called by the debugger in specific events */ +typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar); + + +LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar); +LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar); +LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n); +LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n); +LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n); + +LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n); +LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1, + int fidx2, int n2); + +LUA_API void (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count); +LUA_API lua_Hook (lua_gethook) (lua_State *L); +LUA_API int (lua_gethookmask) (lua_State *L); +LUA_API int (lua_gethookcount) (lua_State *L); + +LUA_API int (lua_setcstacklimit) (lua_State *L, unsigned int limit); + +struct lua_Debug { + int event; + const char *name; /* (n) */ + const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */ + const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */ + const char *source; /* (S) */ + size_t srclen; /* (S) */ + int currentline; /* (l) */ + int linedefined; /* (S) */ + int lastlinedefined; /* (S) */ + unsigned char nups; /* (u) number of upvalues */ + unsigned char nparams;/* (u) number of parameters */ + char isvararg; /* (u) */ + char istailcall; /* (t) */ + unsigned short ftransfer; /* (r) index of first value transferred */ + unsigned short ntransfer; /* (r) number of transferred values */ + char short_src[LUA_IDSIZE]; /* (S) */ + /* private part */ + struct CallInfo *i_ci; /* active function */ +}; + +/* }====================================================================== */ + + +/****************************************************************************** +* Copyright (C) 1994-2020 Lua.org, PUC-Rio. +* +* Permission is hereby granted, free of charge, to any person obtaining +* a copy of this software and associated documentation files (the +* "Software"), to deal in the Software without restriction, including +* without limitation the rights to use, copy, modify, merge, publish, +* distribute, sublicense, and/or sell copies of the Software, and to +* permit persons to whom the Software is furnished to do so, subject to +* the following conditions: +* +* The above copyright notice and this permission notice shall be +* included in all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +******************************************************************************/ + + +#endif diff --git a/vendor/lua/lua.hpp b/vendor/lua/lua.hpp new file mode 100644 index 0000000..ec417f5 --- /dev/null +++ b/vendor/lua/lua.hpp @@ -0,0 +1,9 @@ +// lua.hpp +// Lua header files for C++ +// <> not supplied automatically because Lua also compiles as C++ + +extern "C" { +#include "lua.h" +#include "lualib.h" +#include "lauxlib.h" +} diff --git a/vendor/lua/luaconf.h b/vendor/lua/luaconf.h new file mode 100644 index 0000000..3ad294e --- /dev/null +++ b/vendor/lua/luaconf.h @@ -0,0 +1,763 @@ +/* +** $Id: luaconf.h $ +** Configuration file for Lua +** See Copyright Notice in lua.h +*/ + + +#ifndef luaconf_h +#define luaconf_h + +#include +#include + + +/* +** =================================================================== +** General Configuration File for Lua +** +** Some definitions here can be changed externally, through the +** compiler (e.g., with '-D' options). Those are protected by +** '#if !defined' guards. However, several other definitions should +** be changed directly here, either because they affect the Lua +** ABI (by making the changes here, you ensure that all software +** connected to Lua, such as C libraries, will be compiled with the +** same configuration); or because they are seldom changed. +** +** Search for "@@" to find all configurable definitions. +** =================================================================== +*/ + + +/* +** {==================================================================== +** System Configuration: macros to adapt (if needed) Lua to some +** particular platform, for instance restricting it to C89. +** ===================================================================== +*/ + +/* +@@ LUA_USE_C89 controls the use of non-ISO-C89 features. +** Define it if you want Lua to avoid the use of a few C99 features +** or Windows-specific features on Windows. +*/ +/* #define LUA_USE_C89 */ + + +/* +** By default, Lua on Windows use (some) specific Windows features +*/ +#if !defined(LUA_USE_C89) && defined(_WIN32) && !defined(_WIN32_WCE) +#define LUA_USE_WINDOWS /* enable goodies for regular Windows */ +#endif + + +#if defined(LUA_USE_WINDOWS) +#define LUA_DL_DLL /* enable support for DLL */ +#define LUA_USE_C89 /* broadly, Windows is C89 */ +#endif + + +#if defined(LUA_USE_LINUX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ +#endif + + +#if defined(LUA_USE_MACOSX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* MacOS does not need -ldl */ +#endif + + +/* +@@ LUAI_IS32INT is true iff 'int' has (at least) 32 bits. +*/ +#define LUAI_IS32INT ((UINT_MAX >> 30) >= 3) + +/* }================================================================== */ + + + +/* +** {================================================================== +** Configuration for Number types. +** =================================================================== +*/ + +/* +@@ LUA_32BITS enables Lua with 32-bit integers and 32-bit floats. +*/ +/* #define LUA_32BITS */ + + +/* +@@ LUA_C89_NUMBERS ensures that Lua uses the largest types available for +** C89 ('long' and 'double'); Windows always has '__int64', so it does +** not need to use this case. +*/ +#if defined(LUA_USE_C89) && !defined(LUA_USE_WINDOWS) +#define LUA_C89_NUMBERS +#endif + + +/* +@@ LUA_INT_TYPE defines the type for Lua integers. +@@ LUA_FLOAT_TYPE defines the type for Lua floats. +** Lua should work fine with any mix of these options supported +** by your C compiler. The usual configurations are 64-bit integers +** and 'double' (the default), 32-bit integers and 'float' (for +** restricted platforms), and 'long'/'double' (for C compilers not +** compliant with C99, which may not have support for 'long long'). +*/ + +/* predefined options for LUA_INT_TYPE */ +#define LUA_INT_INT 1 +#define LUA_INT_LONG 2 +#define LUA_INT_LONGLONG 3 + +/* predefined options for LUA_FLOAT_TYPE */ +#define LUA_FLOAT_FLOAT 1 +#define LUA_FLOAT_DOUBLE 2 +#define LUA_FLOAT_LONGDOUBLE 3 + +#if defined(LUA_32BITS) /* { */ +/* +** 32-bit integers and 'float' +*/ +#if LUAI_IS32INT /* use 'int' if big enough */ +#define LUA_INT_TYPE LUA_INT_INT +#else /* otherwise use 'long' */ +#define LUA_INT_TYPE LUA_INT_LONG +#endif +#define LUA_FLOAT_TYPE LUA_FLOAT_FLOAT + +#elif defined(LUA_C89_NUMBERS) /* }{ */ +/* +** largest types available for C89 ('long' and 'double') +*/ +#define LUA_INT_TYPE LUA_INT_LONG +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE + +#endif /* } */ + + +/* +** default configuration for 64-bit Lua ('long long' and 'double') +*/ +#if !defined(LUA_INT_TYPE) +#define LUA_INT_TYPE LUA_INT_LONGLONG +#endif + +#if !defined(LUA_FLOAT_TYPE) +#define LUA_FLOAT_TYPE LUA_FLOAT_DOUBLE +#endif + +/* }================================================================== */ + + + +/* +** {================================================================== +** Configuration for Paths. +** =================================================================== +*/ + +/* +** LUA_PATH_SEP is the character that separates templates in a path. +** LUA_PATH_MARK is the string that marks the substitution points in a +** template. +** LUA_EXEC_DIR in a Windows path is replaced by the executable's +** directory. +*/ +#define LUA_PATH_SEP ";" +#define LUA_PATH_MARK "?" +#define LUA_EXEC_DIR "!" + + +/* +@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for +** Lua libraries. +@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for +** C libraries. +** CHANGE them if your machine has a non-conventional directory +** hierarchy or if you want to install your libraries in +** non-conventional directories. +*/ + +#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR +#if defined(_WIN32) /* { */ +/* +** In Windows, any exclamation mark ('!') in the path is replaced by the +** path of the directory of the executable file of the current process. +*/ +#define LUA_LDIR "!\\lua\\" +#define LUA_CDIR "!\\" +#define LUA_SHRDIR "!\\..\\share\\lua\\" LUA_VDIR "\\" + +#if !defined(LUA_PATH_DEFAULT) +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" \ + LUA_SHRDIR"?.lua;" LUA_SHRDIR"?\\init.lua;" \ + ".\\?.lua;" ".\\?\\init.lua" +#endif + +#if !defined(LUA_CPATH_DEFAULT) +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.dll;" \ + LUA_CDIR"..\\lib\\lua\\" LUA_VDIR "\\?.dll;" \ + LUA_CDIR"loadall.dll;" ".\\?.dll;" \ + LUA_CDIR"?54.dll;" ".\\?54.dll" +#endif + +#else /* }{ */ + +#define LUA_ROOT "/usr/local/" +#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR "/" +#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR "/" + +#if !defined(LUA_PATH_DEFAULT) +#define LUA_PATH_DEFAULT \ + LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" \ + "./?.lua;" "./?/init.lua" +#endif + +#if !defined(LUA_CPATH_DEFAULT) +#define LUA_CPATH_DEFAULT \ + LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so;" \ + LUA_CDIR"lib?54.so;" "./lib?54.so" +#endif + +#endif /* } */ + + +/* +@@ LUA_DIRSEP is the directory separator (for submodules). +** CHANGE it if your machine does not use "/" as the directory separator +** and is not Windows. (On Windows Lua automatically uses "\".) +*/ +#if !defined(LUA_DIRSEP) + +#if defined(_WIN32) +#define LUA_DIRSEP "\\" +#else +#define LUA_DIRSEP "/" +#endif + +#endif + +/* }================================================================== */ + + +/* +** {================================================================== +** Marks for exported symbols in the C code +** =================================================================== +*/ + +/* +@@ LUA_API is a mark for all core API functions. +@@ LUALIB_API is a mark for all auxiliary library functions. +@@ LUAMOD_API is a mark for all standard library opening functions. +** CHANGE them if you need to define those functions in some special way. +** For instance, if you want to create one Windows DLL with the core and +** the libraries, you may want to use the following definition (define +** LUA_BUILD_AS_DLL to get it). +*/ +#if defined(LUA_BUILD_AS_DLL) /* { */ + +#if defined(LUA_CORE) || defined(LUA_LIB) /* { */ +#define LUA_API __declspec(dllexport) +#else /* }{ */ +#define LUA_API __declspec(dllimport) +#endif /* } */ + +#else /* }{ */ + +#define LUA_API extern + +#endif /* } */ + + +/* +** More often than not the libs go together with the core. +*/ +#define LUALIB_API LUA_API +#define LUAMOD_API LUA_API + + +/* +@@ LUAI_FUNC is a mark for all extern functions that are not to be +** exported to outside modules. +@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables, +** none of which to be exported to outside modules (LUAI_DDEF for +** definitions and LUAI_DDEC for declarations). +** CHANGE them if you need to mark them in some special way. Elf/gcc +** (versions 3.2 and later) mark them as "hidden" to optimize access +** when Lua is compiled as a shared library. Not all elf targets support +** this attribute. Unfortunately, gcc does not offer a way to check +** whether the target offers that support, and those without support +** give a warning about it. To avoid these warnings, change to the +** default definition. +*/ +#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ + defined(__ELF__) /* { */ +#define LUAI_FUNC __attribute__((visibility("internal"))) extern +#else /* }{ */ +#define LUAI_FUNC extern +#endif /* } */ + +#define LUAI_DDEC(dec) LUAI_FUNC dec +#define LUAI_DDEF /* empty */ + +/* }================================================================== */ + + +/* +** {================================================================== +** Compatibility with previous versions +** =================================================================== +*/ + +/* +@@ LUA_COMPAT_5_3 controls other macros for compatibility with Lua 5.3. +** You can define it to get all options, or change specific options +** to fit your specific needs. +*/ +#if defined(LUA_COMPAT_5_3) /* { */ + +/* +@@ LUA_COMPAT_MATHLIB controls the presence of several deprecated +** functions in the mathematical library. +** (These functions were already officially removed in 5.3; +** nevertheless they are still available here.) +*/ +#define LUA_COMPAT_MATHLIB + +/* +@@ LUA_COMPAT_APIINTCASTS controls the presence of macros for +** manipulating other integer types (lua_pushunsigned, lua_tounsigned, +** luaL_checkint, luaL_checklong, etc.) +** (These macros were also officially removed in 5.3, but they are still +** available here.) +*/ +#define LUA_COMPAT_APIINTCASTS + + +/* +@@ LUA_COMPAT_LT_LE controls the emulation of the '__le' metamethod +** using '__lt'. +*/ +#define LUA_COMPAT_LT_LE + + +/* +@@ The following macros supply trivial compatibility for some +** changes in the API. The macros themselves document how to +** change your code to avoid using them. +** (Once more, these macros were officially removed in 5.3, but they are +** still available here.) +*/ +#define lua_strlen(L,i) lua_rawlen(L, (i)) + +#define lua_objlen(L,i) lua_rawlen(L, (i)) + +#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ) +#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT) + +#endif /* } */ + +/* }================================================================== */ + + + +/* +** {================================================================== +** Configuration for Numbers. +** Change these definitions if no predefined LUA_FLOAT_* / LUA_INT_* +** satisfy your needs. +** =================================================================== +*/ + +/* +@@ LUA_NUMBER is the floating-point type used by Lua. +@@ LUAI_UACNUMBER is the result of a 'default argument promotion' +@@ over a floating number. +@@ l_floatatt(x) corrects float attribute 'x' to the proper float type +** by prefixing it with one of FLT/DBL/LDBL. +@@ LUA_NUMBER_FRMLEN is the length modifier for writing floats. +@@ LUA_NUMBER_FMT is the format for writing floats. +@@ lua_number2str converts a float to a string. +@@ l_mathop allows the addition of an 'l' or 'f' to all math operations. +@@ l_floor takes the floor of a float. +@@ lua_str2number converts a decimal numeral to a number. +*/ + + +/* The following definitions are good for most cases here */ + +#define l_floor(x) (l_mathop(floor)(x)) + +#define lua_number2str(s,sz,n) \ + l_sprintf((s), sz, LUA_NUMBER_FMT, (LUAI_UACNUMBER)(n)) + +/* +@@ lua_numbertointeger converts a float number with an integral value +** to an integer, or returns 0 if float is not within the range of +** a lua_Integer. (The range comparisons are tricky because of +** rounding. The tests here assume a two-complement representation, +** where MININTEGER always has an exact representation as a float; +** MAXINTEGER may not have one, and therefore its conversion to float +** may have an ill-defined value.) +*/ +#define lua_numbertointeger(n,p) \ + ((n) >= (LUA_NUMBER)(LUA_MININTEGER) && \ + (n) < -(LUA_NUMBER)(LUA_MININTEGER) && \ + (*(p) = (LUA_INTEGER)(n), 1)) + + +/* now the variable definitions */ + +#if LUA_FLOAT_TYPE == LUA_FLOAT_FLOAT /* { single float */ + +#define LUA_NUMBER float + +#define l_floatatt(n) (FLT_##n) + +#define LUAI_UACNUMBER double + +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.7g" + +#define l_mathop(op) op##f + +#define lua_str2number(s,p) strtof((s), (p)) + + +#elif LUA_FLOAT_TYPE == LUA_FLOAT_LONGDOUBLE /* }{ long double */ + +#define LUA_NUMBER long double + +#define l_floatatt(n) (LDBL_##n) + +#define LUAI_UACNUMBER long double + +#define LUA_NUMBER_FRMLEN "L" +#define LUA_NUMBER_FMT "%.19Lg" + +#define l_mathop(op) op##l + +#define lua_str2number(s,p) strtold((s), (p)) + +#elif LUA_FLOAT_TYPE == LUA_FLOAT_DOUBLE /* }{ double */ + +#define LUA_NUMBER double + +#define l_floatatt(n) (DBL_##n) + +#define LUAI_UACNUMBER double + +#define LUA_NUMBER_FRMLEN "" +#define LUA_NUMBER_FMT "%.14g" + +#define l_mathop(op) op + +#define lua_str2number(s,p) strtod((s), (p)) + +#else /* }{ */ + +#error "numeric float type not defined" + +#endif /* } */ + + + +/* +@@ LUA_INTEGER is the integer type used by Lua. +** +@@ LUA_UNSIGNED is the unsigned version of LUA_INTEGER. +** +@@ LUAI_UACINT is the result of a 'default argument promotion' +@@ over a LUA_INTEGER. +@@ LUA_INTEGER_FRMLEN is the length modifier for reading/writing integers. +@@ LUA_INTEGER_FMT is the format for writing integers. +@@ LUA_MAXINTEGER is the maximum value for a LUA_INTEGER. +@@ LUA_MININTEGER is the minimum value for a LUA_INTEGER. +@@ LUA_MAXUNSIGNED is the maximum value for a LUA_UNSIGNED. +@@ LUA_UNSIGNEDBITS is the number of bits in a LUA_UNSIGNED. +@@ lua_integer2str converts an integer to a string. +*/ + + +/* The following definitions are good for most cases here */ + +#define LUA_INTEGER_FMT "%" LUA_INTEGER_FRMLEN "d" + +#define LUAI_UACINT LUA_INTEGER + +#define lua_integer2str(s,sz,n) \ + l_sprintf((s), sz, LUA_INTEGER_FMT, (LUAI_UACINT)(n)) + +/* +** use LUAI_UACINT here to avoid problems with promotions (which +** can turn a comparison between unsigneds into a signed comparison) +*/ +#define LUA_UNSIGNED unsigned LUAI_UACINT + + +#define LUA_UNSIGNEDBITS (sizeof(LUA_UNSIGNED) * CHAR_BIT) + + +/* now the variable definitions */ + +#if LUA_INT_TYPE == LUA_INT_INT /* { int */ + +#define LUA_INTEGER int +#define LUA_INTEGER_FRMLEN "" + +#define LUA_MAXINTEGER INT_MAX +#define LUA_MININTEGER INT_MIN + +#define LUA_MAXUNSIGNED UINT_MAX + +#elif LUA_INT_TYPE == LUA_INT_LONG /* }{ long */ + +#define LUA_INTEGER long +#define LUA_INTEGER_FRMLEN "l" + +#define LUA_MAXINTEGER LONG_MAX +#define LUA_MININTEGER LONG_MIN + +#define LUA_MAXUNSIGNED ULONG_MAX + +#elif LUA_INT_TYPE == LUA_INT_LONGLONG /* }{ long long */ + +/* use presence of macro LLONG_MAX as proxy for C99 compliance */ +#if defined(LLONG_MAX) /* { */ +/* use ISO C99 stuff */ + +#define LUA_INTEGER long long +#define LUA_INTEGER_FRMLEN "ll" + +#define LUA_MAXINTEGER LLONG_MAX +#define LUA_MININTEGER LLONG_MIN + +#define LUA_MAXUNSIGNED ULLONG_MAX + +#elif defined(LUA_USE_WINDOWS) /* }{ */ +/* in Windows, can use specific Windows types */ + +#define LUA_INTEGER __int64 +#define LUA_INTEGER_FRMLEN "I64" + +#define LUA_MAXINTEGER _I64_MAX +#define LUA_MININTEGER _I64_MIN + +#define LUA_MAXUNSIGNED _UI64_MAX + +#else /* }{ */ + +#error "Compiler does not support 'long long'. Use option '-DLUA_32BITS' \ + or '-DLUA_C89_NUMBERS' (see file 'luaconf.h' for details)" + +#endif /* } */ + +#else /* }{ */ + +#error "numeric integer type not defined" + +#endif /* } */ + +/* }================================================================== */ + + +/* +** {================================================================== +** Dependencies with C99 and other C details +** =================================================================== +*/ + +/* +@@ l_sprintf is equivalent to 'snprintf' or 'sprintf' in C89. +** (All uses in Lua have only one format item.) +*/ +#if !defined(LUA_USE_C89) +#define l_sprintf(s,sz,f,i) snprintf(s,sz,f,i) +#else +#define l_sprintf(s,sz,f,i) ((void)(sz), sprintf(s,f,i)) +#endif + + +/* +@@ lua_strx2number converts a hexadecimal numeral to a number. +** In C99, 'strtod' does that conversion. Otherwise, you can +** leave 'lua_strx2number' undefined and Lua will provide its own +** implementation. +*/ +#if !defined(LUA_USE_C89) +#define lua_strx2number(s,p) lua_str2number(s,p) +#endif + + +/* +@@ lua_pointer2str converts a pointer to a readable string in a +** non-specified way. +*/ +#define lua_pointer2str(buff,sz,p) l_sprintf(buff,sz,"%p",p) + + +/* +@@ lua_number2strx converts a float to a hexadecimal numeral. +** In C99, 'sprintf' (with format specifiers '%a'/'%A') does that. +** Otherwise, you can leave 'lua_number2strx' undefined and Lua will +** provide its own implementation. +*/ +#if !defined(LUA_USE_C89) +#define lua_number2strx(L,b,sz,f,n) \ + ((void)L, l_sprintf(b,sz,f,(LUAI_UACNUMBER)(n))) +#endif + + +/* +** 'strtof' and 'opf' variants for math functions are not valid in +** C89. Otherwise, the macro 'HUGE_VALF' is a good proxy for testing the +** availability of these variants. ('math.h' is already included in +** all files that use these macros.) +*/ +#if defined(LUA_USE_C89) || (defined(HUGE_VAL) && !defined(HUGE_VALF)) +#undef l_mathop /* variants not available */ +#undef lua_str2number +#define l_mathop(op) (lua_Number)op /* no variant */ +#define lua_str2number(s,p) ((lua_Number)strtod((s), (p))) +#endif + + +/* +@@ LUA_KCONTEXT is the type of the context ('ctx') for continuation +** functions. It must be a numerical type; Lua will use 'intptr_t' if +** available, otherwise it will use 'ptrdiff_t' (the nearest thing to +** 'intptr_t' in C89) +*/ +#define LUA_KCONTEXT ptrdiff_t + +#if !defined(LUA_USE_C89) && defined(__STDC_VERSION__) && \ + __STDC_VERSION__ >= 199901L +#include +#if defined(INTPTR_MAX) /* even in C99 this type is optional */ +#undef LUA_KCONTEXT +#define LUA_KCONTEXT intptr_t +#endif +#endif + + +/* +@@ lua_getlocaledecpoint gets the locale "radix character" (decimal point). +** Change that if you do not want to use C locales. (Code using this +** macro must include the header 'locale.h'.) +*/ +#if !defined(lua_getlocaledecpoint) +#define lua_getlocaledecpoint() (localeconv()->decimal_point[0]) +#endif + +/* }================================================================== */ + + +/* +** {================================================================== +** Language Variations +** ===================================================================== +*/ + +/* +@@ LUA_NOCVTN2S/LUA_NOCVTS2N control how Lua performs some +** coercions. Define LUA_NOCVTN2S to turn off automatic coercion from +** numbers to strings. Define LUA_NOCVTS2N to turn off automatic +** coercion from strings to numbers. +*/ +/* #define LUA_NOCVTN2S */ +/* #define LUA_NOCVTS2N */ + + +/* +@@ LUA_USE_APICHECK turns on several consistency checks on the C API. +** Define it as a help when debugging C code. +*/ +#if defined(LUA_USE_APICHECK) +#include +#define luai_apicheck(l,e) assert(e) +#endif + +/* }================================================================== */ + + +/* +** {================================================================== +** Macros that affect the API and must be stable (that is, must be the +** same when you compile Lua and when you compile code that links to +** Lua). +** ===================================================================== +*/ + +/* +@@ LUAI_MAXSTACK limits the size of the Lua stack. +** CHANGE it if you need a different limit. This limit is arbitrary; +** its only purpose is to stop Lua from consuming unlimited stack +** space (and to reserve some numbers for pseudo-indices). +** (It must fit into max(size_t)/32.) +*/ +#if LUAI_IS32INT +#define LUAI_MAXSTACK 1000000 +#else +#define LUAI_MAXSTACK 15000 +#endif + + +/* +@@ LUA_EXTRASPACE defines the size of a raw memory area associated with +** a Lua state with very fast access. +** CHANGE it if you need a different size. +*/ +#define LUA_EXTRASPACE (sizeof(void *)) + + +/* +@@ LUA_IDSIZE gives the maximum size for the description of the source +@@ of a function in debug information. +** CHANGE it if you want a different size. +*/ +#define LUA_IDSIZE 60 + + +/* +@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. +*/ +#define LUAL_BUFFERSIZE ((int)(16 * sizeof(void*) * sizeof(lua_Number))) + + +/* +@@ LUAI_MAXALIGN defines fields that, when used in a union, ensure +** maximum alignment for the other items in that union. +*/ +#define LUAI_MAXALIGN lua_Number n; double u; void *s; lua_Integer i; long l + +/* }================================================================== */ + + + + + +/* =================================================================== */ + +/* +** Local configuration. You can use this space to add your redefinitions +** without modifying the main part of the file. +*/ + + + + + +#endif + diff --git a/vendor/lua/lualib.h b/vendor/lua/lualib.h new file mode 100644 index 0000000..eb08b53 --- /dev/null +++ b/vendor/lua/lualib.h @@ -0,0 +1,58 @@ +/* +** $Id: lualib.h $ +** Lua standard libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lualib_h +#define lualib_h + +#include "lua.h" + + +/* version suffix for environment variable names */ +#define LUA_VERSUFFIX "_" LUA_VERSION_MAJOR "_" LUA_VERSION_MINOR + + +LUAMOD_API int (luaopen_base) (lua_State *L); + +#define LUA_COLIBNAME "coroutine" +LUAMOD_API int (luaopen_coroutine) (lua_State *L); + +#define LUA_TABLIBNAME "table" +LUAMOD_API int (luaopen_table) (lua_State *L); + +#define LUA_IOLIBNAME "io" +LUAMOD_API int (luaopen_io) (lua_State *L); + +#define LUA_OSLIBNAME "os" +LUAMOD_API int (luaopen_os) (lua_State *L); + +#define LUA_STRLIBNAME "string" +LUAMOD_API int (luaopen_string) (lua_State *L); + +#define LUA_UTF8LIBNAME "utf8" +LUAMOD_API int (luaopen_utf8) (lua_State *L); + +#define LUA_MATHLIBNAME "math" +LUAMOD_API int (luaopen_math) (lua_State *L); + +#define LUA_DBLIBNAME "debug" +LUAMOD_API int (luaopen_debug) (lua_State *L); + +#define LUA_LOADLIBNAME "package" +LUAMOD_API int (luaopen_package) (lua_State *L); + + +/* open all previous libraries */ +LUALIB_API void (luaL_openlibs) (lua_State *L); + + + +#if !defined(lua_assert) +#define lua_assert(x) ((void)0) +#endif + + +#endif