737 lines
50 KiB
C++
737 lines
50 KiB
C++
#include "MetaCoreScripting/MetaCoreScripting.h"
|
|
#include "MetaCoreFoundation/MetaCoreHash.h"
|
|
|
|
#include <nlohmann/json.hpp>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <cctype>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <fstream>
|
|
#include <sstream>
|
|
#include <stdexcept>
|
|
#include <unordered_set>
|
|
#include <utility>
|
|
|
|
#if defined(__linux__)
|
|
#include <dlfcn.h>
|
|
#endif
|
|
|
|
namespace MetaCore {
|
|
|
|
namespace {
|
|
|
|
using Json = nlohmann::json;
|
|
|
|
Json ParseObject(std::string_view text) {
|
|
if (text.empty()) return Json::object();
|
|
try {
|
|
Json value = Json::parse(text);
|
|
return value.is_object() ? value : Json::object();
|
|
} catch (...) {
|
|
return Json::object();
|
|
}
|
|
}
|
|
|
|
Json DefaultJson(const MetaCoreScriptFieldDefinition& field) {
|
|
switch (field.Type) {
|
|
case MetaCoreScriptFieldType::Bool: return field.BoolDefault;
|
|
case MetaCoreScriptFieldType::Int: return field.IntDefault;
|
|
case MetaCoreScriptFieldType::Float: return field.FloatDefault;
|
|
case MetaCoreScriptFieldType::Vec3: return Json::array({field.Vec3Default.x, field.Vec3Default.y, field.Vec3Default.z});
|
|
case MetaCoreScriptFieldType::String: return field.StringDefault;
|
|
case MetaCoreScriptFieldType::AssetRef: return field.AssetDefault.ToString();
|
|
case MetaCoreScriptFieldType::GameObjectRef: return field.GameObjectDefault;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
MetaCoreScriptFieldType FromAbiType(std::uint32_t type) {
|
|
switch (type) {
|
|
case MetaCoreScriptAbiValue_Bool: return MetaCoreScriptFieldType::Bool;
|
|
case MetaCoreScriptAbiValue_Int: return MetaCoreScriptFieldType::Int;
|
|
case MetaCoreScriptAbiValue_Float: return MetaCoreScriptFieldType::Float;
|
|
case MetaCoreScriptAbiValue_Vec3: return MetaCoreScriptFieldType::Vec3;
|
|
case MetaCoreScriptAbiValue_String: return MetaCoreScriptFieldType::String;
|
|
case MetaCoreScriptAbiValue_AssetRef: return MetaCoreScriptFieldType::AssetRef;
|
|
case MetaCoreScriptAbiValue_GameObjectRef: return MetaCoreScriptFieldType::GameObjectRef;
|
|
default: return MetaCoreScriptFieldType::String;
|
|
}
|
|
}
|
|
|
|
bool JsonToAbi(const Json& json, MetaCoreScriptValueV1& value) {
|
|
value = {};
|
|
if (json.is_boolean()) {
|
|
value.Type = MetaCoreScriptAbiValue_Bool;
|
|
value.IntValue = json.get<bool>() ? 1 : 0;
|
|
} else if (json.is_number_integer() || json.is_number_unsigned()) {
|
|
value.Type = MetaCoreScriptAbiValue_Int;
|
|
value.IntValue = json.get<std::int64_t>();
|
|
} else if (json.is_number()) {
|
|
value.Type = MetaCoreScriptAbiValue_Float;
|
|
value.NumberValue = json.get<double>();
|
|
} else if (json.is_array() && json.size() >= 3) {
|
|
value.Type = MetaCoreScriptAbiValue_Vec3;
|
|
value.Vec3[0] = json[0].get<double>();
|
|
value.Vec3[1] = json[1].get<double>();
|
|
value.Vec3[2] = json[2].get<double>();
|
|
} else if (json.is_string()) {
|
|
value.Type = MetaCoreScriptAbiValue_String;
|
|
std::snprintf(value.Text, sizeof(value.Text), "%s", json.get_ref<const std::string&>().c_str());
|
|
} else {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
Json AbiToJson(const MetaCoreScriptValueV1& value) {
|
|
switch (value.Type) {
|
|
case MetaCoreScriptAbiValue_Bool: return value.IntValue != 0;
|
|
case MetaCoreScriptAbiValue_Int: return value.IntValue;
|
|
case MetaCoreScriptAbiValue_Float: return value.NumberValue;
|
|
case MetaCoreScriptAbiValue_Vec3: return Json::array({value.Vec3[0], value.Vec3[1], value.Vec3[2]});
|
|
case MetaCoreScriptAbiValue_GameObjectRef: return value.ObjectValue.ObjectId;
|
|
case MetaCoreScriptAbiValue_String:
|
|
case MetaCoreScriptAbiValue_AssetRef: return std::string(value.Text);
|
|
default: return nullptr;
|
|
}
|
|
}
|
|
|
|
std::string ShellQuote(const std::filesystem::path& path) {
|
|
std::string text = path.string();
|
|
std::string result = "'";
|
|
for (char c : text) result += c == '\'' ? "'\\''" : std::string(1, c);
|
|
return result + "'";
|
|
}
|
|
|
|
bool WriteIfMissing(const std::filesystem::path& path, std::string_view text) {
|
|
if (std::filesystem::exists(path)) return true;
|
|
std::ofstream output(path, std::ios::binary);
|
|
output.write(text.data(), static_cast<std::streamsize>(text.size()));
|
|
return output.good();
|
|
}
|
|
|
|
std::string SafeIdentifier(std::string_view value) {
|
|
std::string result;
|
|
for (char c : value) result += std::isalnum(static_cast<unsigned char>(c)) ? c : '_';
|
|
return result.empty() ? "MetaCoreProject" : result;
|
|
}
|
|
|
|
MetaCoreScriptInstanceData* FindInstance(MetaCoreGameObject object, std::uint64_t instanceId) {
|
|
if (!object || !object.HasComponent<MetaCoreScriptComponent>()) return nullptr;
|
|
auto& instances = object.GetComponent<MetaCoreScriptComponent>().Instances;
|
|
const auto iterator = std::find_if(instances.begin(), instances.end(), [instanceId](const auto& instance) {
|
|
return instance.InstanceId == instanceId;
|
|
});
|
|
return iterator == instances.end() ? nullptr : &*iterator;
|
|
}
|
|
|
|
const MetaCoreScriptHostApiV1& HostApi();
|
|
|
|
struct LoadedLibrary {
|
|
void* Handle = nullptr;
|
|
MetaCoreScriptModuleApiV1 Api{};
|
|
~LoadedLibrary() {
|
|
if (Api.Shutdown != nullptr) Api.Shutdown();
|
|
#if defined(__linux__)
|
|
if (Handle != nullptr) dlclose(Handle);
|
|
#endif
|
|
}
|
|
};
|
|
|
|
class AbiBehaviour final : public MetaCoreIScriptBehaviour {
|
|
public:
|
|
AbiBehaviour(std::shared_ptr<LoadedLibrary> library, MetaCoreScriptBehaviourDescriptorV1 descriptor)
|
|
: Library_(std::move(library)), Descriptor_(descriptor), Instance_(Descriptor_.Create != nullptr ? Descriptor_.Create() : nullptr) {}
|
|
~AbiBehaviour() override {
|
|
if (Descriptor_.Destroy != nullptr && Instance_ != nullptr) Descriptor_.Destroy(Instance_);
|
|
}
|
|
|
|
void OnPlayStart(MetaCoreScriptExecutionContext& context) override { Call(context, Descriptor_.OnPlayStart, "OnPlayStart"); }
|
|
void FixedUpdate(MetaCoreScriptExecutionContext& context, double delta) override { CallUpdate(context, Descriptor_.FixedUpdate, delta, "FixedUpdate"); }
|
|
void Update(MetaCoreScriptExecutionContext& context, double delta) override { CallUpdate(context, Descriptor_.Update, delta, "Update"); }
|
|
void LateUpdate(MetaCoreScriptExecutionContext& context, double delta) override { CallUpdate(context, Descriptor_.LateUpdate, delta, "LateUpdate"); }
|
|
void OnPlayStop(MetaCoreScriptExecutionContext& context) override { Call(context, Descriptor_.OnPlayStop, "OnPlayStop"); }
|
|
|
|
private:
|
|
MetaCoreScriptExecutionContextV1 BuildContext(MetaCoreScriptExecutionContext& context) const {
|
|
return MetaCoreScriptExecutionContextV1{
|
|
&HostApi(), context.Runtime,
|
|
{context.Runtime != nullptr ? context.Runtime->GetWorldGeneration() : 0U, context.GameObject.GetId()},
|
|
context.Instance.InstanceId, context.Instance.ScriptTypeId.c_str(), context.Instance.FieldsJson.c_str(),
|
|
{context.Time.Frame, context.Time.DeltaSeconds, context.Time.FixedDeltaSeconds, context.Time.ElapsedSeconds,
|
|
context.Time.UnscaledElapsedSeconds, context.Time.TimeScale}
|
|
};
|
|
}
|
|
void Call(MetaCoreScriptExecutionContext& context, MetaCoreScriptLifecycleCallbackV1 callback, const char* phase) {
|
|
if (callback == nullptr) return;
|
|
const auto abiContext = BuildContext(context);
|
|
const char* error = callback(Instance_, &abiContext);
|
|
if (error != nullptr && error[0] != '\0') throw std::runtime_error(std::string(phase) + ": " + error);
|
|
}
|
|
void CallUpdate(MetaCoreScriptExecutionContext& context, MetaCoreScriptUpdateCallbackV1 callback, double delta, const char* phase) {
|
|
if (callback == nullptr) return;
|
|
const auto abiContext = BuildContext(context);
|
|
const char* error = callback(Instance_, &abiContext, delta);
|
|
if (error != nullptr && error[0] != '\0') throw std::runtime_error(std::string(phase) + ": " + error);
|
|
}
|
|
std::shared_ptr<LoadedLibrary> Library_{};
|
|
MetaCoreScriptBehaviourDescriptorV1 Descriptor_{};
|
|
void* Instance_ = nullptr;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
void MetaCoreIScriptBehaviour::OnPlayStart(MetaCoreScriptExecutionContext&) {}
|
|
void MetaCoreIScriptBehaviour::FixedUpdate(MetaCoreScriptExecutionContext&, double) {}
|
|
void MetaCoreIScriptBehaviour::Update(MetaCoreScriptExecutionContext&, double) {}
|
|
void MetaCoreIScriptBehaviour::LateUpdate(MetaCoreScriptExecutionContext&, double) {}
|
|
void MetaCoreIScriptBehaviour::OnPlayStop(MetaCoreScriptExecutionContext&) {}
|
|
|
|
bool MetaCoreScriptRegistry::RegisterScript(MetaCoreScriptDefinition definition, std::string* error) {
|
|
if (definition.TypeId.empty() || !definition.Factory) {
|
|
if (error) *error = "Script TypeId and factory are required";
|
|
return false;
|
|
}
|
|
std::unordered_set<std::string> fieldIds;
|
|
for (const auto& field : definition.Fields) {
|
|
const std::string id(field.StableId());
|
|
if (id.empty() || !fieldIds.insert(id).second) {
|
|
if (error) *error = "Script fields require unique non-empty field ids";
|
|
return false;
|
|
}
|
|
}
|
|
const auto existing = std::find_if(Definitions_.begin(), Definitions_.end(), [&](const auto& value) { return value.TypeId == definition.TypeId; });
|
|
if (existing != Definitions_.end()) *existing = std::move(definition);
|
|
else Definitions_.push_back(std::move(definition));
|
|
return true;
|
|
}
|
|
|
|
bool MetaCoreScriptRegistry::ReplaceModule(std::string_view moduleId, std::vector<MetaCoreScriptDefinition> definitions, std::string* error) {
|
|
std::unordered_set<std::string> ids;
|
|
for (auto& definition : definitions) {
|
|
if (definition.ModuleId.empty()) definition.ModuleId = std::string(moduleId);
|
|
if (definition.ModuleId != moduleId || !ids.insert(definition.TypeId).second) {
|
|
if (error) *error = "Candidate module contains duplicate types or a mismatched module id";
|
|
return false;
|
|
}
|
|
MetaCoreScriptRegistry validator;
|
|
if (!validator.RegisterScript(definition, error)) return false;
|
|
const auto outside = std::find_if(Definitions_.begin(), Definitions_.end(), [&](const auto& current) {
|
|
return current.TypeId == definition.TypeId && current.ModuleId != moduleId;
|
|
});
|
|
if (outside != Definitions_.end()) {
|
|
if (error) *error = "Script TypeId conflicts with another module: " + definition.TypeId;
|
|
return false;
|
|
}
|
|
}
|
|
RemoveModule(moduleId);
|
|
for (auto& definition : definitions) Definitions_.push_back(std::move(definition));
|
|
return true;
|
|
}
|
|
|
|
void MetaCoreScriptRegistry::RemoveModule(std::string_view moduleId) {
|
|
std::erase_if(Definitions_, [&](const auto& definition) { return definition.ModuleId == moduleId; });
|
|
}
|
|
void MetaCoreScriptRegistry::Clear() { Definitions_.clear(); }
|
|
const MetaCoreScriptDefinition* MetaCoreScriptRegistry::FindScript(std::string_view typeId) const {
|
|
const auto it = std::find_if(Definitions_.begin(), Definitions_.end(), [&](const auto& d) { return d.TypeId == typeId; });
|
|
return it == Definitions_.end() ? nullptr : &*it;
|
|
}
|
|
std::vector<MetaCoreScriptDefinition> MetaCoreScriptRegistry::GetScriptDefinitions() const { return Definitions_; }
|
|
std::unique_ptr<MetaCoreIScriptBehaviour> MetaCoreScriptRegistry::CreateBehaviour(std::string_view typeId) const {
|
|
const auto* definition = FindScript(typeId);
|
|
return definition != nullptr && definition->Factory ? definition->Factory() : nullptr;
|
|
}
|
|
std::string MetaCoreScriptRegistry::BuildDefaultFieldsJson(std::string_view typeId) const {
|
|
Json fields = Json::object();
|
|
const auto* definition = FindScript(typeId);
|
|
if (definition) for (const auto& field : definition->Fields) fields[std::string(field.StableId())] = DefaultJson(field);
|
|
return fields.dump();
|
|
}
|
|
std::string MetaCoreScriptRegistry::EnsureFieldsJsonDefaults(std::string_view typeId, std::string_view fieldsJson) const {
|
|
Json fields = ParseObject(fieldsJson);
|
|
const auto* definition = FindScript(typeId);
|
|
if (definition) for (const auto& field : definition->Fields) {
|
|
const std::string stable(field.StableId());
|
|
if (!fields.contains(stable)) {
|
|
if (!field.Name.empty() && fields.contains(field.Name)) fields[stable] = fields[field.Name];
|
|
else fields[stable] = DefaultJson(field);
|
|
}
|
|
if (!field.FieldId.empty() && field.Name != stable) fields.erase(field.Name);
|
|
}
|
|
return fields.dump();
|
|
}
|
|
|
|
namespace {
|
|
class BuiltinRotator final : public MetaCoreIScriptBehaviour {
|
|
public:
|
|
void Update(MetaCoreScriptExecutionContext& context, double delta) override {
|
|
auto fields = ParseObject(context.Instance.FieldsJson);
|
|
if (!fields.value("Enabled", true) || !context.GameObject.HasComponent<MetaCoreTransformComponent>()) return;
|
|
context.GameObject.GetComponent<MetaCoreTransformComponent>().RotationEulerDegrees.y +=
|
|
fields.value("DegreesPerSecond", 90.0F) * static_cast<float>(delta);
|
|
context.Scene.IncrementRevision();
|
|
}
|
|
};
|
|
class BuiltinMover final : public MetaCoreIScriptBehaviour {
|
|
public:
|
|
void Update(MetaCoreScriptExecutionContext& context, double delta) override {
|
|
auto fields = ParseObject(context.Instance.FieldsJson);
|
|
if (!fields.value("Enabled", true) || !context.GameObject.HasComponent<MetaCoreTransformComponent>()) return;
|
|
glm::vec3 velocity(0.0F, 1.0F, 0.0F);
|
|
if (fields.contains("Velocity") && fields["Velocity"].is_array() && fields["Velocity"].size() >= 3)
|
|
velocity = {fields["Velocity"][0].get<float>(), fields["Velocity"][1].get<float>(), fields["Velocity"][2].get<float>()};
|
|
context.GameObject.GetComponent<MetaCoreTransformComponent>().Position += velocity * static_cast<float>(delta);
|
|
context.Scene.IncrementRevision();
|
|
}
|
|
};
|
|
}
|
|
|
|
void MetaCoreRegisterBuiltinScripts(MetaCoreScriptRegistry& registry) {
|
|
MetaCoreScriptDefinition rotator;
|
|
rotator.TypeId = "MetaCore.Script.Rotator"; rotator.DisplayName = "旋转脚本";
|
|
rotator.Fields = {
|
|
MetaCoreScriptFieldDefinition{"Enabled", "启用", MetaCoreScriptFieldType::Bool, true},
|
|
MetaCoreScriptFieldDefinition{"DegreesPerSecond", "角速度 Y (度/秒)", MetaCoreScriptFieldType::Float, false, 90.0F}
|
|
};
|
|
rotator.Factory = [] { return std::make_unique<BuiltinRotator>(); };
|
|
(void)registry.RegisterScript(std::move(rotator));
|
|
MetaCoreScriptDefinition mover;
|
|
mover.TypeId = "MetaCore.Script.Mover"; mover.DisplayName = "移动脚本";
|
|
mover.Fields = {
|
|
MetaCoreScriptFieldDefinition{"Enabled", "启用", MetaCoreScriptFieldType::Bool, true},
|
|
MetaCoreScriptFieldDefinition{"Velocity", "速度", MetaCoreScriptFieldType::Vec3, false, 0.0F, glm::vec3(0.0F, 1.0F, 0.0F)}
|
|
};
|
|
mover.Factory = [] { return std::make_unique<BuiltinMover>(); };
|
|
(void)registry.RegisterScript(std::move(mover));
|
|
}
|
|
|
|
std::optional<MetaCoreLoadedScriptModule> MetaCoreScriptModuleLoader::LoadCandidate(const std::filesystem::path& path, std::string* error) const {
|
|
#if !defined(__linux__)
|
|
if (error) *error = "Native project scripts are currently supported only on Linux";
|
|
return std::nullopt;
|
|
#else
|
|
if (!std::filesystem::is_regular_file(path)) {
|
|
if (error) *error = "Script module does not exist: " + path.string();
|
|
return std::nullopt;
|
|
}
|
|
std::string manifestModuleId;
|
|
std::string manifestBuildId;
|
|
std::filesystem::path manifestPath = path;
|
|
manifestPath += ".mcscriptmodule.json";
|
|
if (std::filesystem::is_regular_file(manifestPath)) {
|
|
try {
|
|
std::ifstream manifestInput(manifestPath);
|
|
Json manifest = Json::parse(manifestInput);
|
|
const auto hash = MetaCoreSha256File(path);
|
|
manifestModuleId = manifest.value("module_id", "");
|
|
manifestBuildId = manifest.value("build_id", "");
|
|
if (manifest.value("format_version", 0U) != 1U ||
|
|
manifest.value("abi_major", 0U) != METACORE_SCRIPT_ABI_MAJOR ||
|
|
manifest.value("abi_minor", 0U) > METACORE_SCRIPT_ABI_MINOR ||
|
|
manifest.value("module_file", "") != path.filename().string() ||
|
|
!hash.has_value() || manifest.value("sha256", "") != *hash) {
|
|
if (error) *error = "Script module manifest or SHA-256 validation failed";
|
|
return std::nullopt;
|
|
}
|
|
} catch (...) {
|
|
if (error) *error = "Script module manifest is unreadable";
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
auto library = std::make_shared<LoadedLibrary>();
|
|
library->Handle = dlopen(path.c_str(), RTLD_NOW | RTLD_LOCAL);
|
|
if (!library->Handle) {
|
|
if (error) *error = dlerror();
|
|
return std::nullopt;
|
|
}
|
|
auto load = reinterpret_cast<MetaCoreLoadScriptModuleV1Fn>(dlsym(library->Handle, "MetaCoreLoadScriptModuleV1"));
|
|
if (!load) {
|
|
if (error) *error = "Module does not export MetaCoreLoadScriptModuleV1";
|
|
return std::nullopt;
|
|
}
|
|
try {
|
|
if (!load(&HostApi(), &library->Api)) {
|
|
if (error) *error = "Module initialization rejected the host";
|
|
return std::nullopt;
|
|
}
|
|
} catch (...) {
|
|
if (error) *error = "Module initialization crossed the ABI with an exception";
|
|
return std::nullopt;
|
|
}
|
|
const auto& api = library->Api;
|
|
if (api.AbiMajor != METACORE_SCRIPT_ABI_MAJOR || api.AbiMinor > METACORE_SCRIPT_ABI_MINOR ||
|
|
(api.RequiredCapabilities & ~METACORE_SCRIPT_HOST_CAPABILITIES) != 0 || api.ModuleId == nullptr || api.ModuleId[0] == '\0') {
|
|
if (error) *error = "Module ABI, capabilities, or module id are incompatible";
|
|
return std::nullopt;
|
|
}
|
|
if (api.BehaviourCount > 0 && api.Behaviours == nullptr) {
|
|
if (error) *error = "Module behaviour table is null";
|
|
return std::nullopt;
|
|
}
|
|
MetaCoreLoadedScriptModule result;
|
|
result.ModuleId = api.ModuleId;
|
|
if (!manifestModuleId.empty() && manifestModuleId != result.ModuleId) {
|
|
if (error) *error = "Loaded module id does not match its validated manifest";
|
|
return std::nullopt;
|
|
}
|
|
result.BuildId = api.BuildId != nullptr ? api.BuildId : "";
|
|
result.Path = path;
|
|
result.Lifetime = library;
|
|
std::unordered_set<std::string> typeIds;
|
|
for (std::size_t i = 0; i < api.BehaviourCount; ++i) {
|
|
const auto descriptor = api.Behaviours[i];
|
|
if (descriptor.TypeId == nullptr || descriptor.TypeId[0] == '\0' || descriptor.Create == nullptr || descriptor.Destroy == nullptr ||
|
|
(descriptor.FieldCount > 0 && descriptor.Fields == nullptr) || !typeIds.insert(descriptor.TypeId).second) {
|
|
if (error) *error = "Module contains an invalid or duplicate behaviour descriptor";
|
|
return std::nullopt;
|
|
}
|
|
if (!manifestBuildId.empty() && manifestBuildId != result.BuildId) {
|
|
if (error) *error = "Loaded module build id does not match its validated manifest";
|
|
return std::nullopt;
|
|
}
|
|
MetaCoreScriptDefinition definition;
|
|
definition.TypeId = descriptor.TypeId;
|
|
definition.DisplayName = descriptor.DisplayName != nullptr ? descriptor.DisplayName : descriptor.TypeId;
|
|
definition.ModuleId = result.ModuleId;
|
|
definition.SchemaVersion = descriptor.SchemaVersion;
|
|
std::unordered_set<std::string> fieldIds;
|
|
for (std::size_t fieldIndex = 0; fieldIndex < descriptor.FieldCount; ++fieldIndex) {
|
|
const auto& source = descriptor.Fields[fieldIndex];
|
|
if (source.FieldId == nullptr || source.FieldId[0] == '\0' || !fieldIds.insert(source.FieldId).second) {
|
|
if (error) *error = "Module contains an invalid or duplicate field id";
|
|
return std::nullopt;
|
|
}
|
|
MetaCoreScriptFieldDefinition field;
|
|
field.Name = source.FieldId;
|
|
field.FieldId = source.FieldId;
|
|
field.DisplayName = source.DisplayName != nullptr ? source.DisplayName : source.FieldId;
|
|
field.Type = FromAbiType(source.Type);
|
|
Json defaultValue;
|
|
try { defaultValue = source.DefaultJson != nullptr ? Json::parse(source.DefaultJson) : Json{}; }
|
|
catch (...) { if (error) *error = "Field default JSON is invalid"; return std::nullopt; }
|
|
if (field.Type == MetaCoreScriptFieldType::Bool && defaultValue.is_boolean()) field.BoolDefault = defaultValue.get<bool>();
|
|
else if (field.Type == MetaCoreScriptFieldType::Int && defaultValue.is_number_integer()) field.IntDefault = defaultValue.get<std::int64_t>();
|
|
else if (field.Type == MetaCoreScriptFieldType::Float && defaultValue.is_number()) field.FloatDefault = defaultValue.get<float>();
|
|
else if (field.Type == MetaCoreScriptFieldType::Vec3 && defaultValue.is_array() && defaultValue.size() >= 3) field.Vec3Default = {defaultValue[0].get<float>(), defaultValue[1].get<float>(), defaultValue[2].get<float>()};
|
|
else if ((field.Type == MetaCoreScriptFieldType::String || field.Type == MetaCoreScriptFieldType::AssetRef) && defaultValue.is_string()) field.StringDefault = defaultValue.get<std::string>();
|
|
else if (field.Type == MetaCoreScriptFieldType::GameObjectRef && defaultValue.is_number_unsigned()) field.GameObjectDefault = defaultValue.get<MetaCoreId>();
|
|
definition.Fields.push_back(std::move(field));
|
|
}
|
|
definition.Factory = [library, descriptor]() { return std::make_unique<AbiBehaviour>(library, descriptor); };
|
|
result.Definitions.push_back(std::move(definition));
|
|
}
|
|
return result;
|
|
#endif
|
|
}
|
|
|
|
struct MetaCoreScriptRuntime::Impl {
|
|
struct Entry { MetaCoreId ObjectId = 0; std::uint64_t InstanceId = 0; std::string TypeId; std::unique_ptr<MetaCoreIScriptBehaviour> Behaviour; bool Started = false; bool Faulted = false; };
|
|
struct Event { std::string Topic; std::vector<MetaCoreScriptValueV1> Fields; };
|
|
struct Subscription { std::uint64_t Id; MetaCoreId ObjectId; std::uint64_t InstanceId; std::string Topic; EventHandler Handler; };
|
|
struct Timer { std::uint64_t Id; MetaCoreId ObjectId; std::uint64_t InstanceId; double Remaining; double Interval; bool Unscaled; std::function<void()> Callback; };
|
|
|
|
MetaCoreScriptRuntime& Owner;
|
|
MetaCoreScene& Scene;
|
|
MetaCoreScriptRegistry& Registry;
|
|
MetaCoreScriptLogHandler Logger;
|
|
std::vector<Entry> Entries;
|
|
std::vector<Event> Events;
|
|
std::vector<Subscription> Subscriptions;
|
|
std::vector<Timer> Timers;
|
|
std::uint64_t NextSubscription = 1;
|
|
std::uint64_t NextTimer = 1;
|
|
bool Running = false;
|
|
|
|
Impl(MetaCoreScriptRuntime& owner, MetaCoreScene& scene, MetaCoreScriptRegistry& registry, MetaCoreScriptLogHandler logger)
|
|
: Owner(owner), Scene(scene), Registry(registry), Logger(std::move(logger)) {}
|
|
|
|
void Log(std::uint32_t level, std::string_view category, std::string_view text) const { if (Logger) Logger(level, category, text); }
|
|
Entry* FindEntry(MetaCoreId object, std::uint64_t instance) {
|
|
auto it = std::find_if(Entries.begin(), Entries.end(), [&](const auto& e) { return e.ObjectId == object && e.InstanceId == instance; });
|
|
return it == Entries.end() ? nullptr : &*it;
|
|
}
|
|
MetaCoreScriptExecutionContext Context(MetaCoreGameObject object, MetaCoreScriptInstanceData& instance) {
|
|
return {Scene, object, instance, &Owner, Owner.Time_};
|
|
}
|
|
void Fault(Entry& entry, std::string_view phase, std::string_view message) {
|
|
entry.Faulted = true;
|
|
std::ostringstream text;
|
|
text << "module/script callback fault type=\"" << entry.TypeId << "\" object=" << entry.ObjectId
|
|
<< " instance=" << entry.InstanceId << " phase=" << phase << " error=" << message;
|
|
Log(2, "Script", text.str());
|
|
CleanupOwner(entry.ObjectId, entry.InstanceId);
|
|
}
|
|
void CleanupOwner(MetaCoreId object, std::uint64_t instance) {
|
|
std::erase_if(Subscriptions, [&](const auto& s) { return s.ObjectId == object && s.InstanceId == instance; });
|
|
std::erase_if(Timers, [&](const auto& t) { return t.ObjectId == object && t.InstanceId == instance; });
|
|
}
|
|
Entry* Ensure(MetaCoreGameObject object, MetaCoreScriptInstanceData& instance) {
|
|
if (instance.InstanceId == 0) instance.InstanceId = MetaCoreIdGenerator::Generate();
|
|
if (auto* current = FindEntry(object.GetId(), instance.InstanceId)) return current;
|
|
const auto* definition = Registry.FindScript(instance.ScriptTypeId);
|
|
if (!definition) { Log(1, "Script", "Missing script type: " + instance.ScriptTypeId); return nullptr; }
|
|
instance.FieldsJson = Registry.EnsureFieldsJsonDefaults(instance.ScriptTypeId, instance.FieldsJson);
|
|
Entry entry{object.GetId(), instance.InstanceId, instance.ScriptTypeId, Registry.CreateBehaviour(instance.ScriptTypeId)};
|
|
if (!entry.Behaviour) return nullptr;
|
|
Entries.push_back(std::move(entry));
|
|
auto& created = Entries.back();
|
|
try { auto context = Context(object, instance); created.Behaviour->OnPlayStart(context); created.Started = true; }
|
|
catch (const std::exception& e) { Fault(created, "OnPlayStart", e.what()); }
|
|
catch (...) { Fault(created, "OnPlayStart", "unknown exception"); }
|
|
return &created;
|
|
}
|
|
void CleanupStale() {
|
|
for (auto it = Entries.begin(); it != Entries.end();) {
|
|
auto object = Scene.FindGameObject(it->ObjectId);
|
|
auto* instance = FindInstance(object, it->InstanceId);
|
|
if (!object || !instance || !instance->Enabled || instance->ScriptTypeId != it->TypeId) {
|
|
StopEntry(*it, object, instance);
|
|
CleanupOwner(it->ObjectId, it->InstanceId);
|
|
it = Entries.erase(it);
|
|
} else ++it;
|
|
}
|
|
}
|
|
void StopEntry(Entry& entry, MetaCoreGameObject object, MetaCoreScriptInstanceData* instance) {
|
|
if (!entry.Started || !object || !instance) return;
|
|
try { auto context = Context(object, *instance); entry.Behaviour->OnPlayStop(context); }
|
|
catch (const std::exception& e) { Log(2, "Script", std::string("OnPlayStop fault: ") + e.what()); }
|
|
catch (...) { Log(2, "Script", "OnPlayStop fault: unknown exception"); }
|
|
entry.Started = false;
|
|
}
|
|
enum class Phase { Fixed, Update, Late };
|
|
void Dispatch(Phase phase, double delta) {
|
|
CleanupStale();
|
|
for (auto object : Scene.GetGameObjects()) {
|
|
if (!object.HasComponent<MetaCoreScriptComponent>()) continue;
|
|
for (auto& instance : object.GetComponent<MetaCoreScriptComponent>().Instances) {
|
|
if (!instance.Enabled) continue;
|
|
auto* entry = Ensure(object, instance);
|
|
if (!entry || entry->Faulted) continue;
|
|
try {
|
|
auto context = Context(object, instance);
|
|
if (phase == Phase::Fixed) entry->Behaviour->FixedUpdate(context, delta);
|
|
else if (phase == Phase::Update) entry->Behaviour->Update(context, delta);
|
|
else entry->Behaviour->LateUpdate(context, delta);
|
|
} catch (const std::exception& e) { Fault(*entry, phase == Phase::Fixed ? "FixedUpdate" : phase == Phase::Update ? "Update" : "LateUpdate", e.what()); }
|
|
catch (...) { Fault(*entry, "Update", "unknown exception"); }
|
|
}
|
|
}
|
|
}
|
|
void DispatchEvents() {
|
|
auto current = std::move(Events);
|
|
Events.clear();
|
|
for (const auto& event : current) {
|
|
const auto subscriptions = Subscriptions;
|
|
for (const auto& subscription : subscriptions) {
|
|
if (subscription.Topic == event.Topic && FindInstance(Scene.FindGameObject(subscription.ObjectId), subscription.InstanceId)) {
|
|
try { subscription.Handler(event.Topic, event.Fields); }
|
|
catch (...) { Log(2, "Script.Event", "Event handler threw an exception"); }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
void TickTimers(double scaled, double unscaled) {
|
|
std::erase_if(Timers, [&](const auto& timer) {
|
|
return !FindInstance(Scene.FindGameObject(timer.ObjectId), timer.InstanceId);
|
|
});
|
|
std::vector<std::uint64_t> fire;
|
|
for (auto& timer : Timers) { timer.Remaining -= timer.Unscaled ? unscaled : scaled; if (timer.Remaining <= 0.0) fire.push_back(timer.Id); }
|
|
for (auto id : fire) {
|
|
auto it = std::find_if(Timers.begin(), Timers.end(), [id](const auto& t) { return t.Id == id; });
|
|
if (it == Timers.end()) continue;
|
|
auto callback = it->Callback;
|
|
const double interval = it->Interval;
|
|
if (interval > 0.0) it->Remaining += interval;
|
|
else Timers.erase(it);
|
|
try { callback(); } catch (...) { Log(2, "Script.Timer", "Timer callback threw an exception"); }
|
|
}
|
|
}
|
|
};
|
|
|
|
MetaCoreScriptRuntime::MetaCoreScriptRuntime(MetaCoreScene& scene, MetaCoreScriptRegistry& registry, MetaCoreScriptLogHandler logger)
|
|
: Impl_(std::make_unique<Impl>(*this, scene, registry, std::move(logger))) {}
|
|
MetaCoreScriptRuntime::~MetaCoreScriptRuntime() { Stop(); }
|
|
void MetaCoreScriptRuntime::Start() { if (Impl_->Running) return; Impl_->Running = true; ++WorldGeneration_; for (auto o : Impl_->Scene.GetGameObjects()) if (o.HasComponent<MetaCoreScriptComponent>()) for (auto& i : o.GetComponent<MetaCoreScriptComponent>().Instances) if (i.Enabled) Impl_->Ensure(o, i); }
|
|
void MetaCoreScriptRuntime::FixedUpdate(double delta) { if (!Impl_->Running) return; Time_.FixedDeltaSeconds = std::max(0.0, delta); Impl_->Dispatch(Impl::Phase::Fixed, Time_.FixedDeltaSeconds); }
|
|
void MetaCoreScriptRuntime::Update(double delta) {
|
|
if (!Impl_->Running) return;
|
|
const double unscaled = std::max(0.0, delta); const double scaled = unscaled * Time_.TimeScale;
|
|
++Time_.Frame; Time_.DeltaSeconds = scaled; Time_.ElapsedSeconds += scaled; Time_.UnscaledElapsedSeconds += unscaled;
|
|
Impl_->TickTimers(scaled, unscaled); Impl_->DispatchEvents(); Impl_->Dispatch(Impl::Phase::Update, scaled);
|
|
}
|
|
void MetaCoreScriptRuntime::LateUpdate(double delta) { if (Impl_->Running) Impl_->Dispatch(Impl::Phase::Late, std::max(0.0, delta) * Time_.TimeScale); }
|
|
void MetaCoreScriptRuntime::Stop() {
|
|
if (!Impl_ || !Impl_->Running) return;
|
|
for (auto& entry : Impl_->Entries) { auto object = Impl_->Scene.FindGameObject(entry.ObjectId); Impl_->StopEntry(entry, object, FindInstance(object, entry.InstanceId)); }
|
|
Impl_->Entries.clear(); Impl_->Events.clear(); Impl_->Subscriptions.clear(); Impl_->Timers.clear(); Impl_->Running = false; Time_ = {}; ++WorldGeneration_;
|
|
}
|
|
void MetaCoreScriptRuntime::SetTimeScale(double scale) { Time_.TimeScale = std::max(0.0, scale); }
|
|
std::size_t MetaCoreScriptRuntime::GetFaultedInstanceCount() const { return std::count_if(Impl_->Entries.begin(), Impl_->Entries.end(), [](const auto& e) { return e.Faulted; }); }
|
|
std::uint64_t MetaCoreScriptRuntime::Subscribe(MetaCoreId object, std::uint64_t instance, std::string topic, EventHandler handler) { const auto id = Impl_->NextSubscription++; Impl_->Subscriptions.push_back({id, object, instance, std::move(topic), std::move(handler)}); return id; }
|
|
void MetaCoreScriptRuntime::Unsubscribe(std::uint64_t id) { std::erase_if(Impl_->Subscriptions, [id](const auto& s) { return s.Id == id; }); }
|
|
void MetaCoreScriptRuntime::Publish(std::string topic, std::vector<MetaCoreScriptValueV1> fields) { Impl_->Events.push_back({std::move(topic), std::move(fields)}); }
|
|
std::uint64_t MetaCoreScriptRuntime::ScheduleTimer(MetaCoreId object, std::uint64_t instance, double delay, double interval, bool unscaled, std::function<void()> callback) { const auto id = Impl_->NextTimer++; Impl_->Timers.push_back({id, object, instance, std::max(0.0, delay), std::max(0.0, interval), unscaled, std::move(callback)}); return id; }
|
|
void MetaCoreScriptRuntime::CancelTimer(std::uint64_t id) { std::erase_if(Impl_->Timers, [id](const auto& t) { return t.Id == id; }); }
|
|
bool MetaCoreScriptRuntime::IsHandleValid(MetaCoreScriptObjectHandleV1 handle) const { return handle.WorldGeneration == WorldGeneration_ && handle.ObjectId != 0 && static_cast<bool>(Impl_->Scene.FindGameObject(handle.ObjectId)); }
|
|
bool MetaCoreScriptRuntime::HasComponent(MetaCoreScriptObjectHandleV1 handle, std::string_view component) const {
|
|
auto object = IsHandleValid(handle) ? Impl_->Scene.FindGameObject(handle.ObjectId) : MetaCoreGameObject{};
|
|
if (!object) return false;
|
|
if (component == "Transform" || component == "Name") return true;
|
|
if (component == "Script") return object.HasComponent<MetaCoreScriptComponent>();
|
|
if (component == "Camera") return object.HasComponent<MetaCoreCameraComponent>();
|
|
if (component == "Light") return object.HasComponent<MetaCoreLightComponent>();
|
|
if (component == "MeshRenderer") return object.HasComponent<MetaCoreMeshRendererComponent>();
|
|
if (component == "Animator") return object.HasComponent<MetaCoreAnimatorComponent>();
|
|
return false;
|
|
}
|
|
bool MetaCoreScriptRuntime::GetProperty(MetaCoreScriptObjectHandleV1 handle, std::string_view component, std::string_view property, MetaCoreScriptValueV1& value) const {
|
|
if (!IsHandleValid(handle)) return false; auto object = Impl_->Scene.FindGameObject(handle.ObjectId); value = {};
|
|
if (component == "Name" && property == "Value") { value.Type = MetaCoreScriptAbiValue_String; std::snprintf(value.Text, sizeof(value.Text), "%s", object.GetName().c_str()); return true; }
|
|
if (component != "Transform") return false; const auto& transform = object.GetComponent<MetaCoreTransformComponent>(); const glm::vec3* source = nullptr;
|
|
if (property == "Position") source = &transform.Position; else if (property == "Rotation") source = &transform.RotationEulerDegrees; else if (property == "Scale") source = &transform.Scale; else return false;
|
|
value.Type = MetaCoreScriptAbiValue_Vec3; value.Vec3[0] = source->x; value.Vec3[1] = source->y; value.Vec3[2] = source->z; return true;
|
|
}
|
|
bool MetaCoreScriptRuntime::SetProperty(MetaCoreScriptObjectHandleV1 handle, std::string_view component, std::string_view property, const MetaCoreScriptValueV1& value) {
|
|
if (!IsHandleValid(handle)) return false; auto object = Impl_->Scene.FindGameObject(handle.ObjectId);
|
|
if (component == "Name" && property == "Value" && value.Type == MetaCoreScriptAbiValue_String) { object.GetName() = value.Text; Impl_->Scene.IncrementRevision(); return true; }
|
|
if (component != "Transform" || value.Type != MetaCoreScriptAbiValue_Vec3) return false; auto& transform = object.GetComponent<MetaCoreTransformComponent>(); glm::vec3* target = nullptr;
|
|
if (property == "Position") target = &transform.Position; else if (property == "Rotation") target = &transform.RotationEulerDegrees; else if (property == "Scale") target = &transform.Scale; else return false;
|
|
*target = {static_cast<float>(value.Vec3[0]), static_cast<float>(value.Vec3[1]), static_cast<float>(value.Vec3[2])}; Impl_->Scene.IncrementRevision(); return true;
|
|
}
|
|
bool MetaCoreScriptRuntime::GetField(MetaCoreScriptObjectHandleV1 handle, std::uint64_t instance, std::string_view field, MetaCoreScriptValueV1& value) const {
|
|
if (!IsHandleValid(handle)) return false;
|
|
auto* data = FindInstance(Impl_->Scene.FindGameObject(handle.ObjectId), instance);
|
|
if (!data) return false;
|
|
auto json = ParseObject(data->FieldsJson);
|
|
if (!json.contains(std::string(field)) || !JsonToAbi(json[std::string(field)], value)) return false;
|
|
if (const auto* definition = Impl_->Registry.FindScript(data->ScriptTypeId); definition != nullptr) {
|
|
const auto fieldDefinition = std::find_if(definition->Fields.begin(), definition->Fields.end(), [&](const auto& candidate) { return candidate.StableId() == field; });
|
|
if (fieldDefinition != definition->Fields.end()) {
|
|
if (fieldDefinition->Type == MetaCoreScriptFieldType::AssetRef) value.Type = MetaCoreScriptAbiValue_AssetRef;
|
|
if (fieldDefinition->Type == MetaCoreScriptFieldType::GameObjectRef) {
|
|
value.Type = MetaCoreScriptAbiValue_GameObjectRef;
|
|
value.ObjectValue = {WorldGeneration_, static_cast<std::uint64_t>(json[std::string(field)].get<MetaCoreId>())};
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
bool MetaCoreScriptRuntime::SetField(MetaCoreScriptObjectHandleV1 handle, std::uint64_t instance, std::string_view field, const MetaCoreScriptValueV1& value) { if (!IsHandleValid(handle)) return false; auto* data = FindInstance(Impl_->Scene.FindGameObject(handle.ObjectId), instance); if (!data) return false; auto json = ParseObject(data->FieldsJson); json[std::string(field)] = AbiToJson(value); data->FieldsJson = json.dump(); Impl_->Scene.IncrementRevision(); return true; }
|
|
void MetaCoreScriptRuntime::Log(std::uint32_t level, std::string_view category, std::string_view message) const { Impl_->Log(level, category, message); }
|
|
|
|
namespace {
|
|
bool HValid(void* c, MetaCoreScriptObjectHandleV1 h) noexcept { try { return c && static_cast<MetaCoreScriptRuntime*>(c)->IsHandleValid(h); } catch (...) { return false; } }
|
|
bool HHas(void* c, MetaCoreScriptObjectHandleV1 h, const char* t) noexcept { try { return c && t && static_cast<MetaCoreScriptRuntime*>(c)->HasComponent(h, t); } catch (...) { return false; } }
|
|
bool HGet(void* c, MetaCoreScriptObjectHandleV1 h, const char* t, const char* p, MetaCoreScriptValueV1* v) noexcept { try { return c && t && p && v && static_cast<MetaCoreScriptRuntime*>(c)->GetProperty(h, t, p, *v); } catch (...) { return false; } }
|
|
bool HSet(void* c, MetaCoreScriptObjectHandleV1 h, const char* t, const char* p, const MetaCoreScriptValueV1* v) noexcept { try { return c && t && p && v && static_cast<MetaCoreScriptRuntime*>(c)->SetProperty(h, t, p, *v); } catch (...) { return false; } }
|
|
bool HGetField(void* c, MetaCoreScriptObjectHandleV1 h, std::uint64_t i, const char* f, MetaCoreScriptValueV1* v) noexcept { try { return c && f && v && static_cast<MetaCoreScriptRuntime*>(c)->GetField(h, i, f, *v); } catch (...) { return false; } }
|
|
bool HSetField(void* c, MetaCoreScriptObjectHandleV1 h, std::uint64_t i, const char* f, const MetaCoreScriptValueV1* v) noexcept { try { return c && f && v && static_cast<MetaCoreScriptRuntime*>(c)->SetField(h, i, f, *v); } catch (...) { return false; } }
|
|
void HLog(void* c, std::uint32_t l, const char* k, const char* m) noexcept { try { if (c) static_cast<MetaCoreScriptRuntime*>(c)->Log(l, k ? k : "Script", m ? m : ""); } catch (...) {} }
|
|
bool HPublish(void* c, const char* topic, const MetaCoreScriptValueV1* values, std::size_t count) noexcept { try { if (!c || !topic) return false; std::vector<MetaCoreScriptValueV1> copied(values, values + count); static_cast<MetaCoreScriptRuntime*>(c)->Publish(topic, std::move(copied)); return true; } catch (...) { return false; } }
|
|
std::uint64_t HSubscribe(void* c, MetaCoreScriptObjectHandleV1 h, std::uint64_t instance, const char* topic, MetaCoreScriptEventCallbackV1 cb, void* user) noexcept { try { if (!c || !topic || !cb) return 0; auto* runtime = static_cast<MetaCoreScriptRuntime*>(c); return runtime->Subscribe(h.ObjectId, instance, topic, [runtime, h, instance, cb, user](std::string_view name, const std::vector<MetaCoreScriptValueV1>& fields) { MetaCoreScriptExecutionContextV1 context{&HostApi(), runtime, h, instance, "", "{}", {}}; if (const char* e = cb(user, &context, std::string(name).c_str(), fields.data(), fields.size()); e) runtime->Log(2, "Script.Event", e); }); } catch (...) { return 0; } }
|
|
void HUnsubscribe(void* c, std::uint64_t id) noexcept { try { if (c) static_cast<MetaCoreScriptRuntime*>(c)->Unsubscribe(id); } catch (...) {} }
|
|
std::uint64_t HSchedule(void* c, MetaCoreScriptObjectHandleV1 h, std::uint64_t instance, double delay, double interval, bool unscaled, MetaCoreScriptTimerCallbackV1 cb, void* user) noexcept { try { if (!c || !cb) return 0; auto* runtime = static_cast<MetaCoreScriptRuntime*>(c); return runtime->ScheduleTimer(h.ObjectId, instance, delay, interval, unscaled, [runtime, h, instance, cb, user] { MetaCoreScriptExecutionContextV1 context{&HostApi(), runtime, h, instance, "", "{}", {}}; if (const char* e = cb(user, &context); e) runtime->Log(2, "Script.Timer", e); }); } catch (...) { return 0; } }
|
|
void HCancel(void* c, std::uint64_t id) noexcept { try { if (c) static_cast<MetaCoreScriptRuntime*>(c)->CancelTimer(id); } catch (...) {} }
|
|
const MetaCoreScriptHostApiV1& HostApi() { static const MetaCoreScriptHostApiV1 api{METACORE_SCRIPT_ABI_MAJOR, METACORE_SCRIPT_ABI_MINOR, METACORE_SCRIPT_HOST_CAPABILITIES, HValid, HHas, HGet, HSet, HGetField, HSetField, HLog, HPublish, HSubscribe, HUnsubscribe, HSchedule, HCancel}; return api; }
|
|
} // namespace
|
|
|
|
bool MetaCoreGenerateScriptProject(const std::filesystem::path& root, std::string_view projectName, const std::filesystem::path& sdkRoot, std::string* error) {
|
|
const auto scripts = root / "Scripts"; std::error_code ec;
|
|
std::filesystem::create_directories(scripts / "Source", ec); std::filesystem::create_directories(scripts / "SDK" / "MetaCoreScripting", ec); std::filesystem::create_directories(root / ".vscode", ec);
|
|
const auto sourceHeader = sdkRoot / "Source" / "MetaCoreScripting" / "Public" / "MetaCoreScripting" / "MetaCoreScriptAbi.h";
|
|
if (ec || !std::filesystem::is_regular_file(sourceHeader)) { if (error) *error = "MetaCore scripting SDK header was not found at " + sourceHeader.string(); return false; }
|
|
std::filesystem::copy_file(sourceHeader, scripts / "SDK" / "MetaCoreScripting" / "MetaCoreScriptAbi.h", std::filesystem::copy_options::overwrite_existing, ec);
|
|
if (ec) { if (error) *error = ec.message(); return false; }
|
|
const std::string id = SafeIdentifier(projectName);
|
|
const std::string cmake = "cmake_minimum_required(VERSION 3.20)\nproject(" + id + "Scripts LANGUAGES CXX)\nif(NOT CMAKE_SYSTEM_NAME STREQUAL \"Linux\" OR NOT CMAKE_SIZEOF_VOID_P EQUAL 8)\n message(FATAL_ERROR \"MetaCore script v1 requires Linux x86_64\")\nendif()\nif(NOT CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n message(FATAL_ERROR \"MetaCore script v1 requires Clang and libc++\")\nendif()\nset(CMAKE_CXX_STANDARD 20)\nset(CMAKE_POSITION_INDEPENDENT_CODE ON)\nfile(GLOB SCRIPT_SOURCES CONFIGURE_DEPENDS Source/*.cpp)\nadd_library(" + id + "Scripts SHARED ${SCRIPT_SOURCES})\ntarget_include_directories(" + id + "Scripts PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/SDK)\ntarget_compile_definitions(" + id + "Scripts PRIVATE METACORE_SCRIPT_MODULE_ID=\\\"" + id + "\\\" METACORE_SCRIPT_BUILD_ID=\\\"${METACORE_SCRIPT_BUILD_ID}\\\")\nset_target_properties(" + id + "Scripts PROPERTIES PREFIX \"\" OUTPUT_NAME \"" + id + "Scripts_${METACORE_SCRIPT_BUILD_ID}\" LIBRARY_OUTPUT_DIRECTORY \"${METACORE_SCRIPT_OUTPUT_DIR}\")\n";
|
|
const std::string sdk = "#pragma once\n#include <MetaCoreScripting/MetaCoreScriptAbi.h>\n#include <exception>\n#include <string>\n#include <vector>\nnamespace MetaCoreScriptSdk { inline std::vector<const MetaCoreScriptBehaviourDescriptorV1*>& Registry(){ static std::vector<const MetaCoreScriptBehaviourDescriptorV1*> value; return value; } struct Registrar { explicit Registrar(const MetaCoreScriptBehaviourDescriptorV1* value){ Registry().push_back(value); } }; template<class F> const char* Guard(F&& function) noexcept { try { function(); return nullptr; } catch(const std::exception& e) { static thread_local std::string error; error=e.what(); return error.c_str(); } catch(...) { return \"unknown C++ exception\"; } } }\n#define MC_REGISTER_SCRIPT(Name, Descriptor) static MetaCoreScriptSdk::Registrar Name##Registrar(&(Descriptor))\n";
|
|
const std::string module = "#include <MetaCoreScripting/MetaCoreScriptSdk.h>\n#include <vector>\nextern \"C\" METACORE_SCRIPT_EXPORT bool MetaCoreLoadScriptModuleV1(const MetaCoreScriptHostApiV1* host, MetaCoreScriptModuleApiV1* out) noexcept { if(!host||!out||host->AbiMajor!=METACORE_SCRIPT_ABI_MAJOR) return false; static std::vector<MetaCoreScriptBehaviourDescriptorV1> descriptors; if(descriptors.empty()) for(const auto* descriptor:MetaCoreScriptSdk::Registry()) descriptors.push_back(*descriptor); *out={METACORE_SCRIPT_ABI_MAJOR,METACORE_SCRIPT_ABI_MINOR,METACORE_SCRIPT_CAP_PROPERTIES|METACORE_SCRIPT_CAP_EVENTS|METACORE_SCRIPT_CAP_TIMERS,METACORE_SCRIPT_MODULE_ID,METACORE_SCRIPT_BUILD_ID,descriptors.size(),descriptors.data(),nullptr}; return true; }\n";
|
|
const std::string launch = "{\n \"version\": \"0.2.0\",\n \"configurations\": [\n {\"name\": \"Attach MetaCore Editor (LLDB)\", \"type\": \"lldb\", \"request\": \"attach\", \"pid\": \"${command:pickMyProcess}\"},\n {\"name\": \"Attach MetaCore Player (LLDB)\", \"type\": \"lldb\", \"request\": \"attach\", \"pid\": \"${command:pickMyProcess}\"}\n ]\n}\n";
|
|
if (!WriteIfMissing(scripts / "CMakeLists.txt", cmake) ||
|
|
!WriteIfMissing(scripts / "SDK" / "MetaCoreScripting" / "MetaCoreScriptSdk.h", sdk) ||
|
|
!WriteIfMissing(scripts / "Source" / "Module.cpp", module) ||
|
|
!WriteIfMissing(root / ".vscode" / "launch.json", launch)) {
|
|
if (error) *error = "Failed to write script project files";
|
|
return false;
|
|
}
|
|
if (std::filesystem::exists(scripts / "Source" / "Mover.cpp")) {
|
|
return true;
|
|
}
|
|
return MetaCoreCreateScriptBehaviour(root, projectName, "Mover", error);
|
|
}
|
|
|
|
bool MetaCoreCreateScriptBehaviour(const std::filesystem::path& root, std::string_view projectName, std::string_view behaviourName, std::string* error) {
|
|
const std::string moduleId = SafeIdentifier(projectName);
|
|
const std::string name = SafeIdentifier(behaviourName);
|
|
if (name.empty() || name != behaviourName) {
|
|
if (error) *error = "Behaviour name must contain only ASCII letters, digits, or underscores";
|
|
return false;
|
|
}
|
|
const auto path = root / "Scripts" / "Source" / (name + ".cpp");
|
|
if (std::filesystem::exists(path)) {
|
|
if (error) *error = "Behaviour source already exists: " + path.string();
|
|
return false;
|
|
}
|
|
const std::string source = "#include <MetaCoreScripting/MetaCoreScriptSdk.h>\n#include <new>\nstruct " + name + " {};\nstatic void* Create" + name + "() noexcept { return new (std::nothrow) " + name + "; }\nstatic void Destroy" + name + "(void* value) noexcept { delete static_cast<" + name + "*>(value); }\nstatic const char* Update" + name + "(void*, const MetaCoreScriptExecutionContextV1* context, double delta) noexcept { return MetaCoreScriptSdk::Guard([&] { MetaCoreScriptValueV1 speed{}; if(!context->Host->GetField(context->HostContext,context->Object,context->InstanceId,\"speed\",&speed)) return; MetaCoreScriptValueV1 position{}; if(!context->Host->GetProperty(context->HostContext,context->Object,\"Transform\",\"Position\",&position)) return; position.Vec3[0]+=speed.NumberValue*delta; context->Host->SetProperty(context->HostContext,context->Object,\"Transform\",\"Position\",&position); }); }\nstatic const MetaCoreScriptFieldDescriptorV1 " + name + "Fields[]={{\"speed\",\"Speed\",MetaCoreScriptAbiValue_Float,\"1.0\"}};\nstatic const MetaCoreScriptBehaviourDescriptorV1 " + name + "Descriptor={\"" + moduleId + "." + name + "\",\"" + name + "\",1,1," + name + "Fields,Create" + name + ",Destroy" + name + ",nullptr,nullptr,Update" + name + ",nullptr,nullptr};\nMC_REGISTER_SCRIPT(" + name + ", " + name + "Descriptor);\n";
|
|
if (!WriteIfMissing(path, source)) {
|
|
if (error) *error = "Failed to create behaviour source: " + path.string();
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
MetaCoreScriptProjectBuildResult MetaCoreBuildScriptProject(const std::filesystem::path& root, std::string_view configuration, const std::filesystem::path&) {
|
|
MetaCoreScriptProjectBuildResult result; const auto now = std::chrono::system_clock::now().time_since_epoch(); result.BuildId = std::to_string(std::chrono::duration_cast<std::chrono::milliseconds>(now).count());
|
|
result.BuildDirectory = root / "Library" / "ScriptBuild" / std::string(configuration);
|
|
const auto output = root / "Library" / "ScriptModules" / "Linux-x86_64" / std::string(configuration) / result.BuildId;
|
|
std::error_code ec;
|
|
std::filesystem::remove(result.BuildDirectory / "CMakeCache.txt", ec);
|
|
ec.clear();
|
|
std::filesystem::remove_all(result.BuildDirectory / "CMakeFiles", ec);
|
|
ec.clear();
|
|
std::filesystem::create_directories(result.BuildDirectory, ec); std::filesystem::create_directories(output, ec);
|
|
const auto log = result.BuildDirectory / ("build-" + result.BuildId + ".log");
|
|
const std::string configure = "cmake -S " + ShellQuote(root / "Scripts") + " -B " + ShellQuote(result.BuildDirectory) + " -DCMAKE_CXX_COMPILER=clang++-15 -DCMAKE_CXX_FLAGS=-stdlib=libc++ -DCMAKE_SHARED_LINKER_FLAGS=-stdlib=libc++ -DCMAKE_BUILD_TYPE=" + std::string(configuration) + " -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DMETACORE_SCRIPT_BUILD_ID=" + result.BuildId + " -DMETACORE_SCRIPT_OUTPUT_DIR=" + ShellQuote(output) + " > " + ShellQuote(log) + " 2>&1";
|
|
int code = std::system(configure.c_str());
|
|
if (code == 0) { const std::string build = "cmake --build " + ShellQuote(result.BuildDirectory) + " --config " + std::string(configuration) + " >> " + ShellQuote(log) + " 2>&1"; code = std::system(build.c_str()); }
|
|
std::ifstream input(log); std::ostringstream text; text << input.rdbuf(); result.Output = text.str();
|
|
if (code == 0) { for (const auto& entry : std::filesystem::directory_iterator(output, ec)) if (entry.path().extension() == ".so") { result.ModulePath = entry.path(); break; } }
|
|
result.Success = code == 0 && !result.ModulePath.empty();
|
|
if (result.Success) {
|
|
std::filesystem::copy_file(result.BuildDirectory / "compile_commands.json", root / "compile_commands.json", std::filesystem::copy_options::overwrite_existing, ec);
|
|
std::string loadError;
|
|
MetaCoreScriptModuleLoader loader;
|
|
const auto loaded = loader.LoadCandidate(result.ModulePath, &loadError);
|
|
const auto hash = MetaCoreSha256File(result.ModulePath);
|
|
if (!loaded.has_value() || !hash.has_value()) {
|
|
result.Success = false;
|
|
result.Output += "\nPost-build module validation failed: " + loadError;
|
|
} else {
|
|
result.ManifestPath = result.ModulePath;
|
|
result.ManifestPath += ".mcscriptmodule.json";
|
|
std::ofstream manifest(result.ManifestPath, std::ios::trunc);
|
|
manifest << Json{{"format_version", 1}, {"abi_major", METACORE_SCRIPT_ABI_MAJOR},
|
|
{"abi_minor", METACORE_SCRIPT_ABI_MINOR}, {"module_id", loaded->ModuleId},
|
|
{"build_id", result.BuildId}, {"module_file", result.ModulePath.filename().string()},
|
|
{"sha256", *hash}}.dump(2) << '\n';
|
|
result.Success = manifest.good();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
std::optional<std::filesystem::path> MetaCoreFindLatestScriptModule(const std::filesystem::path& root, std::string_view configuration) {
|
|
const auto base = root / "Library" / "ScriptModules" / "Linux-x86_64" / std::string(configuration); if (!std::filesystem::is_directory(base)) return std::nullopt;
|
|
std::filesystem::path latest; std::filesystem::file_time_type time{}; std::error_code ec;
|
|
for (const auto& entry : std::filesystem::recursive_directory_iterator(base, ec)) if (entry.path().extension() == ".so") { auto t = entry.last_write_time(ec); if (latest.empty() || t > time) { latest = entry.path(); time = t; } }
|
|
return latest.empty() ? std::nullopt : std::optional<std::filesystem::path>(latest);
|
|
}
|
|
|
|
} // namespace MetaCore
|