Viewport controls

src/Editor/CMakeLists.txt

@@ -1,3 +1,6 @@
+add_subdirectory(System/)
+add_subdirectory(Window/)
+
 target_sources(Editor
     PRIVATE
         main.cpp)

src/Editor/System/CMakeLists.txt

@@ -0,0 +1,2 @@
+target_sources(Editor
+    PRIVATE)

src/Editor/Window/CMakeLists.txt

@@ -0,0 +1,8 @@
+target_sources(Editor
+    PRIVATE
+        InspectorView.h
+        InspectorView.cpp
+        SceneView.h
+        SceneView.cpp
+        ViewportControl.h
+        ViewportControl.cpp)

src/Editor/Window/InspectorView.cpp

@@ -0,0 +1,77 @@
+#include "InspectorView.h"
+#include "Graphics/Graphics.h"
+#include "Actor/Actor.h"
+#include "Window/Window.h"
+#include "Asset/AssetRegistry.h"
+#include "UI/System.h"
+
+using namespace Seele;
+
+InspectorView::InspectorView(Gfx::PGraphics graphics, PWindow window, const ViewportCreateInfo &createInfo) 
+    : View(graphics, window, createInfo, "InspectorView")
+    , renderGraph(RenderGraphBuilder::build(
+        UIPass(graphics),
+        TextPass(graphics)
+    ))
+    , uiSystem(new UI::System())
+{
+    AssetRegistry::importFile("./fonts/Calibri.ttf");
+    renderGraph.updateViewport(viewport);
+    uiSystem->updateViewport(viewport);
+}
+
+InspectorView::~InspectorView() 
+{
+}
+
+void InspectorView::beginUpdate() 
+{
+    //co_return;
+}
+
+void InspectorView::update() 
+{
+    //co_return; 
+}
+
+void InspectorView::commitUpdate() 
+{
+}
+
+void InspectorView::prepareRender() 
+{
+    renderGraph.updatePassData(
+        uiSystem->getUIPassData(),
+        uiSystem->getTextPassData()
+    );
+}
+
+void InspectorView::render() 
+{
+    renderGraph.render(uiSystem->getVirtualCamera());
+}
+
+void InspectorView::keyCallback(KeyCode, InputAction, KeyModifier) 
+{
+    
+}
+
+void InspectorView::mouseMoveCallback(double, double) 
+{
+    
+}
+
+void InspectorView::mouseButtonCallback(MouseButton, InputAction, KeyModifier) 
+{
+    
+}
+
+void InspectorView::scrollCallback(double, double) 
+{
+    
+}
+
+void InspectorView::fileCallback(int, const char**) 
+{
+    
+}

src/Editor/Window/InspectorView.h

@@ -0,0 +1,42 @@
+#pragma once
+#include "Window/View.h"
+#include "Graphics/RenderPass/RenderGraph.h"
+#include "Graphics/RenderPass/UIPass.h"
+#include "Graphics/RenderPass/TextPass.h"
+#include "UI/Elements/Panel.h"
+
+namespace Seele
+{
+DECLARE_REF(Actor)
+class InspectorView : public View
+{
+public:
+    InspectorView(Gfx::PGraphics graphics, PWindow window, const ViewportCreateInfo &createInfo);
+    virtual ~InspectorView();
+
+    virtual void beginUpdate() override;
+	virtual void update() override;
+	virtual void commitUpdate() override;
+    
+    virtual void prepareRender() override;
+    virtual void render() override;
+    void selectActor();
+protected:
+    RenderGraph<
+        UIPass,
+        TextPass> renderGraph;
+    
+    UIPassData uiPassData;
+    TextPassData textPassData;
+
+    UI::PSystem uiSystem;
+    PActor selectedActor;
+    
+	virtual void keyCallback(KeyCode code, InputAction action, KeyModifier modifier) override;
+	virtual void mouseMoveCallback(double xPos, double yPos) override;
+	virtual void mouseButtonCallback(MouseButton button, InputAction action, KeyModifier modifier) override;
+	virtual void scrollCallback(double xOffset, double yOffset) override;
+	virtual void fileCallback(int count, const char** paths) override;
+};
+DEFINE_REF(InspectorView)
+} // namespace Seele

src/Editor/Window/SceneView.cpp

@@ -0,0 +1,108 @@
+#include "SceneView.h"
+#include "Scene/Scene.h"
+#include "Window/Window.h"
+#include "Graphics/Mesh.h"
+#include "Graphics/Graphics.h"
+#include "Asset/MeshAsset.h"
+#include "Asset/AssetRegistry.h"
+#include "Actor/CameraActor.h"
+#include "Component/Camera.h"
+#include "Component/StaticMesh.h"
+
+using namespace Seele;
+using namespace Seele::Editor;
+
+SceneView::SceneView(Gfx::PGraphics graphics, PWindow owner, const ViewportCreateInfo &createInfo)
+    : View(graphics, owner, createInfo, "SceneView")
+    , scene(new Scene(graphics))
+    , renderGraph(RenderGraphBuilder::build(
+        DepthPrepass(graphics),
+        LightCullingPass(graphics),
+        BasePass(graphics)
+    ))
+    , cameraSystem(createInfo.dimensions, Math::Vector(0, 0, 10))
+{
+    AssetRegistry::importFile("C:\\Users\\Dynamitos\\TestSeeleProject\\Assets\\Ayaka\\Avatar_Girl_Sword_Ayaka_Tex_Body_Diffuse.png");
+    AssetRegistry::importFile("C:\\Users\\Dynamitos\\TestSeeleProject\\Assets\\Ayaka\\Avatar_Girl_Sword_Ayaka_Tex_Body_Lightmap.png");
+    AssetRegistry::importFile("C:\\Users\\Dynamitos\\TestSeeleProject\\Assets\\Ayaka\\Avatar_Girl_Sword_Ayaka_Tex_Face_Diffuse.png");
+    AssetRegistry::importFile("C:\\Users\\Dynamitos\\TestSeeleProject\\Assets\\Ayaka\\Avatar_Girl_Sword_Ayaka_Tex_Hair_Diffuse.png");
+    AssetRegistry::importFile("C:\\Users\\Dynamitos\\TestSeeleProject\\Assets\\Ayaka\\Avatar_Girl_Sword_Ayaka_Tex_Hair_Lightmap.png");
+    AssetRegistry::importFile("C:\\Users\\Dynamitos\\TestSeeleProject\\Assets\\Ayaka\\Avatar_Girl_Tex_FaceLightmap.png");
+    AssetRegistry::importFile("C:\\Users\\Dynamitos\\TestSeeleProject\\Assets\\Ayaka\\Ayaka.fbx");
+    auto meshAsset = AssetRegistry::findMesh("Ayaka");
+    for(auto mesh : meshAsset->getMeshes())
+    {
+        PActor actor = new Actor(scene);
+        actor->attachComponent<Component::StaticMesh>(mesh->vertexInput, mesh->indexBuffer, mesh->referencedMaterial);
+    }
+
+    //AssetRegistry::importFile("D:\\Private\\Programming\\Unreal Engine\\Assets\\Ely\\Ely.fbx");
+    //AssetRegistry::importFile("D:\\Private\\Programming\\Unreal Engine\\Assets\\Cube\\cube.obj");
+    AssetRegistry::importFile("D:\\Private\\Programming\\Unreal Engine\\Assets\\Plane\\plane.fbx");
+    
+    cameraSystem.update(viewportCamera, static_cast<float>(Gfx::currentFrameDelta));
+    
+    renderGraph.updateViewport(viewport);
+}
+
+SceneView::~SceneView()
+{
+}
+
+void SceneView::beginUpdate() 
+{
+    scene->beginUpdate(Gfx::currentFrameDelta);
+    //co_return;
+}
+
+void SceneView::update() 
+{
+    cameraSystem.update(viewportCamera, static_cast<float>(Gfx::currentFrameDelta));
+    scene->commitUpdate();
+    //co_return;
+}
+
+void SceneView::commitUpdate() 
+{
+    depthPrepassData.staticDrawList = scene->getStaticMeshes();
+    lightCullingPassData.lightEnv = scene->getLightBuffer();
+    basePassData.staticDrawList = scene->getStaticMeshes();
+}
+
+void SceneView::prepareRender() 
+{
+    renderGraph.updatePassData(depthPrepassData, lightCullingPassData, basePassData);
+}
+
+void SceneView::render() 
+{
+    renderGraph.render(viewportCamera);
+}
+
+static float cameraSpeed = 1;
+
+void SceneView::keyCallback(KeyCode code, InputAction action, KeyModifier)
+{
+    cameraSystem.keyCallback(code, action);
+}
+
+static bool mouseDown = false;
+
+void SceneView::mouseMoveCallback(double xPos, double yPos) 
+{
+    cameraSystem.mouseMoveCallback(xPos, yPos);
+}
+
+void SceneView::mouseButtonCallback(MouseButton button, InputAction action, KeyModifier) 
+{
+    cameraSystem.mouseButtonCallback(button, action);
+}
+
+void SceneView::scrollCallback(double, double) 
+{
+}
+
+void SceneView::fileCallback(int, const char**) 
+{
+    
+}

src/Editor/Window/SceneView.h

@@ -0,0 +1,53 @@
+#pragma once
+#include <thread_pool/thread_pool.h>
+#include "Window/View.h"
+#include "Graphics/RenderPass/DepthPrepass.h"
+#include "Graphics/RenderPass/LightCullingPass.h"
+#include "Graphics/RenderPass/BasePass.h"
+#include "ViewportControl.h"
+
+namespace Seele
+{
+DECLARE_REF(Scene)
+namespace Editor
+{
+
+class SceneView : public View
+{
+public:
+	SceneView(Gfx::PGraphics graphics, PWindow owner, const ViewportCreateInfo &createInfo);
+	~SceneView();
+
+	virtual void beginUpdate() override;
+	virtual void update() override;
+	virtual void commitUpdate() override;
+
+	virtual void prepareRender() override;
+	virtual void render() override;
+
+	PScene getScene() const { return scene; }
+private:
+	PScene scene;
+	Component::Camera viewportCamera;
+	
+	RenderGraph<
+		DepthPrepass,
+		LightCullingPass,
+		BasePass> renderGraph;
+
+	DepthPrepassData depthPrepassData;
+	LightCullingPassData lightCullingPassData;
+	BasePassData basePassData;
+
+	dp::thread_pool<> pool;
+	ViewportControl cameraSystem;
+
+	virtual void keyCallback(KeyCode code, InputAction action, KeyModifier modifier) override;
+	virtual void mouseMoveCallback(double xPos, double yPos) override;
+	virtual void mouseButtonCallback(MouseButton button, InputAction action, KeyModifier modifier) override;
+	virtual void scrollCallback(double xOffset, double yOffset) override;
+	virtual void fileCallback(int count, const char** paths) override;
+};
+DEFINE_REF(SceneView)
+} // namespace Editor
+} // namespace Seele

src/Editor/Window/ViewportControl.cpp

@@ -0,0 +1,102 @@
+#include "ViewportControl.h"
+#include "Component/Camera.h"
+
+using namespace Seele;
+
+ViewportControl::ViewportControl(const Math::URect& viewportDimensions, Math::Vector initialPos)
+    : position(initialPos)
+    , fieldOfView(glm::radians(70.f))
+    , aspectRatio(static_cast<float>(viewportDimensions.size.x) / viewportDimensions.size.y)
+    , yaw(glm::pi<float>()/-2.0f)
+    , pitch(0)
+{
+    std::cout << yaw << " " << pitch << std::endl;
+}
+
+ViewportControl::~ViewportControl()
+{
+    
+}
+
+void ViewportControl::update(Component::Camera& camera, float deltaTime)
+{
+    float cameraMove = deltaTime * 20;
+    if(keys[KeyCode::KEY_LEFT_SHIFT])
+    {
+        cameraMove *= 4;
+    }
+    Math::Vector moveVector = Math::Vector();
+    Math::Vector forward = glm::normalize(springArm);
+    Math::Vector side = glm::cross(Math::Vector(0, 1, 0), forward);
+    if(keys[KeyCode::KEY_W])
+    {
+        moveVector += forward * cameraMove;
+    }
+    if(keys[KeyCode::KEY_S])
+    {
+        moveVector += forward * -cameraMove;
+    }
+    if(keys[KeyCode::KEY_A])
+    {
+        moveVector += side * cameraMove;
+    }
+    if(keys[KeyCode::KEY_D])
+    {
+        moveVector += side * -cameraMove;
+    }
+    if(keys[KeyCode::KEY_E])
+    {
+        moveVector += glm::vec3(0, cameraMove, 0);
+    }      
+    if(keys[KeyCode::KEY_Q])
+    {
+        moveVector += glm::vec3(0, -cameraMove, 0);
+    }
+    position += moveVector;
+    static float lastX, lastY;
+    if(mouse2)
+    {
+        float deltaX = mouseX - lastX;
+        float deltaY = mouseY - lastY;
+        yaw += deltaX / 500.f;
+        pitch -= deltaY / 500.f;
+    }
+    lastX = mouseX;
+    lastY = mouseY;
+    springArm = glm::normalize(
+        Math::Vector(
+            cos(yaw) * cos(pitch),
+            sin(pitch),
+            sin(yaw) * cos(pitch)));
+    camera.viewMatrix = glm::lookAt(position, position + springArm, Math::Vector(0, 1, 0));
+    camera.projectionMatrix = glm::perspective(fieldOfView, aspectRatio, 0.1f, 1000.0f);
+    std::cout << yaw << " " << pitch << std::endl;
+}
+
+void ViewportControl::keyCallback(KeyCode key, InputAction action)
+{
+    keys[static_cast<size_t>(key)] = action != InputAction::RELEASE;
+}
+
+void ViewportControl::mouseMoveCallback(double xPos, double yPos)
+{
+    mouseX = static_cast<float>(xPos);
+    mouseY = static_cast<float>(yPos);
+}
+
+void ViewportControl::mouseButtonCallback(MouseButton button, InputAction action)
+{
+    if(button == MouseButton::MOUSE_BUTTON_1)
+    {
+        mouse1 = action != InputAction::RELEASE;
+    }
+    if(button == MouseButton::MOUSE_BUTTON_2)
+    {
+        mouse2 = action != InputAction::RELEASE;
+    }
+}
+
+void ViewportControl::viewportResize(Math::URect dimensions)
+{
+    aspectRatio = static_cast<float>(dimensions.size.x) / dimensions.size.y;
+}

src/Editor/Window/ViewportControl.h

@@ -0,0 +1,31 @@
+#pragma once
+#include "MinimalEngine.h"
+#include "Math/Vector.h"
+#include "Component/Camera.h"
+
+namespace Seele
+{
+class ViewportControl
+{
+public:
+    ViewportControl(const Math::URect& viewportDimensions, Math::Vector initialPos /*TODO: configurable initial rotations*/);
+    ~ViewportControl();
+    void update(Component::Camera& camera, float deltaTime);
+    void keyCallback(KeyCode key, InputAction action);
+    void mouseMoveCallback(double xPos, double yPos);
+    void mouseButtonCallback(MouseButton button, InputAction action);
+    void viewportResize(Math::URect dimensions);
+private:
+    Math::Vector position;
+    Math::Vector springArm;
+    float fieldOfView;
+    float aspectRatio;
+    StaticArray<bool, static_cast<size_t>(KeyCode::KEY_LAST)> keys;
+    bool mouse1 = false;
+    bool mouse2 = false;
+    float mouseX;
+    float mouseY;
+    float pitch;
+    float yaw;
+};
+} // namespace Seele

src/Editor/main.cpp

@@ -4,6 +4,7 @@
 #include "Asset/AssetRegistry.h"
 
 using namespace Seele;
+using namespace Seele::Editor;
 
 int main()
 {
@@ -18,20 +19,20 @@ int main()
     mainWindowInfo.pixelFormat = Gfx::SE_FORMAT_B8G8R8A8_UNORM;
     auto window = windowManager->addWindow(mainWindowInfo);
     ViewportCreateInfo sceneViewInfo;
-    sceneViewInfo.sizeX = 640;
-    sceneViewInfo.sizeY = 720;
-    sceneViewInfo.offsetX = 0;
-    sceneViewInfo.offsetY = 0;
+    sceneViewInfo.dimensions.size.x = 1280;
+    sceneViewInfo.dimensions.size.y = 720;
+    sceneViewInfo.dimensions.offset.x = 0;
+    sceneViewInfo.dimensions.offset.y = 0;
     PSceneView sceneView = new SceneView(windowManager->getGraphics(), window, sceneViewInfo);
     window->addView(sceneView);
     
     ViewportCreateInfo inspectorViewInfo;
-    inspectorViewInfo.sizeX = 640;
-    inspectorViewInfo.sizeY = 720;
-    inspectorViewInfo.offsetX = 640;
-    inspectorViewInfo.offsetY = 0;
+    inspectorViewInfo.dimensions.size.x = 640;
+    inspectorViewInfo.dimensions.size.y = 720;
+    inspectorViewInfo.dimensions.offset.x = 640;
+    inspectorViewInfo.dimensions.offset.y = 0;
     PInspectorView inspectorView = new InspectorView(windowManager->getGraphics(), window, inspectorViewInfo);
-    window->addView(inspectorView);
+    //window->addView(inspectorView);
     sceneView->setFocused();
 
     window->render();