diff --git a/.gitignore b/.gitignore index c1454f6..5982b10 100755 --- a/.gitignore +++ b/.gitignore @@ -29,5 +29,6 @@ ipch/ [Dd]ebug*/ [Rr]elease*/ Ankh.NoLoad +*.orig !libs/*.lib \ No newline at end of file diff --git a/src/Components/Camera.h b/src/Components/Camera.h index 2cd379d..d30c537 100755 --- a/src/Components/Camera.h +++ b/src/Components/Camera.h @@ -8,8 +8,12 @@ namespace Components struct Camera : Component { - Camera() : FOV(glm::radians(45.f)), NearClip(0.1f), FarClip(100.f) { } + Camera() + : FOV(glm::radians(45.f)) + , NearClip(0.1f) + , FarClip(100.f) { } + std::string Viewport; float FOV; float NearClip; float FarClip; diff --git a/src/Engine.h b/src/Engine.h index 4093d20..25337c4 100755 --- a/src/Engine.h +++ b/src/Engine.h @@ -1,7 +1,10 @@ #include #include +#include "EventBroker.h" #include "Renderer.h" +#include "InputManager.h" +#include "GUI/Frame.h" #include "GameWorld.h" class Engine @@ -9,10 +12,16 @@ class Engine public: Engine(int argc, char* argv[]) { + m_EventBroker = std::make_shared(); + m_Renderer = std::make_shared(); m_Renderer->Initialize(); - m_World = std::make_shared(m_Renderer); + m_InputManager = std::make_shared(m_Renderer->GetWindow(), m_EventBroker); + + m_UIParent = std::make_shared(m_EventBroker); + + m_World = std::make_shared(m_EventBroker, m_Renderer); m_World->Initialize(); m_LastTime = glfwGetTime(); @@ -26,6 +35,7 @@ public: double dt = currentTime - m_LastTime; m_LastTime = currentTime; + m_InputManager->Update(dt); m_World->Update(dt); m_Renderer->Draw(dt); @@ -33,7 +43,10 @@ public: } private: + std::shared_ptr m_EventBroker; std::shared_ptr m_Renderer; + std::shared_ptr m_InputManager; + std::shared_ptr m_UIParent; // TODO: This should ultimately live in GameFrame std::shared_ptr m_World; diff --git a/src/EventBroker.cpp b/src/EventBroker.cpp new file mode 100644 index 0000000..68354c9 --- /dev/null +++ b/src/EventBroker.cpp @@ -0,0 +1,29 @@ +#include "PrecompiledHeader.h" +#include "EventBroker.h" + +BaseEventRelay::~BaseEventRelay() +{ + if (m_Broker != nullptr) + { + m_Broker->Unsubscribe(*this); + } +} + +void EventBroker::Unsubscribe(BaseEventRelay &relay) // ? +{ + auto itpair = m_Subscribers.equal_range(relay.m_TypeName); + for (auto it = itpair.first; it != itpair.second; ++it) + { + if (it->second == &relay) + { + m_Subscribers.erase(it); + break; + } + } +} + +void EventBroker::Subscribe(BaseEventRelay &relay) +{ + relay.m_Broker = this; + m_Subscribers.insert(std::make_pair(relay.m_TypeName, &relay)); +} \ No newline at end of file diff --git a/src/EventBroker.h b/src/EventBroker.h new file mode 100644 index 0000000..f8877e8 --- /dev/null +++ b/src/EventBroker.h @@ -0,0 +1,96 @@ +#ifndef MessageRelay_h__ +#define MessageRelay_h__ + +#include +#include +#include +#include + +#define EVENT_SUBSCRIBE_MEMBER(relay, handler) \ + relay = decltype(relay)(std::bind(handler, this, std::placeholders::_1)); \ + EventBroker->Subscribe(relay); + +struct Event +{ +protected: + Event() { } +}; + +class EventBroker; + +class BaseEventRelay +{ +friend class EventBroker; + +protected: + BaseEventRelay(std::string typeName) + : m_TypeName(typeName), m_Broker(nullptr) { } + ~BaseEventRelay(); + +public: + virtual bool Receive(const Event &event) = 0; + +protected: + std::string m_TypeName; + EventBroker* m_Broker; +}; + +template +class EventRelay : public BaseEventRelay +{ +public: + typedef std::function CallbackType; + + EventRelay() + : m_Callback(nullptr) + , BaseEventRelay(typeid(EventType).name()) { } + EventRelay(CallbackType callback) + : m_Callback(callback) + , BaseEventRelay(typeid(EventType).name()) { } + +protected: + bool Receive(const Event &event) override; + +private: + CallbackType m_Callback; +}; + +template +bool EventRelay::Receive(const Event &event) +{ + if (m_Callback != nullptr) + { + return m_Callback(static_cast(event)); + } + else + { + return false; + } +} + +class EventBroker +{ +template friend class EventRelay; + +public: + template + void Publish(const EventType &event); + void Subscribe(BaseEventRelay &relay); + void Unsubscribe(BaseEventRelay &relay); + +private: + std::unordered_multimap m_Subscribers; +}; + + +template +void EventBroker::Publish(const EventType &event) +{ + auto itpair = m_Subscribers.equal_range(typeid(EventType).name()); + for (auto it = itpair.first; it != itpair.second; ++it) + { + it->second->Receive(event); + } +} + +#endif // MessageRelay_h__ diff --git a/src/Events/BindKey.h b/src/Events/BindKey.h new file mode 100644 index 0000000..a774942 --- /dev/null +++ b/src/Events/BindKey.h @@ -0,0 +1,17 @@ +#ifndef Events_BindKey_h__ +#define Events_BindKey_h__ + +#include "EventBroker.h" + +namespace Events +{ + +struct BindKey : Event +{ + int KeyCode; + std::string Command; +}; + +} + +#endif // Events_BindKey_h__ \ No newline at end of file diff --git a/src/Events/BindMouseButton.h b/src/Events/BindMouseButton.h new file mode 100644 index 0000000..1f46647 --- /dev/null +++ b/src/Events/BindMouseButton.h @@ -0,0 +1,17 @@ +#ifndef Events_BindMouseButton_h__ +#define Events_BindMouseButton_h__ + +#include "EventBroker.h" + +namespace Events +{ + +struct BindMouseButton : Event +{ + int Button; + std::string Command; +}; + +} + +#endif // Events_BindMouseButton_h__ \ No newline at end of file diff --git a/src/Events/InputCommand.h b/src/Events/InputCommand.h new file mode 100644 index 0000000..bd18f6a --- /dev/null +++ b/src/Events/InputCommand.h @@ -0,0 +1,20 @@ +#ifndef Events_InputCommand_h__ +#define Events_InputCommand_h__ + +#include + +#include "EventBroker.h" + +namespace Events +{ + +struct InputCommand : Event +{ + unsigned int PlayerID; + std::string Command; + boost::any Value; +}; + +} + +#endif // Events_InputCommand_h__ \ No newline at end of file diff --git a/src/Events/KeyDown.h b/src/Events/KeyDown.h new file mode 100644 index 0000000..0864862 --- /dev/null +++ b/src/Events/KeyDown.h @@ -0,0 +1,16 @@ +#ifndef Events_KeyDown_h__ +#define Events_KeyDown_h__ + +#include "EventBroker.h" + +namespace Events +{ + +struct KeyDown : Event +{ + int KeyCode; +}; + +} + +#endif // Events_KeyDown_h__ \ No newline at end of file diff --git a/src/Events/KeyUp.h b/src/Events/KeyUp.h new file mode 100644 index 0000000..9fcbf83 --- /dev/null +++ b/src/Events/KeyUp.h @@ -0,0 +1,16 @@ +#ifndef Events_KeyUp_h__ +#define Events_KeyUp_h__ + +#include "EventBroker.h" + +namespace Events +{ + +struct KeyUp : Event +{ + int KeyCode; +}; + +} + +#endif // Events_KeyUp_h__ \ No newline at end of file diff --git a/src/Events/MouseMove.h b/src/Events/MouseMove.h new file mode 100644 index 0000000..2d668a1 --- /dev/null +++ b/src/Events/MouseMove.h @@ -0,0 +1,17 @@ +#ifndef Events_MouseMove_h__ +#define Events_MouseMove_h__ + +#include "EventBroker.h" + +namespace Events +{ + +struct MouseMove : Event +{ + double X, Y; + double DeltaX, DeltaY; +}; + +} + +#endif // Events_MouseMove_h__ \ No newline at end of file diff --git a/src/Events/MousePress.h b/src/Events/MousePress.h new file mode 100644 index 0000000..3116edb --- /dev/null +++ b/src/Events/MousePress.h @@ -0,0 +1,16 @@ +#ifndef Events_MousePress_h__ +#define Events_MousePress_h__ + +#include "EventBroker.h" + +namespace Events +{ + +struct MousePress : Event +{ + int Button; +}; + +} + +#endif // Events_MousePress_h__ \ No newline at end of file diff --git a/src/Events/MouseRelease.h b/src/Events/MouseRelease.h new file mode 100644 index 0000000..7249dcd --- /dev/null +++ b/src/Events/MouseRelease.h @@ -0,0 +1,16 @@ +#ifndef Events_MouseRelease_h__ +#define Events_MouseRelease_h__ + +#include "EventBroker.h" + +namespace Events +{ + +struct MouseRelease : Event +{ + int Button; +}; + +} + +#endif // Events_MouseRelease_h__ \ No newline at end of file diff --git a/src/Events/PlaySound.h b/src/Events/PlaySound.h new file mode 100644 index 0000000..e00ef73 --- /dev/null +++ b/src/Events/PlaySound.h @@ -0,0 +1,17 @@ +#ifndef Event_PlaySound_h__ +#define Event_PlaySound_h__ + +#include "EventBroker.h" + +namespace Events +{ + +struct PlaySound : Event +{ + EntityID Emitter; + std::string Resource; +}; + +} + +#endif // Event_PlaySound_h__ diff --git a/src/GUI/Frame.h b/src/GUI/Frame.h new file mode 100644 index 0000000..19f534a --- /dev/null +++ b/src/GUI/Frame.h @@ -0,0 +1,49 @@ +#ifndef GUI_Frame_h__ +#define GUI_Frame_h__ + +#include + +#include "Util/Rectangle.h" +#include "EventBroker.h" + +namespace GUI +{ + +class Frame : public Rectangle +{ +public: + enum class Anchor + { + Left, + Right, + Top, + Bottom + }; + + // Set up a base frame with an event broker + Frame(std::shared_ptr<::EventBroker> eventBroker) + : EventBroker(eventBroker) + , Rectangle() + { Initialize(); } + // Create a frame as a child + Frame(std::shared_ptr parent) + : Rectangle(static_cast(*parent)) // Clone parent rectangle using copy constructor + { SetParent(parent); Initialize(); } + + virtual void Initialize() { } + std::shared_ptr Parent() const { return m_Parent; } + void SetParent(std::shared_ptr parent) + { + m_Parent = parent; + EventBroker = parent->EventBroker; + } + virtual void Update(double dt) { } + +protected: + std::shared_ptr<::EventBroker> EventBroker; + std::shared_ptr m_Parent; +}; + +} + +#endif // GUI_Frame_h__ diff --git a/src/GUI/Viewport.h b/src/GUI/Viewport.h new file mode 100644 index 0000000..b4568b5 --- /dev/null +++ b/src/GUI/Viewport.h @@ -0,0 +1,21 @@ +#ifndef GUI_Viewport_h__ +#define GUI_Viewport_h__ + +#include + +#include "GUI/Frame.h" + +namespace GUI +{ + +class Viewport : public Frame +{ +public: + // Create a frame as a child + Viewport(std::shared_ptr parent) + : Frame(parent) { } +}; + +} + +#endif // GUI_Viewport_h__ diff --git a/src/GameWorld.cpp b/src/GameWorld.cpp index ad840a9..4744912 100755 --- a/src/GameWorld.cpp +++ b/src/GameWorld.cpp @@ -8,9 +8,31 @@ void GameWorld::Initialize() m_ResourceManager.Preload("Model", "Models/Placeholders/PhysicsTest/Plane.obj"); m_ResourceManager.Preload("Model", "Models/Placeholders/PhysicsTest/ArrowCube.obj"); + BindKey(GLFW_KEY_W, "+forward"); + BindKey(GLFW_KEY_S, "+backward"); + BindKey(GLFW_KEY_A, "+left"); + BindKey(GLFW_KEY_D, "+right"); + BindKey(GLFW_KEY_SPACE, "+up"); + BindKey(GLFW_KEY_LEFT_CONTROL, "+down"); + BindKey(GLFW_KEY_LEFT_ALT, "+slow"); + BindKey(GLFW_KEY_LEFT_SHIFT, "+fast"); + BindMouseButton(GLFW_MOUSE_BUTTON_1, "+attack"); + BindMouseButton(GLFW_MOUSE_BUTTON_2, "+attack2"); + BindMouseButton(GLFW_MOUSE_BUTTON_3, "+attack3"); + RegisterComponents(); - + { + auto camera = CreateEntity(); + auto transform = AddComponent(camera, "Transform"); + transform->Position.z = 20.f; + transform->Position.y = 20.f; + //transform->Orientation = glm::quat(glm::vec3(glm::pi() / 8.f, 0.f, 0.f)); + auto cameraComp = AddComponent(camera, "Camera"); + cameraComp->FarClip = 2000.f; + auto freeSteering = AddComponent(camera, "FreeSteering"); + CommitEntity(camera); + } { @@ -513,9 +535,10 @@ void GameWorld::RegisterComponents() void GameWorld::RegisterSystems() { - m_SystemFactory.Register("TransformSystem", [this]() { return new Systems::TransformSystem(this); }); + m_SystemFactory.Register("TransformSystem", [this]() { return new Systems::TransformSystem(this, m_EventBroker); }); //m_SystemFactory.Register("LevelGenerationSystem", [this]() { return new Systems::LevelGenerationSystem(this); }); - m_SystemFactory.Register("InputSystem", [this]() { return new Systems::InputSystem(this, m_Renderer); }); + m_SystemFactory.Register("InputSystem", [this]() { return new Systems::InputSystem(this, m_EventBroker); }); + m_SystemFactory.Register("DebugSystem", [this]() { return new Systems::DebugSystem(this, m_EventBroker); }); //m_SystemFactory.Register("CollisionSystem", [this]() { return new Systems::CollisionSystem(this); }); ////m_SystemFactory.Register("ParticleSystem", [this]() { return new Systems::ParticleSystem(this); }); //m_SystemFactory.Register("PlayerSystem", [this]() { return new Systems::PlayerSystem(this); }); @@ -523,6 +546,7 @@ void GameWorld::RegisterSystems() m_SystemFactory.Register("SoundSystem", [this]() { return new Systems::SoundSystem(this); }); m_SystemFactory.Register("PhysicsSystem", [this]() { return new Systems::PhysicsSystem(this); }); m_SystemFactory.Register("RenderSystem", [this]() { return new Systems::RenderSystem(this, m_Renderer); }); + m_SystemFactory.Register("FreeSteeringSystem", [this]() { return new Systems::FreeSteeringSystem(this, m_EventBroker); }); } void GameWorld::AddSystems() @@ -530,6 +554,7 @@ void GameWorld::AddSystems() AddSystem("TransformSystem"); //AddSystem("LevelGenerationSystem"); AddSystem("InputSystem"); + AddSystem("DebugSystem"); //AddSystem("CollisionSystem"); ////AddSystem("ParticleSystem"); //AddSystem("PlayerSystem"); @@ -537,4 +562,20 @@ void GameWorld::AddSystems() AddSystem("SoundSystem"); AddSystem("PhysicsSystem"); AddSystem("RenderSystem"); -} \ No newline at end of file +} + +void GameWorld::BindKey(int keyCode, std::string command) +{ + Events::BindKey e; + e.KeyCode = keyCode; + e.Command = command; + m_EventBroker->Publish(e); +} + +void GameWorld::BindMouseButton(int button, std::string command) +{ + Events::BindMouseButton e; + e.Button = button; + e.Command = command; + m_EventBroker->Publish(e); +} diff --git a/src/GameWorld.h b/src/GameWorld.h index cda5836..6c03eb7 100755 --- a/src/GameWorld.h +++ b/src/GameWorld.h @@ -7,6 +7,7 @@ #include "Systems/TransformSystem.h" //#include "Systems/CollisionSystem.h" #include "Systems/InputSystem.h" +#include "Systems/DebugSystem.h" //#include "Systems/LevelGenerationSystem.h" //#include "Systems/ParticleSystem.h" //#include "Systems/PlayerSystem.h" @@ -36,8 +37,8 @@ class GameWorld : public World { public: - GameWorld(std::shared_ptr renderer) - : m_Renderer(renderer), World() { } + GameWorld(std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr renderer) + : World(eventBroker), m_Renderer(renderer) { } void Initialize(); @@ -49,6 +50,9 @@ public: private: std::shared_ptr m_Renderer; + + void BindKey(int keyCode, std::string command); + void BindMouseButton(int button, std::string command); }; #endif // GameWorld_h__ diff --git a/src/InputController.h b/src/InputController.h new file mode 100644 index 0000000..7afd5d5 --- /dev/null +++ b/src/InputController.h @@ -0,0 +1,33 @@ +#ifndef InputController_h__ +#define InputController_h__ + +#include + +#include "EventBroker.h" +#include "Events/InputCommand.h" +#include "Events/MouseMove.h" + +class InputController +{ +public: + InputController(std::shared_ptr<::EventBroker> eventBroker) + : EventBroker(eventBroker) { Initialize(); } + + virtual void Initialize() + { + EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &InputController::OnCommand); + EVENT_SUBSCRIBE_MEMBER(m_EMouseMove, &InputController::OnMouseMove); + } + + virtual bool OnCommand(const Events::InputCommand &event) { return false; } + virtual bool OnMouseMove(const Events::MouseMove &event) { return false; } + +protected: + std::shared_ptr<::EventBroker> EventBroker; + +private: + EventRelay m_EInputCommand; + EventRelay m_EMouseMove; +}; + +#endif // InputController_h__ diff --git a/src/InputManager.cpp b/src/InputManager.cpp new file mode 100644 index 0000000..9f09b1c --- /dev/null +++ b/src/InputManager.cpp @@ -0,0 +1,86 @@ +#include "PrecompiledHeader.h" +#include "InputManager.h" + +void InputManager::Update(double dt) +{ + m_LastKeyState = m_CurrentKeyState; + m_LastMouseState = m_CurrentMouseState; + m_LastMouseX = m_CurrentMouseX; + m_LastMouseY = m_CurrentMouseY; + + // Keyboard input + for (int i = 0; i <= GLFW_KEY_LAST; ++i) + { + m_CurrentKeyState[i] = glfwGetKey(m_GLFWWindow, i); + if (m_CurrentKeyState[i] != m_LastKeyState[i]) + { + // Publish key events + if (m_CurrentKeyState[i]) + { + Events::KeyDown e; + e.KeyCode = i; + m_EventBroker->Publish(e); + } + else + { + Events::KeyUp e; + e.KeyCode = i; + m_EventBroker->Publish(e); + } + } + } + + // Mouse buttons + for (int i = 0; i <= GLFW_MOUSE_BUTTON_LAST; ++i) + { + m_CurrentMouseState[i] = glfwGetMouseButton(m_GLFWWindow, i); + if (m_CurrentMouseState[i] != m_LastMouseState[i]) + { + // Publish mouse button events + if (m_CurrentMouseState[i]) + { + Events::MousePress e; + e.Button = i; + m_EventBroker->Publish(e); + } + else + { + Events::MouseRelease e; + e.Button = i; + m_EventBroker->Publish(e); + } + } + } + + // Cursor position + glfwGetCursorPos(m_GLFWWindow, &m_CurrentMouseX, &m_CurrentMouseY); + m_CurrentMouseDeltaX = m_CurrentMouseX - m_LastMouseX; + m_CurrentMouseDeltaY = m_CurrentMouseY - m_LastMouseY; + if (m_CurrentMouseDeltaX != 0 || m_CurrentMouseDeltaY != 0) + { + // Publish mouse move events + Events::MouseMove e; + e.X = m_CurrentMouseX; + e.Y = m_CurrentMouseY; + e.DeltaX = m_CurrentMouseDeltaX; + e.DeltaY = m_CurrentMouseDeltaY; + m_EventBroker->Publish(e); + } + + // // Lock mouse while holding LMB + // if (m_CurrentMouseState[GLFW_MOUSE_BUTTON_LEFT]) + // { + // m_LastMouseX = m_Renderer->Width() / 2.f; // xpos; + // m_LastMouseY = m_Renderer->Height() / 2.f; // ypos; + // glfwSetCursorPos(m_GLFWWindow, m_LastMouseX, m_LastMouseY); + // } + // // Hide/show cursor with LMB + // if (m_CurrentMouseState[GLFW_MOUSE_BUTTON_LEFT] && !m_LastMouseState[GLFW_MOUSE_BUTTON_LEFT]) + // { + // glfwSetInputMode(m_GLFWWindow, GLFW_CURSOR, GLFW_CURSOR_HIDDEN); + // } + // if (!m_CurrentMouseState[GLFW_MOUSE_BUTTON_LEFT] && m_LastMouseState[GLFW_MOUSE_BUTTON_LEFT]) + // { + // glfwSetInputMode(m_GLFWWindow, GLFW_CURSOR, GLFW_CURSOR_NORMAL); + // } +} diff --git a/src/InputManager.h b/src/InputManager.h new file mode 100644 index 0000000..5acaaa2 --- /dev/null +++ b/src/InputManager.h @@ -0,0 +1,42 @@ +#ifndef InputManager_h__ +#define InputManager_h__ + +#include + +#include "EventBroker.h" +#include "Events/KeyDown.h" +#include "Events/KeyUp.h" +#include "Events/MousePress.h" +#include "Events/MouseRelease.h" +#include "Events/MouseMove.h" + +class InputManager +{ +public: + InputManager(GLFWwindow* window, std::shared_ptr eventBroker) + : m_GLFWWindow(window) + , m_EventBroker(eventBroker) + , m_CurrentKeyState() + , m_LastKeyState() + , m_CurrentMouseState() + , m_LastMouseState() + , m_CurrentMouseX(0), m_CurrentMouseY(0) + , m_LastMouseX(0), m_LastMouseY(0) + , m_CurrentMouseDeltaX(0), m_CurrentMouseDeltaY(0) { } + + void Update(double dt); + +private: + GLFWwindow* m_GLFWWindow; + std::shared_ptr m_EventBroker; + + std::array m_CurrentKeyState; + std::array m_LastKeyState; + std::array m_CurrentMouseState; + std::array m_LastMouseState; + double m_CurrentMouseX, m_CurrentMouseY; + double m_LastMouseX, m_LastMouseY; + double m_CurrentMouseDeltaX, m_CurrentMouseDeltaY; +}; + +#endif // InputManager_h__ diff --git a/src/RenderQueue.h b/src/RenderQueue.h new file mode 100644 index 0000000..7439de2 --- /dev/null +++ b/src/RenderQueue.h @@ -0,0 +1,62 @@ +#ifndef RenderQueue_h__ +#define RenderQueue_h__ + +#include +#include + +#include "ResourceManager.h" +#include "Texture.h" +#include "Model.h" + +class RenderQueue; + +struct RenderJob +{ + friend class RenderQueue; + + unsigned int ViewportID; + unsigned int TextureID; + + GLuint DiffuseTexture; + GLuint NormalTexture; + GLuint SpecularTexture; + GLuint VAO; + unsigned int StartIndex; + unsigned int EndIndex; + glm::mat4 ModelMatrix; + +protected: + uint64_t Hash; + + void CalculateHash() + { + Hash = ViewportID << 58 // 6 bits + | TextureID << 42; // 16 bits + } + + bool operator<(const RenderJob& rhs) + { + return this->Hash < rhs.Hash; + } +}; + +class RenderQueue +{ +public: + void Add(RenderJob &job) + { + job.CalculateHash(); + m_Jobs.push_front(job); + m_Jobs.sort(); + } + + void Clear() + { + m_Jobs.clear(); + } + +private: + std::forward_list m_Jobs; +}; + +#endif // RenderQueue_h__ diff --git a/src/Renderer.cpp b/src/Renderer.cpp index 6cc7dc2..3e30e30 100755 --- a/src/Renderer.cpp +++ b/src/Renderer.cpp @@ -31,11 +31,11 @@ void Renderer::Initialize() } // Create a window - WIDTH = 1280; - HEIGHT = 720; + m_Width = 1280; + m_Height = 720; // Antialiasing //glfwWindowHint(GLFW_SAMPLES, 16); - m_Window = glfwCreateWindow(WIDTH, HEIGHT, "OpenGL", nullptr, nullptr); + m_Window = glfwCreateWindow(m_Width, m_Height, "OpenGL", nullptr, nullptr); if (!m_Window) { LOG_ERROR("GLFW: Failed to create window"); @@ -63,7 +63,7 @@ void Renderer::Initialize() } // Create Camera - m_Camera = std::make_shared(45.f, (float)WIDTH / HEIGHT, 0.01f, 1000.f); + m_Camera = std::make_shared(45.f, (float)m_Width / m_Height, 0.01f, 1000.f); m_Camera->Position(glm::vec3(0.0f, 0.0f, 2.f)); glfwSwapInterval(m_VSync); @@ -187,7 +187,7 @@ void Renderer::Draw(double dt) void Renderer::DrawSkybox() { glBindFramebuffer(GL_FRAMEBUFFER, 0); - glViewport(0, 0, WIDTH, HEIGHT); + glViewport(0, 0, m_Width, m_Height); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); m_ShaderProgramSkybox.Bind(); @@ -200,7 +200,7 @@ void Renderer::DrawSkybox() void Renderer::DrawScene() { glBindFramebuffer(GL_FRAMEBUFFER, 0); - glViewport(0, 0, WIDTH, HEIGHT); + glViewport(0, 0, m_Width, m_Height); glClear(GL_DEPTH_BUFFER_BIT); //glClearColor(1.0f, 1.0f, 0.0f, 1.0f); diff --git a/src/Renderer.h b/src/Renderer.h index 8d0da1f..3c2d957 100755 --- a/src/Renderer.h +++ b/src/Renderer.h @@ -20,7 +20,9 @@ public: glm::mat4 viewMatrix; glm::mat4 projectionMatrix; - int HEIGHT, WIDTH; + + int Width() const { return m_Width; } + int Height() const { return m_Height; } std::list> ModelsToRender; int Lights; @@ -65,9 +67,8 @@ public: void DrawBounds(bool val) { m_DrawBounds = val; } void DrawSkybox(); - - private: + int m_Width, m_Height; GLFWwindow* m_Window; GLint m_glVersion[2]; GLchar* m_glVendor; diff --git a/src/System.h b/src/System.h index ff76450..b40bdef 100755 --- a/src/System.h +++ b/src/System.h @@ -4,6 +4,7 @@ #include "Factory.h" #include "Entity.h" #include "Component.h" +#include "EventBroker.h" #include "ResourceManager.h" class World; @@ -11,7 +12,9 @@ class World; class System { public: - System(World* world) : m_World(world) { } + System(World* world, std::shared_ptr eventBroker) + : m_World(world) + , EventBroker(eventBroker) { } virtual ~System() { } virtual void RegisterComponents(ComponentFactory* cf) { } @@ -33,6 +36,7 @@ public: protected: World* m_World; + std::shared_ptr EventBroker; }; class SystemFactory : public Factory { }; diff --git a/src/Systems/DebugSystem.cpp b/src/Systems/DebugSystem.cpp index 964aa9f..f076664 100644 --- a/src/Systems/DebugSystem.cpp +++ b/src/Systems/DebugSystem.cpp @@ -2,3 +2,30 @@ #include "DebugSystem.h" #include "World.h" + +void Systems::DebugSystem::Initialize() +{ + // Subscribe to events + m_EKeyDown = decltype(m_EKeyDown)(std::bind(&Systems::DebugSystem::OnKeyDown, this, std::placeholders::_1)); + EventBroker->Subscribe(m_EKeyDown); +} + +void Systems::DebugSystem::Update(double dt) +{ + +} + +bool Systems::DebugSystem::OnKeyDown(const Events::KeyDown &event) +{ + if (event.KeyCode == GLFW_KEY_ENTER) + { + Events::PlaySound e; + e.Emitter = 0; + e.Resource = "Sounds/korvring.wav"; + EventBroker->Publish(e); + + return true; + } + + return false; +} diff --git a/src/Systems/DebugSystem.h b/src/Systems/DebugSystem.h index accaa8c..9db4de6 100644 --- a/src/Systems/DebugSystem.h +++ b/src/Systems/DebugSystem.h @@ -3,6 +3,8 @@ #include "System.h" #include "Components/Transform.h" +#include "Events/KeyDown.h" +#include "Events/PlaySound.h" namespace Systems { @@ -10,10 +12,16 @@ namespace Systems class DebugSystem : public System { public: - DebugSystem(World* world) - : System(world) { } + DebugSystem(World* world, std::shared_ptr<::EventBroker> eventBroker) + : System(world, eventBroker) { } + + void Initialize() override; void Update(double dt) override; + + EventRelay m_EKeyDown; + bool OnKeyDown(const Events::KeyDown &event); + //void UpdateEntity(double dt, EntityID entity, EntityID parent) override; }; diff --git a/src/Systems/FreeSteeringSystem.cpp b/src/Systems/FreeSteeringSystem.cpp index 02e0d33..b382b23 100755 --- a/src/Systems/FreeSteeringSystem.cpp +++ b/src/Systems/FreeSteeringSystem.cpp @@ -7,65 +7,127 @@ void Systems::FreeSteeringSystem::RegisterComponents(ComponentFactory* cf) cf->Register("FreeSteering", []() { return new Components::FreeSteering(); }); } +void Systems::FreeSteeringSystem::Initialize() +{ + m_InputController = std::unique_ptr(new FreeSteeringInputController(EventBroker)); +} + void Systems::FreeSteeringSystem::Update(double dt) { - + } void Systems::FreeSteeringSystem::UpdateEntity(double dt, EntityID entity, EntityID parent) { auto steering = m_World->GetComponent(entity, "FreeSteering"); - auto input = m_World->GetComponent(entity, "Input"); - if (steering && input) + if (steering) { auto transform = m_World->GetComponent(entity, "Transform"); - glm::vec3 Camera_Right = glm::vec3(transform->Orientation * glm::vec4(1, 0, 0, 0)); - glm::vec3 Camera_Forward = glm::vec3(transform->Orientation * glm::vec4(0, 0, -1, 0)); - - float speed = steering->Speed; - if (input->KeyState[GLFW_KEY_LEFT_SHIFT]) - { - speed *= 4.0f; - } - if (input->KeyState[GLFW_KEY_LEFT_ALT]) - { - speed /= 4.0f; - } - if (input->KeyState[GLFW_KEY_A]) - { - transform->Position -= Camera_Right * (float)dt * speed; - } - else if (input->KeyState[GLFW_KEY_D]) - { - transform->Position += Camera_Right * (float)dt * speed; - } - if (input->KeyState[GLFW_KEY_W]) - { - transform->Position += Camera_Forward * (float)dt * speed; - } - if (input->KeyState[GLFW_KEY_S]) - { - transform->Position -= Camera_Forward * (float)dt * speed; - } - if (input->KeyState[GLFW_KEY_SPACE]) - { - transform->Position += glm::vec3(0, 1, 0) * (float)dt * speed; - } - if (input->KeyState[GLFW_KEY_LEFT_CONTROL]) - { - transform->Position -= glm::vec3(0, 1, 0) * (float)dt * speed; - } - - if (input->MouseState[GLFW_MOUSE_BUTTON_LEFT]) - { - // TOUCHING THIS CODE MIGHT CAUSE THE UNIVERSE TO IMPLODE, ALSO DRAGONS // spelling tobias :3 - //--------------------------------------------------------------------- - transform->Orientation = glm::angleAxis(input->dX / 300.f, glm::vec3(0, -1, 0)) * transform->Orientation; - transform->Orientation = transform->Orientation * glm::angleAxis(input->dY / 300.f, glm::vec3(-1, 0, 0)); - - //--------------------------------------------------------------------- - // TOUCHING THIS CODE MIGHT CAUSE THE UNIVERSE TO IMPLODE, ALSO DRAGONS - } + glm::vec3 cameraRight = glm::vec3(m_InputController->Orientation * glm::vec4(1, 0, 0, 0)); + glm::vec3 cameraForward = glm::vec3(m_InputController->Orientation * glm::vec4(0, 0, -1, 0)); + glm::vec3 movement; + movement += cameraRight * m_InputController->Movement.x; + movement.y += m_InputController->Movement.y; + movement += cameraForward * -m_InputController->Movement.z; + transform->Position += movement * steering->Speed * m_InputController->SpeedMultiplier * (float)dt; + transform->Orientation = m_InputController->Orientation; } } + +bool Systems::FreeSteeringSystem::FreeSteeringInputController::OnCommand(const Events::InputCommand &event) +{ + // Movement + if (event.Command == "+forward") + { + Movement.z += -1.f; + } + else if (event.Command == "-forward") + { + Movement.z -= -1.f; + } + else if (event.Command == "+backward") + { + Movement.z += 1.f; + } + else if (event.Command == "-backward") + { + Movement.z -= 1.f; + } + else if (event.Command == "+right") + { + Movement.x += 1.f; + } + else if (event.Command == "-right") + { + Movement.x -= 1.f; + } + else if (event.Command == "+left") + { + Movement.x += -1.f; + } + else if (event.Command == "-left") + { + Movement.x -= -1.f; + } + else if (event.Command == "+up") + { + Movement.y += 1.f; + } + else if (event.Command == "-up") + { + Movement.y -= 1.f; + } + else if (event.Command == "+down") + { + Movement.y += -1.f; + } + else if (event.Command == "-down") + { + Movement.y -= -1.f; + } + + // Speed + else if (event.Command == "+fast") + { + SpeedMultiplier *= 4.f; + } + else if (event.Command == "-fast") + { + SpeedMultiplier /= 4.f; + } + else if (event.Command == "+slow") + { + SpeedMultiplier /= 4.f; + } + else if (event.Command == "-slow") + { + SpeedMultiplier *= 4.f; + } + + // Mouse click + else if (event.Command == "+attack") + { + OrientationActive = true; + } + else if (event.Command == "-attack") + { + OrientationActive = false; + } + + return true; +} + +bool Systems::FreeSteeringSystem::FreeSteeringInputController::OnMouseMove(const Events::MouseMove &event) +{ + if (OrientationActive) + { + // TOUCHING THIS CODE MIGHT CAUSE THE UNIVERSE TO IMPLODE, ALSO DRAGONS + //--------------------------------------------------------------------- + Orientation = glm::angleAxis(event.DeltaX / 300.f, glm::vec3(0, -1, 0)) * Orientation * glm::angleAxis(event.DeltaY / 300.f, glm::vec3(-1, 0, 0)); + //--------------------------------------------------------------------- + // TOUCHING THIS CODE MIGHT CAUSE THE UNIVERSE TO IMPLODE, ALSO DRAGONS + } + + return true; +} diff --git a/src/Systems/FreeSteeringSystem.h b/src/Systems/FreeSteeringSystem.h index 11b86ae..4535cbb 100755 --- a/src/Systems/FreeSteeringSystem.h +++ b/src/Systems/FreeSteeringSystem.h @@ -2,19 +2,46 @@ #include "System.h" #include "Components/Transform.h" -#include "Components/Input.h" #include "Components/FreeSteering.h" +#include "InputController.h" namespace Systems { + class FreeSteeringSystem : public System { public: - FreeSteeringSystem(World* world) - : System(world) { } + FreeSteeringSystem(World* world, std::shared_ptr<::EventBroker> eventBroker) + : System(world, eventBroker) { } + void RegisterComponents(ComponentFactory* cf) override; + void Initialize() override; void Update(double dt) override; void UpdateEntity(double dt, EntityID entity, EntityID parent) override; + +private: + class FreeSteeringInputController; + + std::unique_ptr m_InputController; }; + +class FreeSteeringSystem::FreeSteeringInputController : InputController +{ +public: + FreeSteeringInputController(std::shared_ptr<::EventBroker> eventBroker) + : InputController(eventBroker) + , SpeedMultiplier(1.f) + , OrientationActive(false) { } + + glm::vec3 Movement; + glm::quat Orientation; + float SpeedMultiplier; + bool OrientationActive; + +protected: + virtual bool OnCommand(const Events::InputCommand &event); + virtual bool OnMouseMove(const Events::MouseMove &event); +}; + } \ No newline at end of file diff --git a/src/Systems/InputSystem.cpp b/src/Systems/InputSystem.cpp index b64bc03..3c9fdfd 100755 --- a/src/Systems/InputSystem.cpp +++ b/src/Systems/InputSystem.cpp @@ -7,80 +7,123 @@ void Systems::InputSystem::RegisterComponents(ComponentFactory* cf) cf->Register("Input", []() { return new Components::Input(); }); } +void Systems::InputSystem::Initialize() +{ + // Subscribe to events + EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &Systems::InputSystem::OnKeyDown) + EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &Systems::InputSystem::OnKeyUp) + EVENT_SUBSCRIBE_MEMBER(m_EMousePress, &Systems::InputSystem::OnMousePress) + EVENT_SUBSCRIBE_MEMBER(m_EMouseRelease, &Systems::InputSystem::OnMouseRelease) + EVENT_SUBSCRIBE_MEMBER(m_EBindKey, &Systems::InputSystem::OnBindKey) + EVENT_SUBSCRIBE_MEMBER(m_EBindMouseButton, &Systems::InputSystem::OnBindMouseButton) +} + void Systems::InputSystem::Update(double dt) { - m_LastKeyState = m_CurrentKeyState; - m_LastMouseState = m_CurrentMouseState; - - // Keyboard input - for (int i = 0; i <= GLFW_KEY_LAST; ++i) - { - m_CurrentKeyState[i] = glfwGetKey(m_Renderer->GetWindow(), i); - } - - // Mouse buttons - for (int i = 0; i <= GLFW_MOUSE_BUTTON_LAST; ++i) - { - m_CurrentMouseState[i] = glfwGetMouseButton(m_Renderer->GetWindow(), i); - } - - // Cursor position - double xpos, ypos; - glfwGetCursorPos(m_Renderer->GetWindow(), &xpos, &ypos); - m_CurrentMouseDeltaX = xpos - m_LastMouseX; - m_CurrentMouseDeltaY = ypos - m_LastMouseY; - m_LastMouseX = xpos; - m_LastMouseY = ypos; - - // Lock mouse while holding LMB - if (m_CurrentMouseState[GLFW_MOUSE_BUTTON_LEFT]) - { - m_LastMouseX = m_Renderer->WIDTH / 2.f; // xpos; - m_LastMouseY = m_Renderer->HEIGHT / 2.f; // ypos; - glfwSetCursorPos(m_Renderer->GetWindow(), m_LastMouseX, m_LastMouseY); - } - // Hide/show cursor with LMB - if (m_CurrentMouseState[GLFW_MOUSE_BUTTON_LEFT] && !m_LastMouseState[GLFW_MOUSE_BUTTON_LEFT]) - { - glfwSetInputMode(m_Renderer->GetWindow(), GLFW_CURSOR, GLFW_CURSOR_HIDDEN); - } - if (!m_CurrentMouseState[GLFW_MOUSE_BUTTON_LEFT] && m_LastMouseState[GLFW_MOUSE_BUTTON_LEFT]) - { - glfwSetInputMode(m_Renderer->GetWindow(), GLFW_CURSOR, GLFW_CURSOR_NORMAL); - } - -#ifdef DEBUG - // Wireframe - if (m_CurrentKeyState[GLFW_KEY_F1] && !m_LastKeyState[GLFW_KEY_F1]) - { - m_Renderer->DrawWireframe(!m_Renderer->DrawWireframe()); - } - // Normals - if (m_CurrentKeyState[GLFW_KEY_F2] && !m_LastKeyState[GLFW_KEY_F2]) - { - m_Renderer->DrawNormals(!m_Renderer->DrawNormals()); - } - // Bounds - if (m_CurrentKeyState[GLFW_KEY_F3] && !m_LastKeyState[GLFW_KEY_F3]) - { - m_Renderer->DrawBounds(!m_Renderer->DrawBounds()); - } -#endif +// #ifdef DEBUG +// // Wireframe +// if (m_CurrentKeyState[GLFW_KEY_F1] && !m_LastKeyState[GLFW_KEY_F1]) +// { +// m_Renderer->DrawWireframe(!m_Renderer->DrawWireframe()); +// } +// // Normals +// if (m_CurrentKeyState[GLFW_KEY_F2] && !m_LastKeyState[GLFW_KEY_F2]) +// { +// m_Renderer->DrawNormals(!m_Renderer->DrawNormals()); +// } +// // Bounds +// if (m_CurrentKeyState[GLFW_KEY_F3] && !m_LastKeyState[GLFW_KEY_F3]) +// { +// m_Renderer->DrawBounds(!m_Renderer->DrawBounds()); +// } +// #endif } -void Systems::InputSystem::UpdateEntity(double dt, EntityID entity, EntityID parent) +bool Systems::InputSystem::OnKeyDown(const Events::KeyDown &event) { - auto input = m_World->GetComponent(entity, "Input"); - if (input == nullptr) - return; + auto bindingIt = m_KeyBindings.find(event.KeyCode); + if (bindingIt != m_KeyBindings.end()) + { + PublishCommand(0, bindingIt->second, false); + } - input->KeyState = m_CurrentKeyState; - input->LastKeyState = m_LastKeyState; - input->MouseState = m_CurrentMouseState; - input->LastMouseState = m_LastMouseState; - input->dX = m_CurrentMouseDeltaX; - input->dY = m_CurrentMouseDeltaY; + return true; } -std::array Systems::InputSystem::m_CurrentKeyState; -std::array Systems::InputSystem::m_LastKeyState; +bool Systems::InputSystem::OnKeyUp(const Events::KeyUp &event) +{ + auto bindingIt = m_KeyBindings.find(event.KeyCode); + if (bindingIt != m_KeyBindings.end()) + { + PublishCommand(0, bindingIt->second, true); + } + + return true; +} + +bool Systems::InputSystem::OnMousePress(const Events::MousePress &event) +{ + auto bindingIt = m_MouseButtonBindings.find(event.Button); + if (bindingIt != m_MouseButtonBindings.end()) + { + PublishCommand(0, bindingIt->second, false); + } + + return true; +} + +bool Systems::InputSystem::OnMouseRelease(const Events::MouseRelease &event) +{ + auto bindingIt = m_MouseButtonBindings.find(event.Button); + if (bindingIt != m_MouseButtonBindings.end()) + { + PublishCommand(0, bindingIt->second, true); + } + + return true; +} + +bool Systems::InputSystem::OnBindKey(const Events::BindKey &event) +{ + if (event.Command.empty()) + { + m_KeyBindings.erase(event.KeyCode); + } + else + { + m_KeyBindings[event.KeyCode] = event.Command; + LOG_DEBUG("Input: Bound key %c to %s", (char)event.KeyCode, event.Command.c_str()); + } + + return true; +} + +bool Systems::InputSystem::OnBindMouseButton(const Events::BindMouseButton &event) +{ + if (event.Command.empty()) + { + m_MouseButtonBindings.erase(event.Button); + } + else + { + m_MouseButtonBindings[event.Button] = event.Command; + LOG_DEBUG("Input: Bound mouse button %i to %s", event.Button, event.Command.c_str()); + } + + return true; +} + +void Systems::InputSystem::PublishCommand(int playerID, std::string command, bool release /*= false*/) +{ + if (release && command.at(0) == '+') + { + command[0] = '-'; + } + + Events::InputCommand e; + e.PlayerID = playerID; + e.Command = command; + EventBroker->Publish(e); + + LOG_DEBUG("Input: Published command %s for player %i", e.Command.c_str(), playerID); +} diff --git a/src/Systems/InputSystem.h b/src/Systems/InputSystem.h index abceb77..c56cccf 100755 --- a/src/Systems/InputSystem.h +++ b/src/Systems/InputSystem.h @@ -2,10 +2,17 @@ #define InputSystem_h__ #include +#include #include "System.h" -#include "Renderer.h" #include "Components/Input.h" +#include "Events/KeyUp.h" +#include "Events/KeyDown.h" +#include "Events/MousePress.h" +#include "Events/MouseRelease.h" +#include "Events/BindKey.h" +#include "Events/BindMouseButton.h" +#include "Events/InputCommand.h" namespace Systems { @@ -13,22 +20,35 @@ namespace Systems class InputSystem : public System { public: - InputSystem(World* world, std::shared_ptr renderer) - : System(world), m_Renderer(renderer) { } + InputSystem(World* world, std::shared_ptr<::EventBroker> eventBroker) + : System(world, eventBroker) { } + void RegisterComponents(ComponentFactory* cf) override; + void Initialize() override; void Update(double dt) override; - void UpdateEntity(double dt, EntityID entity, EntityID parent) override; private: - std::shared_ptr m_Renderer; - static std::array m_CurrentKeyState; - static std::array m_LastKeyState; - std::array m_CurrentMouseState; - std::array m_LastMouseState; - float m_CurrentMouseDeltaX, m_CurrentMouseDeltaY; - float m_LastMouseX, m_LastMouseY; + // Input binding tables + std::unordered_map m_KeyBindings; // GLFW_KEY... -> command string + std::unordered_map m_MouseButtonBindings; // GLFW_MOUSE_BUTTON... -> command string + // Input events + EventRelay m_EKeyDown; + bool OnKeyDown(const Events::KeyDown &event); + EventRelay m_EKeyUp; + bool OnKeyUp(const Events::KeyUp &event); + EventRelay m_EMousePress; + bool OnMousePress(const Events::MousePress &event); + EventRelay m_EMouseRelease; + bool OnMouseRelease(const Events::MouseRelease &event); + // Input binding events + EventRelay m_EBindKey; + bool OnBindKey(const Events::BindKey &event); + EventRelay m_EBindMouseButton; + bool OnBindMouseButton(const Events::BindMouseButton &event); + + void PublishCommand(int playerID, std::string command, bool release = false); }; } diff --git a/src/Systems/PhysicsSystem.cpp b/src/Systems/PhysicsSystem.cpp index 9e14054..2000a3c 100644 --- a/src/Systems/PhysicsSystem.cpp +++ b/src/Systems/PhysicsSystem.cpp @@ -25,7 +25,7 @@ #include "PhysicsSystem.h" #include "World.h" -Systems::PhysicsSystem::PhysicsSystem(World* world) : System(world) +void Systems::PhysicsSystem::Initialize() { m_Accumulator = 0; diff --git a/src/Systems/PhysicsSystem.h b/src/Systems/PhysicsSystem.h index 9ef1260..7592a7b 100644 --- a/src/Systems/PhysicsSystem.h +++ b/src/Systems/PhysicsSystem.h @@ -63,8 +63,11 @@ namespace Systems class PhysicsSystem : public System { public: - PhysicsSystem(World* world); + PhysicsSystem(World* world, std::shared_ptr<::EventBroker> eventBroker) + : System(world, eventBroker) { } + void RegisterComponents(ComponentFactory* cf) override; + void Initialize() override; void Update(double dt) override; void UpdateEntity(double dt, EntityID entity, EntityID parent) override; diff --git a/src/Systems/PhysicsSystem.h.orig b/src/Systems/PhysicsSystem.h.orig deleted file mode 100644 index 5e00aa1..0000000 --- a/src/Systems/PhysicsSystem.h.orig +++ /dev/null @@ -1,91 +0,0 @@ -#ifndef PhysicsSystem_h__ -#define PhysicsSystem_h__ - - - - - -#include "System.h" -#include "Components/Transform.h" -#include "Components/Physics.h" -#include "Components/Sphere.h" -#include "Components/Box.h" -#include "Components/Vehicle.h" -#include "Components/Input.h" - -// Math and base include - -#include -#include -#include -#include -#include -#include -#include -#include - -// Dynamics includes -#include -#include -#include -#include -#include - - - -#include -#include -#include - -// Visual Debugger includes -#include -#include - - - -#include "Physics/VehicleSetup.h" - - -#include -namespace Systems -{ - -class PhysicsSystem : public System -{ -public: - PhysicsSystem(World* world); - void RegisterComponents(ComponentFactory* cf) override; - - void Update(double dt) override; - void UpdateEntity(double dt, EntityID entity, EntityID parent) override; - void OnComponentCreated(std::string type, std::shared_ptr component) override; - void OnComponentRemoved(std::string type, Component* component) override; - void OnEntityCommit(EntityID entity) override; - -private: -<<<<<<< HEAD - -======= ->>>>>>> havok - double m_Accumulator; - hkpWorld* m_PhysicsWorld; - - void SetUpPhysicsState(EntityID entity, EntityID parent); - void TearDownPhysicsState(EntityID entity, EntityID parent); - - hkVisualDebugger* m_VisualDebugger; - void SetupVisualDebugger(hkpPhysicsContext* worlds); - void StepVisualDebugger(); - static void HK_CALL HavokErrorReport(const char* msg, void*); - void SetupPhysics(hkpWorld* physicsWorld); - - std::unordered_map m_RigidBodies; - std::unordered_map m_Vehicles; - std::vector m_Wheels; - - hkpVehicleInstance* Systems::PhysicsSystem::createVehicle(VehicleSetup& vehicleSetup, hkpRigidBody* chassis); -}; - -} - -#endif // PhysicsSystem_h__ diff --git a/src/Systems/RenderSystem.h b/src/Systems/RenderSystem.h index 4df8658..c3cd09a 100755 --- a/src/Systems/RenderSystem.h +++ b/src/Systems/RenderSystem.h @@ -24,8 +24,9 @@ namespace Systems class RenderSystem : public System { public: - RenderSystem(World* world, std::shared_ptr renderer) - : System(world), m_Renderer(renderer) { } + RenderSystem(World* world, std::shared_ptr<::EventBroker> eventBroker, std::shared_ptr renderer) + : System(world, eventBroker) + , m_Renderer(renderer) { } void RegisterComponents(ComponentFactory* cf) override; void RegisterResourceTypes(ResourceManager* rm) override; diff --git a/src/Systems/SoundSystem.cpp b/src/Systems/SoundSystem.cpp index ffb9b06..02a665e 100755 --- a/src/Systems/SoundSystem.cpp +++ b/src/Systems/SoundSystem.cpp @@ -2,8 +2,7 @@ #include "SoundSystem.h" #include "World.h" -Systems::SoundSystem::SoundSystem(World* world) - : System(world) +void Systems::SoundSystem::Initialize() { //initialize OpenAL ALCdevice* Device = alcOpenDevice(NULL); @@ -22,6 +21,10 @@ Systems::SoundSystem::SoundSystem(World* world) alSpeedOfSound(340.29f); // Speed of sound alDistanceModel(AL_INVERSE_DISTANCE_CLAMPED); + + // Subscribe to events + m_EPlaySound = decltype(m_EPlaySound)(std::bind(&Systems::SoundSystem::OnPlaySound, this, std::placeholders::_1)); + EventBroker->Subscribe(m_EPlaySound); } void Systems::SoundSystem::RegisterComponents(ComponentFactory* cf) @@ -143,3 +146,15 @@ ALuint Systems::SoundSystem::CreateSource() return source; } + +bool Systems::SoundSystem::OnPlaySound(const Events::PlaySound &event) +{ + LOG_DEBUG("Events::PlaySound.Resource = %s", event.Resource.c_str()); + + ALuint buffer = *m_World->GetResourceManager()->Load("Sound", event.Resource); + ALuint source = m_Sources.begin()->second; + alSourcei(source, AL_BUFFER, buffer); + alSourcePlay(source); + + return true; +} diff --git a/src/Systems/SoundSystem.h b/src/Systems/SoundSystem.h index 85ee4fa..7fbc5aa 100755 --- a/src/Systems/SoundSystem.h +++ b/src/Systems/SoundSystem.h @@ -7,6 +7,7 @@ #include "System.h" #include "Components/Transform.h" #include "Components/SoundEmitter.h" +#include "Events/PlaySound.h" #include "Sound.h" namespace Systems @@ -15,9 +16,12 @@ namespace Systems class SoundSystem : public System { public: - SoundSystem(World* world); + SoundSystem(World* world, std::shared_ptr<::EventBroker> eventBroker) + : System(world, eventBroker) { } + void RegisterComponents(ComponentFactory* cf) override; void RegisterResourceTypes(ResourceManager* rm) override; + void Initialize() override; void Update(double dt) override; void UpdateEntity(double dt, EntityID entity, EntityID parent) override; @@ -39,6 +43,10 @@ private: //short bytesPerSample, bitsPerSample; //unsigned long dataSize; + // Events + EventRelay m_EPlaySound; + bool OnPlaySound(const Events::PlaySound &event); + std::map m_Sources; std::map m_BufferCache; // string = fileName }; diff --git a/src/Systems/TransformSystem.h b/src/Systems/TransformSystem.h index 754a567..7852628 100755 --- a/src/Systems/TransformSystem.h +++ b/src/Systems/TransformSystem.h @@ -10,9 +10,8 @@ namespace Systems class TransformSystem : public System { public: - TransformSystem(World* world) - : System(world) { } - + TransformSystem(World* world, std::shared_ptr<::EventBroker> eventBroker) + : System(world, eventBroker) { } //void Update(double dt) override; //void UpdateEntity(double dt, EntityID entity, EntityID parent) override; diff --git a/src/Util/Rectangle.h b/src/Util/Rectangle.h new file mode 100644 index 0000000..0d0db32 --- /dev/null +++ b/src/Util/Rectangle.h @@ -0,0 +1,95 @@ +#ifndef Util_Rectangle_h__ +#define Util_Rectangle_h__ + +#include + +struct Rectangle +{ + Rectangle() + : X(0), Y(0), Width(0), Height(0) { } + + Rectangle(int x, int y, int width = 0, int height = 0) + : X(x), Y(y), Width(width), Height(height) { } + + /*Rectangle(const Rectangle &rect) + : X(rect.X), Y(rect.Y), Width(rect.Width), Height(rect.Height) { }*/ + + int X; + int Y; + int Width; + int Height; + + const int& GetLeft() const { return X; } + void SetLeft(int left) + { + Width += X - left; + X = left; + } + int GetRight() const { return X + Width; } + void SetRight(int right) + { + Width = right - X; + } + const int& GetTop() const { return Y; } + void SetTop(int top) + { + Height += Y - top; + Y = top; + } + int GetBottom() const { return Y + Height; } + int SetBottom(int bottom) + { + Height = bottom - Y; + } + + Rectangle& operator+=(const Rectangle &rhs) + { + SetLeft(std::min(GetLeft(), rhs.GetLeft())); + SetRight(std::max(GetRight(), rhs.GetRight())); + SetTop(std::min(GetTop(), rhs.GetTop())); + SetBottom(std::max(GetBottom(), rhs.GetBottom())); + } + + static bool Intersects(const Rectangle &r1, const Rectangle &r2) + { + return !(r2.GetLeft() > r1.GetRight() || r2.GetRight() < r1.GetLeft() || r2.GetTop() > r1.GetBottom() || r2.GetBottom() < r1.GetTop()); + } +}; + +inline bool operator==(const Rectangle &r1, const Rectangle &r2) +{ + return (r1.X == r2.X) && (r1.Y == r2.Y) && (r1.Width == r2.Width) && (r1.Height == r2.Height); +} + +inline bool operator!=(const Rectangle &lhs, const Rectangle &rhs) +{ + return !(lhs == rhs); +} + +inline bool operator<(const Rectangle &lhs, const Rectangle &rhs) +{ + return (lhs.Width < rhs.Width) && (lhs.Height < rhs.Height); +} + +inline bool operator>(const Rectangle &lhs, const Rectangle &rhs) +{ + return rhs < lhs; +} + +inline bool operator<=(const Rectangle &lhs, const Rectangle &rhs) +{ + return !(lhs > rhs); +} + +inline bool operator>=(const Rectangle &lhs, const Rectangle &rhs) +{ + return !(lhs < rhs); +} + +inline Rectangle operator+(Rectangle lhs, const Rectangle &rhs) +{ + lhs += rhs; + return lhs; +} + +#endif // Util_Rectangle_h__ diff --git a/src/World.cpp b/src/World.cpp index 6e168c2..d8f2a0a 100755 --- a/src/World.cpp +++ b/src/World.cpp @@ -117,16 +117,6 @@ EntityID World::CreateEntity(EntityID parent /*= 0*/) return newEntity; } -World::~World() -{ - -} - -World::World() -{ - m_LastEntityID = 0; -} - void World::Initialize() { RegisterSystems(); diff --git a/src/World.h b/src/World.h index 255ef1b..3581be1 100755 --- a/src/World.h +++ b/src/World.h @@ -14,13 +14,16 @@ #include "Entity.h" #include "Component.h" #include "System.h" +#include "EventBroker.h" #include "ResourceManager.h" class World { public: - World(); - ~World(); + World(std::shared_ptr<::EventBroker> eventBroker) + : m_EventBroker(eventBroker) + , m_LastEntityID(0) { } + ~World() { } virtual void Initialize(); @@ -75,8 +78,10 @@ public: std::unordered_map* GetEntities() { return &m_EntityParents; } ResourceManager* GetResourceManager() { return &m_ResourceManager; } + std::shared_ptr<::EventBroker> EventBroker() { return m_EventBroker; } protected: + std::shared_ptr<::EventBroker> m_EventBroker; SystemFactory m_SystemFactory; ComponentFactory m_ComponentFactory; ResourceManager m_ResourceManager; @@ -138,7 +143,16 @@ std::shared_ptr World::AddComponent(EntityID entity, std::string componentTyp template T* World::GetComponent(EntityID entity, std::string componentType) { - return (T*)m_EntityComponents[entity][componentType].get(); + auto components = m_EntityComponents[entity]; + auto it = components.find(componentType); + if (it != components.end()) + { + return static_cast(it->second.get()); + } + else + { + return nullptr; + } } #endif // World_h__ \ No newline at end of file diff --git a/vs11/Returngeance/Returngeance.vcxproj b/vs11/Returngeance/Returngeance.vcxproj index bae6084..ac4c36b 100755 --- a/vs11/Returngeance/Returngeance.vcxproj +++ b/vs11/Returngeance/Returngeance.vcxproj @@ -96,7 +96,9 @@ + + @@ -144,13 +146,28 @@ + + + + + + + + + + + + + + + @@ -165,6 +182,7 @@ + diff --git a/vs11/Returngeance/Returngeance.vcxproj.filters b/vs11/Returngeance/Returngeance.vcxproj.filters index 6f29356..169f797 100755 --- a/vs11/Returngeance/Returngeance.vcxproj.filters +++ b/vs11/Returngeance/Returngeance.vcxproj.filters @@ -50,9 +50,13 @@ + Physics + + Input + @@ -115,6 +119,15 @@ {9f45f029-46c8-4c0d-b44c-dc9bffd3c6a6} + + {6e633434-4aed-453d-b2f9-8c51ca7f78db} + + + {85692f3a-5241-4780-a3ca-f4d8a2851392} + + + {ee125b77-b275-4841-abc9-374957a89916} + @@ -215,6 +228,7 @@ Audio + Physics\Components @@ -245,6 +259,52 @@ Physics\Components + + GUI + + + Util + + + + Audio\Events + + + Input\Events + + + Input\Events + + + Input + + + Input\Events + + + Input\Events + + + Input\Events + + + Input\Events + + + Input\Events + + + Input\Events + + + Input + + + Rendering + + + GUI +