BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fixed indentation

Browse Source
This commit is contained in:
stiffly
2015-12-11 15:29:57 +01:00
parent 16d636a87c
commit 3da69c8a1b
5 changed files with 171 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/Engine/Core/EventBroker.h
+67 -67
View File
@@ -17,119 +17,119 @@ class EventBroker;
class BaseEventRelay class BaseEventRelay
{ {
friend class EventBroker; friend class EventBroker;
protected: protected:
BaseEventRelay(std::string contextTypeName, std::string eventTypeName) BaseEventRelay(std::string contextTypeName, std::string eventTypeName)
: m_ContextTypeName(contextTypeName) : m_ContextTypeName(contextTypeName)
, m_EventTypeName(eventTypeName) , m_EventTypeName(eventTypeName)
, m_Broker(nullptr) , m_Broker(nullptr)
{ } { }
~BaseEventRelay(); ~BaseEventRelay();
public: public:
virtual bool Receive(const std::shared_ptr<Event> event) = 0; virtual bool Receive(const std::shared_ptr<Event> event) = 0;
protected: protected:
std::string m_ContextTypeName; std::string m_ContextTypeName;
std::string m_EventTypeName; std::string m_EventTypeName;
EventBroker* m_Broker; EventBroker* m_Broker;
}; };
template <typename ContextType, typename EventType> template <typename ContextType, typename EventType>
class EventRelay : public BaseEventRelay class EventRelay : public BaseEventRelay
{ {
public: public:
typedef std::function<bool(const EventType&)> CallbackType; typedef std::function<bool(const EventType&)> CallbackType;
EventRelay() EventRelay()
: m_Callback(nullptr) : m_Callback(nullptr)
, BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name()) , BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name())
{ } { }
EventRelay(CallbackType callback) EventRelay(CallbackType callback)
: m_Callback(callback) : m_Callback(callback)
, BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name()) , BaseEventRelay(typeid(ContextType).name(), typeid(EventType).name())
{ } { }
protected: protected:
bool Receive(const std::shared_ptr<Event> event) override; bool Receive(const std::shared_ptr<Event> event) override;
private: private:
CallbackType m_Callback; CallbackType m_Callback;
}; };
template <typename ContextType, typename EventType> template <typename ContextType, typename EventType>
bool EventRelay<ContextType, EventType>::Receive(const std::shared_ptr<Event> event) bool EventRelay<ContextType, EventType>::Receive(const std::shared_ptr<Event> event)
{ {
if (m_Callback != nullptr) { if (m_Callback != nullptr) {
return m_Callback(*static_cast<const EventType*>(event.get())); return m_Callback(*static_cast<const EventType*>(event.get()));
} else { } else {
return false; return false;
} }
} }
class EventBroker class EventBroker
{ {
template <typename ContextType, typename EventType> friend class EventRelay; template <typename ContextType, typename EventType> friend class EventRelay;
public: public:
EventBroker() EventBroker()
{ {
m_EventQueueRead = std::make_shared<EventQueue_t>(); m_EventQueueRead = std::make_shared<EventQueue_t>();
m_EventQueueWrite = std::make_shared<EventQueue_t>(); m_EventQueueWrite = std::make_shared<EventQueue_t>();
} }
void Subscribe(BaseEventRelay &relay); void Subscribe(BaseEventRelay &relay);
template <typename EventType> template <typename EventType>
void Publish(const EventType &event); void Publish(const EventType &event);
/* /*
Process all events in a given context. Process all events in a given context.
Returns: Number of events processed Returns: Number of events processed
*/ */
template <typename ContextType> template <typename ContextType>
int Process(); int Process();
int Process(std::string contextTypeName); int Process(std::string contextTypeName);
void Swap(); void Swap();
void Clear(); void Clear();
void Unsubscribe(BaseEventRelay &relay); void Unsubscribe(BaseEventRelay &relay);
private: private:
bool m_IsProcessing = false; bool m_IsProcessing = false;
typedef std::string ContextTypeName_t; // typeid(ContextType).name() typedef std::string ContextTypeName_t; // typeid(ContextType).name()
typedef std::string EventTypeName_t; // typeid(EventType).name() typedef std::string EventTypeName_t; // typeid(EventType).name()
typedef std::unordered_multimap<EventTypeName_t, BaseEventRelay*> EventRelays_t; typedef std::unordered_multimap<EventTypeName_t, BaseEventRelay*> EventRelays_t;
typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextRelays_t; typedef std::unordered_map<ContextTypeName_t, EventRelays_t> ContextRelays_t;
ContextRelays_t m_ContextRelays; ContextRelays_t m_ContextRelays;
std::vector<BaseEventRelay*> m_RelaysToSubscribe; std::vector<BaseEventRelay*> m_RelaysToSubscribe;
std::vector<BaseEventRelay*> m_RelaysToUnsubscribe; std::vector<BaseEventRelay*> m_RelaysToUnsubscribe;
typedef std::list<std::pair<EventTypeName_t, std::shared_ptr<Event>>> EventQueue_t; typedef std::list<std::pair<EventTypeName_t, std::shared_ptr<Event>>> EventQueue_t;
std::shared_ptr<EventQueue_t> m_EventQueueRead; std::shared_ptr<EventQueue_t> m_EventQueueRead;
std::shared_ptr<EventQueue_t> m_EventQueueWrite; std::shared_ptr<EventQueue_t> m_EventQueueWrite;
void subscribeImmediate(BaseEventRelay& relay); void subscribeImmediate(BaseEventRelay& relay);
void unsubscribeImmediate(BaseEventRelay& relay); void unsubscribeImmediate(BaseEventRelay& relay);
}; };
template <typename EventType> template <typename EventType>
void EventBroker::Publish(const EventType &event) void EventBroker::Publish(const EventType &event)
{ {
/*auto itpair = m_Subscribers.equal_range(typeid(EventType).name()); /*auto itpair = m_Subscribers.equal_range(typeid(EventType).name());
for (auto it = itpair.first; it != itpair.second; ++it) for (auto it = itpair.first; it != itpair.second; ++it)
{ {
it->second->Receive(event); it->second->Receive(event);
}*/ }*/
m_EventQueueWrite->push_back(std::make_pair(typeid(EventType).name(), std::shared_ptr<EventType>(new EventType(event)))); m_EventQueueWrite->push_back(std::make_pair(typeid(EventType).name(), std::shared_ptr<EventType>(new EventType(event))));
} }
template <typename ContextType> template <typename ContextType>
int EventBroker::Process() int EventBroker::Process()
{ {
const std::string contextTypeName = typeid(ContextType).name(); const std::string contextTypeName = typeid(ContextType).name();
return Process(contextTypeName); return Process(contextTypeName);
} }
#endif #endif
include/Engine/Core/System.h
+2 -2
View File
@@ -14,12 +14,12 @@ public:
: m_EventBroker(eventBroker) : m_EventBroker(eventBroker)
, m_ComponentType(componentType) , m_ComponentType(componentType)
{ } { }
virtual void Update(World* world, ComponentWrapper& component, double dt) = 0; virtual void Update(World* world, ComponentWrapper& component, double dt) = 0;
protected: protected:
std::string m_ComponentType; std::string m_ComponentType;
EventBroker* m_EventBroker; EventBroker* m_EventBroker;
}; };
#endif #endif
include/Game/PlayerSystem.h
+18 -18
View File
@@ -12,33 +12,33 @@
struct KeyInput struct KeyInput
{ {
bool Forward = false; bool Forward = false;
bool Left = false; bool Left = false;
bool Back = false; bool Back = false;
bool Right = false; bool Right = false;
}; };
class PlayerSystem : public System class PlayerSystem : public System
{ {
public: public:
PlayerSystem(EventBroker* eventBroker) PlayerSystem(EventBroker* eventBroker)
: System(eventBroker, "Player") : System(eventBroker, "Player")
{ {
EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &PlayerSystem::OnKeyDown); EVENT_SUBSCRIBE_MEMBER(m_EKeyDown, &PlayerSystem::OnKeyDown);
EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &PlayerSystem::OnKeyUp); EVENT_SUBSCRIBE_MEMBER(m_EKeyUp, &PlayerSystem::OnKeyUp);
} }
virtual void Update(World* world, ComponentWrapper& player, double dt) override; virtual void Update(World* world, ComponentWrapper& player, double dt) override;
private: private:
float m_Speed = 5; float m_Speed = 5;
glm::vec3 m_Direction; glm::vec3 m_Direction;
KeyInput input; KeyInput input;
EventRelay<PlayerSystem, Events::KeyDown> m_EKeyDown; EventRelay<PlayerSystem, Events::KeyDown> m_EKeyDown;
bool OnKeyDown(const Events::KeyDown &event); bool OnKeyDown(const Events::KeyDown &event);
EventRelay<PlayerSystem, Events::KeyUp> m_EKeyUp; EventRelay<PlayerSystem, Events::KeyUp> m_EKeyUp;
bool OnKeyUp(const Events::KeyUp &event); bool OnKeyUp(const Events::KeyUp &event);
}; };
#endif #endif
src/Game/Game.cpp
+40 -40
View File
@@ -2,38 +2,38 @@
Game::Game(int argc, char* argv[]) Game::Game(int argc, char* argv[])
{ {
ResourceManager::RegisterType<ConfigFile>("ConfigFile"); ResourceManager::RegisterType<ConfigFile>("ConfigFile");
ResourceManager::RegisterType<Model>("Model"); ResourceManager::RegisterType<Model>("Model");
ResourceManager::RegisterType<Texture>("Texture"); ResourceManager::RegisterType<Texture>("Texture");
ResourceManager::RegisterType<EntityXMLFile>("EntityXMLFile"); ResourceManager::RegisterType<EntityXMLFile>("EntityXMLFile");
m_Config = ResourceManager::Load<ConfigFile>("Config.ini"); m_Config = ResourceManager::Load<ConfigFile>("Config.ini");
LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1)); LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
// Create the core event broker // Create the core event broker
m_EventBroker = new EventBroker(); m_EventBroker = new EventBroker();
m_RenderQueueFactory = new RenderQueueFactory(); m_RenderQueueFactory = new RenderQueueFactory();
// Create the renderer // Create the renderer
m_Renderer = new Renderer(m_EventBroker); m_Renderer = new Renderer(m_EventBroker);
m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false)); m_Renderer->SetFullscreen(m_Config->Get<bool>("Video.Fullscreen", false));
m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false)); m_Renderer->SetVSYNC(m_Config->Get<bool>("Video.VSYNC", false));
m_Renderer->SetResolution(Rectangle( m_Renderer->SetResolution(Rectangle(
0, 0,
0, 0,
m_Config->Get<int>("Video.Width", 1280), m_Config->Get<int>("Video.Width", 1280),
m_Config->Get<int>("Video.Height", 720) m_Config->Get<int>("Video.Height", 720)
)); ));
m_Renderer->Initialize(); m_Renderer->Initialize();
// Create input manager // Create input manager
m_InputManager = new InputManager(m_Renderer->Window(), m_EventBroker); m_InputManager = new InputManager(m_Renderer->Window(), m_EventBroker);
// Create the root level GUI frame // Create the root level GUI frame
m_FrameStack = new GUI::Frame(m_EventBroker); m_FrameStack = new GUI::Frame(m_EventBroker);
m_FrameStack->Width = m_Renderer->Resolution().Width; m_FrameStack->Width = m_Renderer->Resolution().Width;
m_FrameStack->Height = m_Renderer->Resolution().Height; m_FrameStack->Height = m_Renderer->Resolution().Height;
// Create a world // Create a world
m_World = new World(); m_World = new World();
@@ -41,34 +41,34 @@ Game::Game(int argc, char* argv[])
if (!mapToLoad.empty()) { if (!mapToLoad.empty()) {
ResourceManager::Load<EntityXMLFile>(mapToLoad)->PopulateWorld(m_World); ResourceManager::Load<EntityXMLFile>(mapToLoad)->PopulateWorld(m_World);
} }
// Create system pipeline // Create system pipeline
m_SystemPipeline = new SystemPipeline(m_EventBroker); m_SystemPipeline = new SystemPipeline(m_EventBroker);
m_SystemPipeline->AddSystem<RaptorCopterSystem>(); m_SystemPipeline->AddSystem<RaptorCopterSystem>();
m_SystemPipeline->AddSystem<PlayerSystem>(); m_SystemPipeline->AddSystem<PlayerSystem>();
m_LastTime = glfwGetTime(); m_LastTime = glfwGetTime();
testIntialize(); testIntialize();
} }
Game::~Game() Game::~Game()
{ {
delete m_FrameStack; delete m_FrameStack;
delete m_EventBroker; delete m_EventBroker;
} }
void Game::Tick() void Game::Tick()
{ {
double currentTime = glfwGetTime(); double currentTime = glfwGetTime();
double dt = currentTime - m_LastTime; double dt = currentTime - m_LastTime;
m_LastTime = currentTime; m_LastTime = currentTime;
m_EventBroker->Swap(); m_EventBroker->Swap();
m_InputManager->Update(dt); m_InputManager->Update(dt);
m_EventBroker->Swap(); m_EventBroker->Swap();
// Iterate through systems and update world! // Iterate through systems and update world!
m_SystemPipeline->Update(m_World, dt); m_SystemPipeline->Update(m_World, dt);
@@ -76,12 +76,12 @@ void Game::Tick()
m_Renderer->Update(dt); m_Renderer->Update(dt);
m_RenderQueueFactory->Update(m_World); m_RenderQueueFactory->Update(m_World);
m_Renderer->Draw(m_RenderQueueFactory->RenderQueues()); m_Renderer->Draw(m_RenderQueueFactory->RenderQueues());
m_EventBroker->Swap(); m_EventBroker->Swap();
m_EventBroker->Clear(); m_EventBroker->Clear();
glfwPollEvents(); glfwPollEvents();
} }
src/Game/PlayerSystem.cpp
+44 -48
View File
@@ -3,60 +3,56 @@
void PlayerSystem::Update(World * world, ComponentWrapper & player, double dt) void PlayerSystem::Update(World * world, ComponentWrapper & player, double dt)
{ {
if (input.Forward) { if (input.Forward) {
m_Direction.z = -1; m_Direction.z = -1;
} } else if (input.Back) {
else if (input.Back) { m_Direction.z = 1;
m_Direction.z = 1; } else {
} m_Direction.z = 0;
else { }
m_Direction.z = 0; if (input.Left) {
} m_Direction.x = -1;
if (input.Left) { } else if (input.Right) {
m_Direction.x = -1; m_Direction.x = 1;
} } else {
else if (input.Right) { m_Direction.x = 0;
m_Direction.x = 1; }
} m_EventBroker->Process<PlayerSystem>();
else { ComponentWrapper& transform = world->GetComponent(player.EntityID, "Transform");
m_Direction.x = 0; (glm::vec3&)player["Velocity"] = m_Speed * float(dt) * m_Direction;
} (glm::vec3&)transform["Position"] += (glm::vec3)player["Velocity"];
m_EventBroker->Process<PlayerSystem>();
ComponentWrapper& transform = world->GetComponent(player.EntityID, "Transform");
(glm::vec3&)player["Velocity"] = m_Speed * float(dt) * m_Direction;
(glm::vec3&)transform["Position"] += (glm::vec3)player["Velocity"];
} }
bool PlayerSystem::OnKeyDown(const Events::KeyDown & event) bool PlayerSystem::OnKeyDown(const Events::KeyDown & event)
{ {
if (event.KeyCode == GLFW_KEY_W) { if (event.KeyCode == GLFW_KEY_W) {
input.Forward = true; input.Forward = true;
} }
if (event.KeyCode == GLFW_KEY_A) { if (event.KeyCode == GLFW_KEY_A) {
input.Left = true; input.Left = true;
} }
if (event.KeyCode == GLFW_KEY_S) { if (event.KeyCode == GLFW_KEY_S) {
input.Back = true; input.Back = true;
} }
if (event.KeyCode == GLFW_KEY_D) { if (event.KeyCode == GLFW_KEY_D) {
input.Right = true; input.Right = true;
} }
return true; return true;
} }
bool PlayerSystem::OnKeyUp(const Events::KeyUp & event) bool PlayerSystem::OnKeyUp(const Events::KeyUp & event)
{ {
if (event.KeyCode == GLFW_KEY_W) { if (event.KeyCode == GLFW_KEY_W) {
input.Forward = false; input.Forward = false;
} }
if (event.KeyCode == GLFW_KEY_A) { if (event.KeyCode == GLFW_KEY_A) {
input.Left = false; input.Left = false;
} }
if (event.KeyCode == GLFW_KEY_S) { if (event.KeyCode == GLFW_KEY_S) {
input.Back = false; input.Back = false;
} }
if (event.KeyCode == GLFW_KEY_D) { if (event.KeyCode == GLFW_KEY_D) {
input.Right = false; input.Right = false;
} }
return false; return false;
} }