diff --git a/cmake_modules/dependencies/tracy.cmake b/cmake_modules/dependencies/tracy.cmake
index 35ee3e9..d3d7b3c 100644
--- a/cmake_modules/dependencies/tracy.cmake
+++ b/cmake_modules/dependencies/tracy.cmake
@@ -4,10 +4,17 @@ string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_UPPER_BUILD_TYPE)
 
 message("-- Cmake upper: ${CMAKE_UPPER_BUILD_TYPE}")
 
-if (CMAKE_UPPER_BUILD_TYPE STREQUAL "DEBUG" OR CMAKE_UPPER_BUILD_TYPE STREQUAL "RELWITHDEBINFO" AND DEFINED FGL_ENABLE_PROFILING)
+if (NOT DEFINED FGL_ENABLE_PROFILING)
+	set(FGL_ENABLE_PROFILING 0)
+endif ()
+
+#if (CMAKE_UPPER_BUILD_TYPE STREQUAL "DEBUG" OR CMAKE_UPPER_BUILD_TYPE STREQUAL "RELWITHDEBINFO" AND DEFINED FGL_ENABLE_PROFILING)
+if (FGL_ENABLE_PROFILING)
 	set(TRACY_ENABLE ON)
 	set(TRACY_ON_DEMAND ON)
 	set(TRACY_NO_EXIT ON)
+else ()
+	set(TRACY_ENABLE OFF)
 endif ()
 
 add_subdirectory(${CMAKE_SOURCE_DIR}/dependencies/tracy)
diff --git a/shaders/point_light.frag b/shaders/point_light.frag
deleted file mode 100644
index 7e7ea6d..0000000
--- a/shaders/point_light.frag
+++ /dev/null
@@ -1,43 +0,0 @@
-#version 450
-
-layout (location = 0) in vec2 frag_offset;
-layout (location = 0) out vec4 out_color;
-
-struct PointLight
-{
-    vec4 position;
-    vec4 color;
-};
-
-layout (set = 0, binding = 0) uniform GlobalUbo {
-    mat4 projection;
-    mat4 view;
-    mat4 inverse_view;
-    vec4 ambient_light_color; // w is intensity
-} ubo;
-
-layout (set = 0, binding = 1) uniform LightingUBO
-{
-    PointLight lights[10];
-    int num;
-} point_lights;
-
-layout (push_constant) uniform Push
-{
-    vec4 position;
-    vec4 color;
-    float radius;
-} push;
-
-const float M_PI = 3.14151926538;
-
-void main() {
-    float dis = sqrt(dot(frag_offset, frag_offset));
-
-    if (dis >= 1.0)
-    {
-        discard;
-    }
-
-    out_color = vec4(push.color.xyz, 0.5 * (cos(dis * M_PI) + 1.0));
-}
\ No newline at end of file
diff --git a/shaders/point_light.vert b/shaders/point_light.vert
deleted file mode 100644
index 2ab2273..0000000
--- a/shaders/point_light.vert
+++ /dev/null
@@ -1,53 +0,0 @@
-#version 450
-
-const vec2 OFFSETS[6] = vec2[](
-    vec2(-1.0, -1.0),
-    vec2(-1.0, 1.0),
-    vec2(1.0, -1.0),
-    vec2(1.0, -1.0),
-    vec2(-1.0, 1.0),
-    vec2(1.0, 1.0)
-);
-
-layout (location = 0) out vec2 frag_offset;
-
-struct PointLight
-{
-    vec4 position;
-    vec4 color;
-};
-
-layout (set = 0, binding = 0) uniform GlobalUbo {
-    mat4 projection;
-    mat4 view;
-    mat4 inverse_view;
-    vec4 ambient_light_color; // w is intensity
-} ubo;
-
-layout (set = 0, binding = 1) uniform LightingUBO
-{
-    PointLight lights[10];
-    int num;
-} point_lights;
-
-layout (push_constant) uniform Push
-{
-    vec4 position;
-    vec4 color;
-    float radius;
-} push;
-
-void main() {
-
-    frag_offset = OFFSETS[gl_VertexIndex];
-    vec3 camera_right_world = { ubo.view[0][0], ubo.view[1][0], ubo.view[2][0] };
-    vec3 camera_up_world = { ubo.view[0][1], ubo.view[1][1], ubo.view[2][1] };
-
-    vec3 position_world = push.position.xyz + push.radius * frag_offset.x * camera_right_world + push.radius * frag_offset.y * camera_up_world;
-
-    gl_Position = ubo.projection * ubo.view * vec4(position_world, 1.0);
-
-
-
-
-}
\ No newline at end of file
diff --git a/shaders/textured-gbuffer.frag b/shaders/textured-gbuffer.frag
index 5fe6dfe..db17028 100644
--- a/shaders/textured-gbuffer.frag
+++ b/shaders/textured-gbuffer.frag
@@ -11,13 +11,13 @@ layout (location = 0) out vec4 out_position;
 layout (location = 1) out vec4 out_normal;
 layout (location = 2) out vec4 out_albedo;
 
-layout (set = 0, binding = 0) uniform CameraInfo {
+layout (set = 1, binding = 0) uniform CameraInfo {
     mat4 projection;
     mat4 view;
     mat4 inverse_view;
 } ubo;
 
-layout (set = 1, binding = 0) uniform sampler2D tex[];
+layout (set = 2, binding = 0) uniform sampler2D tex[];
 
 #define NEAR_PLANE 0.01f
 #define FAR_PLANE 1000.0f
diff --git a/shaders/textured-gbuffer.vert b/shaders/textured-gbuffer.vert
index 5011ee4..966eeb5 100644
--- a/shaders/textured-gbuffer.vert
+++ b/shaders/textured-gbuffer.vert
@@ -14,7 +14,7 @@ layout (location = 1) out vec2 out_tex_coord;
 layout (location = 2) out vec3 out_world_pos;
 layout (location = 3) out flat uint out_texture_idx;
 
-layout (set = 0, binding = 0) uniform CameraInfo {
+layout (set = 1, binding = 0) uniform CameraInfo {
     mat4 projection;
     mat4 view;
     mat4 inverse_view;
diff --git a/shaders/textureless-gbuffer.frag b/shaders/textureless-gbuffer.frag
index 0c2281c..db34e43 100644
--- a/shaders/textureless-gbuffer.frag
+++ b/shaders/textureless-gbuffer.frag
@@ -11,7 +11,7 @@ layout (location = 0) out vec4 out_position;
 layout (location = 1) out vec4 out_normal;
 layout (location = 2) out vec4 out_albedo;
 
-layout (set = 0, binding = 0) uniform CameraInfo {
+layout (set = 1, binding = 0) uniform CameraInfo {
     mat4 projection;
     mat4 view;
     mat4 inverse_view;
diff --git a/shaders/textureless-gbuffer.vert b/shaders/textureless-gbuffer.vert
index df9f76c..31afe7e 100644
--- a/shaders/textureless-gbuffer.vert
+++ b/shaders/textureless-gbuffer.vert
@@ -13,14 +13,13 @@ layout (location = 1) out vec2 out_tex_coord;
 layout (location = 2) out vec3 out_world_pos;
 layout (location = 3) out vec3 out_color;
 
-layout (set = 0, binding = 0) uniform CameraInfo {
+layout (set = 1, binding = 0) uniform CameraInfo {
     mat4 projection;
     mat4 view;
     mat4 inverse_view;
 } ubo;
 
 void main() {
-
     vec4 position_world = instance_model_matrix * vec4(position, 1.0);
 
     gl_Position = ubo.projection * ubo.view * position_world;
diff --git a/src/engine/CMakeLists.txt b/src/engine/CMakeLists.txt
index f631ce8..798394b 100644
--- a/src/engine/CMakeLists.txt
+++ b/src/engine/CMakeLists.txt
@@ -40,18 +40,18 @@ target_compile_features(FGLEngine PRIVATE cxx_std_23)
 
 string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_UPPER_BUILD_TYPE)
 
-if (NOT DEFINED FORCE_DISABLE_IMGUI)
-	set(FORCE_DISABLE_IMGUI 0)
+if (NOT DEFINED FGL_ENABLE_IMGUI AND CMAKE_UPPER_BUILD_TYPE STREQUAL "DEBUG")
+	set(FGL_ENABLE_IMGUI 1)
 endif ()
 
-if (FORCE_DISABLE_IMGUI EQUAL 0)
-	if (CMAKE_UPPER_BUILD_TYPE STREQUAL "DEBUG" OR CMAKE_UPPER_BUILD_TYPE STREQUAL "RELWITHDEBINFO")
-		target_compile_definitions(FGLEngine PRIVATE ENABLE_IMGUI=1)
-		target_compile_definitions(FGLEngine PRIVATE ENABLE_IMGUI_DRAWERS=1)
-	else ()
-		target_compile_definitions(FGLEngine PRIVATE ENABLE_IMGUI=0)
-		target_compile_definitions(FGLEngine PRIVATE ENABLE_IMGUI_DRAWERS=0)
-	endif ()
+message("-- FGL_ENABLE_IMGUI: ${FGL_ENABLE_IMGUI}")
+
+if (FGL_ENABLE_IMGUI)
+	target_compile_definitions(FGLEngine PRIVATE ENABLE_IMGUI=1)
+	target_compile_definitions(FGLEngine PRIVATE ENABLE_IMGUI_DRAWERS=1)
+else ()
+	target_compile_definitions(FGLEngine PRIVATE ENABLE_IMGUI=0)
+	target_compile_definitions(FGLEngine PRIVATE ENABLE_IMGUI_DRAWERS=0)
 endif ()
 
 #GLM settings
diff --git a/src/engine/EngineContext.cpp b/src/engine/EngineContext.cpp
index ca4f7b7..1eed1ba 100644
--- a/src/engine/EngineContext.cpp
+++ b/src/engine/EngineContext.cpp
@@ -15,13 +15,13 @@
 #include "assets/stores.hpp"
 #include "buffers/HostSingleT.hpp"
 #include "camera/Camera.hpp"
+#include "camera/CameraManager.hpp"
 #include "engine/Average.hpp"
 #include "engine/assets/TransferManager.hpp"
 #include "engine/buffers/UniqueFrameSuballocation.hpp"
 #include "engine/debug/drawers.hpp"
 #include "engine/literals/size.hpp"
 #include "engine/model/prebuilt/terrainModel.hpp"
-#include "engine/pipeline/PipelineT.hpp"
 #include "engine/systems/EntityRendererSystem.hpp"
 #include "gui/core.hpp"
 #include "model/builders/SceneBuilder.hpp"
@@ -49,16 +49,13 @@ namespace fgl::engine
 	{
 		TracyCZoneN( TRACY_PrepareEngine, "Inital Run", true );
 		std::cout << "Starting main loop run" << std::endl;
-		using namespace fgl::literals::size_literals;
 		memory::Buffer global_ubo_buffer { 512_KiB,
 			                               vk::BufferUsageFlagBits::eUniformBuffer,
 			                               vk::MemoryPropertyFlagBits::eHostVisible }; // 512 KB
 
 		//Camera prep
-		Camera::initCameraRenderer();
 
-		PerFrameSuballocation< HostSingleT< CameraInfo > > camera_info { global_ubo_buffer,
-			                                                             SwapChain::MAX_FRAMES_IN_FLIGHT };
+		CameraManager camera_manager {};
 
 		PerFrameSuballocation< HostSingleT< PointLight > > point_lights { global_ubo_buffer,
 			                                                              SwapChain::MAX_FRAMES_IN_FLIGHT };
@@ -74,7 +71,7 @@ namespace fgl::engine
 
 		std::vector< memory::Buffer > draw_parameter_buffers {};
 
-		std::vector< descriptors::DescriptorSet > global_descriptor_sets {};
+		// std::vector< descriptors::DescriptorSet > global_descriptor_sets {};
 
 		for ( int i = 0; i < SwapChain::MAX_FRAMES_IN_FLIGHT; ++i )
 		{
@@ -88,19 +85,15 @@ namespace fgl::engine
 				vk::BufferUsageFlagBits::eIndirectBuffer,
 				vk::MemoryPropertyFlagBits::eDeviceLocal | vk::MemoryPropertyFlagBits::eHostVisible );
 
-			global_descriptor_sets.emplace_back( GlobalDescriptorSet::createLayout() );
+			// global_descriptor_sets.emplace_back( GlobalDescriptorSet::createLayout() );
 		}
 
-		for ( std::uint8_t i = 0; i < SwapChain::MAX_FRAMES_IN_FLIGHT; ++i )
-		{
-			global_descriptor_sets[ i ].setMaxIDX( 2 );
-			global_descriptor_sets[ i ].bindUniformBuffer( 0, camera_info[ i ] );
-			global_descriptor_sets[ i ].bindUniformBuffer( 2, point_lights[ i ] );
-			global_descriptor_sets[ i ].update();
-		}
-
-		Camera camera { vk::Extent2D( 1920, 1080 ) };
-		debug::setDebugDrawingCamera( camera );
+		// for ( std::uint8_t i = 0; i < SwapChain::MAX_FRAMES_IN_FLIGHT; ++i )
+		// {
+		// global_descriptor_sets[ i ].setMaxIDX( 2 );
+		// global_descriptor_sets[ i ].bindUniformBuffer( 2, point_lights[ i ] );
+		// global_descriptor_sets[ i ].update();
+		// }
 
 		auto viewer { GameObject::createGameObject() };
 
@@ -114,14 +107,22 @@ namespace fgl::engine
 
 		//camera.setOrthographicProjection( -aspect, aspect, -1, 1, -1, 1 );
 		const float aspect { m_renderer.getAspectRatio() };
-		camera.setPerspectiveProjection( glm::radians( 90.0f ), aspect, constants::NEAR_PLANE, constants::FAR_PLANE );
+
+		auto& primary_camera { camera_manager.getPrimary() };
+		auto secondary_camera { camera_manager.createCamera( { 1920, 1080 } ) };
+
+		primary_camera
+			.setPerspectiveProjection( glm::radians( 90.0f ), aspect, constants::NEAR_PLANE, constants::FAR_PLANE );
+		secondary_camera
+			->setPerspectiveProjection( glm::radians( 90.0f ), aspect, constants::NEAR_PLANE, constants::FAR_PLANE );
 
 		const auto old_aspect_ratio { m_renderer.getAspectRatio() };
 
-		TracyCZoneEnd( TRACY_PrepareEngine );
+		camera_controller.moveInPlaneXZ( m_window.window(), 0.0, viewer );
+		primary_camera.setView( viewer.getPosition(), viewer.getRotation() );
+		secondary_camera->setView( viewer.getPosition(), viewer.getRotation() );
 
-		//TODO: Make a camera management object
-		std::vector< Camera* > cameras { &camera };
+		TracyCZoneEnd( TRACY_PrepareEngine );
 
 		while ( !m_window.shouldClose() )
 		{
@@ -148,12 +149,12 @@ namespace fgl::engine
 
 			if ( old_aspect_ratio != m_renderer.getAspectRatio() )
 			{
-				camera.setPerspectiveProjection(
+				primary_camera.setPerspectiveProjection(
 					glm::radians( 90.0f ), m_renderer.getAspectRatio(), constants::NEAR_PLANE, constants::FAR_PLANE );
 			}
 
 			camera_controller.moveInPlaneXZ( m_window.window(), delta_time, viewer );
-			camera.setView( viewer.getPosition(), viewer.getRotation() );
+			primary_camera.setView( viewer.getPosition(), viewer.getRotation() );
 
 			if ( auto& command_buffer = m_renderer.beginFrame(); *command_buffer )
 			{
@@ -161,14 +162,13 @@ namespace fgl::engine
 				const FrameIndex frame_index { m_renderer.getFrameIndex() };
 				const PresentIndex present_idx { m_renderer.getPresentIndex() };
 
-				const auto view_frustum { camera.getFrustumBounds() };
-
 				FrameInfo frame_info { frame_index,
 					                   present_idx,
 					                   delta_time,
 					                   command_buffer,
-					                   { camera, viewer.getTransform() },
-					                   global_descriptor_sets[ frame_index ],
+					                   { nullptr, viewer.getTransform() },
+					                   camera_manager.getCameras(),
+					                   // global_descriptor_sets[ frame_index ],
 					                   m_game_objects_root,
 					                   m_renderer.getCurrentTracyCTX(),
 					                   matrix_info_buffers[ frame_index ],
@@ -176,33 +176,32 @@ namespace fgl::engine
 					                   *this->m_vertex_buffer,
 					                   *this->m_index_buffer,
 					                   m_renderer.getSwapChain().getInputDescriptor( present_idx ),
-					                   view_frustum,
 					                   this->m_renderer.getSwapChain() };
 
 #if TRACY_ENABLE
 				//auto& tracy_ctx { frame_info.tracy_ctx };
 #endif
 
-				CameraInfo current_camera_info { .projection = camera.getProjectionMatrix(),
-					                             .view = camera.getViewMatrix(),
-					                             .inverse_view = camera.getInverseViewMatrix() };
-
-				camera_info[ frame_index ] = current_camera_info;
-
 				TracyVkCollect( frame_info.tracy_ctx, *command_buffer );
 
 				//TODO: Setup semaphores to make this pass not always required.
 				memory::TransferManager::getInstance().recordOwnershipTransferDst( command_buffer );
 
-				for ( auto* current_camera : cameras )
+				for ( auto& current_camera_ptr : camera_manager.getCameras() )
 				{
-					current_camera->pass( frame_info );
+					if ( current_camera_ptr.expired() ) continue;
+
+					auto sh_camera { current_camera_ptr.lock() };
+
+					Camera& current_camera { *sh_camera };
+
+					current_camera.pass( frame_info );
 				}
 
-				auto* primary_camera { cameras[ 0 ] };
+				m_renderer.clearInputImage( command_buffer );
 
-				primary_camera
-					->copyOutput( command_buffer, frame_index, m_renderer.getSwapChain().getInputImage( present_idx ) );
+				//primary_camera
+				//	.copyOutput( command_buffer, frame_index, m_renderer.getSwapChain().getInputImage( present_idx ) );
 
 				m_renderer.beginSwapchainRendererPass( command_buffer );
 
diff --git a/src/engine/FrameInfo.cpp b/src/engine/FrameInfo.cpp
index c891b63..0411c4f 100644
--- a/src/engine/FrameInfo.cpp
+++ b/src/engine/FrameInfo.cpp
@@ -12,7 +12,12 @@ namespace fgl::engine
 
 	descriptors::DescriptorSet& FrameInfo::getGBufferDescriptor()
 	{
-		return camera_data.camera.getSwapchain().getGBufferDescriptor( frame_idx );
+		return camera_data.camera->getSwapchain().getGBufferDescriptor( frame_idx );
+	}
+
+	descriptors::DescriptorSet& FrameInfo::getCameraDescriptor()
+	{
+		return camera_data.camera->getDescriptor( frame_idx );
 	}
 
 } // namespace fgl::engine
diff --git a/src/engine/FrameInfo.hpp b/src/engine/FrameInfo.hpp
index c8dfbf1..72b1803 100644
--- a/src/engine/FrameInfo.hpp
+++ b/src/engine/FrameInfo.hpp
@@ -35,26 +35,13 @@ namespace fgl::engine
 		glm::vec4 color {};
 	};
 
-	struct CameraInfo
-	{
-		glm::mat4 projection { 1.0f };
-		glm::mat4 view { 1.0f };
-		glm::mat4 inverse_view { 1.0f };
-	};
-
 	struct PointLightUBO
 	{
 		alignas( 16 ) PointLight point_lights[ MAX_LIGHTS ] {};
 		alignas( 16 ) int num_lights { 0 };
 	};
 
-	using CameraDescriptor =
-		descriptors::Descriptor< 0, vk::DescriptorType::eUniformBuffer, vk::ShaderStageFlagBits::eAllGraphics >;
-	using LightDescriptor =
-		descriptors::Descriptor< 2, vk::DescriptorType::eUniformBuffer, vk::ShaderStageFlagBits::eAllGraphics >;
-
-	using GlobalDescriptorSet =
-		descriptors::DescriptorSetLayout< 0, CameraDescriptor, descriptors::EmptyDescriptor< 1 >, LightDescriptor >;
+	//using GlobalDescriptorSet = descriptors::DescriptorSetLayout< 0, descriptors::EmptyDescriptor< 0 > >;
 
 	using TextureDescriptor = descriptors::Descriptor<
 		0,
@@ -63,7 +50,7 @@ namespace fgl::engine
 		512,
 		vk::DescriptorBindingFlagBits::eUpdateAfterBind | vk::DescriptorBindingFlagBits::ePartiallyBound >;
 
-	using TextureDescriptorSet = descriptors::DescriptorSetLayout< 1, TextureDescriptor >;
+	using TextureDescriptorSet = descriptors::DescriptorSetLayout< 2, TextureDescriptor >;
 
 	using PositionDescriptor = descriptors::AttachmentDescriptor< 0, vk::ShaderStageFlagBits::eFragment >;
 	using NormalDescriptor = descriptors::AttachmentDescriptor< 1, vk::ShaderStageFlagBits::eFragment >;
@@ -90,11 +77,13 @@ namespace fgl::engine
 
 		struct
 		{
-			Camera& camera;
+			Camera* camera { nullptr };
 			TransformComponent& camera_transform;
 		} camera_data;
 
-		descriptors::DescriptorSet& global_descriptor_set;
+		std::vector< std::weak_ptr< Camera > >& m_camera_list;
+
+		// descriptors::DescriptorSet& global_descriptor_set;
 		OctTreeNode& game_objects;
 		TracyVkCtx tracy_ctx;
 
@@ -108,8 +97,8 @@ namespace fgl::engine
 		descriptors::DescriptorSet& gui_input_descriptor;
 
 		descriptors::DescriptorSet& getGBufferDescriptor();
+		descriptors::DescriptorSet& getCameraDescriptor();
 
-		const Frustum< CoordinateSpace::World >& camera_frustum;
 		SwapChain& swap_chain;
 
 		std::vector< std::vector< GameObject >* > in_view_leafs {};
diff --git a/src/engine/buffers/HostSingleT.hpp b/src/engine/buffers/HostSingleT.hpp
index 80ae30b..9d42400 100644
--- a/src/engine/buffers/HostSingleT.hpp
+++ b/src/engine/buffers/HostSingleT.hpp
@@ -4,6 +4,9 @@
 
 #pragma once
 
+#include "Buffer.hpp"
+#include "BufferSuballocation.hpp"
+
 namespace fgl::engine
 {
 
diff --git a/src/engine/camera/Camera.cpp b/src/engine/camera/Camera.cpp
index 1328c74..c042c44 100644
--- a/src/engine/camera/Camera.cpp
+++ b/src/engine/camera/Camera.cpp
@@ -8,6 +8,9 @@
 #include <glm/gtx/string_cast.hpp>
 #include <tracy/Tracy.hpp>
 
+#include "CameraDescriptor.hpp"
+#include "CameraInfo.hpp"
+#include "CameraRenderer.hpp"
 #include "CameraSwapchain.hpp"
 
 namespace fgl::engine
@@ -40,9 +43,28 @@ namespace fgl::engine
 		return WorldCoordinate( inverse_view_matrix[ 3 ] );
 	}
 
-	void Camera::pass( FrameInfo& frame_info ) const
+	void Camera::updateInfo( const FrameIndex frame_index )
 	{
+		CameraInfo current_camera_info { .projection = getProjectionMatrix(),
+			                             .view = getViewMatrix(),
+			                             .inverse_view = getInverseViewMatrix() };
+
+		m_camera_frame_info[ frame_index ] = current_camera_info;
+	}
+
+	descriptors::DescriptorSet& Camera::getDescriptor( const FrameIndex index )
+	{
+		assert( index < m_camera_info_descriptors.size() );
+		return m_camera_info_descriptors[ index ];
+	}
+
+	void Camera::pass( FrameInfo& frame_info )
+	{
+		assert( frame_info.camera_data.camera == nullptr );
+		frame_info.camera_data.camera = this;
+		updateInfo( frame_info.frame_idx );
 		m_renderer->pass( frame_info, *m_swapchain );
+		frame_info.camera_data.camera = nullptr;
 	}
 
 	vk::raii::RenderPass& Camera::getRenderpass()
@@ -262,12 +284,23 @@ namespace fgl::engine
 		m_renderer = std::make_unique< CameraRenderer >();
 	}
 
-	Camera::Camera( const vk::Extent2D extent ) :
+	Camera::Camera( const vk::Extent2D extent, memory::Buffer& buffer ) :
 	  m_extent( extent ),
+	  m_camera_frame_info( buffer, SwapChain::MAX_FRAMES_IN_FLIGHT ),
 	  m_swapchain( std::make_shared< CameraSwapchain >( m_renderer->getRenderpass(), m_extent ) )
 	{
 		this->setPerspectiveProjection( 90.0f, 16.0f / 9.0f, constants::NEAR_PLANE, constants::FAR_PLANE );
 		this->setView( WorldCoordinate( constants::CENTER ), Rotation( 0.0f, 0.0f, 0.0f ) );
+
+		for ( std::uint8_t i = 0; i < SwapChain::MAX_FRAMES_IN_FLIGHT; ++i )
+		{
+			descriptors::DescriptorSet set { CameraDescriptorSet::createLayout() };
+			set.setMaxIDX( 0 );
+			set.bindUniformBuffer( 0, m_camera_frame_info[ i ] );
+			set.update();
+
+			m_camera_info_descriptors.emplace_back( std::move( set ) );
+		}
 	}
 
 	void Camera::setExtent( const vk::Extent2D extent )
@@ -340,4 +373,7 @@ namespace fgl::engine
 		return last_frustum_pos;
 	}
 
+	Camera::~Camera()
+	{}
+
 } // namespace fgl::engine
diff --git a/src/engine/camera/Camera.hpp b/src/engine/camera/Camera.hpp
index 86490b2..5d07c7c 100644
--- a/src/engine/camera/Camera.hpp
+++ b/src/engine/camera/Camera.hpp
@@ -13,15 +13,26 @@
 #pragma GCC diagnostic pop
 
 #include "CameraRenderer.hpp"
-#include "engine/constants.hpp"
+#include "engine/buffers/HostSingleT.hpp"
+#include "engine/buffers/UniqueFrameSuballocation.hpp"
+#include "engine/descriptors/DescriptorSet.hpp"
 #include "engine/primitives/Frustum.hpp"
-#include "engine/primitives/TransformComponent.hpp"
-#include "engine/primitives/matricies/Matrix.hpp"
-#include "engine/primitives/points/Coordinate.hpp"
-#include "engine/rendering/SwapChain.hpp"
+#include "engine/primitives/Rotation.hpp"
+#include "engine/rendering/types.hpp"
+
+namespace vk::raii
+{
+	class CommandBuffer;
+	class RenderPass;
+} // namespace vk::raii
 
 namespace fgl::engine
 {
+	class Image;
+	struct FrameInfo;
+	class CameraRenderer;
+
+	struct CameraInfo;
 	class CameraSwapchain;
 	class Camera;
 
@@ -49,6 +60,11 @@ namespace fgl::engine
 
 		vk::Extent2D m_extent;
 
+		PerFrameSuballocation< HostSingleT< CameraInfo > > m_camera_frame_info;
+
+		// Camera info is expected at binding 0
+		std::vector< descriptors::DescriptorSet > m_camera_info_descriptors {};
+
 		inline static std::unique_ptr< CameraRenderer > m_renderer;
 		std::shared_ptr< CameraSwapchain > m_swapchain;
 
@@ -56,11 +72,19 @@ namespace fgl::engine
 
 		void updateFrustum();
 
+		Camera( vk::Extent2D extent, memory::Buffer& data_buffer );
+
+		friend class CameraManager;
+
 	  public:
 
-		static void initCameraRenderer();
+		FGL_DELETE_ALL_Ro5( Camera );
 
-		Camera( vk::Extent2D extent );
+		~Camera();
+
+		CameraIDX getIDX() { return camera_idx; }
+
+		static void initCameraRenderer();
 
 		void setExtent( vk::Extent2D extent );
 
@@ -81,25 +105,45 @@ namespace fgl::engine
 
 		glm::mat4 getInverseViewMatrix() const { return glm::inverse( view_matrix ); }
 
+		enum ViewMode
+		{
+			Euler,
+			TaitBryan
+		};
+
+		void setView( WorldCoordinate pos, const Rotation& rotation, ViewMode mode = TaitBryan );
 		void setOrthographicProjection( float left, float right, float top, float bottom, float near, float far );
 		void setPerspectiveProjection( float fovy, float aspect, float near, float far );
 
 		Coordinate< CoordinateSpace::World > getPosition() const;
 
-		Vector getUp() const { return -getDown(); }
+		FGL_FORCE_INLINE Vector getUp() const { return -getDown(); }
 
-		Vector getRight() const { return Vector( glm::normalize( glm::vec3( inverse_view_matrix[ 0 ] ) ) ); }
+		FGL_FORCE_INLINE Vector getRight() const
+		{
+			return Vector( glm::normalize( glm::vec3( inverse_view_matrix[ 0 ] ) ) );
+		}
 
-		Vector getForward() const { return Vector( glm::normalize( glm::vec3( inverse_view_matrix[ 2 ] ) ) ); }
+		FGL_FORCE_INLINE Vector getForward() const
+		{
+			return Vector( glm::normalize( glm::vec3( inverse_view_matrix[ 2 ] ) ) );
+		}
 
-		Vector getLeft() const { return -getRight(); }
+		FGL_FORCE_INLINE Vector getLeft() const { return -getRight(); }
 
-		Vector getBackward() const { return -getForward(); }
+		FGL_FORCE_INLINE Vector getBackward() const { return -getForward(); }
 
-		Vector getDown() const { return Vector( glm::normalize( glm::vec3( inverse_view_matrix[ 1 ] ) ) ); }
+		FGL_FORCE_INLINE Vector getDown() const
+		{
+			return Vector( glm::normalize( glm::vec3( inverse_view_matrix[ 1 ] ) ) );
+		}
+
+		//! Updates the required info for rendering
+		void updateInfo( FrameIndex frame_index );
+		descriptors::DescriptorSet& getDescriptor( FrameIndex index );
 
 		//! Performs the render pass for this camera
-		void pass( FrameInfo& frame_info ) const;
+		void pass( FrameInfo& frame_info );
 
 		static vk::raii::RenderPass& getRenderpass();
 		CameraSwapchain& getSwapchain() const;
@@ -110,14 +154,6 @@ namespace fgl::engine
 		void endRenderpass( const vk::raii::CommandBuffer& command_buffer );
 
 		void copyOutput( const vk::raii::CommandBuffer& command_buffer, FrameIndex frame_index, Image& target );
-
-		enum ViewMode
-		{
-			Euler,
-			TaitBryan
-		};
-
-		void setView( WorldCoordinate pos, const Rotation& rotation, ViewMode mode = TaitBryan );
 	};
 
 } // namespace fgl::engine
diff --git a/src/engine/camera/CameraDescriptor.hpp b/src/engine/camera/CameraDescriptor.hpp
new file mode 100644
index 0000000..046e43e
--- /dev/null
+++ b/src/engine/camera/CameraDescriptor.hpp
@@ -0,0 +1,14 @@
+//
+// Created by kj16609 on 7/27/24.
+//
+
+#pragma once
+#include "engine/descriptors/DescriptorSetLayout.hpp"
+
+namespace fgl::engine
+{
+	using CameraDescriptor =
+		descriptors::Descriptor< 0, vk::DescriptorType::eUniformBuffer, vk::ShaderStageFlagBits::eAllGraphics >;
+
+	using CameraDescriptorSet = descriptors::DescriptorSetLayout< 1, CameraDescriptor >;
+} // namespace fgl::engine
\ No newline at end of file
diff --git a/src/engine/camera/CameraInfo.hpp b/src/engine/camera/CameraInfo.hpp
new file mode 100644
index 0000000..bddc97f
--- /dev/null
+++ b/src/engine/camera/CameraInfo.hpp
@@ -0,0 +1,17 @@
+//
+// Created by kj16609 on 7/23/24.
+//
+
+#pragma once
+
+namespace fgl::engine
+{
+	struct CameraInfo
+	{
+		glm::mat4 projection { 1.0f };
+		glm::mat4 view { 1.0f };
+		glm::mat4 inverse_view { 1.0f };
+	};
+
+
+} // namespace fgl::engine
\ No newline at end of file
diff --git a/src/engine/camera/CameraManager.cpp b/src/engine/camera/CameraManager.cpp
new file mode 100644
index 0000000..69e11d0
--- /dev/null
+++ b/src/engine/camera/CameraManager.cpp
@@ -0,0 +1,43 @@
+//
+// Created by kj16609 on 7/23/24.
+//
+
+#include "CameraManager.hpp"
+
+#include "Camera.hpp"
+#include "engine/debug/drawers.hpp"
+#include "engine/literals/size.hpp"
+
+namespace fgl::engine
+{
+
+	using namespace fgl::literals::size_literals;
+
+	std::vector< std::weak_ptr< Camera > >& CameraManager::getCameras()
+	{
+		return cameras;
+	}
+
+	Camera& CameraManager::getPrimary()
+	{
+		return *m_primary_camera;
+	}
+
+	CameraManager::CameraManager() :
+	  m_data_buffer( 4_KiB, vk::BufferUsageFlagBits::eUniformBuffer, vk::MemoryPropertyFlagBits::eHostVisible )
+	{
+		Camera::initCameraRenderer();
+		debug::setDebugDrawingCamera( getPrimary() );
+
+		m_primary_camera = createCamera( { 1920, 1080 } );
+	}
+
+	std::shared_ptr< Camera > CameraManager::createCamera( const vk::Extent2D extent )
+	{
+		std::shared_ptr< Camera > camera { new Camera( extent, m_data_buffer ) };
+
+		this->cameras.emplace_back( camera );
+
+		return camera;
+	}
+} // namespace fgl::engine
\ No newline at end of file
diff --git a/src/engine/camera/CameraManager.hpp b/src/engine/camera/CameraManager.hpp
new file mode 100644
index 0000000..45fb813
--- /dev/null
+++ b/src/engine/camera/CameraManager.hpp
@@ -0,0 +1,37 @@
+//
+// Created by kj16609 on 7/23/24.
+//
+
+#pragma once
+#include <vector>
+
+#include "Camera.hpp"
+#include "engine/buffers/UniqueFrameSuballocation.hpp"
+
+namespace fgl::engine
+{
+	namespace descriptors
+	{
+		class DescriptorSet;
+	}
+
+	class CameraManager
+	{
+		memory::Buffer m_data_buffer;
+
+		std::shared_ptr< Camera > m_primary_camera { nullptr };
+
+		std::vector< std::weak_ptr< Camera > > cameras {};
+
+	  public:
+
+		std::vector< std::weak_ptr< Camera > >& getCameras();
+
+		Camera& getPrimary();
+
+		CameraManager();
+
+		std::shared_ptr< Camera > createCamera( vk::Extent2D extent );
+	};
+
+} // namespace fgl::engine
\ No newline at end of file
diff --git a/src/engine/camera/CameraRenderer.cpp b/src/engine/camera/CameraRenderer.cpp
index 8cba055..7b2a646 100644
--- a/src/engine/camera/CameraRenderer.cpp
+++ b/src/engine/camera/CameraRenderer.cpp
@@ -137,7 +137,7 @@ namespace fgl::engine
 
 		m_culling_system.wait();
 
-		m_terrain_system.pass( frame_info );
+		//m_terrain_system.pass( frame_info );
 
 		m_entity_renderer.pass( frame_info );
 
diff --git a/src/engine/camera/CameraRenderer.hpp b/src/engine/camera/CameraRenderer.hpp
index c1a5a65..023b4b6 100644
--- a/src/engine/camera/CameraRenderer.hpp
+++ b/src/engine/camera/CameraRenderer.hpp
@@ -9,7 +9,6 @@
 #include "engine/systems/CompositionSystem.hpp"
 #include "engine/systems/CullingSystem.hpp"
 #include "engine/systems/EntityRendererSystem.hpp"
-#include "engine/systems/TerrainSystem.hpp"
 
 namespace fgl::engine
 {
@@ -25,7 +24,7 @@ namespace fgl::engine
 		CullingSystem m_culling_system {};
 
 		// SubPass 0
-		TerrainSystem m_terrain_system { Device::getInstance(), m_renderpass };
+		//TerrainSystem m_terrain_system { Device::getInstance(), m_renderpass };
 		EntityRendererSystem m_entity_renderer { Device::getInstance(), m_renderpass };
 
 		// SubPass 1
diff --git a/src/engine/gui/camera.cpp b/src/engine/gui/camera.cpp
new file mode 100644
index 0000000..209e7b8
--- /dev/null
+++ b/src/engine/gui/camera.cpp
@@ -0,0 +1,42 @@
+//
+// Created by kj16609 on 7/23/24.
+//
+
+#include "engine/camera/Camera.hpp"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Weffc++"
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wconversion"
+#include <imgui.h>
+#pragma GCC diagnostic pop
+
+#include "engine/FrameInfo.hpp"
+#include "preview.hpp"
+
+namespace fgl::engine::gui
+{
+
+	void drawCameraOutputs( FrameInfo& info )
+	{
+		auto& camera_list { info.m_camera_list };
+		for ( const auto& weak_camera_ptr : camera_list )
+		{
+			if ( weak_camera_ptr.expired() ) continue;
+
+			auto camera_ptr { weak_camera_ptr.lock() };
+
+			assert( camera_ptr );
+
+			Camera& camera { *camera_ptr };
+
+			const auto name { std::format( "Camera: {}", camera.getIDX() ) };
+			ImGui::Begin( name.c_str() );
+
+			drawRenderingOutputs( info, camera );
+
+			ImGui::End();
+		}
+	}
+
+} // namespace fgl::engine::gui
\ No newline at end of file
diff --git a/src/engine/gui/core.cpp b/src/engine/gui/core.cpp
index 91941d9..68fb25c 100644
--- a/src/engine/gui/core.cpp
+++ b/src/engine/gui/core.cpp
@@ -143,7 +143,7 @@ namespace fgl::engine::gui
 		//static std::once_flag flag;
 		//std::call_once( flag, prepareDock );
 
-		drawRenderingOutputs( info );
+		drawCameraOutputs( info );
 		drawEntityGUI( info );
 		drawEntityInfo( info );
 		drawFilesystemGUI( info );
diff --git a/src/engine/gui/core.hpp b/src/engine/gui/core.hpp
index d0c26e6..7f636f7 100644
--- a/src/engine/gui/core.hpp
+++ b/src/engine/gui/core.hpp
@@ -23,4 +23,6 @@ namespace fgl::engine::gui
 	void drawEntityInfo( FrameInfo& );
 	void drawFilesystemGUI( FrameInfo& info );
 
+	void drawCameraOutputs( FrameInfo& info );
+
 } // namespace fgl::engine::gui
diff --git a/src/engine/gui/preview.cpp b/src/engine/gui/preview.cpp
index 714e460..7db1ce6 100644
--- a/src/engine/gui/preview.cpp
+++ b/src/engine/gui/preview.cpp
@@ -98,13 +98,34 @@ namespace fgl::engine::gui
 		}
 	}
 
-	void drawRenderingOutputs( FrameInfo& info )
+	vk::Extent2D calculateTargetSize( const float ratio, const vk::Extent2D max_extent )
+	{
+		// r = w/h
+		// w = r*h
+		// h = w/r
+		float height_size { static_cast< float >( max_extent.height ) };
+		float width_size { ratio * static_cast< float >( max_extent.height ) };
+
+		// If height is larger then the size then we need to compute the width from the height max
+		if ( width_size > max_extent.width )
+		{
+			width_size = static_cast< float >( max_extent.width );
+			height_size = static_cast< float >( max_extent.width ) / ratio;
+		}
+
+		return { static_cast< std::uint32_t >( width_size ), static_cast< std::uint32_t >( height_size ) };
+	}
+
+	FGL_FORCE_INLINE_FLATTEN vk::Extent2D calculateTargetSize( const float ratio, const ImVec2 max_extent )
+	{
+		return calculateTargetSize( ratio, vk::Extent2D( max_extent.x, max_extent.y ) );
+	}
+
+	void drawRenderingOutputs( FrameInfo& info, const Camera& camera )
 	{
 		ZoneScoped;
 		const auto frame_index { info.frame_idx };
 
-		ImGui::Begin( "RenderOutputs" );
-
 		enum RenderingOutputSelection : std::uint_fast8_t
 		{
 			Composite = 0,
@@ -118,24 +139,10 @@ namespace fgl::engine::gui
 
 		if ( ImGui::BeginCombo( "Rendering Output", options[ current ] ) )
 		{
-			constexpr float desired_size { 64 };
+			constexpr vk::Extent2D desired_size { 64, 64 };
 			//Calculate size
 			const float ratio { info.swap_chain.extentAspectRatio() };
-
-			// h = w/h
-
-			float fh_size { desired_size };
-			float fv_size { desired_size * ratio };
-
-			// If height is larger then the size then we need to compute the width from the height max
-			if ( fv_size > desired_size )
-			{
-				fv_size = desired_size;
-				fh_size = fv_size / ratio;
-			}
-
-			std::uint32_t h_size { static_cast< std::uint32_t >( fh_size ) };
-			std::uint32_t v_size { static_cast< std::uint32_t >( fv_size ) };
+			const auto size { calculateTargetSize( ratio, desired_size ) };
 
 			//Composite
 			if ( ImGui::Selectable( options[ Composite ], current == Composite ) )
@@ -144,7 +151,7 @@ namespace fgl::engine::gui
 				current = Composite;
 			}
 
-			info.camera_data.camera.getSwapchain().g_buffer_albedo_img[ frame_index ]->drawImGui( { v_size, h_size } );
+			camera.getSwapchain().g_buffer_albedo_img[ frame_index ]->drawImGui( size );
 			ImGui::SameLine();
 			if ( ImGui::Selectable( options[ Albedo ], current == Albedo ) )
 			{
@@ -152,7 +159,7 @@ namespace fgl::engine::gui
 				current = Albedo;
 			}
 
-			info.camera_data.camera.getSwapchain().g_buffer_normal_img[ frame_index ]->drawImGui( { v_size, h_size } );
+			camera.getSwapchain().g_buffer_normal_img[ frame_index ]->drawImGui( size );
 			ImGui::SameLine();
 			if ( ImGui::Selectable( options[ Normal ], current == Normal ) )
 			{
@@ -160,8 +167,7 @@ namespace fgl::engine::gui
 				current = Normal;
 			}
 
-			info.camera_data.camera.getSwapchain().g_buffer_position_img[ frame_index ]->drawImGui( { v_size,
-			                                                                                          h_size } );
+			camera.getSwapchain().g_buffer_position_img[ frame_index ]->drawImGui( size );
 			ImGui::SameLine();
 			if ( ImGui::Selectable( options[ Position ], current == Position ) )
 			{
@@ -172,27 +178,31 @@ namespace fgl::engine::gui
 			ImGui::EndCombo();
 		}
 
+		const float ratio { info.swap_chain.extentAspectRatio() };
+		const auto imgui_size { ImGui::GetWindowSize() };
+		const auto target_size { calculateTargetSize( ratio, imgui_size ) };
+
+		//Compute optimal size using aspect ratio
+
 		switch ( current )
 		{
 			default:
 				[[fallthrough]];
 			case Composite:
-				info.camera_data.camera.getSwapchain().g_buffer_composite_img[ frame_index ]->drawImGui();
+				camera.getSwapchain().g_buffer_composite_img[ frame_index ]->drawImGui( target_size );
 				break;
 			case Albedo:
-				info.camera_data.camera.getSwapchain().g_buffer_albedo_img[ frame_index ]->drawImGui();
+				camera.getSwapchain().g_buffer_albedo_img[ frame_index ]->drawImGui( target_size );
 				break;
 			case Normal:
-				info.camera_data.camera.getSwapchain().g_buffer_normal_img[ frame_index ]->drawImGui();
+				camera.getSwapchain().g_buffer_normal_img[ frame_index ]->drawImGui( target_size );
 				break;
 			case Position:
-				info.camera_data.camera.getSwapchain().g_buffer_position_img[ frame_index ]->drawImGui();
+				camera.getSwapchain().g_buffer_position_img[ frame_index ]->drawImGui( target_size );
 				break;
 		}
 
 		handleDragDrop( info );
-
-		ImGui::End();
 	}
 
 } // namespace fgl::engine::gui
diff --git a/src/engine/gui/preview.hpp b/src/engine/gui/preview.hpp
index f651f8e..6634e50 100644
--- a/src/engine/gui/preview.hpp
+++ b/src/engine/gui/preview.hpp
@@ -7,11 +7,12 @@
 namespace fgl::engine
 {
 	struct FrameInfo;
-}
+	class Camera;
+} // namespace fgl::engine
 
 namespace fgl::engine::gui
 {
 
-	void drawRenderingOutputs( FrameInfo& info );
+	void drawRenderingOutputs( FrameInfo& info, const Camera& camera );
 
 } // namespace fgl::engine::gui
diff --git a/src/engine/pipeline/PipelineT.hpp b/src/engine/pipeline/PipelineT.hpp
index e38b15f..e60d874 100644
--- a/src/engine/pipeline/PipelineT.hpp
+++ b/src/engine/pipeline/PipelineT.hpp
@@ -8,9 +8,7 @@
 #include "Shader.hpp"
 #include "engine/concepts/is_descriptor_set_collection.hpp"
 #include "engine/concepts/is_empty_descriptor_set.hpp"
-#include "engine/concepts/is_valid_pipeline_input.hpp"
 #include "engine/descriptors/DescriptorSet.hpp"
-#include "engine/descriptors/createDescriptorSets.hpp"
 
 namespace fgl::engine
 {
@@ -25,7 +23,7 @@ namespace fgl::engine
 
 		//! Returns the binding type assocaited with the index
 		template < std::uint16_t binding_set_idx >
-		using BindingSet = DescriptorSetCollection::template BindingSet< binding_set_idx >;
+		using BindingSet = typename DescriptorSetCollection::template BindingSet< binding_set_idx >;
 
 		constexpr static std::uint16_t max_binding_set { DescriptorSetCollection::max_binding_set };
 
diff --git a/src/engine/rendering/Renderer.cpp b/src/engine/rendering/Renderer.cpp
index 3380292..df77050 100644
--- a/src/engine/rendering/Renderer.cpp
+++ b/src/engine/rendering/Renderer.cpp
@@ -26,6 +26,24 @@
 namespace fgl::engine
 {
 
+	void Renderer::clearInputImage( vk::raii::CommandBuffer& command_buffer )
+	{
+		auto& image { getSwapChain().getInputImage( current_present_index ) };
+
+		vk::ImageSubresourceRange range {};
+		range.aspectMask = vk::ImageAspectFlagBits::eColor;
+		range.layerCount = 1;
+		range.baseArrayLayer = 0;
+		range.levelCount = 1;
+		range.baseMipLevel = 0;
+
+		command_buffer.clearColorImage(
+			image.getVkImage(),
+			vk::ImageLayout::eShaderReadOnlyOptimal,
+			vk::ClearColorValue( 0.0f, 0.0f, 0.0f, 0.0f ),
+			{ range } );
+	}
+
 	Renderer::Renderer( Window& window, PhysicalDevice& phy_device ) :
 	  m_window( window ),
 	  m_phy_device( phy_device ),
diff --git a/src/engine/rendering/Renderer.hpp b/src/engine/rendering/Renderer.hpp
index 3793d96..2c6ad2b 100644
--- a/src/engine/rendering/Renderer.hpp
+++ b/src/engine/rendering/Renderer.hpp
@@ -87,6 +87,8 @@ namespace fgl::engine
 
 		SwapChain& getSwapChain() { return *m_swapchain; }
 
+		void clearInputImage( vk::raii::CommandBuffer& command_buffer );
+
 		Renderer( Window& window, PhysicalDevice& phy_device );
 		~Renderer();
 		Renderer( Renderer&& other ) = delete;
diff --git a/src/engine/rendering/types.hpp b/src/engine/rendering/types.hpp
index 5f919dc..96dcc6f 100644
--- a/src/engine/rendering/types.hpp
+++ b/src/engine/rendering/types.hpp
@@ -10,4 +10,6 @@ namespace fgl::engine
 {
 	using PresentIndex = std::uint16_t;
 	using FrameIndex = std::uint16_t;
+
+	using CameraIndex = std::uint16_t;
 }
diff --git a/src/engine/systems/CullingSystem.cpp b/src/engine/systems/CullingSystem.cpp
index de80f7a..fbfe0f7 100644
--- a/src/engine/systems/CullingSystem.cpp
+++ b/src/engine/systems/CullingSystem.cpp
@@ -7,7 +7,7 @@
 #include <tracy/TracyC.h>
 
 #include "engine/FrameInfo.hpp"
-#include "engine/debug/drawers.hpp"
+#include "engine/camera/Camera.hpp"
 #include "engine/model/Model.hpp"
 #include "engine/tree/octtree/OctTreeNode.hpp"
 
@@ -24,7 +24,7 @@ namespace fgl::engine
 	{
 		ZoneScopedN( "Culling pass" );
 
-		const auto frustum { info.camera_frustum };
+		const auto frustum { info.camera_data.camera->getFrustumBounds() };
 
 		if ( !enable_culling )
 		{
diff --git a/src/engine/systems/EntityRendererSystem.cpp b/src/engine/systems/EntityRendererSystem.cpp
index 325e4c4..bfa42e6 100644
--- a/src/engine/systems/EntityRendererSystem.cpp
+++ b/src/engine/systems/EntityRendererSystem.cpp
@@ -8,6 +8,7 @@
 #include <vulkan/vulkan.hpp>
 
 #include "DrawPair.hpp"
+#include "engine/camera/Camera.hpp"
 #include "engine/literals/size.hpp"
 #include "engine/tree/octtree/OctTreeNode.hpp"
 
@@ -77,13 +78,12 @@ namespace fgl::engine
 		//Bind pipeline
 		m_standard_pipeline->bind( command_buffer );
 
-		//Bind only descriptor we need.
 		m_standard_pipeline
-			->bindDescriptor( command_buffer, GlobalDescriptorSet::m_set_idx, info.global_descriptor_set );
+			->bindDescriptor( command_buffer, CameraDescriptorSet::m_set_idx, info.getCameraDescriptor() );
 
 		//Get all commands for drawing anything without a texture
-		auto [ draw_commands, model_matricies ] =
-			getDrawCallsFromTree( info.game_objects, info.camera_frustum, IS_VISIBLE | IS_ENTITY, IS_TEXTURELESS );
+		auto [ draw_commands, model_matricies ] = getDrawCallsFromTree(
+			info.game_objects, info.camera_data.camera->getFrustumBounds(), IS_VISIBLE | IS_ENTITY, IS_TEXTURELESS );
 
 		//TODO: Filter Textureless models (#6)
 
@@ -120,14 +120,15 @@ namespace fgl::engine
 
 		m_textured_pipeline->bind( command_buffer );
 
-		m_textured_pipeline
-			->bindDescriptor( command_buffer, GlobalDescriptorSet::m_set_idx, info.global_descriptor_set );
+		// Since the camera was bound in the textureless pass we shouldn't need to bind it here too.
+		// m_textured_pipeline
+		// ->bindDescriptor( command_buffer, CameraDescriptorSet::m_set_idx, info.global_descriptor_set );
 
 		m_textured_pipeline
 			->bindDescriptor( command_buffer, TextureDescriptorSet::m_set_idx, Texture::getTextureDescriptorSet() );
 
-		auto [ draw_commands, model_matricies ] =
-			getDrawCallsFromTree( info.game_objects, info.camera_frustum, IS_VISIBLE | IS_ENTITY );
+		auto [ draw_commands, model_matricies ] = getDrawCallsFromTree(
+			info.game_objects, info.camera_data.camera->getFrustumBounds(), IS_VISIBLE | IS_ENTITY );
 
 		if ( draw_commands.empty() ) return;
 
diff --git a/src/engine/systems/TerrainSystem.cpp b/src/engine/systems/TerrainSystem.cpp
index b75e5fa..5c1692e 100644
--- a/src/engine/systems/TerrainSystem.cpp
+++ b/src/engine/systems/TerrainSystem.cpp
@@ -7,11 +7,13 @@
 #include <tracy/Tracy.hpp>
 
 #include "DrawPair.hpp"
+#include "engine/camera/Camera.hpp"
 #include "engine/literals/size.hpp"
 
 namespace fgl::engine
 {
 
+	/*
 	TerrainSystem::TerrainSystem( Device& device, vk::raii::RenderPass& render_pass )
 	{
 		ZoneScoped;
@@ -58,7 +60,7 @@ namespace fgl::engine
 		return;
 
 		auto [ draw_commands, model_matricies ] =
-			getDrawCallsFromTree( info.game_objects, info.camera_frustum, IS_VISIBLE );
+			getDrawCallsFromTree( info.game_objects, info.camera_data.camera.getFrustumBounds(), IS_VISIBLE );
 
 		if ( draw_commands.size() == 0 ) return;
 
@@ -84,5 +86,6 @@ namespace fgl::engine
 			draw_parameter_buffer->size(),
 			draw_parameter_buffer->stride() );
 	}
+	*/
 
 } // namespace fgl::engine
\ No newline at end of file
diff --git a/src/engine/systems/TerrainSystem.hpp b/src/engine/systems/TerrainSystem.hpp
index 7183270..89edd60 100644
--- a/src/engine/systems/TerrainSystem.hpp
+++ b/src/engine/systems/TerrainSystem.hpp
@@ -8,6 +8,7 @@
 #include "concepts.hpp"
 #include "engine/FrameInfo.hpp"
 #include "engine/buffers/vector/HostVector.hpp"
+#include "engine/camera/Camera.hpp"
 #include "engine/descriptors/DescriptorSetCollection.hpp"
 #include "engine/model/Model.hpp"
 #include "engine/pipeline/PipelineT.hpp"
@@ -15,6 +16,8 @@
 
 namespace fgl::engine
 {
+
+	/*
 	class TerrainSystem
 	{
 		using VertexShader = VertexShaderT< "shaders/terrain/terrain.vert.spv" >;
@@ -23,7 +26,8 @@ namespace fgl::engine
 		using TessEShader = TesselationEvaluationShaderT< "shaders/terrain/terrain.tese.spv" >;
 
 		using Shaders = ShaderCollection< VertexShader, FragmentShader, TessCShader, TessEShader >;
-		using DescriptorSets = descriptors::DescriptorSetCollection< GlobalDescriptorSet, TextureDescriptorSet >;
+		using DescriptorSets =
+			descriptors::DescriptorSetCollection< GlobalDescriptorSet, CameraDescriptorSet, TextureDescriptorSet >;
 
 		using Pipeline = PipelineT< Shaders, DescriptorSets >;
 
@@ -73,6 +77,8 @@ namespace fgl::engine
 	};
 
 	static_assert( is_system< TerrainSystem > );
+	*/
+
 } // namespace fgl::engine
 
 #endif //GAME_TERRAINSYSTEM_HPP
diff --git a/src/engine/systems/modelRendering/StandardPipeline.hpp b/src/engine/systems/modelRendering/StandardPipeline.hpp
index 8054550..689c52e 100644
--- a/src/engine/systems/modelRendering/StandardPipeline.hpp
+++ b/src/engine/systems/modelRendering/StandardPipeline.hpp
@@ -4,6 +4,7 @@
 
 #pragma once
 #include "engine/FrameInfo.hpp"
+#include "engine/camera/CameraDescriptor.hpp"
 #include "engine/descriptors/DescriptorSetCollection.hpp"
 #include "engine/pipeline/PipelineT.hpp"
 #include "engine/pipeline/Shader.hpp"
@@ -15,7 +16,9 @@ namespace fgl::engine
 	using StandardPipelineFragShader = FragmentShaderT< "shaders/textureless-gbuffer.frag.spv" >;
 	using StandardPipelineShaders = ShaderCollection< StandardPipelineVertexShader, StandardPipelineFragShader >;
 
-	using StandardPipelineDescriptorSets = descriptors::DescriptorSetCollection< GlobalDescriptorSet >;
+	// using StandardPipelineDescriptorSets = descriptors::DescriptorSetCollection< GlobalDescriptorSet >;
+	using StandardPipelineDescriptorSets =
+		descriptors::DescriptorSetCollection< descriptors::EmptyDescriptorSet< 0 >, CameraDescriptorSet >;
 
 	//! The standard pipeline is used for models without any form of texturing. They instead rely on Vertex coloring. A UV map is **NOT** expected
 	using StandardPipeline = PipelineT< StandardPipelineShaders, StandardPipelineDescriptorSets >;
diff --git a/src/engine/systems/modelRendering/TexturedPipeline.hpp b/src/engine/systems/modelRendering/TexturedPipeline.hpp
index 4f9e3db..94c0fe9 100644
--- a/src/engine/systems/modelRendering/TexturedPipeline.hpp
+++ b/src/engine/systems/modelRendering/TexturedPipeline.hpp
@@ -15,8 +15,10 @@ namespace fgl::engine
 	using TexturedPipelineFragShader = FragmentShaderT< "shaders/textured-gbuffer.frag.spv" >;
 	using TexturedPipelineShaders = ShaderCollection< TexturedPipelineVertexShader, TexturedPipelineFragShader >;
 
-	using TexturedPipelineDescriptorSets =
-		descriptors::DescriptorSetCollection< GlobalDescriptorSet, TextureDescriptorSet >;
+	//using TexturedPipelineDescriptorSets =
+	//	descriptors::DescriptorSetCollection< GlobalDescriptorSet, TextureDescriptorSet >;
+	using TexturedPipelineDescriptorSets = descriptors::
+		DescriptorSetCollection< descriptors::EmptyDescriptorSet< 0 >, CameraDescriptorSet, TextureDescriptorSet >;
 
 	//! The standard pipeline is used for models without any form of texturing. They instead rely on Vertex coloring. A UV map is **NOT** expected
 	using TexturedPipeline = PipelineT< TexturedPipelineShaders, TexturedPipelineDescriptorSets >;