script_export.cpp

Go to the documentation of this file.

#include "stdafx.h"
#include "include/script.h"
#include "include/debug.h"

namespace yappy {
namespace lua {
namespace export {

namespace {

template <class T>
inline T *getPtrFromUpvalue(lua_State *L, int uvInd)
{
    int idx = lua_upvalueindex(uvInd);
    ASSERT(lua_type(L, idx) == LUA_TLIGHTUSERDATA);
    void *p = lua_touserdata(L, idx);
    return static_cast<T *>(p);
}

template <class F>
inline int exceptToLuaError(lua_State *L, F proc)
{
    try {
        return proc();
    }
    catch (const std::exception &ex) {
        // push string ex.what() and throw
        // noreturn
        return luaL_error(L, "%s", ex.what());
    }
}

template <class T>
using lim = std::numeric_limits<T>;

static_assert(lim<lua_Integer>::min() <= lim<int>::min(),   "Lua type check");
static_assert(lim<lua_Integer>::max() >= lim<int>::max(),   "Lua type check");
static_assert(lim<lua_Number>::max() >= lim<float>::max(),  "Lua type check");

inline int luaintToInt(lua_State *L, int arg,
    lua_Integer val, int min, int max)
{
    luaL_argcheck(L, val >= min, arg, "number too small");
    luaL_argcheck(L, val <= max, arg, "number too large");
    return static_cast<int>(val);
}

inline int getInt(lua_State *L, int arg,
    int min = std::numeric_limits<int>::min(),
    int max = std::numeric_limits<int>::max())
{
    lua_Integer val = luaL_checkinteger(L, arg);
    return luaintToInt(L, arg, val, min, max);
}

inline int getOptInt(lua_State *L, int arg, int def,
    int min = std::numeric_limits<int>::min(),
    int max = std::numeric_limits<int>::max())
{
    lua_Integer val = luaL_optinteger(L, arg, def);
    return luaintToInt(L, arg, val, min, max);
}

inline float luanumToFloat(lua_State *L, int arg,
    lua_Number val, float min, float max)
{
    luaL_argcheck(L, val >= min, arg, "number too small or NaN");
    luaL_argcheck(L, val <= max, arg, "number too large or NaN");
    return static_cast<float>(val);
}

inline double luanumToDouble(lua_State *L, int arg,
    lua_Number val, double min, double max)
{
    luaL_argcheck(L, val >= min, arg, "number too small or NaN");
    luaL_argcheck(L, val <= max, arg, "number too large or NaN");
    return static_cast<double>(val);
}

inline float getFloat(lua_State *L, int arg,
    float min = std::numeric_limits<float>::lowest(),
    float max = std::numeric_limits<float>::max())
{
    lua_Number val = luaL_checknumber(L, arg);
    return luanumToFloat(L, arg, val, min, max);
}

inline float getOptFloat(lua_State *L, int arg, float def,
    float min = std::numeric_limits<float>::lowest(),
    float max = std::numeric_limits<float>::max())
{
    lua_Number val = luaL_optnumber(L, arg, def);
    return luanumToFloat(L, arg, val, min, max);
}

inline double getDouble(lua_State *L, int arg,
    double min = std::numeric_limits<double>::lowest(),
    double max = std::numeric_limits<double>::max())
{
    lua_Number val = luaL_checknumber(L, arg);
    return luanumToDouble(L, arg, val, min, max);
}

inline double getOptDouble(lua_State *L, int arg, double def,
    double min = std::numeric_limits<double>::lowest(),
    double max = std::numeric_limits<double>::max())
{
    lua_Number val = luaL_optnumber(L, arg, def);
    return luanumToDouble(L, arg, val, min, max);
}

}   // namespace

// "trace" table

int trace::write(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        int argc = lua_gettop(L);
        for (int i = 1; i <= argc; i++) {
            const char *str = lua_tostring(L, i);
            if (str != nullptr) {
                debug::writeLine(str);
            }
            else if (lua_type(L, i) == LUA_TBOOLEAN) {
                int b = lua_toboolean(L, i);
                debug::writeLine(b ? "true" : "false");
            }
            else {
                debug::writef("<%s>", luaL_typename(L, i));
            }
        }
        return 0;
    });
}

int trace::perf(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        int argc = lua_gettop(L);
        for (int i = 1; i <= argc; i++) {
            const char *str = ::lua_tostring(L, i);
            if (str != nullptr) {
                yappy::trace::write(str);
            }
            else {
                debug::writef("<%s>", luaL_typename(L, i));
            }
        }
        return 0;
    });
}

// "sys" table

int sys::include(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *lua = getPtrFromUpvalue<Lua>(L, 1);

        int argc = lua_gettop(L);
        for (int i = 1; i <= argc; i++) {
            const char *fileName = ::lua_tostring(L, i);
            luaL_argcheck(L, fileName != nullptr, i, "string needed");

            lua->loadFile(util::utf82wc(fileName).get(), false, false);
        }
        return 0;
    });
}

int sys::readFile(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        const char *fileName = luaL_checkstring(L, 1);

        FILE *tmpfp = nullptr;
        errno_t err = ::fopen_s(&tmpfp, fileName, "r");
        if (err == ENOENT) {
            // return;
            return 0;
        }
        else if (err != 0) {
            luaL_error(L, "File open error: %s, %d", fileName, err);
        }

        // return ...;
        int retcnt = 0;

        util::FilePtr fp(tmpfp);
        char buf[1024];
        while (std::fgets(buf, sizeof(buf), fp.get()) != nullptr) {
            // find new line
            char *pnl = std::strchr(buf, '\n');
            if (pnl != nullptr) {
                // OK, delete '\n'
                *pnl = '\0';
            }
            else {
                // line buffer over or EOF without new line
                // discard until NL is found or reach EOF
                char disc[1024];
                do {
                    if (std::fgets(disc, sizeof(disc), fp.get()) == nullptr) {
                        break;
                    }
                } while (std::strchr(disc, '\n') == nullptr);
            }
            lua_pushstring(L, buf);
            retcnt++;
        }
        return retcnt;
    });
}

int sys::writeFile(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        const char *fileName = luaL_checkstring(L, 1);

        FILE *tmpfp = nullptr;
        errno_t err = ::fopen_s(&tmpfp, fileName, "w");
        if (err != 0) {
            luaL_error(L, "File open error: %s, %d", fileName, err);
        }

        util::FilePtr fp(tmpfp);
        int argc = lua_gettop(L);
        for (int i = 2; i <= argc; i++) {
            // if lua error, destruct fp and throw
            const char *line = luaL_checkstring(L, i);
            std::fputs(line, fp.get());
            std::fputc('\n', fp.get());
        }
        return 0;
    });
}

// "rand" table

int rand::generateSeed(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        unsigned int seed = framework::random::generateRandomSeed();
        lua_pushinteger(L, seed);
        return 1;
    });
}

int rand::setSeed(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto seed = static_cast<unsigned int>(luaL_checkinteger(L, 1));
        framework::random::setSeed(seed);
        return 0;
    });
}

int rand::nextInt(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        int a = getOptInt(L, 1, 0);
        int b = getOptInt(L, 2, std::numeric_limits<int>::max());
        luaL_argcheck(L, a <= b, 1, "Must be a <= b");

        int rnum = framework::random::nextInt(a, b);

        lua_pushinteger(L, rnum);
        return 1;
    });
}

int rand::nextDouble(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        double a = getOptDouble(L, 1, 0.0);
        double b = getOptDouble(L, 2, 1.0);
        luaL_argcheck(L, a <= b, 1, "Must be a <= b");

        double rnum = framework::random::nextDouble(a, b);

        lua_pushnumber(L, rnum);
        return 1;
    });
}

// "resource" table

int resource::addTexture(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);
        int setId = getInt(L, 1, 0);
        const char *resId = luaL_checkstring(L, 2);
        const char *path = luaL_checkstring(L, 3);

        app->addTextureResource(setId, resId, util::utf82wc(path).get());
        return 0;
    });
}

int resource::addFont(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);
        int setId = getInt(L, 1, 0);
        const char *resId = luaL_checkstring(L, 2);
        const char *fontName = luaL_checkstring(L, 3);
        const char *startCharStr = luaL_checkstring(L, 4);
        luaL_argcheck(L, *startCharStr != '\0', 4, "empty string is NG");
        const char *endCharStr = luaL_checkstring(L, 4);
        luaL_argcheck(L, *endCharStr != '\0', 5, "empty string is NG");
        int w = getInt(L, 7, 0);
        int h = getInt(L, 8, 0);

        wchar_t startChar = util::utf82wc(startCharStr)[0];
        wchar_t endChar = util::utf82wc(endCharStr)[0];

        app->addFontResource(setId, resId, util::utf82wc(fontName).get(),
            startChar, endChar, w, h);
        return 0;
    });
}

int resource::addSe(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);
        int setId = getInt(L, 1, 0);
        const char *resId = luaL_checkstring(L, 2);
        const char *path = luaL_checkstring(L, 3);

        app->addSeResource(setId, resId, util::utf82wc(path).get());
        return 0;
    });
}

int resource::addBgm(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);
        int setId = getInt(L, 1, 0);
        const char *resId = luaL_checkstring(L, 2);
        const char *path = luaL_checkstring(L, 3);

        app->addBgmResource(setId, resId, util::utf82wc(path).get());
        return 0;
    });
}

// "graph" table

int graph::getParam(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);

        graphics::GraphicsParam param;
        app->getGraphicsParam(&param);

        lua_pushinteger(L, param.w);
        lua_pushinteger(L, param.h);
        lua_pushinteger(L, param.refreshRate);
        lua_pushboolean(L, param.vsync);
        return 4;
    });
}

int graph::getTextureSize(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);
        int setId = getInt(L, 1, 0);
        const char *resId = luaL_checkstring(L, 2);

        const auto &pTex = app->getTexture(setId, resId);

        lua_pushinteger(L, pTex->w);
        lua_pushinteger(L, pTex->h);
        return 2;
    });
}

int graph::drawTexture(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);
        int setId = getInt(L, 1, 0);
        const char *resId = luaL_checkstring(L, 2);
        int dx = getInt(L, 3);
        int dy = getInt(L, 4);

        bool lrInv = lua_toboolean(L, 5) != 0;
        bool udInv = lua_toboolean(L, 6) != 0;
        int sx = getOptInt(L, 7, 0);
        int sy = getOptInt(L, 8, 0);
        int sw = getOptInt(L, 9, -1);
        int sh = getOptInt(L, 10, -1);
        int cx = getOptInt(L, 11, 0);
        int cy = getOptInt(L, 12, 0);
        float angle = getOptFloat(L, 13, 0.0f);
        float scaleX = getOptFloat(L, 14, 1.0f);
        float scaleY = getOptFloat(L, 15, 1.0f);
        float alpha = getOptFloat(L, 16, 1.0f);

        const auto &pTex = app->getTexture(setId, resId);
        app->graph().drawTexture(pTex, dx, dy, lrInv, udInv, sx, sy, sw, sh, cx, cy,
            angle, scaleX, scaleY, alpha);
        return 0;
    });
}

int graph::drawString(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);
        int setId = getInt(L, 1, 0);
        const char *resId = luaL_checkstring(L, 2);
        const char *str = luaL_checkstring(L, 3);
        int dx = getInt(L, 4);
        int dy = getInt(L, 5);

        int color = getOptInt(L, 6, 0x000000);
        int ajustX = getOptInt(L, 7, 0);
        float scaleX = getOptFloat(L, 8, 1.0f);
        float scaleY = getOptFloat(L, 9, 1.0f);
        float alpha = getOptFloat(L, 10, 1.0f);

        const auto &pFont = app->getFont(setId, resId);
        app->graph().drawString(pFont, util::utf82wc(str).get(), dx, dy,
            color, ajustX, scaleX, scaleY, alpha);
        return 0;
    });
}

// "sound" table

int sound::playSe(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);
        int setId = getInt(L, 1, 0);
        const char *resId = luaL_checkstring(L, 2);

        const auto &pSoundEffect = app->getSoundEffect(setId, resId);
        app->sound().playSoundEffect(pSoundEffect);
        return 0;
    });
}

int sound::playBgm(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);
        int setId = getInt(L, 1, 0);
        const char *resId = luaL_checkstring(L, 2);

        auto &pBgm = app->getBgm(setId, resId);
        app->sound().playBgm(pBgm);
        return 0;
    });
}

int sound::stopBgm(lua_State *L)
{
    return exceptToLuaError(L, [L]() {
        auto *app = getPtrFromUpvalue<framework::Application>(L, 1);

        app->sound().stopBgm();
        return 0;
    });
}

}   // namespace export
}   // namespace lua
}   // namespace yappy