debug_draw_3d.h

#pragma once
 
#include "common/colors.h"
#include "common/i_scope_storage.h"
#include "config_scope_3d.h"
#include "render_instances_enums.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;
    static void _bind_methods() {};
 
public:
    virtual void _process(double p_delta) override;
    virtual void _notification(int p_what);
 
    _DD3D_WorldWatcher() :
            m_world_id() {}
    _DD3D_WorldWatcher(DebugDraw3D *p_root, uint64_t p_world_id);
};
 
#endif

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:
    enum PointType : int {
        POINT_TYPE_SQUARE,
        POINT_TYPE_SPHERE,
    };
 
private:
    static DebugDraw3D *singleton;
 
    String root_settings_section;
    const static char *s_use_icosphere;
    const static char *s_use_icosphere_hd;
    const static char *s_add_bevel_to_volumetric;
    const static char *s_default_frustum_scale;
 
    const static char *s_default_thickness;
    const static char *s_default_center_brightness;
    const static char *s_default_hd_spheres;
    const static char *s_default_plane_size;
 
    const static char *s_render_priority;
    const static char *s_render_mode;
    const static char *s_render_fog_disabled;
 
    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<Ref<ArrayMesh>, (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;
 
    std::array<Ref<ArrayMesh>, (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, std::unique_ptr<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);
 
#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
    Ref<DebugDraw3DScopeConfig> new_scoped_config();
    Ref<DebugDraw3DScopeConfig> scoped_config() override;

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

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

    Ref<DebugDraw3DStats> get_render_stats();

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

    void regenerate_geometry_meshes();

    void clear_all();
 
#pragma region Spheres

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

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

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

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

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

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

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

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

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

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

    void draw_lines_c(const std::vector<Vector3> &lines, const Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    void draw_line(const Vector3 &a, const Vector3 &b, const Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

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

    void draw_lines(const PackedVector3Array &lines, const Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    void draw_line_path(const PackedVector3Array &path, const Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Normal
 
#pragma region Arrows

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

    void draw_arrow(const Vector3 &a, const Vector3 &b, const 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_ray(const Vector3 &origin, const Vector3 &direction, const real_t &length, const 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 PackedVector3Array &path, const 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 PackedVector3Array &path, const PointType type = PointType::POINT_TYPE_SQUARE, const real_t &size = 0.25f, const Color &points_color = Colors::empty_color, const 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 PackedVector3Array &points, const PointType type = PointType::POINT_TYPE_SQUARE, const real_t &size = 0.25f, const Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

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

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

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

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

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

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

    void draw_camera_frustum_planes_c(const std::array<Plane, 6> &planes, const Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
    void draw_camera_frustum(const class godot::Camera3D *camera, const Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;

    void draw_camera_frustum_planes(const Array &camera_frustum, const Color &color = Colors::empty_color, const real_t &duration = 0) FAKE_FUNC_IMPL;
 
#pragma endregion // Camera Frustum
 
#pragma region Text
    void draw_text(const Vector3 &position, const String text, const int size = 32, const 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);