Official v1.0

Engine/Engine.cpp

@@ -4,16 +4,14 @@ Engine::Engine()
 {
 	m_last_time = std::chrono::high_resolution_clock::now();
 
-	mp_camera = std::make_shared<Camera>();
-	mp_player = std::make_shared<Player>(mp_camera);
+	mp_main_camera = std::make_shared<Camera>();
+	mp_controller = std::make_shared<Controller>(mp_main_camera);
 	mp_config = std::make_shared<Config>();
 
-	mp_window = std::make_unique<Window>(mp_config, *mp_player.get());
+	mp_window = std::make_unique<Window>(mp_config, *mp_controller.get());
 
 	mp_renderer = std::make_shared<Renderer>(mp_window->getHandle(), mp_config->width, mp_config->height);
 
-
-	mp_renderer->createNewPipeline(base_pipeline);
 	mp_renderer->createDepthResources();
 	mp_renderer->createFramebuffer();
 
@@ -25,13 +23,13 @@ Engine::~Engine()
 {
 	vkDeviceWaitIdle(mp_renderer->getDevice());
 
-	mp_renderer->cleanSwapchain(std::make_shared<Pipeline>(base_pipeline));
+	mp_renderer->cleanSwapchain();
 
 	for (size_t i = 0; i < mp_scene->getObjects().size(); i++)
 	{
 		for (size_t t = 0; t < mp_scene->getObjects()[i]->getMeshesCount(); t++)
 		{
-			mp_scene->getObjects()[i]->getMesh(t).getMaterial()->destroyTexture();
+			mp_scene->getObjects()[i]->getMesh(t).getMaterial()->DestroyTexture();
 			mp_scene->getObjects()[i]->getMesh(t).destroyMesh();
 		}
 
@@ -58,9 +56,53 @@ void Engine::registerGameObject(std::shared_ptr<GameObject> gameobject)
 	mp_scene->addGameObject(gameobject);
 }
 
-std::shared_ptr<Renderer> Engine::getRenderEngine()
+const std::shared_ptr<Material> Engine::CreateMaterial(const TSHADER shader)
+{
+	return std::make_shared<Material>(shader, mp_renderer);
+}
+
+const std::shared_ptr<Material> Engine::CreateMaterial(const TSHADER shader, const std::string& texture_file)
+{
+	std::shared_ptr<Material> mat = std::make_shared<Material>(shader, mp_renderer);
+	mat->LoadTexture(texture_file);
+	return mat;
+}
+
+const std::shared_ptr<GameObject> Engine::CreateGameObject()
+{
+	return std::make_shared<GameObject>(mp_renderer);
+}
+
+const std::shared_ptr<GameObject> Engine::CreateGameObject(const std::string& object_file)
+{
+	std::shared_ptr<GameObject> go = std::make_shared<GameObject>(mp_renderer);
+	go->loadMesh(object_file);
+	return go;
+}
+
+void Engine::BindKeyToFunc(const int& key, std::function<void()>& func, const ActionType& type)
+{
+	mp_controller->SetKeyToFunc(key, func, type);
+}
+
+const std::shared_ptr<Camera> Engine::GetMainCamera()
+{
+	return mp_main_camera;
+}
+
+void Engine::SetWireframeMode()
+{
+	mp_renderer->SetPolygonFillingMode(VK_POLYGON_MODE_LINE);
+}
+
+void Engine::SetPointMode()
+{
+	mp_renderer->SetPolygonFillingMode(VK_POLYGON_MODE_POINT);
+}
+
+void Engine::SetFillMode()
 {
-	return mp_renderer;
+	mp_renderer->SetPolygonFillingMode(VK_POLYGON_MODE_FILL);
 }
 
 const bool& Engine::shouldClose()
@@ -75,28 +117,27 @@ void Engine::update()
 	std::chrono::steady_clock::time_point current_time = std::chrono::high_resolution_clock::now();
 	float delta_time = std::chrono::duration<float, std::chrono::seconds::period>(current_time - m_last_time).count();
 
-	mp_player->setDeltaTime(delta_time);
-	mp_player->updatePosition();
+	mp_controller->Update(delta_time);
 
 	m_last_time = current_time;
 
-	const int frame = mp_renderer->getFrameIndex();
-	if (mp_scene->isUpdate(frame))
+	const int32_t frame = mp_renderer->AcquireNextImage();
+	if (frame != -1 && (mp_scene->isUpdate(frame) || mp_renderer->IsUpdated(frame)))
 	{
-		mp_renderer->beginRecordCommandBuffers(mp_renderer->getCommandBuffer(frame), mp_renderer->getFrameBuffer(frame), base_pipeline);
-
-		mp_scene->render(base_pipeline, mp_renderer->getCommandBuffer(frame), frame);
-
+		mp_renderer->beginRecordCommandBuffers(mp_renderer->getCommandBuffer(frame), mp_renderer->getFrameBuffer(frame));
+		mp_scene->render(mp_renderer->getCommandBuffer(frame), frame);
 		mp_renderer->endRecordCommandBuffers(mp_renderer->getCommandBuffer(frame));
+
+		mp_renderer->SetUpdate(frame);
 	}
 
-	mp_camera->updateUBO(static_cast<float>(mp_config->width), static_cast<float>(mp_config->height));
-	mp_scene->updateUBO(mp_camera, mp_renderer);
+	mp_main_camera->UpdateUBO(static_cast<float>(mp_config->width), static_cast<float>(mp_config->height));
+	mp_scene->updateUBO(mp_main_camera, mp_renderer);
 
 	//std::this_thread::sleep_for(std::chrono::nanoseconds(500));//delete when not streaming
 }
 
 void Engine::draw()
 {
-	mp_renderer->draw(base_pipeline);
+	mp_renderer->draw();
 }

Engine/Engine.h

@@ -1,10 +1,11 @@
 #ifndef _ENGINE_H
 #define _ENGINE_H
 
-#include "GameObject.h"
-#include "Scene.h"
 #include "Window.h"
 
+#include "world/GameObject.h"
+#include "world/Scene.h"
+
 class Engine
 {
 public:
@@ -18,7 +19,24 @@ class Engine
 	void setScene(std::shared_ptr<Scene> p_scene);
 	void registerGameObject(std::shared_ptr<GameObject> gameobject);
 
-	std::shared_ptr<Renderer> getRenderEngine();
+	// CREATE MATERIAL
+	const std::shared_ptr<Material> CreateMaterial(const TSHADER shader);
+	const std::shared_ptr<Material> CreateMaterial(const TSHADER shader, const std::string& texture_file);
+
+	// CREATE GAMEOBJECT
+	const std::shared_ptr<GameObject> CreateGameObject();
+	const std::shared_ptr<GameObject> CreateGameObject(const std::string& object_file);
+
+	// CONTROLLER
+	void BindKeyToFunc(const int& key, std::function<void()>& func, const ActionType& type = ActionType::R3D_PRESS);
+
+	// CAMERA
+	const std::shared_ptr<Camera> GetMainCamera();
+
+	// VIEWING
+	void SetWireframeMode();
+	void SetPointMode();
+	void SetFillMode();
 
 	const bool& shouldClose();
 
@@ -28,11 +46,10 @@ class Engine
 	std::shared_ptr<Renderer> mp_renderer;
 	std::shared_ptr<Scene> mp_scene;
 
-	std::shared_ptr<Camera> mp_camera;
-	std::shared_ptr<Player> mp_player;
+	std::shared_ptr<Camera> mp_main_camera;
+	std::shared_ptr<Controller> mp_controller;
 	std::shared_ptr<Config> mp_config;
-
-	Pipeline base_pipeline;
+
 	std::chrono::steady_clock::time_point m_last_time;
 };