From 213902021c84e0249f9ecf7a6883a048d1038822 Mon Sep 17 00:00:00 2001 From: falsycat Date: Wed, 25 Aug 2021 12:27:39 +0900 Subject: [PATCH] Implements calling Lua. --- Font.cc | 2 - Game.h | 69 -- GlyphsJuke.vcxproj | 74 +- GlyphsJuke.vcxproj.filters | 102 ++- Texture.h | 117 ---- src/Font.cc | 4 + Font.h => src/Font.h | 4 +- src/Frame.h | 55 ++ src/Game.cc | 19 + src/Game.h | 70 ++ LinearAllocator.h => src/LinearAllocator.h | 2 +- Logger.h => src/Logger.h | 0 src/Lua.cc | 119 ++++ src/Lua.h | 38 + OffsetClock.h => src/OffsetClock.h | 0 src/Period.h | 29 + src/PlayScene.cc | 10 + src/PlayScene.h | 51 ++ Rasterbuffer.h => src/Rasterbuffer.h | 0 StackAllocator.h => src/StackAllocator.h | 2 +- SystemClock.h => src/SystemClock.h | 0 Text.h => src/Text.h | 0 src/Texture.cc | 87 +++ src/Texture.h | 37 + src/TickingClock.h | 43 ++ Win32Console.cc => src/Win32Console.cc | 2 +- Win32Console.h => src/Win32Console.h | 0 common.h => src/common.h | 8 + iAllocator.h => src/iAllocator.h | 16 +- iClock.h => src/iClock.h | 0 iConsole.h => src/iConsole.h | 0 iDrawable.h => src/iDrawable.h | 6 +- src/iElement.h | 28 + src/iElementDriver.h | 29 + src/iElementFactory.h | 27 + iLogger.h => src/iLogger.h | 0 src/iScene.h | 30 + iWritable.h => src/iWritable.h | 0 main.cc => src/main.cc | 8 +- thirdparty/lauxlib.h | 174 +++++ thirdparty/lua.h | 388 +++++++++++ thirdparty/lua.hpp | 9 + thirdparty/lua5.1.dll | Bin 0 -> 212480 bytes thirdparty/lua5.1.lib | Bin 0 -> 25478 bytes thirdparty/luaconf.h | 766 +++++++++++++++++++++ thirdparty/lualib.h | 53 ++ 46 files changed, 2233 insertions(+), 245 deletions(-) delete mode 100644 Font.cc delete mode 100644 Game.h delete mode 100644 Texture.h create mode 100644 src/Font.cc rename Font.h => src/Font.h (94%) create mode 100644 src/Frame.h create mode 100644 src/Game.cc create mode 100644 src/Game.h rename LinearAllocator.h => src/LinearAllocator.h (98%) rename Logger.h => src/Logger.h (100%) create mode 100644 src/Lua.cc create mode 100644 src/Lua.h rename OffsetClock.h => src/OffsetClock.h (100%) create mode 100644 src/Period.h create mode 100644 src/PlayScene.cc create mode 100644 src/PlayScene.h rename Rasterbuffer.h => src/Rasterbuffer.h (100%) rename StackAllocator.h => src/StackAllocator.h (97%) rename SystemClock.h => src/SystemClock.h (100%) rename Text.h => src/Text.h (100%) create mode 100644 src/Texture.cc create mode 100644 src/Texture.h create mode 100644 src/TickingClock.h rename Win32Console.cc => src/Win32Console.cc (97%) rename Win32Console.h => src/Win32Console.h (100%) rename common.h => src/common.h (74%) rename iAllocator.h => src/iAllocator.h (69%) rename iClock.h => src/iClock.h (100%) rename iConsole.h => src/iConsole.h (100%) rename iDrawable.h => src/iDrawable.h (89%) create mode 100644 src/iElement.h create mode 100644 src/iElementDriver.h create mode 100644 src/iElementFactory.h rename iLogger.h => src/iLogger.h (100%) create mode 100644 src/iScene.h rename iWritable.h => src/iWritable.h (100%) rename main.cc => src/main.cc (80%) create mode 100644 thirdparty/lauxlib.h create mode 100644 thirdparty/lua.h create mode 100644 thirdparty/lua.hpp create mode 100644 thirdparty/lua5.1.dll create mode 100644 thirdparty/lua5.1.lib create mode 100644 thirdparty/luaconf.h create mode 100644 thirdparty/lualib.h diff --git a/Font.cc b/Font.cc deleted file mode 100644 index e807d6a..0000000 --- a/Font.cc +++ /dev/null @@ -1,2 +0,0 @@ -#define STB_TRUETYPE_IMPLEMENTATION -#include "Font.h" \ No newline at end of file diff --git a/Game.h b/Game.h deleted file mode 100644 index a44c41b..0000000 --- a/Game.h +++ /dev/null @@ -1,69 +0,0 @@ -#pragma once - -#include -#include - -#include "iDrawable.h" -#include "iWritable.h" -#include "Logger.h" -#include "OffsetClock.h" -#include "SystemClock.h" -#include "Texture.h" - - -namespace gj { - - -class Game : public iDrawable, public iWritable { - public: - Game() = delete; - Game(Game&&) = delete; - Game(const Game&) = delete; - - Game& operator=(Game&&) = delete; - Game& operator=(const Game&) = delete; - - Game(iAllocator* alloc, uint32_t w, uint32_t h) : - alloc_(alloc), uptime_(&SystemClock::instance()), - w_(w), h_(h), logger_(h), test_(Colorbuffer(alloc, 1, 1)) { - Colorbuffer temp(alloc_, 5, 5); - float* ptr = temp.ptr(); - for (size_t i = 0; i < 25; ++i) ptr[i] = i%2*.3+.7; - test_ = Texture(std::move(temp)); - } - - void Update() { - const uint64_t i = uptime_.now(); - if (i%1000 == 0) logger_.Print(L"すべての人類は死滅する: "+std::to_wstring(i)); - - double t = i%2000/2000.; - t = 1 - t; - - mat3 m = mat3{ {.2, 0, 0},{0, .2, 0},{0, 0, 1} }; - - const double s = sin(3.14*2*t*t*t), c = cos(3.14*2*t*t*t); - m = ::linalg::mul(mat3{{c, -s, 0,}, {s, c, 0}, {0, 0, 1}}, m); - m = ::linalg::mul(mat3{{ 1, 0, 0,}, {0, 1, 0}, {(1 - t * t * t * 2) * .6, 0, 1}}, m); - m = ::linalg::mul(mat3{ {1, 0, 0},{0, 16/9., 0},{0, 0, 1} }, m); - test_.SetMatrix(m); - } - - void Draw(Colorbuffer& fb) const override { - test_.Draw(fb); - } - void Write(Textbuffer& fb) const override { - logger_.Write(fb); - } - - private: - iAllocator* alloc_; - OffsetClock uptime_; - - uint32_t w_, h_; - Logger logger_; - - Texture test_; -}; - - -} \ No newline at end of file diff --git a/GlyphsJuke.vcxproj b/GlyphsJuke.vcxproj index 1b66d8c..d273b3f 100644 --- a/GlyphsJuke.vcxproj +++ b/GlyphsJuke.vcxproj @@ -117,11 +117,17 @@ _DEBUG;_CONSOLE;%(PreprocessorDefinitions) true /utf-8 %(AdditionalOptions) + $(SolutionDir)/ + stdcpp20 Console true + + + + @@ -140,31 +146,57 @@ - - - + + + + + + + - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + Document + + + + diff --git a/GlyphsJuke.vcxproj.filters b/GlyphsJuke.vcxproj.filters index ec2bd0b..43a6b52 100644 --- a/GlyphsJuke.vcxproj.filters +++ b/GlyphsJuke.vcxproj.filters @@ -18,39 +18,51 @@ - + Source Files - + Source Files - + + Source Files + + + Source Files + + + Source Files + + + Source Files + + Source Files - + Header Files - + Header Files - + Header Files - + Header Files - + Header Files - + Header Files - + Header Files - + Header Files @@ -59,35 +71,83 @@ Header Files\thirdparty - + Header Files - + Header Files - + Header Files - + Header Files - + Header Files - + Header Files - + Header Files - + Header Files - + Header Files - + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + + Header Files + + Header Files + + + + + + \ No newline at end of file diff --git a/Texture.h b/Texture.h deleted file mode 100644 index 0174332..0000000 --- a/Texture.h +++ /dev/null @@ -1,117 +0,0 @@ -#pragma once - -#include - -#include "thirdparty/linalg.h" - -#include "iDrawable.h" -#include "Rasterbuffer.h" - - -namespace gj { - - -class Texture : public DrawableBase { - public: - Texture() = delete; - Texture(Texture&&) = default; - Texture(const Texture&) = default; - - Texture& operator=(Texture&&) = default; - Texture& operator=(const Texture&) = default; - - Texture(Colorbuffer&& src) : src_(std::move(src)) { - } - - void Draw(Colorbuffer& fb) const override { - const int32_t w = static_cast(fb.width()); - const int32_t h = static_cast(fb.height()); - - const int32_t srcw = static_cast(src_.width()); - const int32_t srch = static_cast(src_.height()); - - vec3 p[4] = { - { -1, 1, 1 }, - { -1, -1, 1 }, - { 1, -1, 1 }, - { 1, 1, 1 }, - }; - for (size_t i = 0; i < 4; ++i) { - p[i] = ::linalg::mul(mat_, p[i]); - } - const double pl = std::min({p[0].x, p[1].x, p[2].x, p[3].x})-.1; - const double pr = std::max({p[0].x, p[1].x, p[2].x, p[3].x})+.1; - const double pu = std::max({p[0].y, p[1].y, p[2].y, p[3].y})+.1; - const double pb = std::min({p[0].y, p[1].y, p[2].y, p[3].y})-.1; - const double pw = pr - pl; - const double ph = pu - pb; - - const int32_t pli = static_cast((pl + 1) / 2 * w); - const int32_t pri = static_cast((pr + 1) / 2 * w); - const int32_t pui = static_cast((pu + 1) / 2 * h); - const int32_t pbi = static_cast((pb + 1) / 2 * h); - const int32_t pwi = pri - pli; - const int32_t phi = pui - pbi; - - vec3 q[4] = { - { pl, pu, 1 }, - { pl, pb, 1 }, - { pr, pb, 1 }, - { pr, pu, 1 }, - }; - for (size_t i = 0; i < 4; ++i) { - q[i] = ::linalg::mul(invmat_, q[i]); - } - const double ql = std::min({q[0].x, q[1].x, q[2].x, q[3].x}); - const double qr = std::max({q[0].x, q[1].x, q[2].x, q[3].x}); - const double qu = std::max({q[0].y, q[1].y, q[2].y, q[3].y}); - const double qb = std::min({q[0].y, q[1].y, q[2].y, q[3].y}); - - const double qldx = q[0].x - q[1].x; - const double qrdx = q[3].x - q[2].x; - const double qldy = q[0].y - q[1].y; - const double qrdy = q[3].y - q[2].y; - - const float* src = src_.ptr(); - float* dst = fb.ptr(); - for (int32_t y = 0; y <= phi; ++y) { - const double yfr = y*1. / phi; - - const double lxf = qldx * yfr + q[1].x; - const double rxf = qrdx * yfr + q[2].x; - const double ax = (rxf - lxf) / pwi; - - const double lyf = qldy * yfr + q[1].y; - const double ryf = qrdy * yfr + q[2].y; - const double ay = (ryf - lyf) / pwi; - - for (int32_t x = 0; x <= pwi; ++x) { - const double xf = lxf + ax*x; - const double yf = lyf + ay*x; - if (std::abs(xf) > 1 || std::abs(yf) > 1) continue; - - int32_t srcx = static_cast((xf+1)/2 * srcw); - int32_t srcy = srch - 1 - static_cast((yf+1)/2 * srch); - if (srcx >= srcw) srcx = srcw - 1; - if (srcy >= srch) srcy = srch - 1; - - const int32_t dstx = pli + x; - const int32_t dsty = (h-pui) + y; - if (dstx < 0 || w <= dstx) continue; - if (dsty < 0 || h <= dsty) continue; - - dst[dstx + w*dsty] = src[srcx + srcw*srcy]; - } - } - } - - void SetSource(Colorbuffer&& src) { - src_ = std::move(src); - } - - private: - Colorbuffer src_; -}; - - -} \ No newline at end of file diff --git a/src/Font.cc b/src/Font.cc new file mode 100644 index 0000000..db56126 --- /dev/null +++ b/src/Font.cc @@ -0,0 +1,4 @@ +/* Because an implementation of stb_truetype is huge, compiles it separately. */ + +#define STB_TRUETYPE_IMPLEMENTATION +#include "Font.h" \ No newline at end of file diff --git a/Font.h b/src/Font.h similarity index 94% rename from Font.h rename to src/Font.h index 3442966..619a950 100644 --- a/Font.h +++ b/src/Font.h @@ -33,7 +33,7 @@ namespace gj { const size_t size = ifs.tellg(); ifs.seekg(0); - buf_ = alloc_->MakeUniqueArray(size); + buf_ = alloc_->MakeUniqArray(size); ifs.read(reinterpret_cast(buf_.get()), size); const int offset = stbtt_GetFontOffsetForIndex(buf_.get(), 0); @@ -66,7 +66,7 @@ namespace gj { stbtt_fontinfo stb_; - iAllocator::UniquePtr buf_; + UniqPtr buf_; }; diff --git a/src/Frame.h b/src/Frame.h new file mode 100644 index 0000000..4932477 --- /dev/null +++ b/src/Frame.h @@ -0,0 +1,55 @@ +#pragma once + +#include + +#include "iDrawable.h" +#include "iWritable.h" + + +namespace gj { + + +class Frame : public iDrawable, public iWritable { + public: + Frame() = delete; + Frame(Frame&&) = delete; + Frame(const Frame&) = delete; + + Frame& operator=(Frame&&) = delete; + Frame& operator=(const Frame&) = delete; + + Frame(size_t dres, size_t wres) { + draw_.reserve(dres); + write_.reserve(wres); + } + + void Clear() { + draw_.clear(); + write_.clear(); + } + + void Add(const iDrawable* d) { + draw_.push_back(d); + } + void Add(const iWritable* w) { + write_.push_back(w); + } + + void Draw(Colorbuffer& fb) const override { + for (auto d : draw_) { + d->Draw(fb); + } + } + void Write(Textbuffer& fb) const override { + for (auto w : write_) { + w->Write(fb); + } + } + + private: + std::vector draw_; + std::vector write_; +}; + + +} \ No newline at end of file diff --git a/src/Game.cc b/src/Game.cc new file mode 100644 index 0000000..7e999e1 --- /dev/null +++ b/src/Game.cc @@ -0,0 +1,19 @@ +#include "Game.h" +#include "PlayScene.h" + + +gj::Game::Game(gj::Game::Param&& p) : + alloc_(p.alloc), + clock_(p.clock), + logger_(p.h), + w_(p.w), h_(p.h), + frame_(kReserveDrawable, kReserveWritable) { + gj::PlayScene::Param param; + param.alloc = alloc_; + param.clock = &clock_; + param.logger = &logger_; + param.w = w_; + param.h = h_; + param.score = "test"; /* TODO test */ + scene_ = alloc_->MakeUniq(std::move(param)); +} \ No newline at end of file diff --git a/src/Game.h b/src/Game.h new file mode 100644 index 0000000..afe836e --- /dev/null +++ b/src/Game.h @@ -0,0 +1,70 @@ +#pragma once + +#include +#include +#include + +#include "Frame.h" +#include "iDrawable.h" +#include "iWritable.h" +#include "iScene.h" +#include "Logger.h" +#include "TickingClock.h" + + +namespace gj { + + +class Game : public iDrawable, public iWritable { + public: + static constexpr size_t kReserveDrawable = 256; + static constexpr size_t kReserveWritable = 64; + + struct Param { + iAllocator* alloc; + const iClock* clock; + + uint32_t w, h; + }; + + Game() = delete; + Game(Game&&) = delete; + Game(const Game&) = delete; + + Game& operator=(Game&&) = delete; + Game& operator=(const Game&) = delete; + + Game(Param&& p); + + void Update() { + clock_.Tick(); + + frame_.Clear(); + UniqPtr next = scene_->Update(frame_); + if (next) { + scene_ = std::move(next); + } + } + + void Draw(Colorbuffer& fb) const override { + frame_.Draw(fb); + } + void Write(Textbuffer& fb) const override { + frame_.Write(fb); + logger_.Write(fb); + } + + private: + iAllocator* alloc_; + TickingClock clock_; + + Logger logger_; + + uint32_t w_, h_; + Frame frame_; + + UniqPtr scene_; +}; + + +} \ No newline at end of file diff --git a/LinearAllocator.h b/src/LinearAllocator.h similarity index 98% rename from LinearAllocator.h rename to src/LinearAllocator.h index 537c2d5..a12a6e1 100644 --- a/LinearAllocator.h +++ b/src/LinearAllocator.h @@ -14,7 +14,7 @@ namespace gj { class LinearAllocator : public iAllocator { public: using iAllocator::Alloc; - using iAllocator::MakeUnique; + using iAllocator::MakeUniq; LinearAllocator() = delete; LinearAllocator(LinearAllocator&&) = delete; diff --git a/Logger.h b/src/Logger.h similarity index 100% rename from Logger.h rename to src/Logger.h diff --git a/src/Lua.cc b/src/Lua.cc new file mode 100644 index 0000000..47a6a76 --- /dev/null +++ b/src/Lua.cc @@ -0,0 +1,119 @@ +#include "Lua.h" + + +class LuaFunc : public gj::iElementDriver { + public: + LuaFunc() = delete; + LuaFunc(LuaFunc&&) = delete; + LuaFunc(const LuaFunc&) = delete; + + LuaFunc& operator=(LuaFunc&&) = delete; + LuaFunc& operator=(const LuaFunc&) = delete; + + LuaFunc(lua_State* L) : L(L) { + func_ = luaL_ref(L, LUA_REGISTRYINDEX); + + lua_createtable(L, 0, 0); + table_ = luaL_ref(L, LUA_REGISTRYINDEX); + } + ~LuaFunc() { + luaL_unref(L, LUA_REGISTRYINDEX, func_); + } + + void Update(Param& param) override { + lua_rawgeti(L, LUA_REGISTRYINDEX, func_); + + lua_rawgeti(L, LUA_REGISTRYINDEX, table_); + for (const auto& p : param) { + lua_pushstring(L, p.first.c_str()); + if (std::holds_alternative(p.second)) { + lua_pushinteger(L, std::get(p.second)); + } else if (std::holds_alternative(p.second)) { + lua_pushnumber(L, std::get(p.second)); + } else if (std::holds_alternative(p.second)) { + const std::string str = std::get(p.second); + lua_pushstring(L, str.c_str()); + } else { + assert(false); + } + lua_rawset(L, -3); + } + + const int ret = lua_pcall(L, 1, 0, 0); + if (ret) { + gj::Abort(std::string("Lua error: ")+lua_tostring(L, -1)); + } + + lua_rawgeti(L, LUA_REGISTRYINDEX, table_); + for (auto& p : param) { + lua_pushstring(L, p.first.c_str()); + lua_rawget(L, -2); + + if (std::holds_alternative(p.second)) { + p.second = luaL_checkinteger(L, -1); + } else if (std::holds_alternative(p.second)) { + p.second = luaL_checknumber(L, -1); + } else if (std::holds_alternative(p.second)) { + p.second = luaL_checkstring(L, -1); + } else { + assert(false); + } + lua_pop(L, 1); + } + lua_pop(L, 1); + } + + private: + lua_State* L; + + int func_ = LUA_REFNIL; + int table_ = LUA_REFNIL; +}; + + +static int CallFactory_(lua_State* L) { + gj::iAllocator* alloc = + reinterpret_cast(lua_touserdata(L, lua_upvalueindex(1))); + gj::iElementFactory* factory = + reinterpret_cast(lua_touserdata(L, lua_upvalueindex(2))); + + const lua_Integer st = luaL_checkinteger(L, 1); + const lua_Integer ed = luaL_checkinteger(L, 2); + if (st >= ed) { + return luaL_error(L, "invalid period"); + } + if (!lua_isfunction(L, 3)) { + return luaL_error(L, "no driver specified"); + } + + lua_pushvalue(L, 3); + factory->Create(gj::Period(st, ed), alloc->MakeUniq(L)); + return 0; +} + + +gj::Lua::Lua(iAllocator* alloc, const FactoryMap& factory, const std::string& path) { + L = luaL_newstate(); + if (L == nullptr) { + Abort("lua_newstate failure"); + } + + for (const auto& f : factory) { + lua_pushstring(L, f.first.c_str()); + + lua_pushlightuserdata(L, alloc); + lua_pushlightuserdata(L, f.second); + lua_pushcclosure(L, CallFactory_, 2); + + lua_rawset(L, LUA_GLOBALSINDEX); + } + + if (0 != luaL_loadfile(L, path.c_str())) { + const char* msg = lua_tostring(L, -1); + Abort(std::string("luaL_loadfile failure: ") + msg); + } + const int ret = lua_pcall(L, 0, 0, 0); + if (ret) { + gj::Abort(std::string("Lua error: ") + lua_tostring(L, -1)); + } +} \ No newline at end of file diff --git a/src/Lua.h b/src/Lua.h new file mode 100644 index 0000000..4b3a20c --- /dev/null +++ b/src/Lua.h @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +#include "thirdparty/lua.hpp" + +#include "common.h" +#include "iAllocator.h" +#include "iElementFactory.h" + + +namespace gj { + + +class Lua { + public: + using FactoryMap = std::map; + + Lua() = delete; + Lua(Lua&&) = delete; + Lua(const Lua&) = delete; + + Lua& operator=(Lua&&) = delete; + Lua& operator=(const Lua&) = delete; + + Lua(iAllocator* alloc, const FactoryMap& factory, const std::string& path); + + ~Lua() { + lua_close(L); + } + + private: + lua_State* L = nullptr; +}; + + +} \ No newline at end of file diff --git a/OffsetClock.h b/src/OffsetClock.h similarity index 100% rename from OffsetClock.h rename to src/OffsetClock.h diff --git a/src/Period.h b/src/Period.h new file mode 100644 index 0000000..9b26a7f --- /dev/null +++ b/src/Period.h @@ -0,0 +1,29 @@ +#pragma once + +#include + +namespace gj { + + +struct Period { + public: + Period() = delete; + + Period(uint64_t st, uint64_t ed) : start(st), end(ed) { + assert(st <= ed); + } + + bool isHit(uint64_t now) const { + return start <= now && now < end; + } + + uint64_t duration() const { + return end - start; + } + + uint64_t start; + uint64_t end; +}; + + +} \ No newline at end of file diff --git a/src/PlayScene.cc b/src/PlayScene.cc new file mode 100644 index 0000000..44c3d02 --- /dev/null +++ b/src/PlayScene.cc @@ -0,0 +1,10 @@ +#include "PlayScene.h" + + +gj::PlayScene::PlayScene(gj::PlayScene::Param&& p) : + alloc_(p.alloc), logger_(p.logger), w_(p.w), h_(p.h), + clock_(p.clock) { + lua_ = alloc_->MakeUniq(alloc_, Lua::FactoryMap(), "res/score/"+p.score+".lua"); + + logger_->Print(L"PlayScene init"); +} \ No newline at end of file diff --git a/src/PlayScene.h b/src/PlayScene.h new file mode 100644 index 0000000..debc3ac --- /dev/null +++ b/src/PlayScene.h @@ -0,0 +1,51 @@ +#pragma once + +#include "Frame.h" +#include "iAllocator.h" +#include "iLogger.h" +#include "iScene.h" +#include "Lua.h" +#include "OffsetClock.h" + + +namespace gj { + + +class PlayScene : public iScene { + public: + struct Param { + iAllocator* alloc; + iLogger* logger; + const iClock* clock; + + uint32_t w, h; + + std::string score; + }; + + PlayScene() = delete; + PlayScene(PlayScene&&) = delete; + PlayScene(const PlayScene&) = delete; + + PlayScene& operator=(PlayScene&&) = delete; + PlayScene& operator=(const PlayScene&) = delete; + + PlayScene(Param&& p); + + UniqPtr Update(Frame& f) override { + return nullptr; + } + + private: + iAllocator* alloc_; + iLogger* logger_; + + uint32_t w_, h_; + + OffsetClock clock_; + + UniqPtr lua_; +}; + + +} \ No newline at end of file diff --git a/Rasterbuffer.h b/src/Rasterbuffer.h similarity index 100% rename from Rasterbuffer.h rename to src/Rasterbuffer.h diff --git a/StackAllocator.h b/src/StackAllocator.h similarity index 97% rename from StackAllocator.h rename to src/StackAllocator.h index 0a6f1ee..b4bcceb 100644 --- a/StackAllocator.h +++ b/src/StackAllocator.h @@ -13,7 +13,7 @@ namespace gj { class StackAllocator : public iAllocator { public: using iAllocator::Alloc; - using iAllocator::MakeUnique; + using iAllocator::MakeUniq; StackAllocator() = delete; StackAllocator(StackAllocator&&) = delete; diff --git a/SystemClock.h b/src/SystemClock.h similarity index 100% rename from SystemClock.h rename to src/SystemClock.h diff --git a/Text.h b/src/Text.h similarity index 100% rename from Text.h rename to src/Text.h diff --git a/src/Texture.cc b/src/Texture.cc new file mode 100644 index 0000000..a0f74d7 --- /dev/null +++ b/src/Texture.cc @@ -0,0 +1,87 @@ +#include "Texture.h" + + +void gj::Texture::Draw(Colorbuffer& fb) const { + const int32_t w = static_cast(fb.width()); + const int32_t h = static_cast(fb.height()); + + const int32_t srcw = static_cast(src_.width()); + const int32_t srch = static_cast(src_.height()); + + /* dst coordinate */ + vec3 p[4] = { + { -1, 1, 1 }, + { -1, -1, 1 }, + { 1, -1, 1 }, + { 1, 1, 1 }, + }; + for (size_t i = 0; i < 4; ++i) { + p[i] = ::linalg::mul(mat_, p[i]); + } + const double pl = std::min({p[0].x, p[1].x, p[2].x, p[3].x})-.1; + const double pr = std::max({p[0].x, p[1].x, p[2].x, p[3].x})+.1; + const double pu = std::max({p[0].y, p[1].y, p[2].y, p[3].y})+.1; + const double pb = std::min({p[0].y, p[1].y, p[2].y, p[3].y})-.1; + const double pw = pr - pl; + const double ph = pu - pb; + + const int32_t pli = static_cast((pl + 1) / 2 * w); + const int32_t pri = static_cast((pr + 1) / 2 * w); + const int32_t pui = static_cast((pu + 1) / 2 * h); + const int32_t pbi = static_cast((pb + 1) / 2 * h); + const int32_t pwi = pri - pli; + const int32_t phi = pui - pbi; + + /* src coordinate */ + vec3 q[4] = { + { pl, pu, 1 }, + { pl, pb, 1 }, + { pr, pb, 1 }, + { pr, pu, 1 }, + }; + for (size_t i = 0; i < 4; ++i) { + q[i] = ::linalg::mul(invmat_, q[i]); + } + const double ql = std::min({q[0].x, q[1].x, q[2].x, q[3].x}); + const double qr = std::max({q[0].x, q[1].x, q[2].x, q[3].x}); + const double qu = std::max({q[0].y, q[1].y, q[2].y, q[3].y}); + const double qb = std::min({q[0].y, q[1].y, q[2].y, q[3].y}); + + const double qldx = q[0].x - q[1].x; + const double qrdx = q[3].x - q[2].x; + const double qldy = q[0].y - q[1].y; + const double qrdy = q[3].y - q[2].y; + + /* blit with transformation */ + const float* src = src_.ptr(); + float* dst = fb.ptr(); + for (int32_t y = 0; y <= phi; ++y) { + const double yfr = y*1. / phi; + + const double lxf = qldx * yfr + q[1].x; + const double rxf = qrdx * yfr + q[2].x; + const double ax = (rxf - lxf) / pwi; + + const double lyf = qldy * yfr + q[1].y; + const double ryf = qrdy * yfr + q[2].y; + const double ay = (ryf - lyf) / pwi; + + for (int32_t x = 0; x <= pwi; ++x) { + const double xf = lxf + ax*x; + const double yf = lyf + ay*x; + if (std::abs(xf) > 1 || std::abs(yf) > 1) continue; + + int32_t srcx = static_cast((xf+1)/2 * srcw); + int32_t srcy = srch - 1 - static_cast((yf+1)/2 * srch); + if (srcx >= srcw) srcx = srcw - 1; + if (srcy >= srch) srcy = srch - 1; + + const int32_t dstx = pli + x; + const int32_t dsty = (h-pui) + y; + if (dstx < 0 || w <= dstx) continue; + if (dsty < 0 || h <= dsty) continue; + + dst[dstx + w*dsty] = src[srcx + srcw*srcy]; + } + } +} \ No newline at end of file diff --git a/src/Texture.h b/src/Texture.h new file mode 100644 index 0000000..9570064 --- /dev/null +++ b/src/Texture.h @@ -0,0 +1,37 @@ +#pragma once + +#include + +#include "thirdparty/linalg.h" + +#include "iDrawable.h" +#include "Rasterbuffer.h" + + +namespace gj { + + +class Texture : public DrawableBase { + public: + Texture() = delete; + Texture(Texture&&) = default; + Texture(const Texture&) = default; + + Texture& operator=(Texture&&) = default; + Texture& operator=(const Texture&) = default; + + Texture(Colorbuffer&& src) : src_(std::move(src)) { + } + + void Draw(Colorbuffer& fb) const override; + + void SetSource(Colorbuffer&& src) { + src_ = std::move(src); + } + + private: + Colorbuffer src_; +}; + + +} \ No newline at end of file diff --git a/src/TickingClock.h b/src/TickingClock.h new file mode 100644 index 0000000..a0c7be8 --- /dev/null +++ b/src/TickingClock.h @@ -0,0 +1,43 @@ +#pragma once + +#include + +#define NOMINMAX +#include +#undef NOMINMAX + +#include "iClock.h" + + +namespace gj { + + + class TickingClock : public iClock { + public: + TickingClock() = delete; + TickingClock(TickingClock&&) = default; + TickingClock(const TickingClock&) = default; + + TickingClock& operator=(TickingClock&&) = default; + TickingClock& operator=(const TickingClock&) = default; + + TickingClock(const iClock* parent) : parent_(parent) { + Tick(); + } + + void Tick() { + now_ = parent_->now(); + } + + uint64_t now() const override { + return now_; + } + + private: + const iClock* parent_; + + uint64_t now_; + }; + + +} \ No newline at end of file diff --git a/Win32Console.cc b/src/Win32Console.cc similarity index 97% rename from Win32Console.cc rename to src/Win32Console.cc index 548b609..f1c39ae 100644 --- a/Win32Console.cc +++ b/src/Win32Console.cc @@ -18,7 +18,7 @@ static void CalcChar(CHAR_INFO& c, float color, uint16_t text) { constexpr size_t reso = char_expr_count*attr_expr_count; /* post effect */ - color = std::pow(color, 1.9); + color = static_cast(std::pow(color, 1.9)); int8_t a = static_cast(color*reso); if (a >= reso) a = reso-1; diff --git a/Win32Console.h b/src/Win32Console.h similarity index 100% rename from Win32Console.h rename to src/Win32Console.h diff --git a/common.h b/src/common.h similarity index 74% rename from common.h rename to src/common.h index 726f5d4..8895a57 100644 --- a/common.h +++ b/src/common.h @@ -5,11 +5,19 @@ #include #include +#define NOMINMAX #include +#undef NOMINMAX + +#include "thirdparty/linalg.h" namespace gj { +using mat3 = ::linalg::mat; +using vec3 = ::linalg::vec; + + static inline std::wstring ConvertUtf8ToUtf16(const std::string& str) { std::wostringstream conv; conv << str.c_str(); diff --git a/iAllocator.h b/src/iAllocator.h similarity index 69% rename from iAllocator.h rename to src/iAllocator.h index 494a230..88927c4 100644 --- a/iAllocator.h +++ b/src/iAllocator.h @@ -32,7 +32,7 @@ public: }; template - using UniquePtr = std::unique_ptr>; + using UniqPtr = std::unique_ptr>; iAllocator(iAllocator&&) = default; iAllocator(const iAllocator&) = default; @@ -53,16 +53,24 @@ public: } template - UniquePtr MakeUnique(Args&&... args) { + UniqPtr MakeUniq(Args&&... args) { T* ptr = Alloc(); - return std::unique_ptr>(new(ptr) T(args...), Deleter(this)); + return std::unique_ptr>(new(ptr) T(std::forward(args)...), Deleter(this)); + } + template + UniqPtr MakeUniq(Args&&... args) { + T* ptr = Alloc(); + return std::unique_ptr>(new(ptr) T(std::forward(args)...), Deleter(this)); } template - UniquePtr MakeUniqueArray(size_t n) { + UniqPtr MakeUniqArray(size_t n) { T* ptr = Alloc(n); return std::unique_ptr>(ptr, Deleter(this)); } }; +template +using UniqPtr = iAllocator::UniqPtr; + } \ No newline at end of file diff --git a/iClock.h b/src/iClock.h similarity index 100% rename from iClock.h rename to src/iClock.h diff --git a/iConsole.h b/src/iConsole.h similarity index 100% rename from iConsole.h rename to src/iConsole.h diff --git a/iDrawable.h b/src/iDrawable.h similarity index 89% rename from iDrawable.h rename to src/iDrawable.h index ab15fed..e69b1b6 100644 --- a/iDrawable.h +++ b/src/iDrawable.h @@ -1,16 +1,12 @@ #pragma once -#include "thirdparty/linalg.h" - +#include "common.h" #include "Rasterbuffer.h" namespace gj { -using mat3 = ::linalg::mat; -using vec3 = ::linalg::vec; - class iDrawable { public: iDrawable(iDrawable&&) = default; diff --git a/src/iElement.h b/src/iElement.h new file mode 100644 index 0000000..b233047 --- /dev/null +++ b/src/iElement.h @@ -0,0 +1,28 @@ +#pragma once + +#include "Frame.h" +#include "Period.h" + + +namespace gj { + + +class iElement { + public: + iElement(iElement&&) = default; + iElement(const iElement&) = default; + + iElement& operator=(iElement&&) = default; + iElement& operator=(const iElement&) = default; + + iElement() = default; + virtual ~iElement() = default; + + virtual void Update(Frame& f) = 0; + + /* Interfaces had better not have a variable but this is for optimization. */ + const Period period; +}; + + +} \ No newline at end of file diff --git a/src/iElementDriver.h b/src/iElementDriver.h new file mode 100644 index 0000000..76e6ecc --- /dev/null +++ b/src/iElementDriver.h @@ -0,0 +1,29 @@ +#pragma once + +#include +#include +#include + + +namespace gj { + + +class iElementDriver { + public: + using Value = std::variant; + using Param = std::map; + + iElementDriver(iElementDriver&&) = default; + iElementDriver(const iElementDriver&) = default; + + iElementDriver& operator=(iElementDriver&&) = default; + iElementDriver& operator=(const iElementDriver&) = default; + + iElementDriver() = default; + virtual ~iElementDriver() = default; + + virtual void Update(Param&) = 0; +}; + + +} \ No newline at end of file diff --git a/src/iElementFactory.h b/src/iElementFactory.h new file mode 100644 index 0000000..e5379d2 --- /dev/null +++ b/src/iElementFactory.h @@ -0,0 +1,27 @@ +#pragma once + +#include "iAllocator.h" +#include "iElement.h" +#include "iElementDriver.h" +#include "Period.h" + + +namespace gj { + + +class iElementFactory { + public: + iElementFactory(iElementFactory&&) = default; + iElementFactory(const iElementFactory&) = default; + + iElementFactory& operator=(iElementFactory&&) = default; + iElementFactory& operator=(const iElementFactory&) = default; + + iElementFactory() = default; + virtual ~iElementFactory() = default; + + virtual UniqPtr Create(const Period& p, UniqPtr&& drv) = 0; +}; + + +} \ No newline at end of file diff --git a/iLogger.h b/src/iLogger.h similarity index 100% rename from iLogger.h rename to src/iLogger.h diff --git a/src/iScene.h b/src/iScene.h new file mode 100644 index 0000000..f9feb02 --- /dev/null +++ b/src/iScene.h @@ -0,0 +1,30 @@ +#pragma once + +#include + +#include "Frame.h" +#include "iAllocator.h" +#include "iDrawable.h" +#include "iWritable.h" + + +namespace gj { + + +class iScene { + public: + iScene() = default; + iScene(iScene&&) = default; + iScene(const iScene&) = default; + + iScene& operator=(iScene&&) = default; + iScene& operator=(const iScene&) = default; + + virtual ~iScene() = default; + + /* Returns next scene if this scene ends, otherwise nullptr. */ + virtual UniqPtr Update(Frame& f) = 0; +}; + + +} \ No newline at end of file diff --git a/iWritable.h b/src/iWritable.h similarity index 100% rename from iWritable.h rename to src/iWritable.h diff --git a/main.cc b/src/main.cc similarity index 80% rename from main.cc rename to src/main.cc index 8f2e391..bdf290e 100644 --- a/main.cc +++ b/src/main.cc @@ -9,6 +9,7 @@ #include "Font.h" #include "Game.h" #include "LinearAllocator.h" +#include "SystemClock.h" #include "Win32Console.h" @@ -24,7 +25,12 @@ int main() { gj::Win32Console console(&alloc, kWidth, kHeight); console.Show(); - gj::Game game(&alloc, kWidth, kHeight); + gj::Game::Param param; + param.alloc = &alloc; + param.clock = &gj::SystemClock::instance(); + param.w = kWidth; + param.h = kHeight; + gj::Game game(std::move(param)); while (true) { game.Update(); { diff --git a/thirdparty/lauxlib.h b/thirdparty/lauxlib.h new file mode 100644 index 0000000..3425823 --- /dev/null +++ b/thirdparty/lauxlib.h @@ -0,0 +1,174 @@ +/* +** $Id: lauxlib.h,v 1.88.1.1 2007/12/27 13:02:25 roberto Exp $ +** Auxiliary functions for building Lua libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lauxlib_h +#define lauxlib_h + + +#include +#include + +#include "lua.h" + + +#if defined(LUA_COMPAT_GETN) +LUALIB_API int (luaL_getn) (lua_State *L, int t); +LUALIB_API void (luaL_setn) (lua_State *L, int t, int n); +#else +#define luaL_getn(L,i) ((int)lua_objlen(L, i)) +#define luaL_setn(L,i,j) ((void)0) /* no op! */ +#endif + +#if defined(LUA_COMPAT_OPENLIB) +#define luaI_openlib luaL_openlib +#endif + + +/* extra error code for `luaL_load' */ +#define LUA_ERRFILE (LUA_ERRERR+1) + + +typedef struct luaL_Reg { + const char *name; + lua_CFunction func; +} luaL_Reg; + + + +LUALIB_API void (luaI_openlib) (lua_State *L, const char *libname, + const luaL_Reg *l, int nup); +LUALIB_API void (luaL_register) (lua_State *L, const char *libname, + const luaL_Reg *l); +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 int (luaL_typerror) (lua_State *L, int narg, const char *tname); +LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg); +LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg, + size_t *l); +LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg, + const char *def, size_t *l); +LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg); +LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def); + +LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg); +LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg, + 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 narg, int t); +LUALIB_API void (luaL_checkany) (lua_State *L, int narg); + +LUALIB_API int (luaL_newmetatable) (lua_State *L, 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 narg, const char *def, + const char *const lst[]); + +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_loadfile) (lua_State *L, const char *filename); +LUALIB_API int (luaL_loadbuffer) (lua_State *L, const char *buff, size_t sz, + const char *name); +LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s); + +LUALIB_API lua_State *(luaL_newstate) (void); + + +LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p, + const char *r); + +LUALIB_API const char *(luaL_findtable) (lua_State *L, int idx, + const char *fname, int szhint); + + + + +/* +** =============================================================== +** some useful macros +** =============================================================== +*/ + +#define luaL_argcheck(L, cond,numarg,extramsg) \ + ((void)((cond) || luaL_argerror(L, (numarg), (extramsg)))) +#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL)) +#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL)) +#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))) + +#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))) + +/* +** {====================================================== +** Generic Buffer manipulation +** ======================================================= +*/ + + + +typedef struct luaL_Buffer { + char *p; /* current position in buffer */ + int lvl; /* number of strings in the stack (level) */ + lua_State *L; + char buffer[LUAL_BUFFERSIZE]; +} luaL_Buffer; + +#define luaL_addchar(B,c) \ + ((void)((B)->p < ((B)->buffer+LUAL_BUFFERSIZE) || luaL_prepbuffer(B)), \ + (*(B)->p++ = (char)(c))) + +/* compatibility only */ +#define luaL_putchar(B,c) luaL_addchar(B,c) + +#define luaL_addsize(B,n) ((B)->p += (n)) + +LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B); +LUALIB_API char *(luaL_prepbuffer) (luaL_Buffer *B); +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); + + +/* }====================================================== */ + + +/* compatibility with ref system */ + +/* pre-defined references */ +#define LUA_NOREF (-2) +#define LUA_REFNIL (-1) + +#define lua_ref(L,lock) ((lock) ? luaL_ref(L, LUA_REGISTRYINDEX) : \ + (lua_pushstring(L, "unlocked references are obsolete"), lua_error(L), 0)) + +#define lua_unref(L,ref) luaL_unref(L, LUA_REGISTRYINDEX, (ref)) + +#define lua_getref(L,ref) lua_rawgeti(L, LUA_REGISTRYINDEX, (ref)) + + +#define luaL_reg luaL_Reg + +#endif + + diff --git a/thirdparty/lua.h b/thirdparty/lua.h new file mode 100644 index 0000000..e4bdfd3 --- /dev/null +++ b/thirdparty/lua.h @@ -0,0 +1,388 @@ +/* +** $Id: lua.h,v 1.218.1.5 2008/08/06 13:30:12 roberto Exp $ +** Lua - An Extensible Extension 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 "Lua 5.1" +#define LUA_RELEASE "Lua 5.1.4" +#define LUA_VERSION_NUM 501 +#define LUA_COPYRIGHT "Copyright (C) 1994-2008 Lua.org, PUC-Rio" +#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo & W. Celes" + + +/* mark for precompiled code (`Lua') */ +#define LUA_SIGNATURE "\033Lua" + +/* option for multiple returns in `lua_pcall' and `lua_call' */ +#define LUA_MULTRET (-1) + + +/* +** pseudo-indices +*/ +#define LUA_REGISTRYINDEX (-10000) +#define LUA_ENVIRONINDEX (-10001) +#define LUA_GLOBALSINDEX (-10002) +#define lua_upvalueindex(i) (LUA_GLOBALSINDEX-(i)) + + +/* thread status; 0 is OK */ +#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; + +typedef int (*lua_CFunction) (lua_State *L); + + +/* +** 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); + + +/* +** prototype for memory-allocation functions +*/ +typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize); + + +/* +** 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 + + + +/* minimum Lua stack available to a C function */ +#define LUA_MINSTACK 20 + + +/* +** generic extra include file +*/ +#if defined(LUA_USER_H) +#include LUA_USER_H +#endif + + +/* type of numbers in Lua */ +typedef LUA_NUMBER lua_Number; + + +/* type for integer functions */ +typedef LUA_INTEGER lua_Integer; + + + +/* +** 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 lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf); + + +/* +** basic stack manipulation +*/ +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_remove) (lua_State *L, int idx); +LUA_API void (lua_insert) (lua_State *L, int idx); +LUA_API void (lua_replace) (lua_State *L, int idx); +LUA_API int (lua_checkstack) (lua_State *L, int sz); + +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_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 int (lua_equal) (lua_State *L, int idx1, int idx2); +LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2); +LUA_API int (lua_lessthan) (lua_State *L, int idx1, int idx2); + +LUA_API lua_Number (lua_tonumber) (lua_State *L, int idx); +LUA_API lua_Integer (lua_tointeger) (lua_State *L, int idx); +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 size_t (lua_objlen) (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); + + +/* +** 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 void (lua_pushlstring) (lua_State *L, const char *s, size_t l); +LUA_API void (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 void (lua_gettable) (lua_State *L, int idx); +LUA_API void (lua_getfield) (lua_State *L, int idx, const char *k); +LUA_API void (lua_rawget) (lua_State *L, int idx); +LUA_API void (lua_rawgeti) (lua_State *L, int idx, int n); +LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec); +LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz); +LUA_API int (lua_getmetatable) (lua_State *L, int objindex); +LUA_API void (lua_getfenv) (lua_State *L, int idx); + + +/* +** set functions (stack -> Lua) +*/ +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_rawset) (lua_State *L, int idx); +LUA_API void (lua_rawseti) (lua_State *L, int idx, int n); +LUA_API int (lua_setmetatable) (lua_State *L, int objindex); +LUA_API int (lua_setfenv) (lua_State *L, int idx); + + +/* +** `load' and `call' functions (load and run Lua code) +*/ +LUA_API void (lua_call) (lua_State *L, int nargs, int nresults); +LUA_API int (lua_pcall) (lua_State *L, int nargs, int nresults, int errfunc); +LUA_API int (lua_cpcall) (lua_State *L, lua_CFunction func, void *ud); +LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt, + const char *chunkname); + +LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data); + + +/* +** coroutine functions +*/ +LUA_API int (lua_yield) (lua_State *L, int nresults); +LUA_API int (lua_resume) (lua_State *L, int narg); +LUA_API int (lua_status) (lua_State *L); + +/* +** 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 + +LUA_API int (lua_gc) (lua_State *L, int what, int data); + + +/* +** 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 lua_Alloc (lua_getallocf) (lua_State *L, void **ud); +LUA_API void lua_setallocf (lua_State *L, lua_Alloc f, void *ud); + + + +/* +** =============================================================== +** some useful macros +** =============================================================== +*/ + +#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_strlen(L,i) lua_objlen(L, (i)) + +#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_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1) + +#define lua_setglobal(L,s) lua_setfield(L, LUA_GLOBALSINDEX, (s)) +#define lua_getglobal(L,s) lua_getfield(L, LUA_GLOBALSINDEX, (s)) + +#define lua_tostring(L,i) lua_tolstring(L, (i), NULL) + + + +/* +** compatibility macros and functions +*/ + +#define lua_open() luaL_newstate() + +#define lua_getregistry(L) lua_pushvalue(L, LUA_REGISTRYINDEX) + +#define lua_getgccount(L) lua_gc(L, LUA_GCCOUNT, 0) + +#define lua_Chunkreader lua_Reader +#define lua_Chunkwriter lua_Writer + + +/* hack */ +LUA_API void lua_setlevel (lua_State *from, lua_State *to); + + +/* +** {====================================================================== +** Debug API +** ======================================================================= +*/ + + +/* +** Event codes +*/ +#define LUA_HOOKCALL 0 +#define LUA_HOOKRET 1 +#define LUA_HOOKLINE 2 +#define LUA_HOOKCOUNT 3 +#define LUA_HOOKTAILRET 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 debuger 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 int 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); + + +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) */ + int currentline; /* (l) */ + int nups; /* (u) number of upvalues */ + int linedefined; /* (S) */ + int lastlinedefined; /* (S) */ + char short_src[LUA_IDSIZE]; /* (S) */ + /* private part */ + int i_ci; /* active function */ +}; + +/* }====================================================================== */ + + +/****************************************************************************** +* Copyright (C) 1994-2008 Lua.org, PUC-Rio. All rights reserved. +* +* 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/thirdparty/lua.hpp b/thirdparty/lua.hpp new file mode 100644 index 0000000..ec417f5 --- /dev/null +++ b/thirdparty/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/thirdparty/lua5.1.dll b/thirdparty/lua5.1.dll new file mode 100644 index 0000000000000000000000000000000000000000..b15fa18e9af4182b09209ca0a9f3d73402bac6c6 GIT binary patch literal 212480 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 SQP#pgpZJoR@^ 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 literal 0 HcmV?d00001 diff --git a/thirdparty/luaconf.h b/thirdparty/luaconf.h new file mode 100644 index 0000000..bb3fa30 --- /dev/null +++ b/thirdparty/luaconf.h @@ -0,0 +1,766 @@ +/* +** $Id: luaconf.h,v 1.82.1.7 2008/02/11 16:25:08 roberto Exp $ +** Configuration file for Lua +** See Copyright Notice in lua.h +*/ + + +#ifndef lconfig_h +#define lconfig_h + +#include +#include + + +/* +** ================================================================== +** Search for "@@" to find all configurable definitions. +** =================================================================== +*/ + + +/* +@@ LUA_ANSI controls the use of non-ansi features. +** CHANGE it (define it) if you want Lua to avoid the use of any +** non-ansi feature or library. +*/ +#if defined(__STRICT_ANSI__) +#define LUA_ANSI +#endif + + +#if !defined(LUA_ANSI) && defined(_WIN32) +#define LUA_WIN +#endif + +#if defined(LUA_USE_LINUX) +#define LUA_USE_POSIX +#define LUA_USE_DLOPEN /* needs an extra library: -ldl */ +#define LUA_USE_READLINE /* needs some extra libraries */ +#endif + +#if defined(LUA_USE_MACOSX) +#define LUA_USE_POSIX +#define LUA_DL_DYLD /* does not need extra library */ +#endif + + + +/* +@@ LUA_USE_POSIX includes all functionallity listed as X/Open System +@* Interfaces Extension (XSI). +** CHANGE it (define it) if your system is XSI compatible. +*/ +#if defined(LUA_USE_POSIX) +#define LUA_USE_MKSTEMP +#define LUA_USE_ISATTY +#define LUA_USE_POPEN +#define LUA_USE_ULONGJMP +#endif + + +/* +@@ LUA_PATH and LUA_CPATH are the names of the environment variables that +@* Lua check to set its paths. +@@ LUA_INIT is the name of the environment variable that Lua +@* checks for initialization code. +** CHANGE them if you want different names. +*/ +#define LUA_PATH "LUA_PATH" +#define LUA_CPATH "LUA_CPATH" +#define LUA_INIT "LUA_INIT" + + +/* +@@ 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. +*/ +#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_PATH_DEFAULT \ + ".\\?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua" +#define LUA_CPATH_DEFAULT \ + ".\\?.dll;" LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" \ + LUA_CDIR"clibs\\?.dll;" LUA_CDIR"clibs\\loadall.dll;" \ + ".\\?51.dll;" LUA_CDIR"?51.dll;" LUA_CDIR"clibs\\?51.dll" + +#else +#define LUA_ROOT "/usr/local/" +#define LUA_LDIR LUA_ROOT "share/lua/5.1/" +#define LUA_CDIR LUA_ROOT "lib/lua/5.1/" +#define LUA_PATH_DEFAULT \ + "./?.lua;" LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \ + LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua" +#define LUA_CPATH_DEFAULT \ + "./?.so;" LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" \ + "./lib?51.so;" LUA_CDIR"lib?51.so;" +#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(_WIN32) +#define LUA_DIRSEP "\\" +#else +#define LUA_DIRSEP "/" +#endif + + +/* +@@ LUA_PATHSEP is the character that separates templates in a path. +@@ LUA_PATH_MARK is the string that marks the substitution points in a +@* template. +@@ LUA_EXECDIR in a Windows path is replaced by the executable's +@* directory. +@@ LUA_IGMARK is a mark to ignore all before it when bulding the +@* luaopen_ function name. +** CHANGE them if for some reason your system cannot use those +** characters. (E.g., if one of those characters is a common character +** in file/directory names.) Probably you do not need to change them. +*/ +#define LUA_PATHSEP ";" +#define LUA_PATH_MARK "?" +#define LUA_EXECDIR "!" +#define LUA_IGMARK "-" + + +/* +@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger. +** CHANGE that if ptrdiff_t is not adequate on your machine. (On most +** machines, ptrdiff_t gives a good choice between int or long.) +*/ +#define LUA_INTEGER ptrdiff_t + + +/* +@@ LUA_API is a mark for all core API functions. +@@ LUALIB_API is a mark for all standard library 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 + + +/* +@@ LUAI_FUNC is a mark for all extern functions that are not to be +@* exported to outside modules. +@@ LUAI_DATA is a mark for all extern (const) variables that are not to +@* be exported to outside modules. +** 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. +*/ +#if defined(luaall_c) +#define LUAI_FUNC static +#define LUAI_DATA /* empty */ + +#elif defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \ + defined(__ELF__) +#define LUAI_FUNC __attribute__((visibility("hidden"))) extern +#define LUAI_DATA LUAI_FUNC + +#else +#define LUAI_FUNC extern +#define LUAI_DATA extern +#endif + + + +/* +@@ LUA_QL describes how error messages quote program elements. +** CHANGE it if you want a different appearance. +*/ +#define LUA_QL(x) "'" x "'" +#define LUA_QS LUA_QL("%s") + + +/* +@@ 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 + + +/* +** {================================================================== +** Stand-alone configuration +** =================================================================== +*/ + +#if defined(lua_c) || defined(luaall_c) + +/* +@@ lua_stdin_is_tty detects whether the standard input is a 'tty' (that +@* is, whether we're running lua interactively). +** CHANGE it if you have a better definition for non-POSIX/non-Windows +** systems. +*/ +#if defined(LUA_USE_ISATTY) +#include +#define lua_stdin_is_tty() isatty(0) +#elif defined(LUA_WIN) +#include +#include +#define lua_stdin_is_tty() _isatty(_fileno(stdin)) +#else +#define lua_stdin_is_tty() 1 /* assume stdin is a tty */ +#endif + + +/* +@@ LUA_PROMPT is the default prompt used by stand-alone Lua. +@@ LUA_PROMPT2 is the default continuation prompt used by stand-alone Lua. +** CHANGE them if you want different prompts. (You can also change the +** prompts dynamically, assigning to globals _PROMPT/_PROMPT2.) +*/ +#define LUA_PROMPT "> " +#define LUA_PROMPT2 ">> " + + +/* +@@ LUA_PROGNAME is the default name for the stand-alone Lua program. +** CHANGE it if your stand-alone interpreter has a different name and +** your system is not able to detect that name automatically. +*/ +#define LUA_PROGNAME "lua" + + +/* +@@ LUA_MAXINPUT is the maximum length for an input line in the +@* stand-alone interpreter. +** CHANGE it if you need longer lines. +*/ +#define LUA_MAXINPUT 512 + + +/* +@@ lua_readline defines how to show a prompt and then read a line from +@* the standard input. +@@ lua_saveline defines how to "save" a read line in a "history". +@@ lua_freeline defines how to free a line read by lua_readline. +** CHANGE them if you want to improve this functionality (e.g., by using +** GNU readline and history facilities). +*/ +#if defined(LUA_USE_READLINE) +#include +#include +#include +#define lua_readline(L,b,p) ((void)L, ((b)=readline(p)) != NULL) +#define lua_saveline(L,idx) \ + if (lua_strlen(L,idx) > 0) /* non-empty line? */ \ + add_history(lua_tostring(L, idx)); /* add it to history */ +#define lua_freeline(L,b) ((void)L, free(b)) +#else +#define lua_readline(L,b,p) \ + ((void)L, fputs(p, stdout), fflush(stdout), /* show prompt */ \ + fgets(b, LUA_MAXINPUT, stdin) != NULL) /* get line */ +#define lua_saveline(L,idx) { (void)L; (void)idx; } +#define lua_freeline(L,b) { (void)L; (void)b; } +#endif + +#endif + +/* }================================================================== */ + + +/* +@@ LUAI_GCPAUSE defines the default pause between garbage-collector cycles +@* as a percentage. +** CHANGE it if you want the GC to run faster or slower (higher values +** mean larger pauses which mean slower collection.) You can also change +** this value dynamically. +*/ +#define LUAI_GCPAUSE 200 /* 200% (wait memory to double before next GC) */ + + +/* +@@ LUAI_GCMUL defines the default speed of garbage collection relative to +@* memory allocation as a percentage. +** CHANGE it if you want to change the granularity of the garbage +** collection. (Higher values mean coarser collections. 0 represents +** infinity, where each step performs a full collection.) You can also +** change this value dynamically. +*/ +#define LUAI_GCMUL 200 /* GC runs 'twice the speed' of memory allocation */ + + + +/* +@@ LUA_COMPAT_GETN controls compatibility with old getn behavior. +** CHANGE it (define it) if you want exact compatibility with the +** behavior of setn/getn in Lua 5.0. +*/ +#undef LUA_COMPAT_GETN + +/* +@@ LUA_COMPAT_LOADLIB controls compatibility about global loadlib. +** CHANGE it to undefined as soon as you do not need a global 'loadlib' +** function (the function is still available as 'package.loadlib'). +*/ +#undef LUA_COMPAT_LOADLIB + +/* +@@ LUA_COMPAT_VARARG controls compatibility with old vararg feature. +** CHANGE it to undefined as soon as your programs use only '...' to +** access vararg parameters (instead of the old 'arg' table). +*/ +#define LUA_COMPAT_VARARG + +/* +@@ LUA_COMPAT_MOD controls compatibility with old math.mod function. +** CHANGE it to undefined as soon as your programs use 'math.fmod' or +** the new '%' operator instead of 'math.mod'. +*/ +#define LUA_COMPAT_MOD + +/* +@@ LUA_COMPAT_LSTR controls compatibility with old long string nesting +@* facility. +** CHANGE it to 2 if you want the old behaviour, or undefine it to turn +** off the advisory error when nesting [[...]]. +*/ +#define LUA_COMPAT_LSTR 1 + +/* +@@ LUA_COMPAT_GFIND controls compatibility with old 'string.gfind' name. +** CHANGE it to undefined as soon as you rename 'string.gfind' to +** 'string.gmatch'. +*/ +#define LUA_COMPAT_GFIND + +/* +@@ LUA_COMPAT_OPENLIB controls compatibility with old 'luaL_openlib' +@* behavior. +** CHANGE it to undefined as soon as you replace to 'luaL_register' +** your uses of 'luaL_openlib' +*/ +#define LUA_COMPAT_OPENLIB + + + +/* +@@ luai_apicheck is the assert macro used by the Lua-C API. +** CHANGE luai_apicheck if you want Lua to perform some checks in the +** parameters it gets from API calls. This may slow down the interpreter +** a bit, but may be quite useful when debugging C code that interfaces +** with Lua. A useful redefinition is to use assert.h. +*/ +#if defined(LUA_USE_APICHECK) +#include +#define luai_apicheck(L,o) { (void)L; assert(o); } +#else +#define luai_apicheck(L,o) { (void)L; } +#endif + + +/* +@@ LUAI_BITSINT defines the number of bits in an int. +** CHANGE here if Lua cannot automatically detect the number of bits of +** your machine. Probably you do not need to change this. +*/ +/* avoid overflows in comparison */ +#if INT_MAX-20 < 32760 +#define LUAI_BITSINT 16 +#elif INT_MAX > 2147483640L +/* int has at least 32 bits */ +#define LUAI_BITSINT 32 +#else +#error "you must define LUA_BITSINT with number of bits in an integer" +#endif + + +/* +@@ LUAI_UINT32 is an unsigned integer with at least 32 bits. +@@ LUAI_INT32 is an signed integer with at least 32 bits. +@@ LUAI_UMEM is an unsigned integer big enough to count the total +@* memory used by Lua. +@@ LUAI_MEM is a signed integer big enough to count the total memory +@* used by Lua. +** CHANGE here if for some weird reason the default definitions are not +** good enough for your machine. (The definitions in the 'else' +** part always works, but may waste space on machines with 64-bit +** longs.) Probably you do not need to change this. +*/ +#if LUAI_BITSINT >= 32 +#define LUAI_UINT32 unsigned int +#define LUAI_INT32 int +#define LUAI_MAXINT32 INT_MAX +#define LUAI_UMEM size_t +#define LUAI_MEM ptrdiff_t +#else +/* 16-bit ints */ +#define LUAI_UINT32 unsigned long +#define LUAI_INT32 long +#define LUAI_MAXINT32 LONG_MAX +#define LUAI_UMEM unsigned long +#define LUAI_MEM long +#endif + + +/* +@@ LUAI_MAXCALLS limits the number of nested calls. +** CHANGE it if you need really deep recursive calls. This limit is +** arbitrary; its only purpose is to stop infinite recursion before +** exhausting memory. +*/ +#define LUAI_MAXCALLS 20000 + + +/* +@@ LUAI_MAXCSTACK limits the number of Lua stack slots that a C function +@* can use. +** CHANGE it if you need lots of (Lua) stack space for your C +** functions. This limit is arbitrary; its only purpose is to stop C +** functions to consume unlimited stack space. (must be smaller than +** -LUA_REGISTRYINDEX) +*/ +#define LUAI_MAXCSTACK 8000 + + + +/* +** {================================================================== +** CHANGE (to smaller values) the following definitions if your system +** has a small C stack. (Or you may want to change them to larger +** values if your system has a large C stack and these limits are +** too rigid for you.) Some of these constants control the size of +** stack-allocated arrays used by the compiler or the interpreter, while +** others limit the maximum number of recursive calls that the compiler +** or the interpreter can perform. Values too large may cause a C stack +** overflow for some forms of deep constructs. +** =================================================================== +*/ + + +/* +@@ LUAI_MAXCCALLS is the maximum depth for nested C calls (short) and +@* syntactical nested non-terminals in a program. +*/ +#define LUAI_MAXCCALLS 200 + + +/* +@@ LUAI_MAXVARS is the maximum number of local variables per function +@* (must be smaller than 250). +*/ +#define LUAI_MAXVARS 200 + + +/* +@@ LUAI_MAXUPVALUES is the maximum number of upvalues per function +@* (must be smaller than 250). +*/ +#define LUAI_MAXUPVALUES 60 + + +/* +@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system. +*/ +#define LUAL_BUFFERSIZE BUFSIZ + +/* }================================================================== */ + + + + +/* +** {================================================================== +@@ LUA_NUMBER is the type of numbers in Lua. +** CHANGE the following definitions only if you want to build Lua +** with a number type different from double. You may also need to +** change lua_number2int & lua_number2integer. +** =================================================================== +*/ + +#define LUA_NUMBER_DOUBLE +#define LUA_NUMBER double + +/* +@@ LUAI_UACNUMBER is the result of an 'usual argument conversion' +@* over a number. +*/ +#define LUAI_UACNUMBER double + + +/* +@@ LUA_NUMBER_SCAN is the format for reading numbers. +@@ LUA_NUMBER_FMT is the format for writing numbers. +@@ lua_number2str converts a number to a string. +@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion. +@@ lua_str2number converts a string to a number. +*/ +#define LUA_NUMBER_SCAN "%lf" +#define LUA_NUMBER_FMT "%.14g" +#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n)) +#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */ +#define lua_str2number(s,p) strtod((s), (p)) + + +/* +@@ The luai_num* macros define the primitive operations over numbers. +*/ +#if defined(LUA_CORE) +#include +#define luai_numadd(a,b) ((a)+(b)) +#define luai_numsub(a,b) ((a)-(b)) +#define luai_nummul(a,b) ((a)*(b)) +#define luai_numdiv(a,b) ((a)/(b)) +#define luai_nummod(a,b) ((a) - floor((a)/(b))*(b)) +#define luai_numpow(a,b) (pow(a,b)) +#define luai_numunm(a) (-(a)) +#define luai_numeq(a,b) ((a)==(b)) +#define luai_numlt(a,b) ((a)<(b)) +#define luai_numle(a,b) ((a)<=(b)) +#define luai_numisnan(a) (!luai_numeq((a), (a))) +#endif + + +/* +@@ lua_number2int is a macro to convert lua_Number to int. +@@ lua_number2integer is a macro to convert lua_Number to lua_Integer. +** CHANGE them if you know a faster way to convert a lua_Number to +** int (with any rounding method and without throwing errors) in your +** system. In Pentium machines, a naive typecast from double to int +** in C is extremely slow, so any alternative is worth trying. +*/ + +/* On a Pentium, resort to a trick */ +#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) && !defined(__SSE2__) && \ + (defined(__i386) || defined (_M_IX86) || defined(__i386__)) + +/* On a Microsoft compiler, use assembler */ +#if defined(_MSC_VER) + +#define lua_number2int(i,d) __asm fld d __asm fistp i +#define lua_number2integer(i,n) lua_number2int(i, n) + +/* the next trick should work on any Pentium, but sometimes clashes + with a DirectX idiosyncrasy */ +#else + +union luai_Cast { double l_d; long l_l; }; +#define lua_number2int(i,d) \ + { volatile union luai_Cast u; u.l_d = (d) + 6755399441055744.0; (i) = u.l_l; } +#define lua_number2integer(i,n) lua_number2int(i, n) + +#endif + + +/* this option always works, but may be slow */ +#else +#define lua_number2int(i,d) ((i)=(int)(d)) +#define lua_number2integer(i,d) ((i)=(lua_Integer)(d)) + +#endif + +/* }================================================================== */ + + +/* +@@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment. +** CHANGE it if your system requires alignments larger than double. (For +** instance, if your system supports long doubles and they must be +** aligned in 16-byte boundaries, then you should add long double in the +** union.) Probably you do not need to change this. +*/ +#define LUAI_USER_ALIGNMENT_T union { double u; void *s; long l; } + + +/* +@@ LUAI_THROW/LUAI_TRY define how Lua does exception handling. +** CHANGE them if you prefer to use longjmp/setjmp even with C++ +** or if want/don't to use _longjmp/_setjmp instead of regular +** longjmp/setjmp. By default, Lua handles errors with exceptions when +** compiling as C++ code, with _longjmp/_setjmp when asked to use them, +** and with longjmp/setjmp otherwise. +*/ +#if defined(__cplusplus) +/* C++ exceptions */ +#define LUAI_THROW(L,c) throw(c) +#define LUAI_TRY(L,c,a) try { a } catch(...) \ + { if ((c)->status == 0) (c)->status = -1; } +#define luai_jmpbuf int /* dummy variable */ + +#elif defined(LUA_USE_ULONGJMP) +/* in Unix, try _longjmp/_setjmp (more efficient) */ +#define LUAI_THROW(L,c) _longjmp((c)->b, 1) +#define LUAI_TRY(L,c,a) if (_setjmp((c)->b) == 0) { a } +#define luai_jmpbuf jmp_buf + +#else +/* default handling with long jumps */ +#define LUAI_THROW(L,c) longjmp((c)->b, 1) +#define LUAI_TRY(L,c,a) if (setjmp((c)->b) == 0) { a } +#define luai_jmpbuf jmp_buf + +#endif + + +/* +@@ LUA_MAXCAPTURES is the maximum number of captures that a pattern +@* can do during pattern-matching. +** CHANGE it if you need more captures. This limit is arbitrary. +*/ +#define LUA_MAXCAPTURES 32 + + +/* +@@ lua_tmpnam is the function that the OS library uses to create a +@* temporary name. +@@ LUA_TMPNAMBUFSIZE is the maximum size of a name created by lua_tmpnam. +** CHANGE them if you have an alternative to tmpnam (which is considered +** insecure) or if you want the original tmpnam anyway. By default, Lua +** uses tmpnam except when POSIX is available, where it uses mkstemp. +*/ +#if defined(loslib_c) || defined(luaall_c) + +#if defined(LUA_USE_MKSTEMP) +#include +#define LUA_TMPNAMBUFSIZE 32 +#define lua_tmpnam(b,e) { \ + strcpy(b, "/tmp/lua_XXXXXX"); \ + e = mkstemp(b); \ + if (e != -1) close(e); \ + e = (e == -1); } + +#else +#define LUA_TMPNAMBUFSIZE L_tmpnam +#define lua_tmpnam(b,e) { e = (tmpnam(b) == NULL); } +#endif + +#endif + + +/* +@@ lua_popen spawns a new process connected to the current one through +@* the file streams. +** CHANGE it if you have a way to implement it in your system. +*/ +#if defined(LUA_USE_POPEN) + +#define lua_popen(L,c,m) ((void)L, fflush(NULL), popen(c,m)) +#define lua_pclose(L,file) ((void)L, (pclose(file) != -1)) + +#elif defined(LUA_WIN) + +#define lua_popen(L,c,m) ((void)L, _popen(c,m)) +#define lua_pclose(L,file) ((void)L, (_pclose(file) != -1)) + +#else + +#define lua_popen(L,c,m) ((void)((void)c, m), \ + luaL_error(L, LUA_QL("popen") " not supported"), (FILE*)0) +#define lua_pclose(L,file) ((void)((void)L, file), 0) + +#endif + +/* +@@ LUA_DL_* define which dynamic-library system Lua should use. +** CHANGE here if Lua has problems choosing the appropriate +** dynamic-library system for your platform (either Windows' DLL, Mac's +** dyld, or Unix's dlopen). If your system is some kind of Unix, there +** is a good chance that it has dlopen, so LUA_DL_DLOPEN will work for +** it. To use dlopen you also need to adapt the src/Makefile (probably +** adding -ldl to the linker options), so Lua does not select it +** automatically. (When you change the makefile to add -ldl, you must +** also add -DLUA_USE_DLOPEN.) +** If you do not want any kind of dynamic library, undefine all these +** options. +** By default, _WIN32 gets LUA_DL_DLL and MAC OS X gets LUA_DL_DYLD. +*/ +#if defined(LUA_USE_DLOPEN) +#define LUA_DL_DLOPEN +#endif + +#if defined(LUA_WIN) +#define LUA_DL_DLL +#endif + + +/* +@@ LUAI_EXTRASPACE allows you to add user-specific data in a lua_State +@* (the data goes just *before* the lua_State pointer). +** CHANGE (define) this if you really need that. This value must be +** a multiple of the maximum alignment required for your machine. +*/ +#define LUAI_EXTRASPACE 0 + + +/* +@@ luai_userstate* allow user-specific actions on threads. +** CHANGE them if you defined LUAI_EXTRASPACE and need to do something +** extra when a thread is created/deleted/resumed/yielded. +*/ +#define luai_userstateopen(L) ((void)L) +#define luai_userstateclose(L) ((void)L) +#define luai_userstatethread(L,L1) ((void)L) +#define luai_userstatefree(L) ((void)L) +#define luai_userstateresume(L,n) ((void)L) +#define luai_userstateyield(L,n) ((void)L) + + +/* +@@ LUA_INTFRMLEN is the length modifier for integer conversions +@* in 'string.format'. +@@ LUA_INTFRM_T is the integer type correspoding to the previous length +@* modifier. +** CHANGE them if your system supports long long or does not support long. +*/ + +#if defined(LUA_USELONGLONG) + +#define LUA_INTFRMLEN "ll" +#define LUA_INTFRM_T long long + +#else + +#define LUA_INTFRMLEN "l" +#define LUA_INTFRM_T long + +#endif + + + +/* =================================================================== */ + +/* +** Local configuration. You can use this space to add your redefinitions +** without modifying the main part of the file. +*/ + + + +#endif + diff --git a/thirdparty/lualib.h b/thirdparty/lualib.h new file mode 100644 index 0000000..469417f --- /dev/null +++ b/thirdparty/lualib.h @@ -0,0 +1,53 @@ +/* +** $Id: lualib.h,v 1.36.1.1 2007/12/27 13:02:25 roberto Exp $ +** Lua standard libraries +** See Copyright Notice in lua.h +*/ + + +#ifndef lualib_h +#define lualib_h + +#include "lua.h" + + +/* Key to file-handle type */ +#define LUA_FILEHANDLE "FILE*" + + +#define LUA_COLIBNAME "coroutine" +LUALIB_API int (luaopen_base) (lua_State *L); + +#define LUA_TABLIBNAME "table" +LUALIB_API int (luaopen_table) (lua_State *L); + +#define LUA_IOLIBNAME "io" +LUALIB_API int (luaopen_io) (lua_State *L); + +#define LUA_OSLIBNAME "os" +LUALIB_API int (luaopen_os) (lua_State *L); + +#define LUA_STRLIBNAME "string" +LUALIB_API int (luaopen_string) (lua_State *L); + +#define LUA_MATHLIBNAME "math" +LUALIB_API int (luaopen_math) (lua_State *L); + +#define LUA_DBLIBNAME "debug" +LUALIB_API int (luaopen_debug) (lua_State *L); + +#define LUA_LOADLIBNAME "package" +LUALIB_API int (luaopen_package) (lua_State *L); + + +/* open all previous libraries */ +LUALIB_API void (luaL_openlibs) (lua_State *L); + + + +#ifndef lua_assert +#define lua_assert(x) ((void)0) +#endif + + +#endif