Need to add menu buttons and stuff

Signed-off-by: Dan Printzell <[email protected]>

Author: Vild

docs/States.org

@@ -12,8 +12,8 @@ class World {
 class State {
 +State()
 +getWorld(): World&
-+onEnter(State& prev):
-+onLeave(State& next):
++onEnter(State* prev):
++onLeave(State* next):
 }
 
 class MainMenuState

docs/States.png

@@ -32,6 +32,7 @@
 #include "world/renderpass/textrenderpass.hpp"
 
 #include "state/ingamestate.hpp"
+#include "state/mainmenustate.hpp"
 
 Engine::~Engine() {
 	TTF_Quit();
@@ -77,7 +78,7 @@ int Engine::run(bool vsync) {
 					_height = event.window.data2;
 					_system_resize(_width, _height);
 
-					World& world = _states[getCurrentState()]->getWorld();
+					World& world = getState().getWorld();
 					for (std::unique_ptr<Entity>& entity : world.getEntities()) {
 						CameraComponent* cc = entity->getComponent<CameraComponent>();
 						if (!cc)
@@ -110,6 +111,8 @@ int Engine::run(bool vsync) {
 		_system_tick(delta);
 		ImGui::Render();
 		SDL_GL_SwapWindow(_window);
+		if (!getStatePtr())
+			break;
 	}
 	return 0;
 }
@@ -124,8 +127,12 @@ void Engine::_init(bool vsync) {
 	_hidInput = std::make_shared<HIDInput>();
 	_textFactory = std::make_shared<TextFactory>("assets/fonts/font.png");
 
-	_currentState = std::make_unique<std::type_index>(typeid(InGameState));
+	_currentState = std::make_unique<std::type_index>(std::type_index(typeid(nullptr)));
+
+	_states[std::type_index(typeid(nullptr))] = std::unique_ptr<State>();
 	_states[std::type_index(typeid(InGameState))] = std::make_unique<InGameState>();
+	_states[std::type_index(typeid(MainMenuState))] = std::make_unique<MainMenuState>();
+	setState<MainMenuState>();
 	_setupSystems();
 }
 
@@ -283,7 +290,7 @@ void Engine::_setupSystems() {
 }
 
 void Engine::_system_tick(float delta) {
-	World& world = _states[getCurrentState()]->getWorld();
+	World& world = getState().getWorld();
 	for (const std::unique_ptr<System>& system : _systems)
 		system->update(world, delta);
 }

src/engine.cpp

@@ -44,15 +44,25 @@ class Engine {
 	inline std::vector<std::unique_ptr<System>>& getSystems() { return _systems; }
 
 	template <typename T>
-	inline std::unique_ptr<T>& getState() {
-		return _states[std::type_index(typeid(T))];
+	inline std::unordered_map<std::type_index, std::unique_ptr<State>>& getStates() {
+		return _states;
 	}
 
-	inline const std::type_index getCurrentState() { return *_currentState; }
+	inline State& getState() { return *_states[*_currentState]; }
+	inline State* getStatePtr() { return _states[*_currentState].get(); }
+
+	inline const std::type_index getStateType() { return *_currentState; }
 
 	template <typename T>
-	inline void setCurrentState() {
+	inline void setState() {
+		State* prev = getStatePtr();
 		*_currentState = std::type_index(typeid(T));
+		State* next = getStatePtr();
+		if (next)
+			next->onEnter(prev);
+
+		if (prev)
+			prev->onLeave(next);
 	}
 
 private:

src/engine.hpp

@@ -4,6 +4,7 @@
 #include "../engine.hpp"
 
 #include "../lib/glad.h"
+#include "../lib/imgui.h"
 #include "../gl/shader.hpp"
 
 #include "../world/component/transformcomponent.hpp"
@@ -19,24 +20,22 @@
 InGameState::InGameState() {
 	auto& engine = Engine::getInstance();
 
-	Entity* camera = _world.addEntity(sole::rebuild("f8bb5ea8-e3fb-4ec7-939d-5d70ae3e9d12"), "Camera");
-	Entity* player = _world.addEntity(sole::rebuild("31bcc9bd-78bb-45b7-bb86-1917bcf5df6d"), "Player");
-	Entity* floor = _world.addEntity(sole::rebuild("b056cfea-b2cd-4c91-b921-5b8ee6b286d6"), "Floor");
+	_camera = _world.addEntity(sole::rebuild("f8bb5ea8-e3fb-4ec7-939d-5d70ae3e9d12"), "Camera");
+	_player = _world.addEntity(sole::rebuild("31bcc9bd-78bb-45b7-bb86-1917bcf5df6d"), "Player");
+	_floor = _world.addEntity(sole::rebuild("b056cfea-b2cd-4c91-b921-5b8ee6b286d6"), "Floor");
 
 	{ // Adding Camera
-		camera->addComponent<TransformComponent>();
-		camera->addComponent<CameraComponent>();
-		auto lookAt = camera->addComponent<LookAtComponent>();
-		lookAt->target = player;
-		lookAt->followMode = FollowMode::followByOffset;
-		lookAt->offsetFromTarget = glm::vec3(0, 2.5, -5);
+		_camera->addComponent<TransformComponent>();
+		_camera->addComponent<CameraComponent>();
+		_addLookAt();
+		_camera->registerImGui = &InGameState::_registerImGUI;
 	}
 
 	{ // Adding Player
-		auto transform = player->addComponent<TransformComponent>();
+		auto transform = _player->addComponent<TransformComponent>();
 		transform->scale = glm::vec3(0.01);
 		transform->recalculateMatrix();
-		auto model = player->addComponent<ModelComponent>();
+		auto model = _player->addComponent<ModelComponent>();
 		model->meshData = engine.getMeshLoader()->getMesh("assets/objects/player.fbx");
 		model->meshData->mesh
 			->addBuffer("m",
@@ -53,22 +52,22 @@ InGameState::InGameState() {
 										glBindBuffer(GL_ARRAY_BUFFER, 0);
 									})
 			.finalize();
-		auto particle = player->addComponent<ParticleComponent>();
+		auto particle = _player->addComponent<ParticleComponent>();
 		particle->addEmitter(glm::vec3(0, 1, 0), 1024);
-		player->addComponent<KBMouseInputComponent>();
-		player->addComponent<PhysicsComponent>();
-		auto text = player->addComponent<TextComponent>();
+		_player->addComponent<KBMouseInputComponent>();
+		_player->addComponent<PhysicsComponent>();
+		auto text = _player->addComponent<TextComponent>();
 		text->textRenderer = engine.getTextFactory()->makeRenderer("Hello, My name is Mr. Duck!\x01");
 
 		text->transform.position = glm::vec3(0, 2, 0);
 		text->transform.scale = glm::vec3(100 * 2); // To counteract transform->scale
 		text->transform.recalculateMatrix();
 	}
 
-	{ // Adding Floor
+	{															// Adding Floor
 		constexpr int gridSize = 8; // will be gridSize*gridSize
 
-		auto transform = floor->addComponent<FloorTransformComponent>();
+		auto transform = _floor->addComponent<FloorTransformComponent>();
 		transform->gridSize = gridSize;
 		transform->scale = glm::vec3(1, 0.1, 1);
 		transform->recalculateMatrices();
@@ -115,7 +114,7 @@ InGameState::InGameState() {
 				point[backwards] = std::min(minFloor, point[backwards]);
 			}
 
-		auto model = floor->addComponent<ModelComponent>();
+		auto model = _floor->addComponent<ModelComponent>();
 		model->meshData = engine.getMeshLoader()->getMesh("assets/objects/box.obj");
 		model->meshData->mesh
 			->addBuffer("m",
@@ -157,5 +156,25 @@ InGameState::InGameState() {
 		delete[] topData;
 		delete[] neighborData;
 	}
+}
+
+void InGameState::onEnter(State* prev) {}
+void InGameState::onLeave(State* next) {}
 
+void InGameState::_addLookAt() {
+	auto lookAt = _camera->addComponent<LookAtComponent>();
+	lookAt->target = _player;
+	lookAt->followMode = FollowMode::followByOffset;
+	lookAt->offsetFromTarget = glm::vec3(0, 2.5, -5);
 }
+
+void InGameState::_registerImGUI(Entity& self, State& state) {
+	static bool follow = true;
+	InGameState& this_ = static_cast<InGameState&>(state);
+	if (ImGui::Checkbox("Follow target", &follow)) {
+		if (follow)
+			this_._addLookAt();
+		else
+			self.removeComponent<LookAtComponent>();
+	}
+}

src/state/ingamestate.cpp

@@ -5,4 +5,16 @@
 class InGameState : public State {
 public:
 	InGameState();
+
+	virtual void onEnter(State* prev);
+	virtual void onLeave(State* next);
+
+private:
+	Entity* _camera;
+	Entity* _player;
+	Entity* _floor;
+
+	void _addLookAt();
+
+	static void _registerImGUI(Entity& self, State& state);
 };

src/state/ingamestate.hpp

@@ -0,0 +1,28 @@
+#include "mainmenustate.hpp"
+
+#include "../world/component/transformcomponent.hpp"
+#include "../world/component/cameracomponent.hpp"
+#include "../world/component/particlecomponent.hpp"
+#include "../world/component/textcomponent.hpp"
+#include "../world/component/modelcomponent.hpp"
+
+MainMenuState::MainMenuState() {
+	_camera = _world.addEntity(sole::uuid4(), "Camera");
+	_title = _world.addEntity(sole::uuid4(), "Title");
+	_play = _world.addEntity(sole::uuid4(), "Play");
+	_quit = _world.addEntity(sole::uuid4(), "Quit");
+
+	{
+		_camera->addComponent<TransformComponent>();
+		_camera->addComponent<CameraComponent>();
+	}
+
+	{ auto transform = _title->addComponent<TransformComponent>(); }
+
+	{ auto transform = _play->addComponent<TransformComponent>(); }
+
+	{ auto transform = _quit->addComponent<TransformComponent>(); }
+}
+
+void MainMenuState::onEnter(State* prev) {}
+void MainMenuState::onLeave(State* next) {}

src/state/mainmenustate.cpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "state.hpp"
+
+class MainMenuState : public State {
+public:
+	MainMenuState();
+
+	virtual void onEnter(State* prev);
+	virtual void onLeave(State* next);
+
+private:
+	Entity* _camera;
+	Entity* _title;
+	Entity* _play;
+	Entity* _quit;
+};

src/state/mainmenustate.hpp

@@ -5,8 +5,8 @@
 
 class State {
 public:
-	//virtual void onEnter(State& prev);
-	//virtual void onLeave(State& next);
+	virtual void onEnter(State* prev) = 0;
+	virtual void onLeave(State* next) = 0;
 
 	inline World& getWorld() { return _world; }
 

src/state/state.hpp

@@ -13,6 +13,7 @@
 // Kinda like GameObject - https://docs.unity3d.com/ScriptReference/GameObject.html
 
 class World;
+class State;
 
 class Entity {
 public:
@@ -48,25 +49,26 @@ class Entity {
 
 	template <typename T, typename std::enable_if<std::is_base_of<IComponent, T>::value>::type* = nullptr>
 	void removeComponent() {
-		auto list = T::getActiveComponents();
-		for (auto it = list.begin(); it != list.end(); it++) {
-			auto com = std::dynamic_pointer_cast<T>(*it);
+		for (auto it = _components.begin(); it != _components.end(); it++) {
+			T* com = dynamic_cast<T*>(*it);
 			if (!com)
 				continue;
-			list.erase(it);
+			_components.erase(it);
 			break;
 		}
 
-		for (auto it = _components.begin(); it != _components.end(); it++) {
-			auto com = dynamic_cast<T*>(*it);
+		auto& list = T::getActiveComponents();
+		for (auto it = list.begin(); it != list.end(); it++) {
+			T* com = dynamic_cast<T*>(it->get());
 			if (!com)
 				continue;
-			_components.erase(it);
+			list.erase(it);
 			break;
 		}
 	}
 
-	void (*registerImGui)(Entity* entity) = nullptr;
+	typedef void (*registerImGui_f)(Entity& self, State& state);
+	registerImGui_f registerImGui = nullptr;
 
 	inline sole::uuid& getUUID() { return _uuid; }
 	inline std::string& getName() { return _name; }