Started abstraction for scene viewports

Editor/src/Windows/SceneEditor/Widgets/ViewportWidget.cpp

@@ -5,10 +5,29 @@
 
 #include "../../EditorInterface.h"
 
+#include "src/Rendering/Vulkan/VulkanRenderer.h"
+#include "src/Rendering/Vulkan/SceneViewport.h"
+
 #include <glm/gtc/type_ptr.hpp>
 
 using namespace Nuake;
 
+ViewportWidget::ViewportWidget(EditorContext& context) : IEditorWidget(context)
+{
+    
+	const Vector2& defaultSize = { 1280, 720 };
+	const UUID viewId = editorContext.GetScene()->m_EditorCamera->ID;
+    auto& vkRenderer = Nuake::VkRenderer::Get();
+    auto viewport = vkRenderer.CreateViewport(viewId, defaultSize);
+    vkRenderer.RegisterSceneViewport(context.GetScene(), viewport->GetID());
+	sceneViewport = viewport;
+}
+
+ViewportWidget::~ViewportWidget()
+{
+    Nuake::VkRenderer::Get().RemoveViewport(sceneViewport->GetID());
+}
+
 void ViewportWidget::Update(float ts)
 {
 

Editor/src/Windows/SceneEditor/Widgets/ViewportWidget.h

@@ -6,17 +6,24 @@
 
 class EditorContext;
 
+namespace MyNamespace
+{
+	class Viewport;
+}
+
 class ViewportWidget : public IEditorWidget
 {
 private:
+	Ref<Viewport> sceneViewport;
+
 	ImGuizmo::OPERATION CurrentOperation = ImGuizmo::TRANSLATE;
 	ImGuizmo::MODE CurrentMode = ImGuizmo::WORLD;
 	bool UseSnapping = true;
 	Nuake::Vector3 CurrentSnapping = { 0.05f, 0.05f, 0.05f };
 
 public:
-	ViewportWidget(EditorContext& context) : IEditorWidget(context) {}
-	~ViewportWidget() = default;
+	ViewportWidget(EditorContext& context) : IEditorWidget(context);
+	~ViewportWidget();
 
 public:
 	void Update(float ts) override;

Nuake/src/Rendering/Vulkan/SceneViewport.cpp

@@ -0,0 +1,15 @@
+#include "SceneViewport.h"
+
+#include "src/Rendering/Vulkan/VulkanImage/VulkanImage.h"
+
+using namespace Nuake;
+
+Viewport::Viewport(UUID inViewId, const Vector2& inViewportSize) :
+	id(UUID()),
+	viewportSize(inViewportSize),
+	viewId(inViewId)
+{
+	// Create render target
+	renderTarget = CreateRef<VulkanImage>(ImageFormat::RGBA8, viewportSize);
+}
+

Nuake/src/Rendering/Vulkan/SceneViewport.h

@@ -0,0 +1,35 @@
+#pragma once
+#include "src/Core/Core.h"
+#include "src/Core/Maths.h"
+#include "src/Resource/UUID.h"
+
+
+namespace Nuake
+{
+	class VulkanImage;
+
+	class Viewport
+	{
+	private:
+		UUID id;
+		Vector2 viewportSize;
+
+		UUID viewId;
+		Ref<VulkanImage> renderTarget;
+
+	public:
+		Viewport(UUID viewId, const Vector2& size);
+		~Viewport() = default;
+
+	public:
+		UUID GetID() const { return id; }
+
+		const Vector2& GetViewportSize() const { return viewportSize; }
+		void SetViewportSize(const Vector2& size)
+		{
+			viewportSize = size;
+		}
+
+		Ref<VulkanImage> GetRenderTarget() const { return renderTarget; }
+	};
+}

Nuake/src/Rendering/Vulkan/VulkanRenderer.cpp

@@ -380,10 +380,55 @@ void VkRenderer::UpdateDescriptorSets()
 	vkUpdateDescriptorSets(Device, 1, &drawImageWrite, 0, nullptr);
 }
 
-void VkRenderer::DrawScene(RenderContext ctx)
+Ref<Viewport> VkRenderer::CreateViewport(const UUID& viewId, const Vector2& size)
 {
-	SceneRenderer->BeginScene(ctx);
-	SceneRenderer->EndScene();
+
+	Ref<Viewport> newViewport = CreateRef<Viewport>(viewId, size);
+	Viewports[viewId] = newViewport;
+	return newViewport;
+}
+
+void VkRenderer::RemoveViewport(const UUID& viewportId)
+{
+	Viewports.erase(viewportId);
+}
+
+void VkRenderer::RegisterSceneViewport(const Ref<Scene>& scene, const UUID& viewportId)
+{
+	if (Viewports.find(viewportId) == Viewports.end())
+	{
+		Logger::Log("Failed to register scene viewport: viewport not found", "vulkan", CRITICAL);
+		return;
+	}
+
+	SceneViewports[scene].push_back(viewportId);
+}
+
+void VkRenderer::UnRegisterSceneViewport(const Ref<Scene>& scene, const UUID& viewportId)
+{
+	if (SceneViewports.find(scene) == SceneViewports.end())
+	{
+		Logger::Log("Failed to unregister scene viewport: scene not found", "vulkan", CRITICAL);
+		return;
+	}
+
+	auto& viewports = SceneViewports[scene];
+	auto it = std::find(viewports.begin(), viewports.end(), viewportId);
+	if (it != viewports.end())
+	{
+		viewports.erase(it);
+	}
+}
+
+void PrepareSceneData(const Ref<Scene>& scene)
+{
+	// Prepare scene data
+
+}
+
+void DrawSceneViewport(const Ref<Scene>& scene, const UUID& viewportId)
+{
+	// Draw scene viewport
 }
 
 void VkRenderer::InitImgui()

Nuake/src/Rendering/Vulkan/VulkanRenderer.h

@@ -12,6 +12,8 @@
 #include "VulkanAllocatedBuffer.h"
 #include "VulkanSceneRenderer.h"
 
+#include "src/Resource/UUID.h"
+
 #include <functional>
 #include <span>
 
@@ -131,6 +133,8 @@ namespace Nuake
 
 	// Renderer configuration
 	constexpr uint32_t FRAME_OVERLAP = 2;
+	
+	class Viewport;
 
 	class VkRenderer
 	{
@@ -163,6 +167,8 @@ namespace Nuake
 		DeletionQueue MainDeletionQueue;
 		DescriptorAllocator GlobalDescriptorAllocator;
 
+
+
 	public:
 		VkDescriptorSet DrawImageDescriptors;
 		VkDescriptorSetLayout DrawImageDescriptorLayout;
@@ -174,6 +180,8 @@ namespace Nuake
 
 		Ref<VkSceneRenderer> SceneRenderer;
 
+
+
 	public:
 		static VkRenderer& Get()
 		{
@@ -192,6 +200,9 @@ namespace Nuake
 		Ref<VulkanImage> DepthImage;
 		VkExtent2D DrawExtent;
 
+		std::map<UUID, Ref<Viewport>> Viewports;
+		std::map<Ref<Scene>, std::vector<UUID>> SceneViewports;
+
 	public:
 		void Initialize();
 		void CleanUp();
@@ -210,6 +221,15 @@ namespace Nuake
 		void DrawScene(RenderContext ctx);
 		void InitImgui();
 
+		Ref<Viewport> CreateViewport(const UUID& viewId, const Vector2& size);
+		void RemoveViewport(const UUID& viewportId);
+
+		void RegisterSceneViewport(const Ref<Scene>& scene, const UUID& viewportId);
+		void UnRegisterSceneViewport(const Ref<Scene>& scene, const UUID& viewportId);
+
+		void PrepareSceneData(const Ref<Scene>& scene);
+		void DrawSceneViewport(const Ref<Scene>& scene, const UUID& viewportId);
+
 		void BeginScene(const UUID& camera);
 		bool Draw();
 		void EndDraw();