Commit 070bae78 authored by Libor Moravčík's avatar Libor Moravčík
Browse files

PHX debug renderer reworked and moved to utils module

parent 98943d15

phx/include/phx/debug_renderer.hpp

deleted100644 → 0
+0 −133
Original line number Diff line number Diff line 
#ifndef PHX_DEBUG_RENDERER_HPP_INCLUDED

#define PHX_DEBUG_RENDERER_HPP_INCLUDED



#include <math/math.hpp>

#include <phx/coll/contact.hpp>

#include <com/system.hpp>

#include <unordered_map>

#include <phx/coll/narrow/simplex.hpp>

#include <phx/coll/narrow/polytope.hpp>



namespace com

{

struct Folder;

struct Frame;

} // namespace com



namespace gfx

{

struct Buffer;

struct Material;

} // namespace gfx



namespace std

{

// Hash of CollisionID

template <> struct hash<std::pair<com::Frame *, com::Folder *>>

{

	std::size_t operator()(const std::pair<com::Frame *, com::Folder *> &pair) const noexcept

	{

		using boost::hash_combine;

		using boost::hash_value;



		std::size_t seed = 0;



		hash_combine(seed, hash_value(pair.first));

		hash_combine(seed, hash_value(pair.second));

		// Return the result.

		return seed;

	}

};

} // namespace std



namespace phx::coll

{

	struct Collider;

}



namespace phx

{



struct DebugRenderer : public com::System

{

	static inline std::string self_name()

	{

		return "debug_renderer.lib";

	}



	DebugRenderer() : com::System(self_name(), self_system_path()) {};



	void initialize() override;

	void release() override;



	void register_base_bodies_world_frame(com::Folder *folder, scalar scale = 2.0f);

	void register_basis(com::Frame *frame, scalar scale = 2.0f);

	void register_bases(com::Folder *folder, scalar scale = 2.0f);

	void register_collider(coll::Collider *collider);

	void register_colliders(com::Folder *folder);



	void unregister_basis(com::Frame *frame);

	void unregister_bases(com::Folder *folder);

	void unregister_collider(coll::Collider *collider);

	void unregister_colliders(com::Folder *folder);



	void push_contacts(coll::Contact const *contacts, int n, int simulation_step, scalar radius = 0.05f);

	void push_simplex(coll::Simplex const & simplex);

	void push_polytope(coll::Polytope const &polytope);

	void clear_contacts();

	void clear_simplex();

	void clear_polytope();



      private:

	void push_contact(coll::Contact const &contact, int simulation_step, scalar radius = 0.5f);

	void push_sphere_solid_red(const vec3 &position, scalar radius = 0.5f);

	void push_sphere_solid_orange(const vec3 &position, scalar radius = 0.5f);

	void push_sphere_solid_magenta(const vec3 &position, scalar radius = 0.5f);

	void push_line_magenta(const vec3 &from, const vec3 &to);

	void push_line_orange(const vec3& from, const vec3 &to);



	void register_sphere_wireframe(com::Frame *frame, scalar radius = 0.5f);

	void register_box_wireframe(com::Frame *frame, vec3 const &half_extents);

	void unregister_sphere_wireframe(com::Frame *frame);

	void unregister_box_wireframe(com::Frame *frame);



	gfx::Buffer *m_buffer_basis;

	gfx::Buffer *m_buffer_sphere_wireframe;

	gfx::Buffer *m_buffer_box_wirefame;

	gfx::Buffer *m_buffer_sphere_solid;

	gfx::Buffer *m_buffer_line;



	com::Folder *m_folder_frames_lines_magenta;

	com::Folder *m_folder_frames_lines_orange;

	com::Folder *m_folder_frames_spheres_wireframe;

	com::Folder *m_folder_frames_spheres_solid_red;

	com::Folder *m_folder_frames_spheres_solid_orange;

	com::Folder *m_folder_frames_spheres_solid_magenta;

	com::Folder *m_folder_frames_bases;

	com::Folder *m_folder_frames_boxes_wireframe;



	com::Folder *m_gfx_instances_line_magenta;

	com::Folder *m_gfx_instances_line_orange;

	com::Folder *m_gfx_instances_sphere_wireframe;

	com::Folder *m_gfx_instances_sphere_solid_red;

	com::Folder *m_gfx_instances_sphere_solid_orange;

	com::Folder *m_gfx_instances_sphere_solid_magenta;

	com::Folder *m_gfx_instances_basis;

	com::Folder *m_gfx_instances_box_wireframe;



	gfx::Material *m_material_no_color;

	gfx::Material *m_material_red;

	gfx::Material *m_material_orange;

	gfx::Material *m_material_green;

	gfx::Material *m_material_magenta;



	std::unordered_map<std::pair<com::Frame *, com::Folder *>, com::Folder *> m_registered;



	static inline com::ContextPath self_system_path()

	{

		return {"debug_renderer"};

	}

};

} // namespace phx



#endif
 
 No newline at end of file

phx/include/phx/index.hpp

+0 −11
Original line number Diff line number Diff line
@@ -23,7 +23,6 @@ namespace phx 
struct WorldSystem;

struct BodySystem;

struct Timer;

struct DebugRenderer;





struct Index final
@@ -51,10 +50,6 @@ struct Index final 
	{

		return m_timer;

	}

	DebugRenderer *debug_renderer() const

	{

		return m_debug_renderer;

	}

	dyn::RigidBodySimulator *rigid_body_simulator() const

	{

		return m_rigid_body_simulator;
@@ -92,7 +87,6 @@ struct Index final 
	BodySystem *m_body_system;

	WorldSystem *m_world_system;

	dyn::JointSystem *m_joint_system;

	DebugRenderer *m_debug_renderer;

	dyn::RigidBodySimulator *m_rigid_body_simulator;

	Timer *m_timer;

	coll::LayerSystem *m_layer_system;
@@ -132,11 +126,6 @@ inline Timer *timer() 
	return index().timer();

}



inline DebugRenderer *debug_renderer()

{

	return index().debug_renderer();

}



inline dyn::RigidBodySimulator *rigid_body_simulator()

{

	return index().rigid_body_simulator();

phx/src/debug_renderer.cpp

deleted100644 → 0
+0 −487
Original line number Diff line number Diff line 
#include <com/context.hpp>

#include <com/frame.hpp>

#include <gfx/buffer.hpp>

#include <gfx/index.hpp>

#include <gfx/material.hpp>

#include <phx/coll/collider.hpp>

#include <phx/debug_renderer.hpp>

#include <utils/context_utils.hpp>



namespace phx

{



void DebugRenderer::initialize()

{

	System::initialize();

	m_material_no_color = gfx::material_system()->insert_material(

	    "nocolor", gfx::shader_system()->forward_unlit_vertex_color_shader(),

	    {"phx", "debug_renderer", "draw_frame"});

	m_material_red = gfx::material_system()->insert_default_material(

	    "red", {"phx", "debug_renderer", "materials"}, {1, 0, 0});

	m_material_green = gfx::material_system()->insert_default_material(

	    "green", {"phx", "debug_renderer", "materials"}, {0, 1, 0});

	m_material_magenta = gfx::material_system()->insert_default_material(

	    "magenta", {"phx", "debug_renderer", "materials"}, {1, 0, 1});

	m_material_orange = gfx::material_system()->insert_default_material(

	    "orange", {"phx", "debug_renderer", "materials"}, {1, 0.7f, 0.0f});



	m_buffer_basis = gfx::buffer_generators()->insert_procedural_basis(

	    1.0f, "basis", {"phx", "debug_renderer"});

	m_buffer_sphere_solid = gfx::buffer_generators()->insert_procedural_sphere_solid(

	    1.0f, 16, "sphere_solid", {"phx", "debug_renderer"});

	m_buffer_sphere_wireframe = gfx::buffer_generators()->insert_procedural_sphere_wireframe(

	    1.0f, 32, "sphere_wireframe", {"phx", "debug_renderer"});

	m_buffer_line = gfx::buffer_system()->insert_buffer(

	    "line", gfx::Buffer::PrimitiveType::LINE, {"phx", "debug_renderer"});

	m_buffer_box_wirefame = gfx::buffer_generators()->insert_procedural_box_wireframe(

	    {1.0f, 1.0f, 1.0f}, "box_wireframe", {"phx", "debug_renderer"});

	m_buffer_line->insert_positions({{0, 0, 0}, {0, 0, 1}});



	m_gfx_instances_sphere_solid_red =

	    gfx::object_system()->insert_object({"phx", "debug_renderer", "draw_sphere_solid_red"},

						m_material_red, m_buffer_sphere_solid);

	m_gfx_instances_sphere_solid_orange = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_sphere_solid_orange"}, m_material_orange,

	    m_buffer_sphere_solid);

	m_gfx_instances_sphere_solid_magenta = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_sphere_solid_magenta"}, m_material_magenta,

	    m_buffer_sphere_solid);



	m_gfx_instances_sphere_wireframe =

	    gfx::object_system()->insert_object({"phx", "debug_renderer", "draw_sphere_wireframe"},

						m_material_green, m_buffer_sphere_wireframe);

	m_gfx_instances_line_magenta = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_line_magenta"}, m_material_magenta, m_buffer_line);

	m_gfx_instances_line_orange = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_line_orange"}, m_material_orange, m_buffer_line);

	m_gfx_instances_basis = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_frame"}, m_material_no_color, m_buffer_basis);

	m_gfx_instances_box_wireframe =

	    gfx::object_system()->insert_object({"phx", "debug_renderer", "draw_box_wireframe"},

						m_material_green, m_buffer_box_wirefame);



	m_folder_frames_lines_magenta =

	    system_folder()->push_back_folders({"frames_lines_magenta"});

	m_folder_frames_spheres_solid_red =

	    system_folder()->push_back_folders({"frames_spheres_solid_red"});

	m_folder_frames_spheres_solid_orange =

	    system_folder()->push_back_folders({"frames_spheres_solid_orange"});

	m_folder_frames_spheres_solid_magenta =

	    system_folder()->push_back_folders({"frames_spheres_solid_magenta"});

	m_folder_frames_spheres_wireframe =

	    system_folder()->push_back_folders({"frames_spheres_wireframe"});

	m_folder_frames_bases = system_folder()->push_back_folders({"frames_bases"});

	m_folder_frames_boxes_wireframe =

	    system_folder()->push_back_folders({"frames_boxes_wireframe"});

	m_folder_frames_lines_orange = system_folder()->push_back_folders({"frames_lines_orange"});

}



void DebugRenderer::release()

{

	gfx::buffer_system()->erase_buffer(m_buffer_basis);

	gfx::buffer_system()->erase_buffer(m_buffer_sphere_solid);

	gfx::buffer_system()->erase_buffer(m_buffer_sphere_wireframe);

	gfx::buffer_system()->erase_buffer(m_buffer_line);

}



void DebugRenderer::register_base_bodies_world_frame(com::Folder *folder, scalar scale)

{

	auto fn = [this, &scale](com::ContextItem *item)

	{

		if (com::Frame *frame = dynamic_cast<com::Frame *>(item))

		{

			if (frame->folder() && frame->folder()->name() == "world_frame")

			{

				register_basis(frame, scale);

			}

		}



		return false;

	};



	foreach_tree::bfs(folder, fn, false);

}



void DebugRenderer::register_basis(com::Frame *frame, scalar scale)

{

	auto folder = m_folder_frames_bases->push_back<com::Folder>(

	    m_folder_frames_bases->generate_unique_name("frame_basis"));

	const auto f = folder->push_back<com::Frame>();

	folder->push_back<com::Link>(com::Frame::parent_link_file_name(), frame);

	f->set_scale_in_world_space(vec3{scale, scale, scale});

	gfx::object_system()->push_frame_back(m_gfx_instances_basis, f);

	if (m_registered.contains({frame, m_folder_frames_bases}) == false)

	{

		m_registered.insert({{frame, m_folder_frames_bases}, {}});

	}

	m_registered.at({frame, m_folder_frames_bases}) = folder;

}



void DebugRenderer::register_bases(com::Folder *folder, scalar scale)

{

	auto fn = [this, &scale](com::ContextItem *item)

	{

		if (com::Frame *frame = dynamic_cast<com::Frame *>(item))

		{

			register_basis(frame, scale);

		}



		return false;

	};



	foreach_tree::bfs(folder, fn, false);

}



void DebugRenderer::register_collider(coll::Collider *collider)

{

	if (coll::SphereCollider *sphere_collider = dynamic_cast<coll::SphereCollider *>(collider))

	{

		register_sphere_wireframe(collider->frame(), sphere_collider->shape()->radius());

	}



	if (coll::BoxCollider *box_collider = dynamic_cast<coll::BoxCollider *>(collider))

	{

		register_box_wireframe(collider->frame(), box_collider->shape()->half_extents());

	}

}



void DebugRenderer::register_colliders(com::Folder *folder)

{

	auto fn = [this](com::ContextItem *item)

	{

		if (coll::Collider *collider = dynamic_cast<coll::Collider *>(item))

		{

			register_collider(collider);

		}



		return false;

	};



	foreach_tree::bfs(folder, fn, false);

}



void DebugRenderer::register_sphere_wireframe(com::Frame *frame, scalar radius)

{

	auto folder = m_folder_frames_spheres_wireframe->push_back<com::Folder>(

	    m_folder_frames_spheres_wireframe->generate_unique_name("sphere_wireframe"));

	const auto f = folder->push_back<com::Frame>();

	folder->push_back<com::Link>(com::Frame::parent_link_file_name(), frame);

	f->set_scale_in_world_space({radius, radius, radius});

	gfx::object_system()->push_frame_back(m_gfx_instances_sphere_wireframe, f);

	if (m_registered.contains({frame, m_folder_frames_spheres_wireframe}) == false)

	{

		m_registered.insert({{frame, m_folder_frames_spheres_wireframe}, {}});

	}

	m_registered.at({frame, m_folder_frames_spheres_wireframe}) = folder;

}



void DebugRenderer::register_box_wireframe(com::Frame *frame, vec3 const &half_extents)

{

	auto folder = m_folder_frames_boxes_wireframe->push_back<com::Folder>(

	    m_folder_frames_boxes_wireframe->generate_unique_name("box_wireframe"));

	const auto f = folder->push_back<com::Frame>();

	folder->push_back<com::Link>(com::Frame::parent_link_file_name(), frame);

	f->set_scale_in_world_space({half_extents.x, half_extents.y, half_extents.z});

	gfx::object_system()->push_frame_back(m_gfx_instances_box_wireframe, f);

	if (m_registered.contains({frame, m_folder_frames_boxes_wireframe}) == false)

	{

		m_registered.insert({{frame, m_folder_frames_boxes_wireframe}, {}});

	}

	m_registered.at({frame, m_folder_frames_boxes_wireframe}) = folder;

}



void DebugRenderer::unregister_basis(com::Frame *frame)

{

	if (m_registered.contains({frame, m_folder_frames_bases}) == false)

	{

		return;

	}



	auto subfolder = m_registered.at({frame, m_folder_frames_bases});

	com::Frame *f = dynamic_cast<com::Frame *>(subfolder->find(com::Frame::self_file_name()));

	ASSUMPTION(f);

	gfx::object_system()->erase_frame(m_gfx_instances_basis, f);

	m_folder_frames_bases->erase(subfolder);

	m_registered.erase({frame, m_folder_frames_bases});

}



void DebugRenderer::unregister_sphere_wireframe(com::Frame *frame)

{

	if (m_registered.contains({frame, m_folder_frames_spheres_wireframe}) == false)

	{

		return;

	}



	auto subfolder = m_registered.at({frame, m_folder_frames_spheres_wireframe});

	com::Frame *f = dynamic_cast<com::Frame *>(subfolder->find(com::Frame::self_file_name()));

	ASSUMPTION(f);

	gfx::object_system()->erase_frame(m_gfx_instances_sphere_wireframe, f);

	m_folder_frames_spheres_wireframe->erase(subfolder);

	m_registered.erase({frame, m_folder_frames_spheres_wireframe});

}



void DebugRenderer::unregister_box_wireframe(com::Frame *frame)

{

	if (m_registered.contains({frame, m_folder_frames_boxes_wireframe}) == false)

	{

		return;

	}



	auto subfolder = m_registered.at({frame, m_folder_frames_boxes_wireframe});

	com::Frame *f = dynamic_cast<com::Frame *>(subfolder->find(com::Frame::self_file_name()));

	ASSUMPTION(f);

	gfx::object_system()->erase_frame(m_gfx_instances_box_wireframe, f);

	m_folder_frames_boxes_wireframe->erase(subfolder);

	m_registered.erase({frame, m_folder_frames_boxes_wireframe});

}



void DebugRenderer::unregister_bases(com::Folder *folder)

{

	auto fn = [this](com::ContextItem *item)

	{

		if (com::Frame *frame = dynamic_cast<com::Frame *>(item))

		{

			unregister_basis(frame);

		}



		return false;

	};



	foreach_tree::bfs(folder, fn, true);

}



void DebugRenderer::unregister_collider(coll::Collider *collider)

{

	if (coll::SphereCollider *sphere_collider = dynamic_cast<coll::SphereCollider *>(collider))

	{

		unregister_sphere_wireframe(collider->frame());

	}



	if (coll::BoxCollider *box_collider = dynamic_cast<coll::BoxCollider *>(collider))

	{

		unregister_box_wireframe(collider->frame());

	}

}



void DebugRenderer::unregister_colliders(com::Folder *folder)

{

	auto fn = [this](com::ContextItem *item)

	{

		if (coll::Collider *collider = dynamic_cast<coll::Collider *>(item))

		{

			unregister_collider(collider);

		}



		return false;

	};



	foreach_tree::bfs(folder, fn, true);

}



void DebugRenderer::push_contacts(coll::Contact const *contacts, int n, int simulation_step,

				  scalar radius)

{

	for (int i = 0; i < n; i++)

	{

		push_contact(contacts[i], simulation_step, radius);

	}

}



void DebugRenderer::push_contact(coll::Contact const &contact, int simulation_step, scalar radius)

{

	if (contact.m_is_new_contact)

	{

		push_sphere_solid_red(contact.point_on_a_ws(), radius);

		push_sphere_solid_red(contact.point_on_b_ws(), radius);

	}

	else

	{

		push_sphere_solid_orange(contact.point_on_a_ws(), radius);

		push_sphere_solid_orange(contact.point_on_b_ws(), radius);

	}



	// render normals

	push_line_magenta(contact.point_on_b_ws(),

			  contact.point_on_b_ws() + contact.normal_on_b_ws() * 0.5f);



	push_sphere_solid_magenta(contact.point_on_b_ws() + contact.normal_on_b_ws() * 0.5f,

				  radius / 2);



}



void DebugRenderer::push_sphere_solid_red(const vec3 &position, scalar radius)

{

	const auto frame =

	    m_folder_frames_spheres_solid_red

		->push_back<com::Folder>(

		    m_folder_frames_spheres_solid_red->generate_unique_name("sphere_solid"))

		->push_back<com::Frame>();

	frame->set_origin(position);

	frame->set_scale({radius, radius, radius});

	gfx::object_system()->push_frame_back(m_gfx_instances_sphere_solid_red, frame);

}



void DebugRenderer::push_sphere_solid_magenta(const vec3 &position, scalar radius)

{

	const auto frame =

	    m_folder_frames_spheres_solid_magenta

		->push_back<com::Folder>(

		    m_folder_frames_spheres_solid_magenta->generate_unique_name("sphere_solid"))

		->push_back<com::Frame>();

	frame->set_origin(position);

	frame->set_scale({radius, radius, radius});

	gfx::object_system()->push_frame_back(m_gfx_instances_sphere_solid_magenta, frame);

}



void DebugRenderer::push_sphere_solid_orange(const vec3 &position, scalar radius)

{

	const auto frame =

	    m_folder_frames_spheres_solid_orange

		->push_back<com::Folder>(

		    m_folder_frames_spheres_solid_orange->generate_unique_name("sphere_solid"))

		->push_back<com::Frame>();

	frame->set_origin(position);

	frame->set_scale({radius, radius, radius});

	gfx::object_system()->push_frame_back(m_gfx_instances_sphere_solid_orange, frame);

}



void DebugRenderer::push_line_magenta(const vec3 &from, const vec3 &to)

{

	const auto direction = normalize(to - from);

	const auto length = distance(to, from);



	if (length < Num::epsilon) return;



	const auto direction_quat = normalized(look_at(direction, vec3{0, 0, 1}, vec3{0, 1, 0}));



	const auto frame = m_folder_frames_lines_magenta

			       ->push_back<com::Folder>(

				   m_folder_frames_lines_magenta->generate_unique_name("line"))

			       ->push_back<com::Frame>();

	frame->set_origin(from + direction * length);

	frame->set_rotation(direction_quat);

	frame->set_scale({length, length, length});



	gfx::object_system()->push_frame_back(m_gfx_instances_line_magenta, frame);

}



void DebugRenderer::push_line_orange(const vec3 &from, const vec3 &to)

{

	const auto direction = normalize(to - from);

	const auto length = distance(to, from);



	if (length < Num::epsilon) return;



	const auto direction_quat = normalized(look_at(direction, vec3{0, 0, 1}, vec3{0, 1, 0}));



	const auto frame =

	    m_folder_frames_lines_orange

		->push_back<com::Folder>(m_folder_frames_lines_orange->generate_unique_name("line"))

		->push_back<com::Frame>();

	frame->set_origin(from + direction * length);

	frame->set_rotation(direction_quat);

	frame->set_scale({length, length, length});



	gfx::object_system()->push_frame_back(m_gfx_instances_line_orange, frame);

}



void DebugRenderer::push_simplex(coll::Simplex const &simplex)

{

	

	if (simplex.size() == 1)

	{

		push_sphere_solid_orange(simplex.at(0).m_point_on_polytope_ws, 0.02f);

	}



	if (simplex.size() == 2)

	{

		push_line_orange(simplex.at(0).m_point_on_polytope_ws,

				 simplex.at(1).m_point_on_polytope_ws);

	}



	if (simplex.size() == 3)

	{

		push_line_orange(simplex.at(0).m_point_on_polytope_ws,

				 simplex.at(1).m_point_on_polytope_ws);

		push_line_orange(simplex.at(1).m_point_on_polytope_ws,

				 simplex.at(2).m_point_on_polytope_ws);

		push_line_orange(simplex.at(2).m_point_on_polytope_ws,

				 simplex.at(0).m_point_on_polytope_ws);

	}



	if (simplex.size() == 4)

	{

		push_line_orange(simplex.at(0).m_point_on_polytope_ws,

				 simplex.at(1).m_point_on_polytope_ws);

		push_line_orange(simplex.at(1).m_point_on_polytope_ws,

				 simplex.at(2).m_point_on_polytope_ws);

		push_line_orange(simplex.at(2).m_point_on_polytope_ws,

				 simplex.at(0).m_point_on_polytope_ws);

		push_line_orange(simplex.at(0).m_point_on_polytope_ws,

				 simplex.at(3).m_point_on_polytope_ws);

		push_line_orange(simplex.at(1).m_point_on_polytope_ws,

				 simplex.at(3).m_point_on_polytope_ws);

		push_line_orange(simplex.at(2).m_point_on_polytope_ws,

				 simplex.at(3).m_point_on_polytope_ws);

	}

}



void DebugRenderer::push_polytope(coll::Polytope const &polytope)

{

	for (std::size_t i = 0; i < polytope.m_faces.size(); i++)

	{

		auto const &a = polytope.m_points.at(polytope.m_faces[i][0]);

		auto const &b = polytope.m_points.at(polytope.m_faces[i][1]);

		auto const &c = polytope.m_points.at(polytope.m_faces[i][2]);



		push_line_orange(a, b);

		push_line_orange(b, c);

		push_line_orange(c, a);

	}

}



void DebugRenderer::clear_contacts()

{

	m_gfx_instances_sphere_solid_red->folder()->erase(m_gfx_instances_sphere_solid_red);

	m_gfx_instances_sphere_solid_red =

	    gfx::object_system()->insert_object({"phx", "debug_renderer", "draw_sphere_solid_red"},

						m_material_red, m_buffer_sphere_solid);

	m_folder_frames_spheres_solid_red->clear();



	m_gfx_instances_sphere_solid_magenta->folder()->erase(m_gfx_instances_sphere_solid_magenta);

	m_gfx_instances_sphere_solid_magenta = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_sphere_solid_magenta"}, m_material_magenta,

	    m_buffer_sphere_solid);

	m_folder_frames_spheres_solid_magenta->clear();



	m_gfx_instances_sphere_solid_orange->folder()->erase(m_gfx_instances_sphere_solid_orange);

	m_gfx_instances_sphere_solid_orange = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_sphere_solid_orange"}, m_material_orange,

	    m_buffer_sphere_solid);

	m_folder_frames_spheres_solid_orange->clear();



	m_gfx_instances_line_magenta->folder()->erase(m_gfx_instances_line_magenta);

	m_gfx_instances_line_magenta = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_line_magenta"}, m_material_magenta, m_buffer_line);

	m_folder_frames_lines_magenta->clear();

}



void DebugRenderer::clear_simplex()

{

	clear_polytope();

	m_gfx_instances_sphere_solid_orange->folder()->erase(m_gfx_instances_sphere_solid_orange);

	m_gfx_instances_sphere_solid_orange = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_sphere_solid_orange"}, m_material_orange,

	    m_buffer_sphere_solid);

	m_folder_frames_spheres_solid_orange->clear();

}



void DebugRenderer::clear_polytope()

{

	m_gfx_instances_line_orange->folder()->erase(m_gfx_instances_line_orange);

	m_gfx_instances_line_orange = gfx::object_system()->insert_object(

	    {"phx", "debug_renderer", "draw_line_orange"}, m_material_orange, m_buffer_line);

	m_folder_frames_lines_orange->clear();

}



} // namespace phx
 
 No newline at end of file

phx/src/index.cpp

+1 −3
Original line number Diff line number Diff line
@@ -2,7 +2,6 @@ 
#include <phx/coll/collision_matrix.hpp>

#include <phx/coll/collision_system.hpp>

#include <phx/coll/layer_system.hpp>

#include <phx/debug_renderer.hpp>

#include <phx/dyn/rigid_body_simulator.hpp>

#include <phx/index.hpp>

#include <phx/timer.hpp>
@@ -30,8 +29,7 @@ Index::Index() 
      m_world_system(m_root->find<WorldSystem>(WorldSystem::self_name())),

      m_joint_system(m_root->find<dyn::JointSystem>(dyn::JointSystem::self_name())),

      m_collision_system(m_root->find<coll::CollisionSystem>(coll::CollisionSystem::self_name())),

      m_rigid_body_simulator(m_root->find<dyn::RigidBodySimulator>(dyn::RigidBodySimulator::self_name())),

      m_debug_renderer(m_root->find<DebugRenderer>(DebugRenderer::self_name()))

      m_rigid_body_simulator(m_root->find<dyn::RigidBodySimulator>(dyn::RigidBodySimulator::self_name()))

      

{

}

phx/src/module.cpp

+0 −3
Original line number Diff line number Diff line
@@ -3,7 +3,6 @@ 
#include <phx/coll/collision_matrix.hpp>

#include <phx/coll/collision_system.hpp>

#include <phx/coll/layer_system.hpp>

#include <phx/debug_renderer.hpp>

#include <phx/dyn/rigid_body_simulator.hpp>

#include <phx/index.hpp>

#include <phx/module.hpp>
@@ -29,14 +28,12 @@ void boot(com::Folder *ctx_root) 
	root_phx->push_back<dyn::JointSystem>();

	root_phx->push_back<coll::CollisionSystem>();

	root_phx->push_back<dyn::RigidBodySimulator>();

	root_phx->push_back<DebugRenderer>();

	phx::index();

}



void shutdown(com::Folder *ctx_root)

{

	auto *root_phx = ctx_root->find<com::Folder>("phx");

	root_phx->erase(DebugRenderer::self_name());

	root_phx->erase(dyn::RigidBodySimulator::self_name());

	root_phx->erase(coll::CollisionSystem::self_name());

	root_phx->erase(dyn::JointSystem::self_name());