src/client/input.c

   1 #include <math.h>
   2 #include "client/camera.h"
   3 #include "client/client.h"
   4 #include "client/client_player.h"
   5 #include "client/hud.h"
   6 #include "client/input.h"
   7 #include "client/window.h"
   8
   9 typedef struct
  10 {
  11         int key;
  12         bool was_pressed;
  13         bool fired;
  14 } KeyListener;
  15
  16 static struct
  17 {
  18         HUDElement *pause_menu_hud;
  19         bool paused;
  20         KeyListener pause_listener;
  21         KeyListener fullscreen_listener;
  22         KeyListener fly_listener;
  23         KeyListener collision_listener;
  24 } input;
  25
  26 void input_on_cursor_pos(double current_x, double current_y)
  27 {
  28         if (input.paused)
  29                 return;
  30
  31         static double last_x, last_y = 0.0;
  32
  33         double delta_x = current_x - last_x;
  34         double delta_y = current_y - last_y;
  35         last_x = current_x;
  36         last_y = current_y;
  37
  38         client_player.yaw += (f32) delta_x * M_PI / 180.0f / 8.0f;
  39         client_player.pitch -= (f32) delta_y * M_PI / 180.0f / 8.0f;
  40
  41         client_player.pitch = fmax(fmin(client_player.pitch, M_PI / 2.0f - 0.01f), -M_PI / 2.0f + 0.01f);
  42
  43         camera_set_angle(client_player.yaw, client_player.pitch);
  44 }
  45
  46 static bool move(int forward, int backward, vec3 dir)
  47 {
  48         f64 sign;
  49         f64 speed = client_player.fly ? 25.0f : 4.317f;
  50
  51         if (glfwGetKey(window.handle, forward) == GLFW_PRESS)
  52                 sign = +1.0f;
  53         else if (glfwGetKey(window.handle, backward) == GLFW_PRESS)
  54                 sign = -1.0f;
  55         else
  56                 return false;
  57
  58         client_player.velocity.x += dir[0] * speed * sign;
  59         client_player.velocity.y += dir[1] * speed * sign;
  60         client_player.velocity.z += dir[2] * speed * sign;
  61
  62         return true;
  63 }
  64
  65 static void enter_game()
  66 {
  67         glfwSetInputMode(window.handle, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
  68         input.pause_menu_hud->visible = false;
  69 }
  70
  71 static void do_key_listener(KeyListener *listener)
  72 {
  73         bool is_pressed = glfwGetKey(window.handle, listener->key) == GLFW_PRESS;
  74         listener->fired = listener->was_pressed && ! is_pressed;
  75         listener->was_pressed = is_pressed;
  76 }
  77
  78 static KeyListener create_key_listener(int key)
  79 {
  80         return (KeyListener) {
  81                 .key = key,
  82                 .was_pressed = false,
  83                 .fired = false,
  84         };
  85 }
  86
  87 void input_tick()
  88 {
  89         do_key_listener(&input.pause_listener);
  90         do_key_listener(&input.fullscreen_listener);
  91         do_key_listener(&input.fly_listener);
  92         do_key_listener(&input.collision_listener);
  93
  94         if (input.pause_listener.fired) {
  95                 input.paused = ! input.paused;
  96
  97                 if (input.paused) {
  98                         glfwSetInputMode(window.handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
  99                         input.pause_menu_hud->visible = true;
 100                 } else {
 101                         enter_game();
 102                 }
 103         }
 104
 105         if (input.fullscreen_listener.fired) {
 106                 if (window.fullscreen)
 107                         window_exit_fullscreen();
 108                 else
 109                         window_enter_fullscreen();
 110         }
 111
 112         if (input.fly_listener.fired) {
 113                 client_player.fly = ! client_player.fly;
 114                 client_player_update_info();
 115         }
 116
 117         if (input.collision_listener.fired) {
 118                 client_player.collision = ! client_player.collision;
 119                 client_player_update_info();
 120         }
 121
 122         client_player.velocity.x = 0.0f;
 123         client_player.velocity.z = 0.0f;
 124
 125         if (client_player.fly)
 126                 client_player.velocity.y = 0.0f;
 127
 128         if (! input.paused) {
 129                 move(GLFW_KEY_W, GLFW_KEY_S, camera_movement_dirs.front);
 130                 move(GLFW_KEY_D, GLFW_KEY_A, camera_movement_dirs.right);
 131
 132                 if (client_player.fly)
 133                         move(GLFW_KEY_SPACE, GLFW_KEY_LEFT_SHIFT, camera_movement_dirs.up);
 134                 else if (glfwGetKey(window.handle, GLFW_KEY_SPACE) == GLFW_PRESS)
 135                         client_player_jump();
 136         }
 137 }
 138
 139 void input_init()
 140 {
 141         input.paused = false;
 142
 143         input.pause_listener = create_key_listener(GLFW_KEY_ESCAPE);
 144         input.fullscreen_listener = create_key_listener(GLFW_KEY_F11);
 145         input.fly_listener = create_key_listener(GLFW_KEY_F);
 146         input.collision_listener = create_key_listener(GLFW_KEY_C);
 147
 148         input.pause_menu_hud = hud_add((HUDElementDefinition) {
 149                 .type = HUD_IMAGE,
 150                 .pos = {-1.0f, -1.0f, 0.5f},
 151                 .offset = {0, 0},
 152                 .type_def = {
 153                         .image = {
 154                                 .texture = texture_get(RESSOURCEPATH "textures/pause_layer.png"),
 155                                 .scale = {1.0f, 1.0f},
 156                                 .scale_type = HUD_SCALE_SCREEN
 157                         },
 158                 },
 159         });
 160
 161         glfwSetInputMode(window.handle, GLFW_STICKY_KEYS, GL_TRUE);
 162
 163         enter_game();
 164 }