My current input.jai

input.jai

events_this_frame: [..] SDL_Event;

mouse_delta_x := 0;
mouse_delta_y := 0;

cursor : Vector2;

#scope_file;

key_states    : Table(Key_Code,    Key_Current_State);
button_states : Table(Button_Code, Key_Current_State);

Key_Current_State :: enum_flags u32 {
  NONE  :: 0x0;
  DOWN  :: 0x1;
  START :: 0x4;
  END   :: 0x8;
}

#scope_module;

init_window :: () {
  #if OS == .MACOS {
    SDL_SetHint(SDL_HINT_RENDER_DRIVER, "metal");
  } else {
    compiler_report("[TODO] Must set proper SDL render hint for '%'", OS);
  }

  SDL_Init(SDL_INIT_GAMECONTROLLER | SDL_INIT_EVENTS);

  flags := (SDL_WINDOW_SHOWN | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_RESIZABLE);
  window = SDL_CreateWindow("Oleg", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, DEFAULT_WIDTH, DEFAULT_HEIGHT, flags);

  assert(window != null, "Failed to create window on platform: %", OS);
}

poll_events :: () {
  reset_events_and_flags();

  event: SDL_Event;
  while SDL_PollEvent(*event) {
    array_add(*events_this_frame, event);

    if event.type == {
      case .SDL_KEYUP;
        state := find_or_add(*key_states, xx event.key.keysym.sym);
        state.* |= .END;

      case .SDL_KEYDOWN;
        state := find_or_add(*key_states, xx event.key.keysym.sym);
        state.* |= ifx event.key.repeat then .DOWN else (.DOWN | .START);


      case .SDL_MOUSEBUTTONDOWN;
        state := find_or_add(*button_states, xx event.button.button);
        state.* |= (.DOWN | .START);

      case .SDL_MOUSEBUTTONUP;
        state := find_or_add(*button_states, xx event.button.button);
        state.* |= .END;


      case .SDL_MOUSEMOTION;
        delta_x := event.motion.xrel;
        delta_y := event.motion.yrel;

        mouse_delta_x += delta_x;
        mouse_delta_y += delta_y;
    }
  }

  // Updates cursor, window and framebuffer sizes.
  update_platform_sizes();
}


is_pressed_this_frame :: (button: Button_Code) -> bool {
  state := find_or_add(*button_states, xx button);
  return state.* & .START != 0;
}

is_pressed :: (button: Button_Code) -> bool {
  state := find_or_add(*button_states, xx button);
  return state.* & .DOWN != 0;
}

is_pressed_this_frame :: (keycode: Key_Code) -> bool {
  state := find_or_add(*key_states, keycode);
  return state.* & .START != 0;
}

is_pressed :: (keycode: Key_Code) -> bool {
  state := find_or_add(*key_states, keycode);
  return state.* & .DOWN != 0;
}

has_modifier :: inline (modifier: Modifier_Code) -> bool {
  return SDL_GetModState() == xx modifier;
}

show_cursor :: () {
  SDL_SetRelativeMouseMode(xx false);
}

hide_cursor :: () {
  SDL_SetRelativeMouseMode(xx true);
}

get_framebuffer_size :: inline  () -> w: float, h: float {
  return framebuffer_size.w, framebuffer_size.h;
}

using Key_Code :: enum s32 {
    UNKNOWN :: 0;

    RETURN :: #char "\r";
    ESCAPE :: 27; // 0o33
    BACKSPACE :: 8; // '\b';
    TAB :: #char "\t";
    SPACE :: #char " ";
    EXCLAIM :: #char "!";
    QUOTEDBL ::  #char "\"";
    HASH :: #char "#";
    PERCENT :: #char "%";
    DOLLAR :: #char "$";
    AMPERSAND :: #char "&";
    QUOTE :: #char "'";
    LEFTPAREN :: #char "(";
    RIGHTPAREN :: #char ")";
    ASTERISK :: #char "*";
    PLUS :: #char "+";
    COMMA :: #char ",";
    MINUS :: #char "-";
    PERIOD :: #char ".";
    SLASH :: #char "/";
    _0 :: #char "0";
    _1 :: #char "1";
    _2 :: #char "2";
    _3 :: #char "3";
    _4 :: #char "4";
    _5 :: #char "5";
    _6 :: #char "6";
    _7 :: #char "7";
    _8 :: #char "8";
    _9 :: #char "9";
    COLON :: #char ":";
    SEMICOLON :: #char ";";
    LESS :: #char "<";
    EQUALS :: #char "=";
    GREATER :: #char ">";
    QUESTION :: #char "?";
    AT :: #char "@";
    /*
       Skip uppercase letters
     */
    LEFTBRACKET :: #char "[";
    BACKSLASH :: #char "\\";
    RIGHTBRACKET :: #char "]";
    CARET :: #char "^";
    UNDERSCORE :: #char "_";
    BACKQUOTE :: #char "`";
    A :: #char "a";
    B :: #char "b";
    C :: #char "c";
    D :: #char "d";
    E :: #char "e";
    F :: #char "f";
    G :: #char "g";
    H :: #char "h";
    I :: #char "i";
    J :: #char "j";
    K :: #char "k";
    L :: #char "l";
    M :: #char "m";
    N :: #char "n";
    O :: #char "o";
    P :: #char "p";
    Q :: #char "q";
    R :: #char "r";
    S :: #char "s";
    T :: #char "t";
    U :: #char "u";
    V :: #char "v";
    W :: #char "w";
    X :: #char "x";
    Y :: #char "y";
    Z :: #char "z";

    SCANCODE_MASK :: 1 << 30;

    //
    // Note: All this #run SDL_SCANCODE_TO_KEYCODE is crazy in terms of
    // expense required to do simple things. Eventually we will probably be
    // able to substitute a macro here (when we have macros) but that will
    // still be perhaps a bit more expensive than I'd like.
    //

    CAPSLOCK :: #run Hack.K(SDL_SCANCODE_CAPSLOCK);

    F1 :: #run Hack.K(SDL_SCANCODE_F1);
    F2 :: #run Hack.K(SDL_SCANCODE_F2);
    F3 :: #run Hack.K(SDL_SCANCODE_F3);
    F4 :: #run Hack.K(SDL_SCANCODE_F4);
    F5 :: #run Hack.K(SDL_SCANCODE_F5);
    F6 :: #run Hack.K(SDL_SCANCODE_F6);
    F7 :: #run Hack.K(SDL_SCANCODE_F7);
    F8 :: #run Hack.K(SDL_SCANCODE_F8);
    F9 :: #run Hack.K(SDL_SCANCODE_F9);
    F10 :: #run Hack.K(SDL_SCANCODE_F10);
    F11 :: #run Hack.K(SDL_SCANCODE_F11);
    F12 :: #run Hack.K(SDL_SCANCODE_F12);

    PRINTSCREEN :: #run Hack.K(SDL_SCANCODE_PRINTSCREEN);
    SCROLLLOCK :: #run Hack.K(SDL_SCANCODE_SCROLLLOCK);
    PAUSE :: #run Hack.K(SDL_SCANCODE_PAUSE);
    INSERT :: #run Hack.K(SDL_SCANCODE_INSERT);
    HOME :: #run Hack.K(SDL_SCANCODE_HOME);
    PAGEUP :: #run Hack.K(SDL_SCANCODE_PAGEUP);
    DELETE :: 127;// #run Hack.K(SDL_SCANCODE_DELETE); // 177? @@ Why is this one different ???
    END :: #run Hack.K(SDL_SCANCODE_END);
    PAGEDOWN :: #run Hack.K(SDL_SCANCODE_PAGEDOWN);
    RIGHT :: #run Hack.K(SDL_SCANCODE_RIGHT);
    LEFT :: #run Hack.K(SDL_SCANCODE_LEFT);
    DOWN :: #run Hack.K(SDL_SCANCODE_DOWN);
    UP :: #run Hack.K(SDL_SCANCODE_UP);


    NUMLOCKCLEAR :: #run Hack.K(SDL_SCANCODE_NUMLOCKCLEAR);
    KP_DIVIDE :: #run Hack.K(SDL_SCANCODE_KP_DIVIDE);
    KP_MULTIPLY :: #run Hack.K(SDL_SCANCODE_KP_MULTIPLY);
    KP_MINUS :: #run Hack.K(SDL_SCANCODE_KP_MINUS);
    KP_PLUS :: #run Hack.K(SDL_SCANCODE_KP_PLUS);
    KP_ENTER :: #run Hack.K(SDL_SCANCODE_KP_ENTER);
    KP_1 :: #run Hack.K(SDL_SCANCODE_KP_1);
    KP_2 :: #run Hack.K(SDL_SCANCODE_KP_2);
    KP_3 :: #run Hack.K(SDL_SCANCODE_KP_3);
    KP_4 :: #run Hack.K(SDL_SCANCODE_KP_4);
    KP_5 :: #run Hack.K(SDL_SCANCODE_KP_5);
    KP_6 :: #run Hack.K(SDL_SCANCODE_KP_6);
    KP_7 :: #run Hack.K(SDL_SCANCODE_KP_7);
    KP_8 :: #run Hack.K(SDL_SCANCODE_KP_8);
    KP_9 :: #run Hack.K(SDL_SCANCODE_KP_9);
    KP_0 :: #run Hack.K(SDL_SCANCODE_KP_0);
    KP_PERIOD :: #run Hack.K(SDL_SCANCODE_KP_PERIOD);

    APPLICATION :: #run Hack.K(SDL_SCANCODE_APPLICATION);
    POWER :: #run Hack.K(SDL_SCANCODE_POWER);
    KP_EQUALS :: #run Hack.K(SDL_SCANCODE_KP_EQUALS);
    F13 :: #run Hack.K(SDL_SCANCODE_F13);
    F14 :: #run Hack.K(SDL_SCANCODE_F14);
    F15 :: #run Hack.K(SDL_SCANCODE_F15);
    F16 :: #run Hack.K(SDL_SCANCODE_F16);
    F17 :: #run Hack.K(SDL_SCANCODE_F17);
    F18 :: #run Hack.K(SDL_SCANCODE_F18);
    F19 :: #run Hack.K(SDL_SCANCODE_F19);
    F20 :: #run Hack.K(SDL_SCANCODE_F20);
    F21 :: #run Hack.K(SDL_SCANCODE_F21);
    F22 :: #run Hack.K(SDL_SCANCODE_F22);
    F23 :: #run Hack.K(SDL_SCANCODE_F23);
    F24 :: #run Hack.K(SDL_SCANCODE_F24);
    EXECUTE :: #run Hack.K(SDL_SCANCODE_EXECUTE);
    HELP :: #run Hack.K(SDL_SCANCODE_HELP);
    MENU :: #run Hack.K(SDL_SCANCODE_MENU);
    SELECT :: #run Hack.K(SDL_SCANCODE_SELECT);
    STOP :: #run Hack.K(SDL_SCANCODE_STOP);
    AGAIN :: #run Hack.K(SDL_SCANCODE_AGAIN);
    UNDO :: #run Hack.K(SDL_SCANCODE_UNDO);
    CUT :: #run Hack.K(SDL_SCANCODE_CUT);
    COPY :: #run Hack.K(SDL_SCANCODE_COPY);
    PASTE :: #run Hack.K(SDL_SCANCODE_PASTE);
    FIND :: #run Hack.K(SDL_SCANCODE_FIND);
    MUTE :: #run Hack.K(SDL_SCANCODE_MUTE);
    VOLUMEUP :: #run Hack.K(SDL_SCANCODE_VOLUMEUP);
    VOLUMEDOWN :: #run Hack.K(SDL_SCANCODE_VOLUMEDOWN);
    KP_COMMA :: #run Hack.K(SDL_SCANCODE_KP_COMMA);
    KP_EQUALSAS400 :: #run Hack.K(SDL_SCANCODE_KP_EQUALSAS400);

    ALTERASE :: #run Hack.K(SDL_SCANCODE_ALTERASE);
    SYSREQ :: #run Hack.K(SDL_SCANCODE_SYSREQ);
    CANCEL :: #run Hack.K(SDL_SCANCODE_CANCEL);
    CLEAR :: #run Hack.K(SDL_SCANCODE_CLEAR);
    PRIOR :: #run Hack.K(SDL_SCANCODE_PRIOR);
    RETURN2 :: #run Hack.K(SDL_SCANCODE_RETURN2);
    SEPARATOR :: #run Hack.K(SDL_SCANCODE_SEPARATOR);
    OUT :: #run Hack.K(SDL_SCANCODE_OUT);
    OPER :: #run Hack.K(SDL_SCANCODE_OPER);
    CLEARAGAIN :: #run Hack.K(SDL_SCANCODE_CLEARAGAIN);
    CRSEL :: #run Hack.K(SDL_SCANCODE_CRSEL);
    EXSEL :: #run Hack.K(SDL_SCANCODE_EXSEL);

    KP_00 :: #run Hack.K(SDL_SCANCODE_KP_00);
    KP_000 :: #run Hack.K(SDL_SCANCODE_KP_000);
    THOUSANDSSEPARATOR :: #run Hack.K(SDL_SCANCODE_THOUSANDSSEPARATOR);
    DECIMALSEPARATOR :: #run Hack.K(SDL_SCANCODE_DECIMALSEPARATOR);
    CURRENCYUNIT :: #run Hack.K(SDL_SCANCODE_CURRENCYUNIT);
    CURRENCYSUBUNIT :: #run Hack.K(SDL_SCANCODE_CURRENCYSUBUNIT);
    KP_LEFTPAREN :: #run Hack.K(SDL_SCANCODE_KP_LEFTPAREN);
    KP_RIGHTPAREN :: #run Hack.K(SDL_SCANCODE_KP_RIGHTPAREN);
    KP_LEFTBRACE :: #run Hack.K(SDL_SCANCODE_KP_LEFTBRACE);
    KP_RIGHTBRACE :: #run Hack.K(SDL_SCANCODE_KP_RIGHTBRACE);
    KP_TAB :: #run Hack.K(SDL_SCANCODE_KP_TAB);
    KP_BACKSPACE :: #run Hack.K(SDL_SCANCODE_KP_BACKSPACE);
    KP_A :: #run Hack.K(SDL_SCANCODE_KP_A);
    KP_B :: #run Hack.K(SDL_SCANCODE_KP_B);
    KP_C :: #run Hack.K(SDL_SCANCODE_KP_C);
    KP_D :: #run Hack.K(SDL_SCANCODE_KP_D);
    KP_E :: #run Hack.K(SDL_SCANCODE_KP_E);
    KP_F :: #run Hack.K(SDL_SCANCODE_KP_F);
    KP_XOR :: #run Hack.K(SDL_SCANCODE_KP_XOR);
    KP_POWER :: #run Hack.K(SDL_SCANCODE_KP_POWER);
    KP_PERCENT :: #run Hack.K(SDL_SCANCODE_KP_PERCENT);
    KP_LESS :: #run Hack.K(SDL_SCANCODE_KP_LESS);
    KP_GREATER :: #run Hack.K(SDL_SCANCODE_KP_GREATER);
    KP_AMPERSAND :: #run Hack.K(SDL_SCANCODE_KP_AMPERSAND);
    KP_DBLAMPERSAND :: #run Hack.K(SDL_SCANCODE_KP_DBLAMPERSAND);
    KP_VERTICALBAR :: #run Hack.K(SDL_SCANCODE_KP_VERTICALBAR);
    KP_DBLVERTICALBAR :: #run Hack.K(SDL_SCANCODE_KP_DBLVERTICALBAR);
    KP_COLON :: #run Hack.K(SDL_SCANCODE_KP_COLON);
    KP_HASH :: #run Hack.K(SDL_SCANCODE_KP_HASH);
    KP_SPACE :: #run Hack.K(SDL_SCANCODE_KP_SPACE);
    KP_AT :: #run Hack.K(SDL_SCANCODE_KP_AT);
    KP_EXCLAM :: #run Hack.K(SDL_SCANCODE_KP_EXCLAM);
    KP_MEMSTORE :: #run Hack.K(SDL_SCANCODE_KP_MEMSTORE);
    KP_MEMRECALL :: #run Hack.K(SDL_SCANCODE_KP_MEMRECALL);
    KP_MEMCLEAR :: #run Hack.K(SDL_SCANCODE_KP_MEMCLEAR);
    KP_MEMADD :: #run Hack.K(SDL_SCANCODE_KP_MEMADD);
    KP_MEMSUBTRACT :: #run Hack.K(SDL_SCANCODE_KP_MEMSUBTRACT);
    KP_MEMMULTIPLY :: #run Hack.K(SDL_SCANCODE_KP_MEMMULTIPLY);
    KP_MEMDIVIDE :: #run Hack.K(SDL_SCANCODE_KP_MEMDIVIDE);
    KP_PLUSMINUS :: #run Hack.K(SDL_SCANCODE_KP_PLUSMINUS);
    KP_CLEAR :: #run Hack.K(SDL_SCANCODE_KP_CLEAR);
    KP_CLEARENTRY :: #run Hack.K(SDL_SCANCODE_KP_CLEARENTRY);
    KP_BINARY :: #run Hack.K(SDL_SCANCODE_KP_BINARY);
    KP_OCTAL :: #run Hack.K(SDL_SCANCODE_KP_OCTAL);
    KP_DECIMAL :: #run Hack.K(SDL_SCANCODE_KP_DECIMAL);
    KP_HEXADECIMAL :: #run Hack.K(SDL_SCANCODE_KP_HEXADECIMAL);

    LCTRL :: #run Hack.K(SDL_SCANCODE_LCTRL);
    LSHIFT :: #run Hack.K(SDL_SCANCODE_LSHIFT);
    LALT :: #run Hack.K(SDL_SCANCODE_LALT);
    LGUI :: #run Hack.K(SDL_SCANCODE_LGUI);
    RCTRL :: #run Hack.K(SDL_SCANCODE_RCTRL);
    RSHIFT :: #run Hack.K(SDL_SCANCODE_RSHIFT);
    RALT :: #run Hack.K(SDL_SCANCODE_RALT);
    RGUI :: #run Hack.K(SDL_SCANCODE_RGUI);

    MODE :: #run Hack.K(SDL_SCANCODE_MODE);

    AUDIONEXT :: #run Hack.K(SDL_SCANCODE_AUDIONEXT);
    AUDIOPREV :: #run Hack.K(SDL_SCANCODE_AUDIOPREV);
    AUDIOSTOP :: #run Hack.K(SDL_SCANCODE_AUDIOSTOP);
    AUDIOPLAY :: #run Hack.K(SDL_SCANCODE_AUDIOPLAY);
    AUDIOMUTE :: #run Hack.K(SDL_SCANCODE_AUDIOMUTE);
    MEDIASELECT :: #run Hack.K(SDL_SCANCODE_MEDIASELECT);
    WWW :: #run Hack.K(SDL_SCANCODE_WWW);
    MAIL :: #run Hack.K(SDL_SCANCODE_MAIL);
    CALCULATOR :: #run Hack.K(SDL_SCANCODE_CALCULATOR);
    COMPUTER :: #run Hack.K(SDL_SCANCODE_COMPUTER);
    AC_SEARCH :: #run Hack.K(SDL_SCANCODE_AC_SEARCH);
    AC_HOME :: #run Hack.K(SDL_SCANCODE_AC_HOME);
    AC_BACK :: #run Hack.K(SDL_SCANCODE_AC_BACK);
    AC_FORWARD :: #run Hack.K(SDL_SCANCODE_AC_FORWARD);
    AC_STOP :: #run Hack.K(SDL_SCANCODE_AC_STOP);
    AC_REFRESH :: #run Hack.K(SDL_SCANCODE_AC_REFRESH);
    AC_BOOKMARKS :: #run Hack.K(SDL_SCANCODE_AC_BOOKMARKS);

    BRIGHTNESSDOWN :: #run Hack.K(SDL_SCANCODE_BRIGHTNESSDOWN);
    BRIGHTNESSUP :: #run Hack.K(SDL_SCANCODE_BRIGHTNESSUP);
    DISPLAYSWITCH :: #run Hack.K(SDL_SCANCODE_DISPLAYSWITCH);
    KBDILLUMTOGGLE :: #run Hack.K(SDL_SCANCODE_KBDILLUMTOGGLE);
    KBDILLUMDOWN :: #run Hack.K(SDL_SCANCODE_KBDILLUMDOWN);
    KBDILLUMUP :: #run Hack.K(SDL_SCANCODE_KBDILLUMUP);
    EJECT :: #run Hack.K(SDL_SCANCODE_EJECT);
    SLEEP :: #run Hack.K(SDL_SCANCODE_SLEEP);
    APP1 :: #run Hack.K(SDL_SCANCODE_APP1);
    APP2 :: #run Hack.K(SDL_SCANCODE_APP2);

    //AUDIOREWIND :: #run Hack.K(SDL_SCANCODE_AUDIOREWIND);
    //AUDIOFASTFORWARD :: #run Hack.K(SDL_SCANCODE_AUDIOFASTFORWARD);
}

using Modifier_Code :: enum u16 {
  _NONE         :: 0x0000;
  LEFT_SHIFT    :: 0x0001;
  RIGHT_SHIFT   :: 0x0002;
  SHIFT         :: LEFT_SHIFT|RIGHT_SHIFT;
  LEFT_CTRL     :: 0x0040;
  RIGHT_CTRL    :: 0x0080;
  CTRL          :: LEFT_CTRL|RIGHT_CTRL;
  LEFT_ALT      :: 0x0100;
  RIGHT_ALT     :: 0x0200;
  ALT           :: LEFT_ALT|RIGHT_ALT;
  _LGUI         :: 0x0400;
  _RGUI         :: 0x0800;
  _GUI          :: _LGUI|_RGUI;
  NUM           :: 0x1000;
  CAPS          :: 0x2000;
  _MODE         :: 0x4000;
  _RESERVED     :: 0x8000;
}

using Button_Code :: enum {
  BUTTON_LEFT   :: 1;
  BUTTON_MIDDLE :: 2;
  BUTTON_RIGHT  :: 3;
  BUTTON_X1     :: 4;
  BUTTON_X2     :: 5;
}


#scope_file;

reset_events_and_flags :: inline () {
  array_reset(*events_this_frame);

  mouse_delta_x = 0;
  mouse_delta_y = 0;

  mask     := ~Key_Current_State.START;
  end_mask := ~(Key_Current_State.END | .DOWN | .START);

  for * key_states {
    if (it.* & .END) {
      it.* &= end_mask;
    } else {
      it.* &= mask;
    }
  }

  for * button_states {
    if (it.* & .END) {
      it.* &= end_mask;
    } else {
      it.* &= mask;
    }
  }
}

update_platform_sizes :: inline () {
  resizing := false;

  win_width, win_height: s32;
  SDL_GetWindowSize(window, *win_width, *win_height);

  resizing    = xx window_size.w != win_width || xx window_size.h != win_height;
  window_size = .{ xx win_width, xx win_height };

  #if OS == {
    case .MACOS;
      AppKit   :: #import "Objective_C/Appkit";
      NSWindow :: AppKit.NSWindow;

      AppKit.init_app_kit(); // We don't want to crash if not initialized yet.

      sysinfo: SDL_SysWMinfo;
      SDL_GetWindowWMInfo(window, *sysinfo);
      assert(sysinfo.subsystem == SDL_SYSWM_COCOA);

      ns_window := cast(*NSWindow) sysinfo.info.cocoa.window;

      physical_size := NSWindow.convertRectToBacking(ns_window, .{ size = .{ window_size.w, window_size.h } });

      framebuffer_size = .{
        xx physical_size.size.width,
        xx physical_size.size.height
      };

    case;
      compiler_report("[TODO] Must update framebuffer_size for platform '%'", OS);
  }

  x_scaler := framebuffer_size.w / window_size.w;
  y_scaler := framebuffer_size.h / window_size.h;
  assert(x_scaler == y_scaler); // It's weird if it's not, no?

  scale_factor = cast(int) x_scaler;

  mx, my: s32;
  SDL_GetMouseState(*mx, *my);
  cursor = Vector2.{ xx (mx * x_scaler), xx (my * y_scaler) };

  if resizing {
    set_render_target_size(framebuffer_size.w, framebuffer_size.h);
  }
}

#import "SDL";