Merge pull request #18 from Im-Bee/textures-blocks-engine-changes

Separate voxel state per frame

Author: 1mB33

Engine/Application/Private/Input/KeysMap.cpp

@@ -1,4 +1,5 @@
 #include "Input/KeysMap.hpp"
+#include "Debug/Assert.h"
 
 namespace App
 {
@@ -14,22 +15,22 @@ KeysMap::KeysMap()
 void KeysMap::BindActionImpl(const AbInputBind& ib, void* pThis, AbAction a, AbMouseAction ma)
 {
 	AB_ASSERT(ib.Type == EAbBindType::Keyboard);
-	AB_ASSERT(ib.keyboard.KeyCode > AB_INVALID_KEY && ib.keyboard.KeyCode < AB_KEY_COUNT);
-	AB_ASSERT(m_vKeys[ib.keyboard.KeyCode].pThis == nullptr);
+    AB_ASSERT(ib.Keyboard.KeyCode > AB_INVALID_KEY && ib.Keyboard.KeyCode < AB_KEY_COUNT);
+    AB_ASSERT(m_vKeys[ib.Keyboard.KeyCode].pThis == nullptr);
     AB_ASSERT(ma == nullptr);
     AB_ASSERT(pThis != nullptr);
 
-	m_vKeys[ib.keyboard.KeyCode] = ActionReplayData { pThis, a };
+	m_vKeys[ib.Keyboard.KeyCode] = ActionReplayData { pThis, a };
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
 void KeysMap::UnbindActionImpl(const AbInputBind& ib, void* pThis)
 {
 	AB_ASSERT(ib.Type == EAbBindType::Keyboard);
-	AB_ASSERT(ib.keyboard.KeyCode > AB_INVALID_KEY && ib.keyboard.KeyCode < AB_KEY_COUNT);
+	AB_ASSERT(ib.Keyboard.KeyCode > AB_INVALID_KEY && ib.Keyboard.KeyCode < AB_KEY_COUNT);
     AB_ASSERT(pThis != nullptr);
 
-	m_vKeys[ib.keyboard.KeyCode].pThis = nullptr;
+	m_vKeys[ib.Keyboard.KeyCode].pThis = nullptr;
 }
 
 // ---------------------------------------------------------------------------------------------------------------------

Engine/Application/Private/Input/MouseMap.cpp

@@ -1,4 +1,7 @@
 #include "Input/MouseMap.hpp"
+#include "Core.h"
+#include "Debug/Assert.h"
+#include "Debug/Logger.hpp"
 
 namespace App
 {
@@ -19,11 +22,15 @@ void MouseMap::UnbindActionImpl(const AbInputBind& ib, void* pThis)
 	AB_ASSERT(ib.Type == EAbBindType::Mouse);
     AB_ASSERT(pThis != nullptr);
 
-    for (auto it = m_vMouseBinds.begin(); it != m_vMouseBinds.end(); ++it) {
+    auto it = m_vMouseBinds.begin();
+    for (; it != m_vMouseBinds.end(); ++it) {
         if (it->pThis == pThis) {
             m_vMouseBinds.erase(it);
+            return;
         }
     }
+
+    AB_ASSERT(it != m_vMouseBinds.end());
 }
 
 // ---------------------------------------------------------------------------------------------------------------------

Engine/Application/Private/Input/UserInput.cpp

@@ -1,4 +1,6 @@
 #include "Input/UserInput.hpp"
+#include "Core.h"
+#include "Debug/Logger.hpp"
 #include "Input/InputEvents.h"
 #include "Input/ControllerObject.hpp"
 
@@ -10,7 +12,7 @@ using namespace Core;
 // ---------------------------------------------------------------------------------------------------------------------
 void UserInput::StartCapturing()
 { 
-    if (!m_bIsCapturing && m_pWindowDesc)
+    if (!m_bIsCapturing && this->GetWindowDesc())
         m_bIsCapturing = true;
 }
 
@@ -36,9 +38,9 @@ void UserInput::Update()
         }
     }
 
-    while (!m_pWindowDesc->InputStruct.empty()) {
-        AbInputStruct& is = m_pWindowDesc->InputStruct.front();
-        m_pWindowDesc->InputStruct.pop();
+    while (!this->GetWindowDesc()->InputStruct.empty()) {
+        AbInputStruct& is = this->GetWindowDesc()->InputStruct.front();
+        this->GetWindowDesc()->InputStruct.pop();
 
         switch (is.Event) {
             case EAbInputEvents::AbKeyPress: {
@@ -85,7 +87,7 @@ void UserInput::Update()
         }
 
 		// Consume the input event
-		m_pWindowDesc->LastEvent &= ~EAbWindowEvents::Input;
+		this->GetWindowDesc()->LastEvent &= ~EAbWindowEvents::Input;
     }
 }
 
@@ -99,57 +101,61 @@ void UserInput::Bind(void* pThis, ControllerObject* pCo, AbAction action, AbMous
 
     if (bind.Type & EAbBindType::Keyboard) 
     {
-        if (bind.keyboard.KeyCode <= AB_INVALID_KEY || bind.keyboard.KeyCode >= AB_KEY_COUNT) {
+        if (bind.Keyboard.KeyCode <= AB_INVALID_KEY || bind.Keyboard.KeyCode >= AB_KEY_COUNT) {
             AB_LOG(Debug::Error, L"Key code is an invalid code (code outside of boundries for keys).");
             AB_LOG(Debug::Error, L"Can't bind the action for the keyboard.");
             AB_LOG(Debug::Error, L"Action wasn't bound.");
             return;
         }
 
-        if (bind.keyboard.KeyState & EAbOnKeyState::Press) {
+        if (bind.Keyboard.KeyState & EAbOnState::Press) {
             m_KeyPressMap.BindAction(bind, pThis, action, nullptr);
         }
-        else if (bind.keyboard.KeyState & EAbOnKeyState::Release) {
+        else if (bind.Keyboard.KeyState & EAbOnState::Release) {
             m_KeyReleaseMap.BindAction(bind, pThis, action, nullptr);
         }
-        else if (bind.keyboard.KeyState & EAbOnKeyState::Continuous) {
+        else if (bind.Keyboard.KeyState & EAbOnState::Continuous) {
             m_KeyContinuous.BindAction(bind, pThis, action, nullptr);
         }
-
-        m_BindsHandles[pThis].push_back(bind);
     }
     else if (bind.Type & EAbBindType::Mouse) {
         m_MouseMap.BindAction(bind, pThis, nullptr, mouseAction);
     }
+
+    m_BindsHandles[pCo].push_back({ bind, pThis });
+    AB_LOG(Core::Debug::Info, L"New bind for %p, type %d", pCo, bind.Type);
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
-void UserInput::Unbind(void* pThis)
+void UserInput::Unbind(ControllerObject* pCo)
 {
-    const auto& handle = m_BindsHandles.find(pThis);
+    const auto& handle = m_BindsHandles.find(pCo);
 
     if (handle == m_BindsHandles.end()) {
-        AB_LOG(Debug::Warning, L"Cannot unbind this bind from this UserInput, because UserInput doesn't handles it.");
+        AB_LOG(Debug::Warning, L"Cannot unbind this bind from this UserInput, because UserInput doesn't handles it. "
+                                "%p", pCo);
         return;
     }
+    AB_LOG(Core::Debug::Info, L"Unbind for %p", pCo);
 
-    for (const auto& inputBind : handle->second) {
+    for (const auto& bindHandle : handle->second) {
+        auto& inputBind = bindHandle.Ib;
 
         if (inputBind.Type & EAbBindType::Keyboard) 
         {
-            if (inputBind.keyboard.KeyState & EAbOnKeyState::Press) {
-                m_KeyPressMap.UnbindAction(inputBind, pThis);
+            if (inputBind.Keyboard.KeyState & EAbOnState::Press) {
+                m_KeyPressMap.UnbindAction(inputBind, bindHandle.pThis);
             }
-            else if (inputBind.keyboard.KeyState & EAbOnKeyState::Release) {
-                m_KeyReleaseMap.UnbindAction(inputBind, pThis);
+            else if (inputBind.Keyboard.KeyState & EAbOnState::Release) {
+                m_KeyReleaseMap.UnbindAction(inputBind, bindHandle.pThis);
             }
-            else if (inputBind.keyboard.KeyState & EAbOnKeyState::Continuous) {
-                m_KeyContinuous.UnbindAction(inputBind, pThis);
+            else if (inputBind.Keyboard.KeyState & EAbOnState::Continuous) {
+                m_KeyContinuous.UnbindAction(inputBind, bindHandle.pThis);
             }
         }
         else if (inputBind.Type & EAbBindType::Mouse)
         {
-            m_MouseMap.UnbindAction(inputBind, pThis);
+            m_MouseMap.UnbindAction(inputBind, bindHandle.pThis);
         }
     }
 

Engine/Application/Public/Input/Bind.h

@@ -12,32 +12,38 @@ typedef struct AbActionType {
 
 typedef uint8_t AbKeyId;
 
-typedef enum EKeyState {
+typedef enum EState {
     IsPressed = 1,
     IsReleased = IsPressed << 1,
-} EKeyState;
+} EState;
 
-typedef enum EAbOnKeyState {
+typedef enum EAbOnState {
     Release = 1,
     Press = Release << 1,
     Continuous = Press << 1,
-} EAbOnKeyState;
+} EAbOnState;
 
 typedef enum EAbBindType {
     Keyboard = 1,
     Mouse = Keyboard << 1,
+    MouseButton = Mouse << 1,
 } EAbBindType;
 
 typedef struct AbKeyboardBind {
-    EAbOnKeyState KeyState;
+    EAbOnState KeyState;
     AbKeyId KeyCode;
 } AbKeyboardBind;
 
+typedef struct AbMouseButtonBind {
+    EAbOnState ButtonState;
+} AbMouseButtonBind;
+
 typedef struct AbInputBind {
     EAbBindType Type;
 
     union {
-        AbKeyboardBind keyboard;
+        AbKeyboardBind Keyboard;
+        AbMouseButtonBind MouseButton;
     };
 } AbInputBind;
 

Engine/Application/Public/Input/UserInput.hpp

@@ -18,8 +18,8 @@ class UserInput : public WindowListener
 public:
 
     BEAST_API explicit UserInput(::std::shared_ptr<WindowDesc> pWd = nullptr)
-        : m_bIsCapturing(false)
-        , m_pWindowDesc(pWd)
+        : WindowListener(pWd)
+        , m_bIsCapturing(false)
         , m_KeyReleaseMap()
         , m_KeyPressMap()
         , m_KeyContinuous()
@@ -38,6 +38,8 @@ class UserInput : public WindowListener
     BEAST_API void StopCapturing();
 
     /**
+     * @brief Binds an action or mouse action to a key or mouse.
+     *
      * @param pThis - pointer to an object on which we are performing action
      * @param pCo - pointer to an object that controlls life time of pThis
      * @param action - action to be performed, should be null, if we are performing mouse action instead
@@ -46,7 +48,7 @@ class UserInput : public WindowListener
      **/
     BEAST_API void Bind(void* pThis, ControllerObject* pCo, AbAction action, AbMouseAction mouseAction, AbInputBind bind);
 
-    BEAST_API void Unbind(void* pThis);
+    BEAST_API void Unbind(ControllerObject* pCo);
 
     /**
      * Reads and consumes the input queue from WindowDesc.
@@ -56,11 +58,17 @@ class UserInput : public WindowListener
 
 private:
 
-    bool m_bIsCapturing;
+    struct BindHandle
+    {
+        AbInputBind Ib;
+        void* pThis;
+    };
+
+private:
 
-    ::std::shared_ptr<WindowDesc> m_pWindowDesc;
+    bool m_bIsCapturing;
 
-    ::std::unordered_map<void*, ::std::vector<AbInputBind>> m_BindsHandles;
+    ::std::unordered_map<void*, ::std::vector<BindHandle>> m_BindsHandles;
 
     ::std::bitset<AB_KEY_COUNT> m_vCurrentlyPressedKeys;
 

Engine/Application/Public/Window/IBaseWindow.hpp

@@ -27,7 +27,8 @@ class IBaseWindow
 
     template<class U>
     explicit IBaseWindow(U&& windowDesc = WindowDesc())
-        : m_pWindowDesc(::std::make_shared<WindowDesc>(::std::forward<U>(windowDesc)))
+		: m_Policy(::std::make_unique<WindowPolicy>())
+        , m_pWindowDesc(::std::make_shared<WindowDesc>(::std::forward<U>(windowDesc)))
     { }
 
     ~IBaseWindow()
@@ -38,7 +39,8 @@ class IBaseWindow
     IBaseWindow(const IBaseWindow& other) = delete;
 
     IBaseWindow(IBaseWindow&& other) noexcept
-        : m_pWindowDesc(::std::move(other.m_pWindowDesc))
+		: m_Policy(::std::move(other.m_Policy))
+        , m_pWindowDesc(::std::move(other.m_pWindowDesc))
     { }
 
 public:
@@ -48,9 +50,10 @@ class IBaseWindow
     {
         bool bWasAlive = m_pWindowDesc->IsAlive;
 
-        m_Policy.WindowPolicyDestroy(m_pWindowDesc.get());
+        if (bWasAlive)
+            this->Destroy();
 
-        m_Policy = NewPolicy();
+        m_Policy = ::std::make_unique<NewPolicy>();
 
         if (bWasAlive) 
             this->Create();
@@ -61,14 +64,15 @@ class IBaseWindow
     void Create()
     { 
         AB_ASSERT(m_pWindowDesc != nullptr);
+		AB_ASSERT(m_Policy != nullptr);
 
         if (m_pWindowDesc->IsAlive) {
             return;
         }
 
         m_pWindowDesc->uUinqueIndex = App::AppStatus::Get().SendOpenedWindowSignal();
 
-        if (m_Policy.WindowPolicyCreate(m_pWindowDesc.get()) != 0) {
+        if (m_Policy->WindowPolicyCreate(m_pWindowDesc.get()) != 0) {
             throw AB_EXCEPT("Couldn't create the window");
         }
 
@@ -78,39 +82,46 @@ class IBaseWindow
     void Show()
     { 
         AB_ASSERT(m_pWindowDesc != nullptr);
-        m_Policy.WindowPolicyShow(m_pWindowDesc.get()); 
+        AB_ASSERT(m_Policy != nullptr);
+
+        m_Policy->WindowPolicyShow(m_pWindowDesc.get()); 
     }
 
     void Hide()
     { 
         AB_ASSERT(m_pWindowDesc != nullptr);
-        m_Policy.WindowPolicyHide(m_pWindowDesc.get()); 
+        AB_ASSERT(m_Policy != nullptr);
+
+        m_Policy->WindowPolicyHide(m_pWindowDesc.get()); 
     }
 
     void Destroy()
     { 
         AB_ASSERT(m_pWindowDesc != nullptr);
+        AB_ASSERT(m_Policy != nullptr);
 
         if (!m_pWindowDesc->IsAlive) {
             return;
         }
 
         App::AppStatus::Get().SendClosedWindowSignal();
 
-        m_Policy.WindowPolicyDestroy(m_pWindowDesc.get());
+        m_Policy->WindowPolicyDestroy(m_pWindowDesc.get());
 
         m_pWindowDesc->IsAlive = false;
     }
 
     void Update()
     { 
         AB_ASSERT(m_pWindowDesc != nullptr);
+        AB_ASSERT(m_Policy != nullptr);
+
         if (!m_pWindowDesc->IsAlive) {
             return;
         }
 
         m_pWindowDesc->LastEvent &= 0;
-        m_Policy.WindowPolicyUpdate(m_pWindowDesc.get());
+        m_Policy->WindowPolicyUpdate(m_pWindowDesc.get());
 
         if (m_pWindowDesc->LastEvent & EAbWindowEvents::Destroy) {
             AB_LOG(Core::Debug::Info, L"Window is being closed by user");
@@ -134,7 +145,7 @@ class IBaseWindow
 
 private:
 
-    WindowPolicy m_Policy;
+    ::std::unique_ptr<WindowPolicy> m_Policy;
 
     ::std::shared_ptr<WindowDesc> m_pWindowDesc;
 

Engine/Core/Private/Exception.cpp

@@ -1,4 +1,5 @@
 #include "Core.h"
+#include "Exception.hpp"
 
 namespace Core
 {