Removes a shit ton of random debug logging

src/editor/src/gui/FileBrowser.cpp

@@ -6,12 +6,12 @@
 
 #include <cmath>
 
+#include "engine/assets/image/ImageView.hpp"
 #include "engine/assets/stores.hpp"
+#include "engine/assets/texture/Texture.hpp"
 #include "engine/debug/logging/logging.hpp"
 #include "engine/filesystem/scanner/FileScanner.hpp"
 #include "engine/filesystem/types.hpp"
-#include "engine/assets/image/ImageView.hpp"
-#include "engine/assets/texture/Texture.hpp"
 #include "safe_include.hpp"
 
 namespace fgl::engine::filesystem
@@ -41,6 +41,14 @@ namespace fgl::engine::filesystem
 		current = std::make_unique< DirInfo >( test_path );
 	}
 
+	void destroyFileGUI()
+	{
+		folder_texture.reset();
+		file_texture.reset();
+		up_texture.reset();
+		file_textures.clear();
+	}
+
 	void FileBrowser::drawGui( [[maybe_unused]] FrameInfo& info )
 	{
 		ZoneScoped;

src/editor/src/gui/FileBrowser.hpp

@@ -26,4 +26,6 @@ namespace fgl::engine::filesystem
 		static void drawFolder( const DirInfo& data );
 	};
 
+	void destroyFileGUI();
+
 } // namespace fgl::engine::filesystem

src/editor/src/gui/core.cpp

@@ -235,6 +235,7 @@ namespace fgl::engine::gui
 	void cleanupImGui()
 	{
 		ZoneScoped;
+		filesystem::destroyFileGUI();
 		ImGui_ImplVulkan_Shutdown();
 		ImGui_ImplGlfw_Shutdown();
 		ImGui::DestroyContext();

src/editor/src/main.cpp

@@ -22,7 +22,7 @@ int main()
 	engine_ctx.TEMPhookGuiRender( gui::drawMainGUI );
 
 	// Now we need to create the camera for the editor.
-	CameraManager& camera_manager { CameraManager::getInstance() };
+	CameraManager& camera_manager { engine_ctx.cameraManager() };
 
 	auto& editor_camera { camera_manager.getPrimary() };
 

src/engine/EngineContext.cpp

@@ -15,6 +15,7 @@
 #include "assets/material/Material.hpp"
 #include "camera/Camera.hpp"
 #include "camera/CameraManager.hpp"
+#include "camera/CameraRenderer.hpp"
 #include "engine/assets/model/builders/SceneBuilder.hpp"
 #include "engine/assets/transfer/TransferManager.hpp"
 #include "engine/math/Average.hpp"
@@ -104,8 +105,7 @@ namespace fgl::engine
 	void EngineContext::renderCameras( FrameInfo frame_info )
 	{
 		ZoneScoped;
-		auto& camera_manager { CameraManager::getInstance() };
-		for ( auto& current_camera_ptr : camera_manager.getCameras() )
+		for ( auto& current_camera_ptr : m_camera_manager.getCameras() )
 		{
 			if ( current_camera_ptr.expired() ) continue;
 
@@ -125,14 +125,12 @@ namespace fgl::engine
 			const FrameIndex frame_index { m_renderer.getFrameIndex() };
 			const PresentIndex present_idx { m_renderer.getPresentIndex() };
 
-			auto& camera_manager { CameraManager::getInstance() };
-
 			FrameInfo frame_info { frame_index,
 				                   present_idx,
 				                   m_delta_time,
 				                   command_buffer,
 				                   nullptr, // Camera
-				                   camera_manager.getCameras(),
+				                   m_camera_manager.getCameras(),
 				                   // global_descriptor_sets[ frame_index ],
 				                   m_game_objects_root,
 				                   m_renderer.getCurrentTracyCTX(),
@@ -187,6 +185,11 @@ namespace fgl::engine
 		return m_renderer.getAspectRatio();
 	}
 
+	CameraManager& EngineContext::cameraManager()
+	{
+		return m_camera_manager;
+	}
+
 	void EngineContext::run()
 	{
 		TracyCZoneN( TRACY_PrepareEngine, "Inital Run", true );
@@ -260,6 +263,9 @@ namespace fgl::engine
 
 	EngineContext::~EngineContext()
 	{
+		// Destroy all objects
+		m_game_objects_root.clear();
+		destroyMaterialDataVec();
 		cleanupImGui();
 	}
 

src/engine/EngineContext.hpp

@@ -5,6 +5,7 @@
 #pragma once
 
 #include "Window.hpp"
+#include "camera/CameraManager.hpp"
 #include "clock.hpp"
 #include "engine/math/literals/size.hpp"
 #include "engine/rendering/Renderer.hpp"
@@ -64,6 +65,8 @@ namespace fgl::engine
 		memory::Buffer m_matrix_info_pool;
 		memory::Buffer m_draw_parameter_pool;
 
+		CameraManager m_camera_manager {};
+
 		std::chrono::time_point< fgl::clock > last_tick { fgl::clock::now() };
 		double m_delta_time;
 
@@ -105,6 +108,8 @@ namespace fgl::engine
 		Window& getWindow();
 		float getWindowAspectRatio();
 
+		CameraManager& cameraManager();
+
 		void run();
 	};
 

src/engine/assets/material/Material.cpp

@@ -93,6 +93,11 @@ namespace fgl::engine
 		material_data = std::make_unique< DeviceVector< DeviceMaterialData > >( buffer, MAX_MATERIAL_COUNT );
 	}
 
+	void destroyMaterialDataVec()
+	{
+		material_data.reset();
+	}
+
 	DeviceVector< DeviceMaterialData >& getDeviceMaterialGPUData()
 	{
 		if ( material_data )

src/engine/assets/material/Material.hpp

@@ -136,5 +136,5 @@ namespace fgl::engine
 
 	DeviceVector< DeviceMaterialData >& getDeviceMaterialGPUData();
 	void initMaterialDataVec( memory::Buffer& buffer );
-
+	void destroyMaterialDataVec();
 } // namespace fgl::engine

src/engine/assets/model/builders/SceneBuilder.cpp

@@ -252,8 +252,6 @@ namespace fgl::engine
 			++counter;
 		}
 
-		log::debug( "Found materials: {}", str );
-
 		PrimitiveTextures textures {};
 
 		const auto albedo { findParameter( "baseColorTexture" ) };
@@ -501,8 +499,6 @@ namespace fgl::engine
 		const auto mesh { root.meshes[ mesh_idx ] };
 		const auto& primitives { mesh.primitives };
 
-		log::debug( "Mesh idx {} has {} primitives", mesh_idx, primitives.size() );
-
 		std::vector< Primitive > finished_primitives {};
 
 		for ( const auto& prim : primitives )
@@ -511,8 +507,6 @@ namespace fgl::engine
 			finished_primitives.emplace_back( std::move( primitive ) );
 		}
 
-		log::debug( "Finished loading model with {} primitives", finished_primitives.size() );
-
 		const auto bounding_box { createModelBoundingBox( finished_primitives ) };
 
 		return std::make_shared<
@@ -561,14 +555,6 @@ namespace fgl::engine
 			const auto& metallic_roughness { gltf_material.pbrMetallicRoughness };
 			const auto& pbr_tex_id { metallic_roughness.baseColorTexture.index };
 			material->properties.pbr.color_tex = loadTexture( pbr_tex_id, root );
-			log::debug(
-				"Color factors: {}, {}, {}, {}",
-				metallic_roughness.baseColorFactor[ 0 ],
-				metallic_roughness.baseColorFactor[ 1 ],
-				metallic_roughness.baseColorFactor[ 2 ],
-				metallic_roughness.baseColorFactor[ 3 ]
-
-			);
 
 			material->properties.pbr.color_factors = { metallic_roughness.baseColorFactor[ 0 ],
 				                                       metallic_roughness.baseColorFactor[ 1 ],
@@ -605,14 +591,10 @@ namespace fgl::engine
 	{
 		ZoneScoped;
 		const tinygltf::Node& node { root.nodes[ node_idx ] };
-		log::debug( "Handling node: Index:{} Name:\"{}\"", node_idx, node.name );
 
 		const int mesh_idx { node.mesh };
 		const int skin_idx { node.skin };
 
-		log::debug( "Mesh IDX: {}", mesh_idx );
-		log::debug( "Skin IDX: {}", skin_idx );
-
 		GameObject obj { GameObject::createGameObject() };
 
 		std::shared_ptr< Model > model { loadModel( mesh_idx, root ) };

src/engine/assets/model/builders/loadObj.cpp

@@ -110,7 +110,5 @@ namespace fgl::engine
 			IndexBufferSuballocation( m_index_buffer, std::move( indicies ) ),
 			bounding_box,
 			PrimitiveMode::TRIS );
-
-		log::debug( "{} unique verts loading model {}", unique_verts.size(), filepath );
 	}
 } // namespace fgl::engine

src/engine/assets/texture/Texture.cpp

@@ -61,7 +61,6 @@ namespace fgl::engine
 	{
 		if ( !ready() )
 		{
-			log::debug( "Unable to draw Image {}. Image not ready", this->getID() );
 			return;
 		}
 
@@ -89,7 +88,6 @@ namespace fgl::engine
 		if ( !ready() )
 		{
 			//TODO: Render placeholder
-			log::warn( "Attempted to render texture {} but texture was not ready!", this->m_texture_id );
 			return ImGui::Button( "No texture :(" );
 		}
 
@@ -142,7 +140,10 @@ namespace fgl::engine
 
 	Texture::~Texture()
 	{
-		if ( m_imgui_set != VK_NULL_HANDLE ) ImGui_ImplVulkan_RemoveTexture( m_imgui_set );
+#if ENABLE_IMGUI
+		if ( ImGui::GetCurrentContext() != nullptr && m_imgui_set != VK_NULL_HANDLE )
+			ImGui_ImplVulkan_RemoveTexture( m_imgui_set );
+#endif
 		texture_id_pool.markUnused( m_texture_id );
 	}
 
@@ -166,11 +167,9 @@ namespace fgl::engine
 	{
 		if ( !this->ready() )
 		{
-			log::debug( "Unable to create ImGui set. Texture was not ready" );
 			return;
 		}
 
-		log::debug( "Created ImGui set for image ID {}", this->getID() );
 		if ( m_imgui_set != VK_NULL_HANDLE ) return;
 
 		auto& view { m_image_view };

src/engine/assets/transfer/TransferManager.cpp

@@ -278,8 +278,6 @@ namespace fgl::engine::memory
 		assert( std::get< TransferData::RawData >( transfer_data.m_source ).size() > 0 );
 
 		queue.emplace( std::move( transfer_data ) );
-
-		log::debug( "[TransferManager]: Queue size now {}", queue.size() );
 	}
 
 	TransferManager::TransferManager( Device& device, std::uint64_t buffer_size ) :

src/engine/camera/Camera.cpp

@@ -15,8 +15,6 @@
 namespace fgl::engine
 {
 
-	inline static std::unique_ptr< CameraRenderer > camera_renderer;
-
 	Matrix< MatrixType::WorldToScreen > Camera::getProjectionViewMatrix() const
 	{
 		assert( projection_matrix != constants::MAT4_IDENTITY );
@@ -88,15 +86,10 @@ namespace fgl::engine
 		}
 
 		updateInfo( frame_info.frame_idx );
-		camera_renderer->pass( frame_info, *m_swapchain );
+		m_camera_renderer->pass( frame_info, *m_swapchain );
 		frame_info.camera = nullptr;
 	}
 
-	vk::raii::RenderPass& Camera::getRenderpass()
-	{
-		return camera_renderer->getRenderpass();
-	}
-
 	CameraSwapchain& Camera::getSwapchain() const
 	{
 		return *m_swapchain;
@@ -132,7 +125,7 @@ namespace fgl::engine
 	{
 		this->setPerspectiveProjection( m_fov_y, aspectRatio(), constants::NEAR_PLANE, constants::FAR_PLANE );
 		m_old_swapchain = m_swapchain;
-		m_swapchain = std::make_shared< CameraSwapchain >( camera_renderer->getRenderpass(), extent );
+		m_swapchain = std::make_shared< CameraSwapchain >( m_camera_renderer->getRenderpass(), extent );
 	}
 
 	void Camera::setName( const std::string_view str )
@@ -312,12 +305,6 @@ namespace fgl::engine
 		return name;
 	}
 
-	void Camera::initCameraRenderer()
-	{
-		assert( !camera_renderer );
-		camera_renderer = std::make_unique< CameraRenderer >();
-	}
-
 	constexpr descriptors::Descriptor camera_descriptor { 0,
 		                                                  vk::DescriptorType::eUniformBuffer,
 		                                                  vk::ShaderStageFlagBits::eAllGraphics };
@@ -329,11 +316,12 @@ namespace fgl::engine
 		return camera_descriptor_set;
 	}
 
-	Camera::Camera( const vk::Extent2D extent, memory::Buffer& buffer ) :
+	Camera::Camera( const vk::Extent2D extent, memory::Buffer& buffer, std::unique_ptr< CameraRenderer >& renderer ) :
+	  m_camera_renderer( renderer ),
 	  m_transform(),
 	  m_target_extent( extent ),
 	  m_camera_frame_info( buffer, SwapChain::MAX_FRAMES_IN_FLIGHT ),
-	  m_swapchain( std::make_shared< CameraSwapchain >( camera_renderer->getRenderpass(), m_target_extent ) ),
+	  m_swapchain( std::make_shared< CameraSwapchain >( m_camera_renderer->getRenderpass(), m_target_extent ) ),
 	  name()
 	{
 		this->setPerspectiveProjection( m_fov_y, aspectRatio(), constants::NEAR_PLANE, constants::FAR_PLANE );

src/engine/camera/Camera.hpp

@@ -48,6 +48,8 @@ namespace fgl::engine
 	{
 		inline static CameraIDX camera_counter { 0 };
 
+		std::unique_ptr< CameraRenderer >& m_camera_renderer;
+
 		//! True if the camera is active and to be rendered
 		bool m_active { true };
 
@@ -94,7 +96,7 @@ namespace fgl::engine
 		Camera( vk::Extent2D test_extent ) : m_target_extent( test_extent ) {}
 #endif
 
-		Camera( vk::Extent2D extent, memory::Buffer& data_buffer );
+		Camera( vk::Extent2D extent, memory::Buffer& buffer, std::unique_ptr< CameraRenderer >& renderer );
 
 		friend class CameraManager;
 
@@ -175,7 +177,6 @@ namespace fgl::engine
 		//! Performs the render pass for this camera
 		void pass( FrameInfo& frame_info );
 
-		static vk::raii::RenderPass& getRenderpass();
 		CameraSwapchain& getSwapchain() const;
 		void setViewport( const vk::raii::CommandBuffer& command_buffer );
 		void setScissor( const vk::raii::CommandBuffer& command_buffer );

src/engine/camera/CameraManager.cpp

@@ -5,6 +5,7 @@
 #include "CameraManager.hpp"
 
 #include "Camera.hpp"
+#include "CameraRenderer.hpp"
 #include "engine/debug/DEBUG_NAMES.hpp"
 #include "engine/math/literals/size.hpp"
 
@@ -13,18 +14,6 @@ namespace fgl::engine
 
 	using namespace fgl::literals::size_literals;
 
-	inline static std::unique_ptr< CameraManager > camera_manager_instance;
-
-	CameraManager& CameraManager::getInstance()
-	{
-		if ( !camera_manager_instance )
-		{
-			camera_manager_instance = std::unique_ptr< CameraManager >( new CameraManager() );
-		}
-
-		return *camera_manager_instance;
-	}
-
 	std::vector< std::weak_ptr< Camera > >& CameraManager::getCameras()
 	{
 		return cameras;
@@ -36,17 +25,16 @@ namespace fgl::engine
 	}
 
 	CameraManager::CameraManager() :
+	  m_renderer( std::make_unique< CameraRenderer >() ),
 	  m_data_buffer( 4_KiB, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostVisible )
 	{
-		Camera::initCameraRenderer();
-
 		m_primary_camera = createCamera( { 1920, 1080 } );
 		m_primary_camera->setName( CAMERA_EDITOR_NAME );
 	}
 
 	std::shared_ptr< Camera > CameraManager::createCamera( const vk::Extent2D extent )
 	{
-		std::shared_ptr< Camera > camera { new Camera( extent, m_data_buffer ) };
+		std::shared_ptr< Camera > camera { new Camera( extent, m_data_buffer, m_renderer ) };
 
 		this->cameras.emplace_back( camera );
 
@@ -54,5 +42,7 @@ namespace fgl::engine
 	}
 
 	CameraManager::~CameraManager()
-	{}
+	{
+		m_primary_camera.reset();
+	}
 } // namespace fgl::engine

src/engine/camera/CameraManager.hpp

@@ -17,20 +17,18 @@ namespace fgl::engine
 
 	class CameraManager
 	{
+		std::unique_ptr< CameraRenderer > m_renderer;
 		memory::Buffer m_data_buffer;
 
 		std::shared_ptr< Camera > m_primary_camera { nullptr };
 
 		std::vector< std::weak_ptr< Camera > > cameras {};
 
-		CameraManager();
-
 	  public:
 
+		CameraManager();
 		~CameraManager();
 
-		static CameraManager& getInstance();
-
 		std::vector< std::weak_ptr< Camera > >& getCameras();
 
 		std::shared_ptr< Camera >& getPrimary();

src/engine/descriptors/DescriptorSet.cpp

@@ -95,8 +95,6 @@ namespace fgl::engine::descriptors
 		write.pImageInfo = VK_NULL_HANDLE;
 		write.pTexelBufferView = VK_NULL_HANDLE;
 
-		log::info( "Bound idx {} to data", array_idx );
-
 		descriptor_writes.push_back( write );
 	}
 

src/engine/descriptors/DescriptorSetLayout.cpp

@@ -52,8 +52,6 @@ namespace fgl::engine::descriptors
 		info.setBindings( bindings );
 		info.setPNext( &flags_info );
 
-		log::debug( "Created layout with as set = {} and {} bindings", m_set_idx, bindings.size() );
-
 		return Device::getInstance()->createDescriptorSetLayout( info );
 	}
 

src/engine/filesystem/scanner/FileScanner.cpp

@@ -79,7 +79,6 @@ namespace fgl::engine::filesystem
 			{
 				std::filesystem::path to_scan { std::move( nested_dirs_to_scan.front() ) };
 				nested_dirs_to_scan.pop();
-				log::debug( "Processed folder: {}", to_scan );
 
 				DirInfo info { to_scan };
 

src/engine/primitives/boxes/OrientedBoundingBox.cpp

@@ -297,7 +297,6 @@ namespace fgl::engine
 	OrientedBoundingBox< CoordinateSpace::Model > generateBoundingFromVerts( const std::vector< ModelVertex >& verts )
 	{
 		assert( verts.size() > 0 );
-		log::debug( "Generating bounding box for {} verts", verts.size() );
 
 		constexpr auto inf_float { std::numeric_limits< float >::infinity() };
 		// neg (min)

src/engine/rendering/devices/PhysicalDevice.cpp

@@ -36,7 +36,6 @@ namespace fgl::engine
 			// We need at least 1 queue that can do graphics.
 			if ( queue_family.queueFlags & vk::QueueFlagBits::eGraphics )
 			{
-				log::debug( "Graphics capable queue found at idx: {}", idx );
 				has_graphics_queue = true;
 			}
 
@@ -44,7 +43,6 @@ namespace fgl::engine
 			vk::Bool32 can_present { device.getSurfaceSupportKHR( idx, surface ) };
 			if ( can_present == VK_TRUE )
 			{
-				log::debug( "Present capable queue found at idx: {}", idx );
 				has_present_queue = true;
 			}
 

src/engine/rendering/pipelines/shaders/Compiler.cpp

@@ -66,7 +66,6 @@ namespace fgl::engine
 	{
 		const std::string_view requsted { requested_source };
 		const std::string_view requster { requesting_source };
-		log::debug( "Source file {} is requesting {}", requster, requsted );
 
 		std::vector< char > file_data {};
 
@@ -77,7 +76,6 @@ namespace fgl::engine
 			file_data.resize( std::filesystem::file_size( path ) );
 
 			ifs.read( file_data.data(), file_data.size() );
-			log::debug( "Found source file {} to be included into {}", requsted, requster );
 		}
 		else
 		{

src/engine/rendering/pipelines/v2/Pipeline.hpp

@@ -2,11 +2,8 @@
 // Created by kj16609 on 10/9/24.
 //
 
-#include <memory>
-
-#include "engine/assets/model/Primitive.hpp"
 #include "engine/descriptors/DescriptorSet.hpp"
-#include "engine/rendering/pipelines/Shader.hpp"
+#include "engine/rendering/pipelines/Pipeline.hpp"
 
 namespace fgl::engine
 

src/engine/rendering/pipelines/v2/PipelineBuilder.cpp

@@ -57,7 +57,6 @@ namespace fgl::engine
 
 		for ( const auto& [ set_idx, layout ] : descriptor_set_layouts )
 		{
-			log::debug( "{} populated", set_idx );
 			set_layouts[ set_idx ] = layout;
 		}
 
@@ -70,7 +69,6 @@ namespace fgl::engine
 		addDescriptorSet( const SetID idx, const vk::raii::DescriptorSetLayout& descriptor_set_layout )
 	{
 		FGL_ASSERT( !descriptor_set_layouts.contains( idx ), "Descriptor already set!" );
-		log::debug( "Setting descriptor layout for set idx {}", idx );
 		descriptor_set_layouts.insert( std::make_pair( idx, *descriptor_set_layout ) );
 	}
 

src/engine/systems/CompositionSystem.cpp

@@ -32,6 +32,9 @@ namespace fgl::engine
 		m_composite_pipeline->setDebugName( "Composition pipeline" );
 	}
 
+	CompositionSystem::~CompositionSystem()
+	{}
+
 	vk::raii::CommandBuffer& CompositionSystem::setupSystem( FrameInfo& info )
 	{
 		auto& command_buffer { info.command_buffer };

src/engine/systems/CompositionSystem.hpp

@@ -6,23 +6,21 @@
 
 #include "concepts.hpp"
 #include "engine/FrameInfo.hpp"
-#include "engine/rendering/pipelines/Shader.hpp"
 
 namespace fgl::engine
 {
-		class Pipeline;
+	class Pipeline;
 
 	class CompositionSystem
 	{
-
 		std::unique_ptr< Pipeline > m_composite_pipeline { nullptr };
 
 		vk::raii::CommandBuffer& setupSystem( FrameInfo& info );
 
 	  public:
 
-		CompositionSystem(  vk::raii::RenderPass& render_pass );
-		~CompositionSystem() = default;
+		CompositionSystem( vk::raii::RenderPass& render_pass );
+		~CompositionSystem();
 
 		void pass( FrameInfo& info );
 	};

src/engine/systems/CullingSystem.cpp

@@ -19,6 +19,21 @@ namespace fgl::engine
 		return enable_culling;
 	}
 
+	CullingSystem::CullingSystem() : m_thread( &CullingSystem::runner, this )
+	{}
+
+	CullingSystem::~CullingSystem()
+	{
+		m_info = {};
+		m_start_sem.release();
+		if ( !m_source.request_stop() )
+		{
+			log::critical( "Oh shit" );
+			std::terminate();
+		}
+		m_thread.join();
+	}
+
 	void CullingSystem::pass( FrameInfo& info )
 	{
 		ZoneScopedN( "Culling pass" );
@@ -41,7 +56,7 @@ namespace fgl::engine
 		while ( !m_stop_token.stop_requested() )
 		{
 			m_start_sem.acquire();
-			pass( *m_info.value() );
+			if ( m_info.has_value() ) pass( *m_info.value() );
 			m_end_sem.release();
 		}
 	}

src/engine/systems/CullingSystem.hpp

@@ -17,7 +17,8 @@ namespace fgl::engine
 		std::thread m_thread;
 
 		std::optional< FrameInfo* > m_info { std::nullopt };
-		std::stop_token m_stop_token {};
+		std::stop_source m_source {};
+		std::stop_token m_stop_token { m_source.get_token() };
 
 		void runner();
 
@@ -30,7 +31,9 @@ namespace fgl::engine
 
 		[[maybe_unused]] vk::raii::CommandBuffer& setupSystem( FrameInfo& info );
 
-		CullingSystem() : m_thread( &CullingSystem::runner, this ) {}
+		CullingSystem();
+
+		~CullingSystem();
 
 		void pass( FrameInfo& info );
 		void startPass( FrameInfo& info );

src/engine/systems/GuiSystem.cpp

@@ -5,6 +5,7 @@
 #include "GuiSystem.hpp"
 
 #include "engine/FrameInfo.hpp"
+#include "engine/assets/model/SimpleVertex.hpp"
 #include "engine/rendering/pipelines/v2/AttachmentBuilder.hpp"
 #include "engine/rendering/pipelines/v2/Pipeline.hpp"
 #include "engine/rendering/pipelines/v2/PipelineBuilder.hpp"

src/engine/systems/LineDrawer.cpp

@@ -11,6 +11,7 @@
 #include "engine/memory/buffers/vector/HostVector.hpp"
 #include "engine/primitives/points/Coordinate.hpp"
 #include "engine/rendering/pipelines/v2/AttachmentBuilder.hpp"
+#include "engine/rendering/pipelines/v2/Pipeline.hpp"
 #include "engine/rendering/pipelines/v2/PipelineBuilder.hpp"
 
 namespace fgl::engine

src/engine/systems/LineDrawer.hpp

@@ -6,10 +6,10 @@
 #include "engine/descriptors/Descriptor.hpp"
 #include "engine/memory/buffers/vector/HostVector.hpp"
 #include "engine/rendering/SwapChain.hpp"
-#include "engine/rendering/pipelines/v2/Pipeline.hpp"
 
 namespace fgl::engine
 {
+	class Pipeline;
 	struct VertexLine;
 	struct FrameInfo;
 	struct ModelVertex;

src/engine/tree/octtree/OctTreeNode.cpp

@@ -176,8 +176,6 @@ namespace fgl::engine
 		assert( !std::isinf( forward_y ) && !std::isinf( backward_y ) );
 		assert( !std::isinf( top_z ) && !std::isinf( bottom_z ) );
 
-		log::debug( "Splitting node at {}", m_bounds.span() );
-
 		new_nodes[ LEFT ][ FORWARD ][ TOP ] =
 			std::make_unique< OctTreeNode >( WorldCoordinate( left_x, forward_y, top_z ), half_span, this );
 
@@ -241,7 +239,6 @@ namespace fgl::engine
 				return node;
 			}
 
-			log::debug( "Added game object" );
 			objects.emplace_back( std::move( obj ) );
 			return this;
 		}
@@ -330,6 +327,22 @@ namespace fgl::engine
 		}
 	}
 
+	void OctTreeNode::clear()
+	{
+		if ( std::holds_alternative< OctTreeNodeLeaf >( this->m_node_data ) )
+		{
+			std::get< OctTreeNodeLeaf >( this->m_node_data ).clear();
+		}
+		else if ( std::holds_alternative< OctTreeNodeArray >( this->m_node_data ) )
+		{
+			const auto& node_array { std::get< OctTreeNodeArray >( this->m_node_data ) };
+
+			for ( std::size_t x = 0; x < 2; ++x )
+				for ( std::size_t y = 0; y < 2; ++y )
+					for ( std::size_t z = 0; z < 2; ++z ) node_array[ x ][ y ][ z ]->clear();
+		}
+	}
+
 	OctTreeNode* OctTreeNode::findID( const GameObject::GameObjectID id )
 	{
 		ZoneScoped;

src/engine/tree/octtree/OctTreeNode.hpp

@@ -66,6 +66,7 @@ namespace fgl::engine
 
 		OctTreeNode& operator=( const OctTreeNode& ) = delete;
 		OctTreeNode& operator=( OctTreeNode&& ) = delete;
+		void clear();
 
 	  private: