script_system.h

Go to the documentation of this file.

#pragma once
#include <engine/engine_export.h>
#include <engine/physics/ecs/components/physics_component.h>
#include <engine/scripting/ecs/components/script_component.h>
 
#include <engine/threading/threader.h>
 
#include <base/basetypes.hpp>
#include <cmd_line/parser.h>
#include <context/context.hpp>
#include <filesystem/filesystem.h>
#include <hpp/span.hpp>
 
#include <dotnetpp/dotnetpp.h>
 
namespace unravel
{
 
struct script_system
{
    static void set_needs_recompile(const std::string& protocol, bool now = false);
    static auto get_script_debug_mode() -> bool;
    static void set_script_debug_mode(bool debug);
    static auto get_lib_name(const std::string& protocol) -> std::string;
    static auto get_lib_data_key(const std::string& protocol) -> std::string;
    static auto get_lib_temp_compiled_key(const std::string& protocol) -> std::string;
    static auto get_lib_compiled_key(const std::string& protocol) -> std::string;
    static void copy_compiled_lib(const fs::path& from, const fs::path& to);
    static auto is_debugger_attached() -> bool;
    static void log_exception(const dotnet::exception& e,
                              const hpp::source_location& loc = hpp::source_location::current());
    static auto find_dotnet_paths(const rtti::context& ctx) -> dotnet::compiler_paths;
 
    script_system(rtti::context& ctx, cmd_line::parser& parser);
 
    auto init(rtti::context& ctx, const cmd_line::parser& parser) -> bool;
    auto deinit(rtti::context& ctx) -> bool;
 
    void set_debug_config(const std::string& address, uint32_t port, uint32_t loglevel);
 
    auto load_engine_domain(rtti::context& ctx, bool recompile) -> bool;
    void unload_engine_domain();
 
    auto load_app_domain(rtti::context& ctx, bool recompile) -> bool;
    void unload_app_domain();
 
    auto get_all_scriptable_components() const -> const std::vector<dotnet::type>&;
    auto get_scriptable_component_base_type() const -> dotnet::type;
    auto get_engine_assembly() const -> dotnet::assembly;
    auto get_app_assembly() const -> dotnet::assembly;
 
    struct engine_script_cache
    {
        dotnet::type update_manager_type;
        dotnet::type script_system_type;
        dotnet::type component_type;
        dotnet::type script_component_type;
        dotnet::type ui_event_manager_type;
 
        // SystemManager frame hooks
        dotnet::method update_method;
        dotnet::method fixed_update_method;
        dotnet::method late_update_method;
 
        // Component / ScriptComponent lifecycle (resolved once per engine domain)
        dotnet::method set_entity_method;
        dotnet::method on_create_method;
        dotnet::method on_enable_method;
        dotnet::method on_disable_method;
        dotnet::method on_start_method;
        dotnet::method on_destroy_method;
        dotnet::method on_sensor_enter_method;
        dotnet::method on_sensor_exit_method;
        dotnet::method on_collision_enter_method;
        dotnet::method on_collision_exit_method;
 
        // UIEventManager
        dotnet::method ui_dispatch_event_method;
    };
 
    auto get_cache() const -> const engine_script_cache&
    {
        return cache_;
    }
 
    auto get_type_by_fullname(const std::string& fullname) const -> dotnet::type;
    auto get_type(const std::string& name_space, const std::string& name) const -> dotnet::type;
 
    auto is_create_called() const -> bool;
    auto is_update_called() const -> bool;
    void wait_for_jobs_to_finish(rtti::context& ctx);
    auto has_compilation_errors() const -> bool;
 
    void on_sensor_enter(entt::handle sensor, entt::handle other, const std::vector<manifold_point>& manifolds);
    void on_sensor_exit(entt::handle sensor, entt::handle other, const std::vector<manifold_point>& manifolds);
 
    void on_collision_enter(entt::handle a, entt::handle b, const std::vector<manifold_point>& manifolds);
    void on_collision_exit(entt::handle a, entt::handle b, const std::vector<manifold_point>& manifolds);
 
    static void on_create_component(entt::registry& r, entt::entity e);
    static void on_create_active_component(entt::registry& r, entt::entity e);
 
    static void on_load_component(entt::registry& r, entt::entity e);
 
    static void on_destroy_component(entt::registry& r, entt::entity e);
    static void on_destroy_active_component(entt::registry& r, entt::entity e);
 
 
    void on_play_begin(rtti::context& ctx);
    void on_play_begin(hpp::span<const entt::handle> entities);
    void on_play_begin(entt::registry& entities);
 
private:
    void on_frame_update(rtti::context& ctx, delta_t dt);
    void on_frame_fixed_update(rtti::context& ctx, delta_t dt);
    void on_frame_late_update(rtti::context& ctx, delta_t dt);
 
    void on_play_end(rtti::context& ctx);
 
    void on_pause(rtti::context& ctx);
 
    void on_resume(rtti::context& ctx);
 
    void on_skip_next_frame(rtti::context& ctx);
 
    auto bind_internal_calls(rtti::context& ctx) -> bool;
 
    void check_for_recompile(rtti::context& ctx, delta_t dt, bool emit_callback);
 
    auto create_compilation_job(rtti::context& ctx, const std::string& protocol, bool debug) -> tpp::job_future<bool>;
 
    std::shared_ptr<int> sentinel_ = std::make_shared<int>(0);
 
    delta_t time_since_last_check_{};
 
    dotnet::debugging_config debug_config_;
    std::unique_ptr<dotnet::domain> domain_;
 
    engine_script_cache cache_;
 
    std::unique_ptr<dotnet::domain> app_domain_;
 
    struct app_script_cache
    {
        std::vector<dotnet::type> scriptable_component_types;
 
    } app_cache_;
 
    enum class call_progress
    {
        not_called,
        started,
        finished
    };
 
    call_progress create_call_{call_progress::not_called};
    bool is_updating_{};
    std::vector<tpp::future<void>> compilation_jobs_;
 
    bool has_compilation_errors_{};
 
    delta_t elapsed_time_{};
};
} // namespace unravel