debug_draw_3d.h

#pragma once
 
#include "common/colors.h"
#include "common/i_scope_storage.h"
#include "config_scope_3d.h"
#include "utils/profiler.h"
 
#include <map>
#include <memory>
#include <mutex>
 
GODOT_WARNING_DISABLE()
#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 DataGraphManager;
class DebugDrawManager;
class DebugDraw3DConfig;
class DebugDraw3DStats;
 
#ifndef DISABLE_DEBUG_RENDERING
class DebugGeometryContainer;
class DelayedRendererLine;
 
enum class InstanceType : char;
enum class ConvertableInstanceType : char;
#endif
 
class DebugDraw3D : public Object, public IScopeStorage<DebugDraw3DScopeConfig> {
    GDCLASS(DebugDraw3D, Object)
 
    friend DebugDrawManager;
 
#ifndef DISABLE_DEBUG_RENDERING
    friend DebugGeometryContainer;
 
    enum GeometryType{
        Wireframe,
        Volumetric,
        Solid,
    };
#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_thickness;
    const static char *s_default_center_brightness;
    const static char *s_default_hd_spheres;
    const static char *s_default_plane_size;
 
    std::vector<SubViewport *> custom_editor_viewports;
    DebugDrawManager *root_node = nullptr;
 
    Ref<DebugDraw3DStats> stats_3d;
    Ref<DebugDraw3DScopeConfig> default_scoped_config;
 
#ifndef DISABLE_DEBUG_RENDERING
    ProfiledMutex(std::recursive_mutex, datalock, "3D Geometry lock");
 
    typedef std::pair<uint64_t, DebugDraw3DScopeConfig *> ScopedPairIdConfig;
    // 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, DebugDraw3DScopeConfig *> cached_scoped_configs;
    uint64_t create_scoped_configs = 0;
 
    // Inherited via IScopeStorage
    DebugDraw3DScopeConfig *scoped_config_for_current_thread() override;
 
    // Meshes
    std::unique_ptr<DebugGeometryContainer> dgc;
 
    Vector3 previous_camera_position;
    double previous_camera_far_plane = 0;
 
    // Default materials and shaders
    Ref<ShaderMaterial> shader_wireframe_mat;
    Ref<Shader> shader_wireframe_code;
 
    Ref<ShaderMaterial> shader_billboard_mat;
    Ref<Shader> shader_billboard_code;
 
    Ref<ShaderMaterial> shader_plane_mat;
    Ref<Shader> shader_plane_code;
 
    Ref<ShaderMaterial> shader_extendable_mat;
    Ref<Shader> shader_extendable_code;
 
    // Inherited via IScopeStorage
    void _register_scoped_config(uint64_t thread_id, uint64_t guard_id, DebugDraw3DScopeConfig *cfg) override;
    void _unregister_scoped_config(uint64_t thread_id, uint64_t guard_id) override;
    void _clear_scoped_configs() override;
 
    // Internal use of raw pointer to avoid ref/unref
    Color _scoped_config_to_custom(DebugDraw3DScopeConfig *cfg);
    InstanceType _scoped_config_type_convert(ConvertableInstanceType type, DebugDraw3DScopeConfig *cfg);
    GeometryType _scoped_config_get_geometry_type(DebugDraw3DScopeConfig *cfg);
 
    _FORCE_INLINE_ Vector3 get_up_vector(const Vector3 &dir);
    void add_or_update_line_with_thickness(real_t _exp_time, std::unique_ptr<Vector3[]> _lines, const size_t _line_count, const Color &_col, const std::function<void(DelayedRendererLine *)> _custom_upd = nullptr);
    Node *get_root_node();
 
    void create_arrow(const Vector3 &a, const Vector3 &b, const Color &color, const real_t &arrow_size, const bool &is_absolute_size, const real_t &duration = 0);
 
#endif
 
    void init(DebugDrawManager *root);
 
    void set_custom_editor_viewport(std::vector<SubViewport *> _viewports);
    std::vector<SubViewport *> get_custom_editor_viewports();
 
    Ref<ShaderMaterial> get_wireframe_material();
    Ref<ShaderMaterial> get_billboard_material();
    Ref<ShaderMaterial> get_plane_material();
    Ref<ShaderMaterial> get_extendable_material();
 
    void _load_materials();
    void _set_base_world_node(Node *world_base);
    inline bool _is_enabled_override() const;
 
    void process(double delta);
    void physics_process_start(double delta);
    void physics_process_end(double delta);
 
#pragma region Exposed Parameter Values
 
    bool debug_enabled = true;
    Viewport *custom_viewport = nullptr;
 
    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;
 
    void set_custom_viewport(Viewport *_viewport);
    Viewport *get_custom_viewport() const;
 
#pragma endregion // Exposed Parametes
 
#pragma region Exposed Draw Methods
 
    Ref<DebugDraw3DStats> get_render_stats();
 
#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 endregion // Misc
#pragma endregion // Exposed Draw Methods
 
#undef FAKE_FUNC_IMPL
};
 
VARIANT_ENUM_CAST(DebugDraw3D::PointType);