KeyEvent.h

// Copyright(c) 2019 - 2020, #Momo
// All rights reserved.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met :
// 
// 1. Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
// 
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and /or other materials provided with the distribution.
// 
// 3. Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
// 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#pragma once

#include "Core/Event/IEvent.h"
#include <bitset>

namespace MxEngine
{
    // from glfw header file
    enum class KeyCode
    {
        UNKNOWN = -1,
        SPACE = 32,
        APOSTROPHE = 39,
        COMMA = 44,
        MINUS = 45,
        PERIOD = 46,
        SLASH = 47,
        D0 = 48,
        D1 = 49,
        D2 = 50,
        D3 = 51,
        D4 = 52,
        D5 = 53,
        D6 = 54,
        D7 = 55,
        D8 = 56,
        D9 = 57,
        SEMICOLON = 59,
        EQUAL = 61,
        A = 65,
        B = 66,
        C = 67,
        D = 68,
        E = 69,
        F = 70,
        G = 71,
        H = 72,
        I = 73,
        J = 74,
        K = 75,
        L = 76,
        M = 77,
        N = 78,
        O = 79,
        P = 80,
        Q = 81,
        R = 82,
        S = 83,
        T = 84,
        U = 85,
        V = 86,
        W = 87,
        X = 88,
        Y = 89,
        Z = 90,
        LEFT_BRACKET = 91,
        BACKSLASH = 92,
        RIGHT_BRACKET = 93,
        GRAVE_ACCENT = 96,
        WORLD_1 = 16,
        WORLD_2 = 16,
        ESCAPE = 256,
        ENTER = 257,
        TAB = 258,
        BACKSPACE = 259,
        INSERT = 260,
        DELETE = 261,
        RIGHT = 262,
        LEFT = 263,
        DOWN = 264,
        UP = 265,
        PAGE_UP = 266,
        PAGE_DOWN = 267,
        HOME = 268,
        END = 269,
        CAPS_LOCK = 280,
        SCROLL_LOCK = 281,
        NUM_LOCK = 282,
        PRINT_SCREEN = 283,
        PAUSE = 284,
        F1 = 290,
        F2 = 291,
        F3 = 292,
        F4 = 293,
        F5 = 294,
        F6 = 295,
        F7 = 296,
        F8 = 297,
        F9 = 298,
        F10 = 299,
        F11 = 300,
        F12 = 301,
        F13 = 302,
        F14 = 303,
        F15 = 304,
        F16 = 305,
        F17 = 306,
        F18 = 307,
        F19 = 308,
        F20 = 309,
        F21 = 310,
        F22 = 311,
        F23 = 312,
        F24 = 313,
        F25 = 314,
        KP_0 = 320,
        KP_1 = 321,
        KP_2 = 322,
        KP_3 = 323,
        KP_4 = 324,
        KP_5 = 325,
        KP_6 = 326,
        KP_7 = 327,
        KP_8 = 328,
        KP_9 = 329,
        KP_DECIMAL = 330,
        KP_DIVIDE = 331,
        KP_MULTIPLY = 332,
        KP_SUBTRACT = 333,
        KP_ADD = 334,
        KP_ENTER = 335,
        KP_EQUAL = 336,
        LEFT_SHIFT = 340,
        LEFT_CONTROL = 341,
        LEFT_ALT = 342,
        LEFT_SUPER = 343,
        RIGHT_SHIFT = 344,
        RIGHT_CONTROL = 345,
        RIGHT_ALT = 346,
        RIGHT_SUPER = 347,
        MENU = 348,
    };

    inline const char* EnumToString(KeyCode key)
    {
        #define STRKEY(val) case MxEngine::KeyCode::val: return #val
        switch (key)
        {
            STRKEY(UNKNOWN);
            STRKEY(SPACE);
            STRKEY(APOSTROPHE);
            STRKEY(COMMA);
            STRKEY(MINUS);
            STRKEY(PERIOD);
            STRKEY(SLASH);
            STRKEY(D0);
            STRKEY(D1);
            STRKEY(D2);
            STRKEY(D3);
            STRKEY(D4);
            STRKEY(D5);
            STRKEY(D6);
            STRKEY(D7);
            STRKEY(D8);
            STRKEY(D9);
            STRKEY(SEMICOLON);
            STRKEY(EQUAL);
            STRKEY(A);
            STRKEY(B);
            STRKEY(C);
            STRKEY(D);
            STRKEY(E);
            STRKEY(F);
            STRKEY(G);
            STRKEY(H);
            STRKEY(I);
            STRKEY(J);
            STRKEY(K);
            STRKEY(L);
            STRKEY(M);
            STRKEY(N);
            STRKEY(O);
            STRKEY(P);
            STRKEY(Q);
            STRKEY(R);
            STRKEY(S);
            STRKEY(T);
            STRKEY(U);
            STRKEY(V);
            STRKEY(W);
            STRKEY(X);
            STRKEY(Y);
            STRKEY(Z);
            STRKEY(LEFT_BRACKET);
            STRKEY(BACKSLASH);
            STRKEY(RIGHT_BRACKET);
            STRKEY(GRAVE_ACCENT);
            STRKEY(WORLD_1);
            STRKEY(ESCAPE);
            STRKEY(ENTER);
            STRKEY(TAB);
            STRKEY(BACKSPACE);
            STRKEY(INSERT);
            STRKEY(DELETE);
            STRKEY(RIGHT);
            STRKEY(LEFT);
            STRKEY(DOWN);
            STRKEY(UP);
            STRKEY(PAGE_UP);
            STRKEY(PAGE_DOWN);
            STRKEY(HOME);
            STRKEY(END);
            STRKEY(CAPS_LOCK);
            STRKEY(SCROLL_LOCK);
            STRKEY(NUM_LOCK);
            STRKEY(PRINT_SCREEN);
            STRKEY(PAUSE);
            STRKEY(F1);
            STRKEY(F2);
            STRKEY(F3);
            STRKEY(F4);
            STRKEY(F5);
            STRKEY(F6);
            STRKEY(F7);
            STRKEY(F8);
            STRKEY(F9);
            STRKEY(F10);
            STRKEY(F11);
            STRKEY(F12);
            STRKEY(F13);
            STRKEY(F14);
            STRKEY(F15);
            STRKEY(F16);
            STRKEY(F17);
            STRKEY(F18);
            STRKEY(F19);
            STRKEY(F20);
            STRKEY(F21);
            STRKEY(F22);
            STRKEY(F23);
            STRKEY(F24);
            STRKEY(F25);
            STRKEY(KP_0);
            STRKEY(KP_1);
            STRKEY(KP_2);
            STRKEY(KP_3);
            STRKEY(KP_4);
            STRKEY(KP_5);
            STRKEY(KP_6);
            STRKEY(KP_7);
            STRKEY(KP_8);
            STRKEY(KP_9);
            STRKEY(KP_DECIMAL);
            STRKEY(KP_DIVIDE);
            STRKEY(KP_MULTIPLY);
            STRKEY(KP_SUBTRACT);
            STRKEY(KP_ADD);
            STRKEY(KP_ENTER);
            STRKEY(KP_EQUAL);
            STRKEY(LEFT_SHIFT);
            STRKEY(LEFT_CONTROL);
            STRKEY(LEFT_ALT);
            STRKEY(LEFT_SUPER);
            STRKEY(RIGHT_SHIFT);
            STRKEY(RIGHT_CONTROL);
            STRKEY(RIGHT_ALT);
            STRKEY(RIGHT_SUPER);
            STRKEY(MENU);
        }
        #undef STRKEY
        return "INVALID_KEY";
    }

    class KeyEvent : public IEvent
    {
        MAKE_EVENT(KeyEvent);

        using KeyVectorPointer = const std::bitset<350>*;

        // pointer to bitset. Is is okay as event lives less than bitset
        KeyVectorPointer keyHeld;
        KeyVectorPointer keyPressed;
        KeyVectorPointer keyReleased;
    public:
        inline KeyEvent(KeyVectorPointer held, KeyVectorPointer pressed, KeyVectorPointer released) noexcept
            : keyHeld(held), keyPressed(pressed), keyReleased(released) { }

        inline bool IsHeld(KeyCode key)     const { return (key != KeyCode::UNKNOWN) && (*keyHeld)[size_t(key)]; }
        inline bool IsPressed(KeyCode key)  const { return (key != KeyCode::UNKNOWN) && (*keyPressed)[size_t(key)]; }
        inline bool IsReleased(KeyCode key) const { return (key != KeyCode::UNKNOWN) && (*keyReleased)[size_t(key)]; }
    };
}