debug_draw_3d.h

#pragma once
 
#include "common/colors.h"
#include "common/i_scope_storage.h"
#include "config_scope_3d.h"
#include "geometry_generators.h"
#include "render_instances_enums.h"
#include "utils/compiler.h"
#include "utils/native_api_hooks.h"
#include "utils/profiler.h"
 
#include <map>
#include <memory>
#include <mutex>
 
GODOT_WARNING_DISABLE()
#include <godot_cpp/classes/array_mesh.hpp>
#include <godot_cpp/classes/node3d.hpp>
#include <godot_cpp/classes/shader.hpp>
#include <godot_cpp/classes/shader_material.hpp>
#include <godot_cpp/classes/sub_viewport.hpp>
GODOT_WARNING_RESTORE()
using namespace godot;
 
class DebugDraw3D;
class DebugDrawManager;
class DebugDraw3DConfig;
class DebugDraw3DStats;
 
#ifndef DISABLE_DEBUG_RENDERING
class DebugGeometryContainer;
class NodesContainer;
struct DelayedRendererLine;
#endif

enum class MeshMaterialType : char {
    Wireframe,
    Billboard,
    Plane,
    Extendable,
    MAX,
};

enum class MeshMaterialVariant : char {
    Normal,
    NoDepth,
    MAX,
};
 
#ifndef DISABLE_DEBUG_RENDERING
class _DD3D_WorldWatcher : public Node3D {
    GDCLASS(_DD3D_WorldWatcher, Node3D)
protected:
    DebugDraw3D *m_owner = nullptr;
    uint64_t m_world_id;
    Node *m_nodes_root = nullptr;
    static void _bind_methods() {}
 
public:
    virtual void _process(double p_delta) override;
    virtual void _notification(int p_what);
    Node *get_nodes_root() const;
 
    _DD3D_WorldWatcher() :
            m_world_id() {}
    _DD3D_WorldWatcher(DebugDraw3D *p_root, uint64_t p_world_id);
};
 
#endif

NAPI_CLASS_SINGLETON class DebugDraw3D : public Object, public IScopeStorage<DebugDraw3DScopeConfig, DebugDraw3DScopeConfig::Data> {
    GDCLASS(DebugDraw3D, Object)
 
    friend DebugDrawManager;
 
#ifndef DISABLE_DEBUG_RENDERING
    friend DebugGeometryContainer;
    friend NodesContainer;
    friend _DD3D_WorldWatcher;
#endif
 
public:
    NAPI_ENUM enum PointType : uint32_t {
        POINT_TYPE_SQUARE,
        POINT_TYPE_SPHERE,
    };
 
private:
    static DebugDraw3D *singleton;
 
    String root_settings_section;
    static constexpr const char *s_use_icosphere = "use_icosphere";
    static constexpr const char *s_use_icosphere_hd = "use_icosphere_for_hd";
    static constexpr const char *s_add_bevel_to_volumetric = "add_bevel_to_volumetric_geometry";
    static constexpr const char *s_default_frustum_scale = "defaults/frustum_length_scale";
 
    static constexpr const char *s_default_thickness = "volumetric_defaults/thickness";
    static constexpr const char *s_default_center_brightness = "volumetric_defaults/center_brightness";
    static constexpr const char *s_default_hd_spheres = "volumetric_defaults/hd_spheres";
    static constexpr const char *s_default_plane_size = "volumetric_defaults/plane_size";
 
    static constexpr const char *s_render_priority = "rendering/render_priority";
    static constexpr const char *s_render_mode = "rendering/render_mode";
    static constexpr const char *s_render_fog_disabled = "rendering/disable_fog";
 
    std::vector<SubViewport *> custom_editor_viewports;
    DebugDrawManager *root_node = nullptr;
 
    Ref<DebugDraw3DScopeConfig> default_scoped_config;
 
#ifndef DISABLE_DEBUG_RENDERING
    ProfiledMutex(std::recursive_mutex, datalock, "3D Geometry lock");
 
    struct ScopedPairIdConfig {
        uint64_t id;
        DebugDraw3DScopeConfig *scfg;
        ScopedPairIdConfig(uint64_t id, DebugDraw3DScopeConfig *scfg) :
                id(id), scfg(scfg) {}
    };
    // stores thread id and array of id's with ptrs
    std::unordered_map<uint64_t, std::vector<ScopedPairIdConfig>> scoped_configs;
    // stores thread id and most recent config
    std::unordered_map<uint64_t, std::shared_ptr<DebugDraw3DScopeConfig::Data>> cached_scoped_configs;
    uint64_t created_scoped_configs = 0;
    struct {
        uint64_t created;
        uint64_t orphans;
    } scoped_stats_3d = {};
 
    // Inherited via IScopeStorage
    const DebugDraw3DScopeConfig::Data *scoped_config_for_current_thread() override;
 
    // Meshes
    std::vector<std::array<GeometryGenerator::GeneratedMeshData, (int)MeshMaterialVariant::MAX>> shared_generated_meshes;

    struct ViewportToDebugContainerItem {
        uint64_t world_id;
        _DD3D_WorldWatcher *world_watcher;
        std::unique_ptr<DebugGeometryContainer> dgcs[(int)MeshMaterialVariant::MAX];
        std::unique_ptr<NodesContainer> ncs[(int)MeshMaterialVariant::MAX];
 
        ViewportToDebugContainerItem();
        ViewportToDebugContainerItem(ViewportToDebugContainerItem &&other) noexcept;
        ~ViewportToDebugContainerItem();
    };
 
    std::unordered_map<uint64_t /* World3D */, ViewportToDebugContainerItem> debug_containers;
    // invalidate on add/remove operations or use ptrs
    std::unordered_map<const Viewport *, ViewportToDebugContainerItem *> viewport_to_world_cache;
    std::unordered_map<uint64_t /*Viewport * */, Ref<World3D>> world3ds_found_for_threads_cache;
 
    // Default materials and shaders
    Ref<ShaderMaterial> mesh_shaders[(int)MeshMaterialType::MAX][(int)MeshMaterialVariant::MAX];
 
    // Inherited via IScopeStorage
    void _register_scoped_config(uint64_t p_thread_id, uint64_t p_guard_id, DebugDraw3DScopeConfig *p_cfg) override;
    void _unregister_scoped_config(uint64_t p_thread_id, uint64_t p_guard_id) override;
    void _clear_scoped_configs() override;
    void _clear_all_remove_watcher_as_child(uint64_t world_watcher_id);
 
    std::array<GeometryGenerator::GeneratedMeshData, (int)MeshMaterialVariant::MAX> *get_shared_meshes();
    DebugDraw3D::ViewportToDebugContainerItem *get_debug_container(const DebugDraw3DScopeConfig::DebugContainerDependent &p_dgcd, const bool p_generate_new_container);
    void _deferred_find_world_in_viewport(uint64_t p_viewport_id);
    void _register_viewport_world_deferred(uint64_t /*Viewport * */ p_viewport_id, const uint64_t p_world_id, _DD3D_WorldWatcher *watcher);
    Node *_get_root_world_node(Node *p_scene_root, Viewport *p_vp);
    void _remove_debug_container(const uint64_t &p_world_id);
 
    _FORCE_INLINE_ Vector3 get_up_vector(const Vector3 &p_dir);
    void add_or_update_line_with_thickness(real_t p_exp_time, const Vector3 *p_lines, const size_t p_line_count, const Color &p_col, const std::function<void(DelayedRendererLine *)> p_custom_upd = nullptr);
    Node *get_root_node();
 
    void create_arrow(const Vector3 &p_a, const Vector3 &p_b, const Color &p_color, const real_t &p_arrow_size, const bool &p_is_absolute_size, const real_t &p_duration = 0);
    void create_capsule(const Transform3D &p_xf, const Vector3 &p_center, const Vector3 &p_top_cap, const Vector3 &p_bottom_cap, const real_t &p_radius, const real_t &p_height, const Color &p_color, const real_t &p_duration = 0);
 
#ifdef DEV_ENABLED
    void _save_generated_meshes();
#endif
 
#endif
 
    void init(DebugDrawManager *p_root);
 
    void set_custom_editor_viewport(std::vector<SubViewport *> p_viewports);
    std::vector<SubViewport *> get_custom_editor_viewports();
 
    Ref<ShaderMaterial> get_material_variant(MeshMaterialType p_type, MeshMaterialVariant p_var);
 
    void _load_materials();
    inline bool _is_enabled_override() const;
 
    void process_start(double delta);
    void process_end(double delta);
    void physics_process_start(double p_delta);
    void physics_process_end(double p_delta);
 
#pragma region Exposed Parameter Values

    bool debug_enabled = true;
 
    Ref<DebugDraw3DConfig> config;
 
#pragma endregion // Exposed Parameter Values
 
protected:
    static void _bind_methods();
 
public:
    DebugDraw3D();
    ~DebugDraw3D();

    static DebugDraw3D *get_singleton() {
        return singleton;
    }
 
#pragma region Configs
    NAPI Ref<DebugDraw3DScopeConfig> new_scoped_config();
    NAPI Ref<DebugDraw3DScopeConfig> scoped_config() override;

    NAPI void set_config(Ref<DebugDraw3DConfig> cfg);
    NAPI Ref<DebugDraw3DConfig> get_config() const;
 
#pragma endregion // Configs
 
#pragma region Exposed Parameters
    void set_empty_color(const godot::Color &col) {}
    Color get_empty_color() const;

    NAPI void set_debug_enabled(const bool &state);
    NAPI bool is_debug_enabled() const;
 
#pragma endregion // Exposed Parametes
 
#pragma region Exposed Draw Methods

    NAPI Ref<DebugDraw3DStats> get_render_stats();

    NAPI Ref<DebugDraw3DStats> get_render_stats_for_world(godot::Viewport *viewport);
 
#ifndef DISABLE_DEBUG_RENDERING
#define FAKE_FUNC_IMPL
#else
#define FAKE_FUNC_IMPL \
    {                  \
    }
#endif

    NAPI void regenerate_geometry_meshes();

    NAPI void clear_all();
 
#pragma region Spheres

    void draw_sphere_base(const godot::Transform3D &transform, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    NAPI void draw_sphere(const godot::Vector3 &position, const real_t &radius = 0.5f, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    NAPI void draw_sphere_xf(const godot::Transform3D &transform, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Spheres
 
#pragma region Cylinders

    NAPI void draw_capsule(const godot::Vector3 &position, const godot::Quaternion &rotation, const real_t &radius, const real_t &height, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_capsule_ab(const godot::Vector3 &a, const godot::Vector3 &b, const real_t &radius = 0.5f, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_cylinder(const godot::Transform3D &transform, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_cylinder_ab(const godot::Vector3 &a, const godot::Vector3 &b, const real_t &radius = 0.5f, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Cylinders
 
#pragma region Boxes

    NAPI void draw_box(const godot::Vector3 &position, const godot::Quaternion &rotation, const godot::Vector3 &size, const godot::Color &color = Colors::empty_color, const bool &is_box_centered = false, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_box_ab(const godot::Vector3 &a, const godot::Vector3 &b, const godot::Vector3 &up, const godot::Color &color = Colors::empty_color, const bool &is_ab_diagonal = true, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_box_xf(const godot::Transform3D &transform, const godot::Color &color = Colors::empty_color, const bool &is_box_centered = true, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_aabb(const godot::AABB &aabb, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_aabb_ab(const godot::Vector3 &a, const godot::Vector3 &b, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Boxes
 
#pragma region Lines

    NAPI void draw_line_hit(const godot::Vector3 &start, const godot::Vector3 &end, const godot::Vector3 &hit, const bool &is_hit, const real_t &hit_size = 0.25f, const godot::Color &hit_color = Colors::empty_color, const godot::Color &after_hit_color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_line_hit_offset(const godot::Vector3 &start, const godot::Vector3 &end, const bool &is_hit, const real_t &unit_offset_of_hit = 0.5f, const real_t &hit_size = 0.25f, const godot::Color &hit_color = Colors::empty_color, const godot::Color &after_hit_color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma region Normal

    NAPI void draw_line(const godot::Vector3 &a, const godot::Vector3 &b, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_ray(const godot::Vector3 &origin, const godot::Vector3 &direction, const real_t &length, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    void draw_lines(const godot::PackedVector3Array &lines, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    // #docs_func draw_lines
    NAPI void draw_lines_c(const godot::Vector3 *lines_data, const uint64_t &lines_size, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    void draw_line_path(const godot::PackedVector3Array &path, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    // #docs_func draw_line_path
    NAPI void draw_line_path_c(const godot::Vector3 *path_data, const uint64_t &path_size, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Normal
 
#pragma region Arrows

    NAPI void draw_arrowhead(const godot::Transform3D &transform, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_arrow(const godot::Vector3 &a, const godot::Vector3 &b, const godot::Color &color = Colors::empty_color, const real_t &arrow_size = 0.5f, const bool &is_absolute_size = false, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_arrow_ray(const godot::Vector3 &origin, const godot::Vector3 &direction, const real_t &length, const godot::Color &color = Colors::empty_color, const real_t &arrow_size = 0.5f, const bool &is_absolute_size = false, const real_t &duration = 0) FAKE_FUNC_IMPL;

    void draw_arrow_path(const godot::PackedVector3Array &path, const godot::Color &color = Colors::empty_color, const real_t &arrow_size = 0.75f, const bool &is_absolute_size = true, const real_t &duration = 0) FAKE_FUNC_IMPL;
    // #docs_func draw_arrow_path
    NAPI void draw_arrow_path_c(const godot::Vector3 *path_data, const uint64_t &path_size, const godot::Color &color = Colors::empty_color, const real_t &arrow_size = 0.75f, const bool &is_absolute_size = true, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Arrows
#pragma region Points

    void draw_point_path(const godot::PackedVector3Array &path, const DebugDraw3D::PointType type = PointType::POINT_TYPE_SQUARE, const real_t &size = 0.25f, const godot::Color &points_color = Colors::empty_color, const godot::Color &lines_color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    // #docs_func draw_point_path
    NAPI void draw_point_path_c(const godot::Vector3 *path_data, const uint64_t &path_size, const DebugDraw3D::PointType type = PointType::POINT_TYPE_SQUARE, const real_t &size = 0.25f, const godot::Color &points_color = Colors::empty_color, const godot::Color &lines_color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Points
#pragma endregion // Lines
 
#pragma region Misc

    void draw_points(const godot::PackedVector3Array &points, const DebugDraw3D::PointType type = DebugDraw3D::PointType::POINT_TYPE_SQUARE, const real_t &size = 0.25f, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    // #docs_func draw_points
    NAPI void draw_points_c(const godot::Vector3 *points_data, const uint64_t &points_size, const DebugDraw3D::PointType type = DebugDraw3D::PointType::POINT_TYPE_SQUARE, const real_t &size = 0.25f, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_square(const godot::Vector3 &position, const real_t &size = 0.2f, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_plane(const godot::Plane &plane, const godot::Color &color = Colors::empty_color, const godot::Vector3 &anchor_point = godot::Vector3(INFINITY, INFINITY, INFINITY), const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_position(const godot::Transform3D &transform, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_gizmo(const godot::Transform3D &transform, const godot::Color &color = Colors::empty_color, const bool &is_centered = false, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_grid(const godot::Vector3 &origin, const godot::Vector3 &x_size, const godot::Vector3 &y_size, const godot::Vector2i &subdivision, const godot::Color &color = Colors::empty_color, const bool &is_centered = true, const real_t &duration = 0) FAKE_FUNC_IMPL;

    NAPI void draw_grid_xf(const godot::Transform3D &transform, const godot::Vector2i &p_subdivision, const godot::Color &color = Colors::empty_color, const bool &is_centered = true, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma region Camera Frustum

    NAPI void draw_camera_frustum(const class godot::Camera3D *camera, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    void draw_camera_frustum_planes(const godot::Array &camera_frustum, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    // #docs_func draw_camera_frustum_planes
    NAPI void draw_camera_frustum_planes_c(const godot::Plane *camera_frustum_data, const uint64_t camera_frustum_size, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Camera Frustum
 
#pragma region Text
    void draw_text(const godot::Vector3 &position, const godot::String text, const int size = 32, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    // #docs_func draw_text
    NAPI void draw_text_c(const godot::Vector3 &position, const char *text_string, const int size = 32, const godot::Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Text
 
#pragma endregion // Misc
#pragma endregion // Exposed Draw Methods
 
#undef FAKE_FUNC_IMPL
};
 
VARIANT_ENUM_CAST(DebugDraw3D::PointType);