render pass

engine/src/engine/app.cpp

@@ -9,8 +9,8 @@ namespace engineapi {
 	App::App(const string& path)
 	{
 		const char* name = "zengine";
-		RenderAPI::MakeInstance();
+		_RenderAPI = RenderAPI::MakeInstance();
-		Window::MakeInstance(3, 640, 720, name);
+		_Window = Window::MakeInstance(3, 640, 720, name);
 		auto scene_manager = new SceneManager();
 		scene_manager->LoadScene(path);
 		new AssetManager();
@@ -29,6 +29,11 @@ namespace engineapi {
 			auto actor = ActorMesh::New(property);
 		}
 	}
+	App::~App()
+	{
+		delete _Window;
+		delete _RenderAPI;
+	}
 	void App::Launch()
 	{
 		while (true) {
@@ -38,13 +43,13 @@ namespace engineapi {
 	}
 	void App::Update()
 	{
-		SceneManager::GetSingletonPtr()->GetCurScene()->Update();
+		SceneManager::GetSingletonPtr()->Update();
 	}
 	void App::Render()
 	{
 		RenderAPI::GetSingletonPtr()->BeginFrame();
 
-		SceneManager::GetSingletonPtr()->GetCurScene()->Render();
+		SceneManager::GetSingletonPtr()->Render();
 
 		RenderAPI::GetSingletonPtr()->EndFrame();
 	}

engine/src/engine/app.h

@@ -3,11 +3,15 @@
 using std::string;
 namespace engineapi
 {
+	class RenderAPI;
+	class Window;
 	class App {
-	protected:
+	public:
-
+		RenderAPI* _RenderAPI{nullptr};
+		Window* _Window{ nullptr };
 	public:
 		App(const string& path);
+		~App();
 		void Launch();
 	public:
 		void Update();

engine/src/engine/object/camera/camera.cpp

@@ -0,0 +1,10 @@
+#include "camera.h"
+
+namespace engineapi {
+	Camera::Camera()
+	{
+	}
+	Camera::~Camera()
+	{
+	}
+}

engine/src/engine/object/camera/camera.h

@@ -0,0 +1,9 @@
+#pragma once
+namespace engineapi {
+	class Camera {
+	protected:
+	public:
+		Camera();
+		~Camera();
+	};
+};

engine/src/engine/object/component/mesh_render.h

@@ -0,0 +1,8 @@
+#pragma once
+#include "../component.h"
+
+namespace engineapi {
+	class MeshRenderer : public Component {
+
+	};
+};

engine/src/engine/object/scene/scene_manager.cpp

@@ -58,6 +58,16 @@ namespace engineapi {
 
 	}
 
+	void SceneManager::Render()
+	{
+		curScene->scene->Render();
+	}
+
+	void SceneManager::Update()
+	{
+		curScene->scene->Update();
+	}
+
 	Scene* SceneManager::GetCurScene()
 	{
 		return curScene->scene;

engine/src/engine/object/scene/scene_manager.h

@@ -19,6 +19,8 @@ namespace engineapi {
 		void DeleteScene(const string& name);
 		void DeleteAllScene();
 		void ReloadScene();
+		void Render();
+		void Update();
 		Scene* GetCurScene();
 		SceneInfo* GetSceneInfo(const string& name);
 	};

engine/src/engine/render/asset/material.h

@@ -1,3 +1,4 @@
+#pragma once
 #include "asset_render.h"
 
 namespace engineapi {

engine/src/engine/render/asset/texture.h

@@ -1,3 +1,4 @@
+#pragma once
 #include "asset_render.h"
 
 namespace engineapi {

engine/src/engine/render/pass/renderpass.h

@@ -0,0 +1,37 @@
+#pragma once
+#include "../asset/material.h"
+#include "../asset/mesh.h"
+#include "../asset/texture.h"
+namespace engineapi {
+	enum RenderPassType
+	{
+		ZX_RENDER_PASS_SHADOW_GENERATION,
+		ZX_RENDER_PASS_FORWARD_RENDERING,
+		ZX_RENDER_PASS_RAY_TRACING,
+		ZX_RENDER_PASS_AFTER_EFFECT_RENDERING,
+		ZX_RENDER_PASS_UI_RENDERING,
+		ZX_RENDER_PASS_COUNT
+	};
+	class Camera;
+	class RenderPass
+	{
+	public:
+		RenderPass() {};
+		~RenderPass() {};
+
+		virtual void Render(Camera* camera) = 0;
+	};
+	class RenderStateSetting
+	{
+	public:
+		bool depthTest = true;
+		bool depthWrite = true;
+		BlendFactor srcFactor = BlendFactor::SRC_ALPHA;
+		BlendFactor dstFactor = BlendFactor::ONE_MINUS_SRC_ALPHA;
+		Vector4 clearColor = Vector4();
+		float clearDepth = 1.0f;
+		uint32_t clearStencil = 0;
+		bool faceCull = true;
+		FaceCullOption faceCullOption = FaceCullOption::Back;
+	};
+};

engine/src/engine/render/pass/renderpass_forward.cpp

@@ -0,0 +1,33 @@
+#include "renderpass_forward.h"
+#include "../renderapi.h"
+namespace engineapi {
+	RenderPassForwardRendering::RenderPassForwardRendering()
+	{
+		skyBox = nullptr;
+		skyBoxMaterial = nullptr;
+
+		skyBoxRenderState = new RenderStateSetting();
+		skyBoxRenderState->depthTest = false;
+		skyBoxRenderState->depthWrite = false;
+
+		opaqueRenderState = new RenderStateSetting();
+
+		transparentRenderState = new RenderStateSetting();
+		transparentRenderState->depthWrite = false;
+
+		//drawCommandID = RenderAPI::GetSingletonPtr()->AllocateDrawCommand(CommandType::ForwardRendering);
+	}
+	RenderPassForwardRendering::~RenderPassForwardRendering()
+	{
+	}
+	void RenderPassForwardRendering::Render(Camera* camera)
+	{
+	}
+	void RenderPassForwardRendering::RenderSkyBox(Camera* camera)
+	{
+	}
+	void RenderPassForwardRendering::RenderBatches(const map<uint32_t, vector<MeshRenderer*>>& batchs)
+	{
+
+	}
+}

engine/src/engine/render/pass/renderpass_forward.h

@@ -0,0 +1,24 @@
+#pragma once
+#include "renderpass.h"
+#include "object/component/mesh_render.h"
+namespace engineapi {
+	class RenderPassForwardRendering : public RenderPass
+	{
+	public:
+		RenderPassForwardRendering();
+		~RenderPassForwardRendering();
+
+		virtual void Render(Camera* camera);
+
+	private:
+		uint32_t drawCommandID = 0;
+		Mesh* skyBox;
+		Material* skyBoxMaterial;
+		RenderStateSetting* skyBoxRenderState;
+		RenderStateSetting* opaqueRenderState;
+		RenderStateSetting* transparentRenderState;
+
+		void RenderSkyBox(Camera* camera);
+		void RenderBatches(const map<uint32_t, vector<MeshRenderer*>>& batchs);
+	};
+}

engine/src/engine/render/renderapi.cpp

@@ -1,13 +1,34 @@
 #include "renderapi.h"
+#include "pass/renderpass.h"
+#include "pass/renderpass_forward.h"
 #ifdef VULKAN_API
 #include "vulkanapi/vulkanapi.h"
 #endif // VULKAN_API
 namespace engineapi {
+	RenderAPI::RenderAPI()
+	{
+		mAllPasses.resize(ZX_RENDER_PASS_COUNT);
 
-	void RenderAPI::MakeInstance()
+		//mAllPasses[ZX_RENDER_PASS_SHADOW_GENERATION] = new RenderPassShadowGeneration();
+		mAllPasses[ZX_RENDER_PASS_FORWARD_RENDERING] = new RenderPassForwardRendering();
+		//mAllPasses[ZX_RENDER_PASS_RAY_TRACING] = new RenderPassRayTracing();
+		//mAllPasses[ZX_RENDER_PASS_AFTER_EFFECT_RENDERING] = new RenderPassAfterEffectRendering();
+		//mAllPasses[ZX_RENDER_PASS_UI_RENDERING] = new RenderPassUIRendering();
+
+		SetUpRenderPasses();
+	}
+	void RenderAPI::SetUpRenderPasses()
+	{
+		mCurPasses.clear();
+		//mCurPasses.push_back(mAllPasses[ZX_RENDER_PASS_SHADOW_GENERATION]);
+		mCurPasses.push_back(mAllPasses[ZX_RENDER_PASS_FORWARD_RENDERING]);
+		//mCurPasses.push_back(mAllPasses[ZX_RENDER_PASS_AFTER_EFFECT_RENDERING]);
+		//mCurPasses.push_back(mAllPasses[ZX_RENDER_PASS_UI_RENDERING]);
+	}
+	RenderAPI* RenderAPI::MakeInstance()
 	{
 #ifdef VULKAN_API
-		new RenderVulkanAPI();
+		return new RenderVulkanAPI();
 #endif
 	}
 }

engine/src/engine/render/renderapi.h

@@ -4,14 +4,23 @@
 namespace engineapi
 {
 	class Mesh;
+	class Camera;
+	class RenderPass;
 	class RenderAPI : public Singleton<RenderAPI>
 	{
+	protected:
+		vector<RenderPass*> mCurPasses;
+		vector<RenderPass*> mAllPasses;
+	public:
+		RenderAPI();
+		virtual void SetUpRenderPasses();
 	public:
 		virtual void BeginFrame() = 0;
+		virtual void Render(Camera& camera) = 0;
 		virtual void EndFrame() = 0;
 		virtual void SetStaticMesh(Mesh* mesh) = 0;
 	public:
-		static void MakeInstance();
+		static RenderAPI* MakeInstance();
 	};
 }
 template<>

engine/src/engine/render/window.cpp

@@ -4,10 +4,10 @@
 #endif // VULKAN_API
 namespace engineapi {
 	Window::WindowClass Window::WindowClass::wndClass;
-	void Window::MakeInstance(int frames, uint32_t width, uint32_t height, const char* title)
+	Window* Window::MakeInstance(int frames, uint32_t width, uint32_t height, const char* title)
 	{
 #ifdef VULKAN_API
-		new vulkanapi::Window(frames, width, height, title);
+		return new vulkanapi::Window(frames, width, height, title);
 #endif
 	}
 	Window::WindowClass::WindowClass() noexcept

engine/src/engine/render/window.h

@@ -35,7 +35,7 @@ namespace engineapi {
 			return mPtr;
 		}
 		static bool ProcessMessages(int& code);
-		static void MakeInstance(int frames, uint32_t width, uint32_t height, const char* title);
+		static Window* MakeInstance(int frames, uint32_t width, uint32_t height, const char* title);
 	};
 };
 template<>

engine/src/engine/vulkanapi/pass/forwardpass.h

@@ -1,9 +1,7 @@
 #pragma once
-#include "../vulkan.h"
 #include "gbuffer.h"
 namespace vulkanapi {
 	class RenderPass;
-	class Device;
 	//class MaterialCache;
 	class ForwardPass {
 	protected:

engine/src/engine/vulkanapi/vulkanapi.cpp

@@ -4,6 +4,7 @@
 #include "wrapper/commandbuffer.h"
 #include "thread/worker.h"
 #include "render/asset/mesh.h"
+#include "object/camera/camera.h"
 namespace engineapi {
 	RenderVulkanAPI::RenderVulkanAPI()
 		:backend("vulkan")
@@ -13,6 +14,10 @@ namespace engineapi {
 	void RenderVulkanAPI::BeginFrame()
 	{
 
+	}
+	void RenderVulkanAPI::Render(Camera& camera)
+	{
+
 	}
 	void RenderVulkanAPI::EndFrame()
 	{

engine/src/engine/vulkanapi/vulkanapi.h

@@ -14,6 +14,7 @@ namespace engineapi
 		RenderVulkanAPI();
 
 		virtual void BeginFrame()override;
+		virtual void Render(Camera& camera)override;
 		virtual void EndFrame()override;
 		virtual void SetStaticMesh(Mesh* mesh)override;
 	public: