C++ 嵌入式与游戏引擎集成：宿主嵌入、绑定生成与性能内存约束

extern "C" {
#include <lua.h>
#include <lauxlib.h>
#include <lualib.h>
}

int main() {
    lua_State* L = luaL_newstate();       // 创建 Lua 虚拟机
    luaL_openlibs(L);                     // 打开标准库

    // 执行一段 Lua 脚本
    luaL_dostring(L, "print('hello from lua')");

    // 调用 Lua 函数
    lua_getglobal(L, "update");
    lua_pushnumber(L, 0.016);             // 传入 dt
    if (lua_pcall(L, 1, 0, 0) != LUA_OK) {
        const char* err = lua_tostring(L, -1);
        // 处理脚本错误
    }
    lua_close(L);
    return 0;
}

#include <sol/sol.hpp>

struct Player {
    int hp = 100;
    void take_damage(int d) { hp -= d; }
    int get_hp() const { return hp; }
};

int main() {
    sol::state lua;
    lua.open_libraries(sol::lib::base);

    // 注册 C++ 类型到 Lua
    lua.new_usertype<Player>("Player",
        sol::constructors<Player()>(),
        "hp", &Player::hp,
        "take_damage", &Player::take_damage,
        "get_hp", &Player::get_hp);

    // 在 Lua 中使用
    lua.script(R"(
        local p = Player()
        p:take_damage(30)
        print("hp=" .. p:get_hp())
    )");

    // 调用 Lua 中定义的逻辑（热更新点）
    auto update = lua.get<std::function<void(float)>>("game_update");
    update(0.016f);
    return 0;
}

#include <sol/sol.hpp>

// 纯数据组件：布局与生命周期由 C++ 的 ECS 仓储（Sparse Set / archetype）管理
struct Transform {
    float x = 0.f, y = 0.f, rot = 0.f;
};

struct Health {
    int max_hp = 100;
    int hp = 100;
};

void register_components(sol::state& lua) {
    // 组件注册为可读写的表类型：脚本只改字段，不负责 new/delete
    lua.new_usertype<Transform>("Transform",
        "x", &Transform::x,
        "y", &Transform::y,
        "rot", &Transform::rot);

    lua.new_usertype<Health>("Health",
        "max_hp", &Health::max_hp,
        "hp", &Health::hp);
}

// 每帧把实体 id 与组件引用交给脚本决策
void update_ai(sol::state& lua, std::vector<Health>& healths) {
    auto fn = lua["tick_ai"];
    if (!fn.valid()) return;
    for (auto& h : healths) {
        // 批量传引用，避免逐字段跨边界
        fn(&h);
    }
}

// bindings.cpp
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

namespace py = pybind11;

struct Vec3 {
    double x, y, z;
    double length() const { return std::sqrt(x*x + y*y + z*z); }
};

PYBIND11_MODULE(geometry, m) {
    m.doc() = "geometry native module";
    py::class_<Vec3>(m, "Vec3")
        .def(py::init<double, double, double>())
        .def_readwrite("x", &Vec3::x)
        .def_readwrite("y", &Vec3::y)
        .def_readwrite("z", &Vec3::z)
        .def("length", &Vec3::length)
        .def("__repr__", [](const Vec3& v) {
            return "<Vec3 " + std::to_string(v.x) + ","
                             + std::to_string(v.y) + ","
                             + std::to_string(v.z) + ">";
        });

    // 允许 STL 容器自动转换
    m.def("sum_points", [](const std::vector<Vec3>& pts) -> double {
        double s = 0;
        for (auto& p : pts) s += p.length();
        return s;
    });
}

extern "C" {

typedef struct game_engine GameEngine;

GameEngine* ge_create(void);
void ge_destroy(GameEngine*);
int ge_update(GameEngine*, double dt);
void ge_set_player_hp(GameEngine*, int hp);
int ge_get_player_hp(const GameEngine*);

}

# 嵌入式交叉编译的编译选项示例
add_executable(firmware main.cpp)
target_compile_options(firmware PRIVATE
  -fno-exceptions -fno-rtti -fvisibility=hidden
  -ffreestanding -fno-stack-protector)
target_link_options(firmware PRIVATE
  -Wl,-T,linker.ld --specs=nano.specs)

// 简单的脚本热更骨架
void hot_reload(const std::string& script_path, sol::state& lua) {
    auto result = lua.safe_script_file(script_path, sol::script_pass_on_error);
    if (!result.valid()) {
        // 保留旧逻辑，记录错误并上报，切勿崩溃引擎
        sol::error err = result;
        log_error(err.what());
        return;
    }
    // 重新提取入口函数
    auto update = lua.get<std::function<void(float)>>("game_update");
    g_update = std::move(update);
}

// pybind11 支持 shared_ptr 自动管理生命周期
py::class_<Session, std::shared_ptr<Session>>(m, "Session")
    .def(py::init<>());