initial commit
This commit is contained in:
Confideo-IOM
@@ -0,0 +1,390 @@
|
||||
#include "HydraEngine.h"
|
||||
#include "HydraInputManager.h"
|
||||
|
||||
#include "../scheduler/HydraTaskScheduler.h"
|
||||
|
||||
#include "../scheduler/HydraTaskScheduler.h"
|
||||
#include "../windowmanager/HydraWindowManager.h"
|
||||
|
||||
#include "../game/HydraGameProxy.h"
|
||||
#include "../renderer/HydraRenderer.h"
|
||||
#include "../buffer/HydraBufferManager.h"
|
||||
#include "../buffer/HydraVertexBufferManager.h"
|
||||
#include "../buffer/HydraTextureBufferManager.h"
|
||||
#include "../buffer/HydraMaterialBufferManager.h"
|
||||
#include "../buffer/HydraLightBufferManager.h"
|
||||
|
||||
#include "../ecs/HydraECS.h"
|
||||
#include "../ecs/systems/HydraTransformSystem.h"
|
||||
#include "../ecs/systems/HydraMeshSystem.h"
|
||||
#include "../ecs/systems/HydraRenderSystem.h"
|
||||
#include "../ecs/systems/HydraMaterialSystem.h"
|
||||
#include "../ecs/systems/HydraLightSystem.h"
|
||||
|
||||
#include "../ecs/components/HydraPositionComponent.h"
|
||||
#include "../ecs/components/HydraMeshComponent.h"
|
||||
#include "../ecs/components/HydraRenderableComponent.h"
|
||||
#include "../ecs/components/HydraTextureComponent.h"
|
||||
#include "../ecs/components/HydraMaterialComponent.h"
|
||||
#include "../ecs/components/HydraLightComponent.h"
|
||||
|
||||
|
||||
#include "../camera/HydraCamera.h"
|
||||
#include "../actor/HydraActorManager.h"
|
||||
|
||||
#include "../pipeline/HydraPipeline.h"
|
||||
#include "../pipeline/HydraForwardPipeline.h"
|
||||
#include "../pipeline/HydraDeferredPipeline.h"
|
||||
|
||||
#include "../task/windowmanager/HydraInitialiseWindowManagerTask.hpp"
|
||||
#include "../task/windowmanager/HydraShutdownWindowManagerTask.hpp"
|
||||
#include "../task/windowmanager/HydraProcessInputTask.hpp"
|
||||
#include "../task/renderer/HydraInitialiseRendererTask.hpp"
|
||||
#include "../task/renderer/HydraRenderTask.hpp"
|
||||
#include "../task/pipeline/HydraInitialisePipelineTask.hpp"
|
||||
#include "../task/pipeline/HydraShutdownPipelineTask.hpp"
|
||||
#include "../task/pipeline/HydraRenderPipelineTask.hpp"
|
||||
|
||||
#include "../task/ecs/HydraUpdateSystemTask.hpp"
|
||||
#include "../task/ecs/HydraInitialiseComponentsTask.hpp"
|
||||
#include "../task/buffer/HydraShutdownBufferManagerTask.hpp"
|
||||
#include "../task/buffer/HydraInitialiseTextureManagerTask.hpp"
|
||||
#include "../task/actor/HydraUpdatePlayerTask.h"
|
||||
|
||||
#include "../mesh/HydraMeshManager.h"
|
||||
HydraTaskScheduler *const HydraEngine::TaskScheduler()
|
||||
{
|
||||
return m_task_scheduler;
|
||||
}
|
||||
|
||||
void HydraEngine::InitialiseGame(HydraGameProxy *game)
|
||||
{
|
||||
m_game = game;
|
||||
}
|
||||
|
||||
void HydraEngine::Start()
|
||||
{
|
||||
_CreateManagers();
|
||||
_InitialiseManagers();
|
||||
_InitialiseSystems();
|
||||
m_game->Initialise();
|
||||
_GameLoop();
|
||||
_Shutdown();
|
||||
}
|
||||
|
||||
HydraWindowManager *const HydraEngine::WindowManager()
|
||||
{
|
||||
return m_window_manager;
|
||||
}
|
||||
|
||||
HydraRenderSettings HydraEngine::RenderSettings()
|
||||
{
|
||||
return m_render_settings;
|
||||
}
|
||||
|
||||
HydraInputManager *const HydraEngine::InputManager()
|
||||
{
|
||||
return m_input_manager;
|
||||
}
|
||||
|
||||
HydraRenderer *const HydraEngine::Renderer()
|
||||
{
|
||||
return m_renderer;
|
||||
}
|
||||
|
||||
HydraECS *const HydraEngine::ECS()
|
||||
{
|
||||
return m_ecs;
|
||||
}
|
||||
|
||||
HydraActorManager *const HydraEngine::ActorManager()
|
||||
{
|
||||
return m_actor_manager;
|
||||
}
|
||||
|
||||
HydraCamera *const HydraEngine::Camera()
|
||||
{
|
||||
return m_camera;
|
||||
}
|
||||
|
||||
HydraBufferManager *const HydraEngine::BufferManager()
|
||||
{
|
||||
return m_buffer_manager;
|
||||
}
|
||||
|
||||
HydraVertexBufferManager *const HydraEngine::VertexBufferManager()
|
||||
{
|
||||
return m_vertex_buffer_manager;
|
||||
}
|
||||
|
||||
HydraMeshManager *const HydraEngine::MeshManager()
|
||||
{
|
||||
return m_mesh_manager;
|
||||
}
|
||||
|
||||
HydraPipeline *const HydraEngine::Pipeline()
|
||||
{
|
||||
return m_pipeline;
|
||||
}
|
||||
|
||||
HydraTextureBufferManager *const HydraEngine::TextureBufferManager()
|
||||
{
|
||||
return m_texture_buffer_manager;
|
||||
}
|
||||
|
||||
HydraMaterialBufferManager *const HydraEngine::MaterialBufferManager()
|
||||
{
|
||||
return m_material_buffer_manager;
|
||||
}
|
||||
|
||||
HydraLightBufferManager *const HydraEngine::LightBufferManager()
|
||||
{
|
||||
return m_light_buffer_manager;
|
||||
}
|
||||
|
||||
void HydraEngine::PossessPlayer(HydraID actor_id)
|
||||
{
|
||||
m_possessed_actor_id = actor_id;
|
||||
}
|
||||
|
||||
HydraID HydraEngine::GetPossessedPlayer()
|
||||
{
|
||||
return m_possessed_actor_id;
|
||||
}
|
||||
|
||||
float HydraEngine::GetDeltaT()
|
||||
{
|
||||
return m_delta_t;
|
||||
}
|
||||
|
||||
uint32_t HydraEngine::GetLightCount()
|
||||
{
|
||||
return m_light_system->GetLightCount();
|
||||
}
|
||||
|
||||
void HydraEngine::_CreateManagers()
|
||||
{
|
||||
m_camera = new HydraCamera();
|
||||
m_task_scheduler = new HydraTaskScheduler();
|
||||
m_window_manager = new HydraWindowManager();
|
||||
m_input_manager = new HydraInputManager();
|
||||
m_renderer = new HydraRenderer();
|
||||
m_ecs = new HydraECS();
|
||||
m_actor_manager = new HydraActorManager();
|
||||
m_buffer_manager = new HydraBufferManager();
|
||||
m_vertex_buffer_manager = new HydraVertexBufferManager();
|
||||
m_mesh_manager = new HydraMeshManager();
|
||||
m_pipeline = new HydraForwardPipeline();
|
||||
m_deferred_pipeline = new HydraDeferredPipeline();
|
||||
m_texture_buffer_manager = new HydraTextureBufferManager();
|
||||
m_material_buffer_manager = new HydraMaterialBufferManager();
|
||||
m_light_buffer_manager = new HydraLightBufferManager();
|
||||
}
|
||||
|
||||
void HydraEngine::_InitialiseManagers()
|
||||
{
|
||||
m_task_scheduler->Initialise(1);
|
||||
HydraID create_window_task_id = m_task_scheduler->CreateTask<HydraInitialiseWindowManagerTask>(HydraThreadAffinity::Render);
|
||||
m_task_scheduler->WaitForTask(create_window_task_id);
|
||||
|
||||
HydraID create_renderer_task_id = m_task_scheduler->CreateTask<HydraInitialiseRendererTask>(HydraThreadAffinity::Render);
|
||||
m_task_scheduler->WaitForTask(create_renderer_task_id);
|
||||
|
||||
m_mesh_manager->Initialise();
|
||||
m_ecs->Init();
|
||||
m_actor_manager->Initialise(MAX_ACTORS);
|
||||
|
||||
m_buffer_manager->Initialise();
|
||||
m_vertex_buffer_manager->Initialise();
|
||||
m_texture_buffer_manager->Intialise();
|
||||
m_material_buffer_manager->Intialise();
|
||||
m_light_buffer_manager->Initialise();
|
||||
|
||||
}
|
||||
|
||||
void HydraEngine::_InitialiseSystems()
|
||||
{
|
||||
m_ecs->RegisterComponentType<HydraPositionComponent>();
|
||||
m_ecs->RegisterComponentType<HydraMeshComponent>();
|
||||
m_ecs->RegisterComponentType<HydraRenderableComponent>();
|
||||
m_ecs->RegisterComponentType<HydraTextureComponent>();
|
||||
m_ecs->RegisterComponentType<HydraMaterialComponent>();
|
||||
m_ecs->RegisterComponentType<HydraLightComponent>();
|
||||
|
||||
m_mesh_system = m_ecs->RegisterSystem<HydraMeshSystem>();
|
||||
m_transform_system = m_ecs->RegisterSystem<HydraTransformSystem>();
|
||||
m_render_system = m_ecs->RegisterSystem<HydraRenderSystem>();
|
||||
m_material_system = m_ecs->RegisterSystem<HydraMaterialSystem>();
|
||||
m_light_system = m_ecs->RegisterSystem<HydraLightSystem>();
|
||||
|
||||
HydraSignature mesh_sig;
|
||||
HydraSignature trans_sig;
|
||||
HydraSignature render_sig;
|
||||
HydraSignature material_sig;
|
||||
HydraSignature light_sig;
|
||||
|
||||
mesh_sig.set(m_ecs->GetComponentType<HydraMeshComponent>(),true);
|
||||
trans_sig.set(m_ecs->GetComponentType<HydraPositionComponent>(),true);
|
||||
render_sig.set(m_ecs->GetComponentType<HydraRenderableComponent>(),true);
|
||||
material_sig.set(m_ecs->GetComponentType<HydraMaterialComponent>(),true);
|
||||
light_sig.set(m_ecs->GetComponentType<HydraLightComponent>(), true);
|
||||
|
||||
m_ecs->SetSystemSignature<HydraMeshSystem>(mesh_sig);
|
||||
m_ecs->SetSystemSignature<HydraTransformSystem>(trans_sig);
|
||||
m_ecs->SetSystemSignature<HydraRenderSystem>(render_sig);
|
||||
m_ecs->SetSystemSignature<HydraMaterialSystem>(material_sig);
|
||||
m_ecs->SetSystemSignature<HydraLightSystem>(light_sig);
|
||||
}
|
||||
|
||||
void HydraEngine::_UpdateSystems()
|
||||
{
|
||||
HydraID posUpdateBarrierID = m_task_scheduler->CreateBarrier();
|
||||
|
||||
HydraID update_trans_id = m_task_scheduler->CreateTask<HydraUpdateSystemTask>(HydraThreadAffinity::General, posUpdateBarrierID);
|
||||
HydraUpdateSystemTask* update_trans_task = static_cast<HydraUpdateSystemTask*>(m_task_scheduler->GetTask(update_trans_id));
|
||||
update_trans_task->Initialise(m_delta_t, m_transform_system);
|
||||
|
||||
HydraID update_mat_id = m_task_scheduler->CreateTask<HydraUpdateSystemTask>(HydraThreadAffinity::General, posUpdateBarrierID);
|
||||
HydraUpdateSystemTask* update_mat_task = static_cast<HydraUpdateSystemTask*>(m_task_scheduler->GetTask(update_mat_id));
|
||||
update_mat_task->Initialise(m_delta_t, m_material_system);
|
||||
|
||||
m_task_scheduler->StartTask(update_trans_id);
|
||||
m_task_scheduler->StartTask(update_mat_id);
|
||||
|
||||
m_task_scheduler->WaitForBarrier(posUpdateBarrierID);
|
||||
|
||||
HydraID update_light_id = m_task_scheduler->CreateTask<HydraUpdateSystemTask>(HydraThreadAffinity::General);
|
||||
HydraUpdateSystemTask* update_light_task = static_cast<HydraUpdateSystemTask*>(m_task_scheduler->GetTask(update_light_id));
|
||||
update_light_task->Initialise(m_delta_t, m_light_system);
|
||||
m_task_scheduler->WaitForTask(update_light_id);
|
||||
}
|
||||
|
||||
void HydraEngine::_GameLoop()
|
||||
{
|
||||
// game loop
|
||||
std::chrono::steady_clock clock;
|
||||
int fpsFrameCount = 0;
|
||||
int fpsHighLowCount = 0;
|
||||
|
||||
float fpsLow = 99999;
|
||||
float fpsHigh = 0;
|
||||
float totalTime = 0.0f;
|
||||
bool fixed_tick = false;
|
||||
|
||||
std::chrono::time_point<std::chrono::steady_clock> last_tick = clock.now();
|
||||
std::chrono::time_point<std::chrono::steady_clock> last_fixed_tick = clock.now();
|
||||
|
||||
// m_fps_label_id = UIManager()->CreateWidget<HydraUILabelWidget>();
|
||||
// HydraUILabelWidget* label = (HydraUILabelWidget*)UIManager()->GetWidget(m_fps_label_id);
|
||||
// label->SetText("FPS");
|
||||
// label->Position = glm::vec3(0, 200, 0);
|
||||
// label->SetFont("Calibri", 10.0f);
|
||||
|
||||
HydraID initialise_pipeline_task_id = m_task_scheduler->CreateTask<HydraInitialisePipelineTask>(HydraThreadAffinity::Render);
|
||||
HydraInitialisePipelineTask *pipeline_task = static_cast<HydraInitialisePipelineTask*>(m_task_scheduler->GetTask(initialise_pipeline_task_id));
|
||||
pipeline_task->Initialise(m_pipeline);
|
||||
m_task_scheduler->WaitForTask(initialise_pipeline_task_id);
|
||||
|
||||
HydraID initialise_def_pipeline_task_id = m_task_scheduler->CreateTask<HydraInitialisePipelineTask>(HydraThreadAffinity::Render);
|
||||
HydraInitialisePipelineTask *pipeline_def_task = static_cast<HydraInitialisePipelineTask*>(m_task_scheduler->GetTask(initialise_def_pipeline_task_id));
|
||||
pipeline_def_task->Initialise(m_deferred_pipeline);
|
||||
m_task_scheduler->WaitForTask(initialise_def_pipeline_task_id);
|
||||
|
||||
while (m_running)
|
||||
{
|
||||
HydraID barrierID = m_task_scheduler->CreateBarrier();
|
||||
std::chrono::time_point<std::chrono::steady_clock> this_tick = clock.now();
|
||||
std::chrono::duration<float> diff = this_tick - last_tick;
|
||||
std::chrono::duration<float> fixed_diff = this_tick - last_fixed_tick;
|
||||
|
||||
totalTime = totalTime += diff.count();
|
||||
|
||||
m_delta_t = diff.count();
|
||||
float fixed_delta_t = fixed_diff.count();
|
||||
if (fixed_delta_t > 0.016666666666f)
|
||||
{
|
||||
m_fixed_delta_t = fixed_diff.count();
|
||||
last_fixed_tick = this_tick;
|
||||
fixed_tick = true;
|
||||
HydraID processInputID = m_task_scheduler->CreateTask<HydraProcessInputTask>(HydraThreadAffinity::Render, barrierID);
|
||||
m_task_scheduler->StartTask(processInputID);
|
||||
|
||||
//Physics here
|
||||
}
|
||||
if (fpsFrameCount >= 15)
|
||||
{
|
||||
float fps = 1.0f / (totalTime / fpsFrameCount);
|
||||
// m_fps_label->SetText("FPS: " + std::to_string(fps));
|
||||
// label->SetText("FPS: " + std::to_string(fps));
|
||||
fpsFrameCount = 0;
|
||||
totalTime = 0.0f;
|
||||
}
|
||||
|
||||
last_tick = this_tick;
|
||||
|
||||
fpsFrameCount++;
|
||||
HydraID initialise_components_id = m_task_scheduler->CreateTask<HydraInitialiseComponentsTask>(HydraThreadAffinity::General, barrierID);
|
||||
HydraID update_player_task_id = m_task_scheduler->CreateTask<HydraUpdatePlayerTask>(HydraThreadAffinity::General, barrierID);
|
||||
|
||||
m_task_scheduler->StartTask(initialise_components_id);
|
||||
m_task_scheduler->StartTask(update_player_task_id);
|
||||
m_task_scheduler->WaitForBarrier(barrierID);
|
||||
m_game->Update(m_delta_t);
|
||||
|
||||
_UpdateSystems();
|
||||
|
||||
// HydraID render_task_id = m_task_scheduler->CreateTask<HydraRenderPipelineTask>(HydraThreadAffinity::Render);
|
||||
// HydraRenderPipelineTask* render_task = static_cast<HydraRenderPipelineTask*>(m_task_scheduler->GetTask(render_task_id));
|
||||
// render_task->Initialise(m_pipeline);
|
||||
// m_task_scheduler->WaitForTask(render_task_id);
|
||||
|
||||
HydraID render_def_task_id = m_task_scheduler->CreateTask<HydraRenderPipelineTask>(HydraThreadAffinity::Render);
|
||||
HydraRenderPipelineTask* render_def_task = static_cast<HydraRenderPipelineTask*>(m_task_scheduler->GetTask(render_def_task_id));
|
||||
render_def_task->Initialise(m_deferred_pipeline);
|
||||
m_task_scheduler->WaitForTask(render_def_task_id);
|
||||
}
|
||||
}
|
||||
|
||||
void HydraEngine::_Shutdown()
|
||||
{
|
||||
m_actor_manager->Shutdown();
|
||||
m_ecs->Shutdown();
|
||||
|
||||
//Shutdown the buffer and vertex buffer managers
|
||||
HydraID shutdown_buffer_mgr_id = m_task_scheduler->CreateTask<HydraShutdownBufferManagerTask>(HydraThreadAffinity::Render);
|
||||
m_task_scheduler->WaitForTask(shutdown_buffer_mgr_id);
|
||||
|
||||
HydraID shutdown_pipeline_id = m_task_scheduler->CreateTask<HydraShutdownPipelineTask>(HydraThreadAffinity::Render);
|
||||
HydraShutdownPipelineTask *pipeline_task = static_cast<HydraShutdownPipelineTask*>(m_task_scheduler->GetTask(shutdown_pipeline_id));
|
||||
pipeline_task->Initialise(m_pipeline);
|
||||
m_task_scheduler->WaitForTask(shutdown_pipeline_id);
|
||||
|
||||
m_task_scheduler->Shutdown();
|
||||
|
||||
delete m_actor_manager;
|
||||
delete m_ecs;
|
||||
delete m_input_manager;
|
||||
delete m_window_manager;
|
||||
delete m_task_scheduler;
|
||||
delete m_buffer_manager;
|
||||
delete m_vertex_buffer_manager;
|
||||
delete m_pipeline;
|
||||
delete m_texture_buffer_manager;
|
||||
delete m_material_buffer_manager;
|
||||
delete m_light_buffer_manager;
|
||||
}
|
||||
|
||||
bool HydraEngine::KeyPressed(HYDRA_KEY_CODES key)
|
||||
{
|
||||
return m_input_manager->KeyPressed(key);
|
||||
}
|
||||
|
||||
glm::vec2 HydraEngine::MouseChange()
|
||||
{
|
||||
return m_input_manager->MouseChange();
|
||||
}
|
||||
|
||||
void HydraEngine::Exit()
|
||||
{
|
||||
m_running = false;
|
||||
}
|
||||
@@ -0,0 +1,102 @@
|
||||
#ifndef HYDRAENGINE
|
||||
#define HYDRAENGINE
|
||||
|
||||
#include "HydraObject.h"
|
||||
#include "../windowmanager/HydraRenderSettings.h"
|
||||
#include <GLMIncludes.h>
|
||||
|
||||
class HydraTaskScheduler;
|
||||
class HydraGameProxy;
|
||||
class HydraWindowManager;
|
||||
class HydraInputManager;
|
||||
class HydraRenderer;
|
||||
class HydraECS;
|
||||
class HydraActorManager;
|
||||
class HydraCamera;
|
||||
class HydraBufferManager;
|
||||
class HydraVertexBufferManager;
|
||||
class HydraMeshManager;
|
||||
class HydraMeshSystem;
|
||||
class HydraRenderSystem;
|
||||
class HydraTransformSystem;
|
||||
class HydraMaterialSystem;
|
||||
class HydraPipeline;
|
||||
class HydraTextureBufferManager;
|
||||
class HydraMaterialBufferManager;
|
||||
class HydraLightBufferManager;
|
||||
class HydraLightSystem;
|
||||
|
||||
class CLASS_DEFINE HydraEngine : public HydraObject
|
||||
{
|
||||
public:
|
||||
static HydraEngine *GetInstance()
|
||||
{
|
||||
static HydraEngine instance;
|
||||
return &instance;
|
||||
}
|
||||
HydraTaskScheduler* const TaskScheduler();
|
||||
void InitialiseGame(HydraGameProxy* game);
|
||||
void Start();
|
||||
|
||||
bool KeyPressed(HYDRA_KEY_CODES key);
|
||||
glm::vec2 MouseChange();
|
||||
void Exit();
|
||||
|
||||
HydraWindowManager* const WindowManager();
|
||||
HydraRenderSettings RenderSettings();
|
||||
HydraInputManager* const InputManager();
|
||||
HydraRenderer* const Renderer();
|
||||
HydraECS* const ECS();
|
||||
HydraActorManager* const ActorManager();
|
||||
HydraCamera* const Camera();
|
||||
HydraBufferManager* const BufferManager();
|
||||
HydraVertexBufferManager* const VertexBufferManager();
|
||||
HydraMeshManager* const MeshManager();
|
||||
HydraPipeline* const Pipeline();
|
||||
HydraTextureBufferManager* const TextureBufferManager();
|
||||
HydraMaterialBufferManager* const MaterialBufferManager();
|
||||
HydraLightBufferManager* const LightBufferManager();
|
||||
void PossessPlayer(HydraID actor_id);
|
||||
HydraID GetPossessedPlayer();
|
||||
float GetDeltaT();
|
||||
uint32_t GetLightCount();
|
||||
private:
|
||||
void _CreateManagers();
|
||||
void _InitialiseManagers();
|
||||
void _InitialiseSystems();
|
||||
void _UpdateSystems();
|
||||
void _GameLoop();
|
||||
void _Shutdown();
|
||||
|
||||
class HydraGameProxy* m_game = nullptr;
|
||||
HydraTaskScheduler* m_task_scheduler = nullptr;
|
||||
HydraWindowManager* m_window_manager = nullptr;
|
||||
HydraInputManager* m_input_manager = nullptr;
|
||||
HydraRenderer* m_renderer = nullptr;
|
||||
HydraECS* m_ecs = nullptr;
|
||||
HydraActorManager* m_actor_manager = nullptr;
|
||||
HydraCamera* m_camera = nullptr;
|
||||
HydraBufferManager* m_buffer_manager = nullptr;
|
||||
HydraVertexBufferManager* m_vertex_buffer_manager = nullptr;
|
||||
HydraMeshManager* m_mesh_manager = nullptr;
|
||||
HydraRenderSettings m_render_settings;
|
||||
HydraPipeline* m_pipeline = nullptr;
|
||||
HydraPipeline* m_deferred_pipeline = nullptr;
|
||||
HydraTextureBufferManager* m_texture_buffer_manager = nullptr;
|
||||
HydraMaterialBufferManager* m_material_buffer_manager = nullptr;
|
||||
HydraLightBufferManager* m_light_buffer_manager = nullptr;
|
||||
|
||||
std::shared_ptr<HydraMeshSystem> m_mesh_system;
|
||||
std::shared_ptr<HydraTransformSystem> m_transform_system;
|
||||
std::shared_ptr<HydraRenderSystem> m_render_system;
|
||||
std::shared_ptr<HydraMaterialSystem> m_material_system;
|
||||
std::shared_ptr<HydraLightSystem> m_light_system;
|
||||
|
||||
bool m_running = true;
|
||||
float m_delta_t = 0.0f;
|
||||
float m_fixed_delta_t = 0.0f;
|
||||
HydraID m_possessed_actor_id = INVALID_HYDRA_ID;
|
||||
|
||||
};
|
||||
|
||||
#endif /* HYDRAENGINE */
|
||||
@@ -0,0 +1,82 @@
|
||||
#include "HydraInputManager.h"
|
||||
#include "../windowmanager/HydraWindowManager.h"
|
||||
|
||||
void HydraInputManager::ProcessInput()
|
||||
{
|
||||
bool quit = false;
|
||||
m_mouse_change = glm::vec2();
|
||||
m_key_down.clear();
|
||||
m_key_up.clear();
|
||||
while (!quit)
|
||||
{
|
||||
HydraKeyPressStuct key_press;
|
||||
if (HydraWindowManager::GetKeyPress(key_press))
|
||||
{
|
||||
//DebugLog("Got Key " + std::to_string(key_press.key_code));
|
||||
m_key_presses.push_back(key_press);
|
||||
if ((key_press.key_code >= 0) && (key_press.key_code < 512))
|
||||
{
|
||||
if (key_press.key_action == KEY_PRESS_ACTIONS::HYDRA_KEY_PRESSED)
|
||||
{
|
||||
m_keys[key_press.key_code] = 1;
|
||||
m_key_up.push_back(key_press.key_code);
|
||||
}
|
||||
else
|
||||
{
|
||||
m_keys[key_press.key_code] = 0;
|
||||
m_key_down.push_back(key_press.key_code);
|
||||
}
|
||||
}
|
||||
if (m_key_presses.size() > 10000)
|
||||
{
|
||||
m_key_presses.pop_back();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
quit = true;
|
||||
}
|
||||
}
|
||||
quit = false;
|
||||
bool new_mouse_movement = false;
|
||||
|
||||
|
||||
while (!quit)
|
||||
{
|
||||
HydraMouseMoveStruct mouse_move;
|
||||
if (HydraWindowManager::GetMouseMove(mouse_move))
|
||||
{
|
||||
m_mouse_moves.push(glm::vec2(mouse_move.x, mouse_move.y));
|
||||
new_mouse_movement = true;
|
||||
if (m_mouse_moves.size() > 10000)
|
||||
{
|
||||
m_mouse_moves.pop();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
quit = true;
|
||||
}
|
||||
}
|
||||
if (m_mouse_moves.size() > 0)
|
||||
{
|
||||
if (!m_mouse_reset)
|
||||
{
|
||||
m_mouse_change = m_last_mouse - m_mouse_moves.back();
|
||||
m_last_mouse = m_mouse_moves.back();
|
||||
}
|
||||
else
|
||||
{
|
||||
m_mouse_change = glm::vec2(0);
|
||||
m_last_mouse = m_mouse_moves.back();
|
||||
m_mouse_reset = false;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
bool HydraInputManager::KeyPressed(HYDRA_KEY_CODES key)
|
||||
{
|
||||
return m_keys[(unsigned int)key] == 1;
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
#ifndef HYDRAINPUTMANAGER
|
||||
#define HYDRAINPUTMANAGER
|
||||
#include "HydraObject.h"
|
||||
#include <vector>
|
||||
#include <queue>
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
class HydraInputManager : public HydraObject
|
||||
{
|
||||
private:
|
||||
int m_keys[512] = { };
|
||||
std::vector<int> m_key_down;
|
||||
std::vector<int> m_key_up;
|
||||
glm::vec2 m_last_mouse = glm::vec2(0, 0);
|
||||
glm::vec2 m_mouse_change = glm::vec2(0, 0);
|
||||
glm::vec2 m_mouse_pos = glm::vec2(0, 0);
|
||||
std::vector<HydraKeyPressStuct> m_key_presses;
|
||||
std::queue<glm::vec2> m_mouse_moves;
|
||||
bool m_mouse_reset = true;
|
||||
|
||||
|
||||
|
||||
friend class HydraEngine;
|
||||
public:
|
||||
void ProcessInput();
|
||||
bool KeyPressed(HYDRA_KEY_CODES key);
|
||||
glm::vec2 MouseChange() {return m_mouse_change;}
|
||||
|
||||
};
|
||||
|
||||
|
||||
#endif /* HYDRAINPUTMANAGER */
|
||||
@@ -0,0 +1,17 @@
|
||||
#include "HydraObject.h"
|
||||
#include "HydraEngine.h"
|
||||
|
||||
HydraEngine *const HydraObject::GetEngine()
|
||||
{
|
||||
return HydraEngine::GetInstance();
|
||||
}
|
||||
|
||||
void HydraObject::DebugLog(std::string log_entry)
|
||||
{
|
||||
std::cout << log_entry + "\r\n";
|
||||
}
|
||||
|
||||
void HydraObject::ClearLog()
|
||||
{
|
||||
std::cout << "\x1B[2J\x1B[H";
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
#ifndef HYDRAOBJECT
|
||||
#define HYDRAOBJECT
|
||||
#include "../HydraDefines.h"
|
||||
//#include "HydraEngine.h"
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <assert.h>
|
||||
|
||||
class HydraEngine;
|
||||
|
||||
class CLASS_DEFINE HydraObject
|
||||
{
|
||||
private:
|
||||
public:
|
||||
class HydraEngine* const GetEngine();
|
||||
void DebugLog(std::string log_entry);
|
||||
void ClearLog();
|
||||
};
|
||||
|
||||
|
||||
#endif /* HYDRAOBJECT */
|
||||
Reference in New Issue
Block a user