git.mutantstargoat.com Git - vrlugburz/blob - src/game.c

   1 #include <stdio.h>
   2 #include <assert.h>
   3 #include "cgmath/cgmath.h"
   4 #include "game.h"
   5 #include "opengl.h"
   6 #include "level.h"
   7 #include "player.h"
   8 #include "scenefile.h"
   9 #include "sdr.h"
  10
  11 static void draw_level(void);
  12
  13 struct level lvl;
  14 struct player player;
  15
  16 int win_width, win_height;
  17 float win_aspect;
  18 int mouse_x, mouse_y;
  19 int bnstate[8];
  20
  21 float cam_dist;
  22 float view_matrix[16], proj_matrix[16];
  23
  24 unsigned int sdr_foo;
  25
  26 static long prev_step, prev_turn;
  27
  28 int game_init(void)
  29 {
  30         if(init_opengl() == -1) {
  31                 return -1;
  32         }
  33
  34         glEnable(GL_DEPTH_TEST);
  35         glEnable(GL_CULL_FACE);
  36
  37         if(!(sdr_foo = create_program_load("sdr/foo.v.glsl", "sdr/foo.p.glsl"))) {
  38                 return -1;
  39         }
  40         glBindAttribLocation(sdr_foo, MESH_ATTR_VERTEX, "apos");
  41         glBindAttribLocation(sdr_foo, MESH_ATTR_NORMAL, "anorm");
  42         glBindAttribLocation(sdr_foo, MESH_ATTR_TANGENT, "atang");
  43         glBindAttribLocation(sdr_foo, MESH_ATTR_TEXCOORD, "atex");
  44         link_program(sdr_foo);
  45
  46         if(load_level(&lvl, "data/test.lvl") == -1) {
  47                 return -1;
  48         }
  49
  50         init_player(&player);
  51         player.lvl = &lvl;
  52         player.cx = lvl.px;
  53         player.cy = lvl.py;
  54
  55         return 0;
  56 }
  57
  58 void game_shutdown(void)
  59 {
  60         destroy_level(&lvl);
  61         free_program(sdr_foo);
  62 }
  63
  64 #define STEP_INTERVAL   250
  65 #define TURN_INTERVAL   500
  66
  67 void update(float dt)
  68 {
  69         int fwd = 0, right = 0, turn = 0;
  70
  71         if(time_msec - prev_turn >= TURN_INTERVAL) {
  72                 if(input_state[INP_LTURN]) turn--;
  73                 if(input_state[INP_RTURN]) turn++;
  74
  75                 if(turn) {
  76                         turn_player(&player, turn);
  77                         prev_turn = time_msec;
  78                 }
  79         }
  80
  81         if(time_msec - prev_step >= STEP_INTERVAL) {
  82                 if(input_state[INP_FWD]) fwd++;
  83                 if(input_state[INP_BACK]) fwd--;
  84                 if(input_state[INP_LEFT]) right--;
  85                 if(input_state[INP_RIGHT]) right++;
  86
  87                 if(fwd | right) {
  88                         move_player(&player, right, fwd);
  89                         prev_step = time_msec;
  90                 }
  91         }
  92
  93         upd_player_xform(&player);
  94 }
  95
  96 void game_display(void)
  97 {
  98         float dt;
  99         static long prev_msec;
 100
 101         dt = (prev_msec - time_msec) / 1000.0f;
 102         prev_msec = time_msec;
 103
 104         update(dt);
 105
 106         glClearColor(0.1, 0.1, 0.1, 1);
 107         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 108
 109         cgm_midentity(proj_matrix);
 110         cgm_mperspective(proj_matrix, cgm_deg_to_rad(80), win_aspect, 0.5, 500.0);
 111         glMatrixMode(GL_PROJECTION);
 112         glLoadMatrixf(proj_matrix);
 113
 114         glMatrixMode(GL_MODELVIEW);
 115         glLoadIdentity();
 116         glTranslatef(0, 0, -cam_dist);
 117         glMultMatrixf(player.view_xform);
 118
 119         draw_level();
 120
 121         game_swap_buffers();
 122         assert(glGetError() == GL_NO_ERROR);
 123 }
 124
 125 static void draw_level(void)
 126 {
 127         int i, j, k;
 128         struct cell *cell;
 129         float xform[16];
 130
 131         glUseProgram(sdr_foo);
 132
 133         cell = lvl.cells;
 134         for(i=0; i<lvl.height; i++) {
 135                 for(j=0; j<lvl.width; j++) {
 136                         cgm_mtranslation(xform, j * lvl.cell_size, 0, -i * lvl.cell_size);
 137
 138                         glPushMatrix();
 139                         glMultMatrixf(xform);
 140
 141                         if(cell->tile) {
 142                                 cgm_mrotation_y(xform, cell->tilerot * M_PI / 2.0f);
 143
 144                                 glPushMatrix();
 145                                 glMultMatrixf(xform);
 146                                 draw_meshgroup(&cell->tile->mgrp);
 147                                 glPopMatrix();
 148                         }
 149
 150                         for(k=0; k<cell->num_mgrp; k++) {
 151                                 draw_meshgroup(cell->mgrp + k);
 152                         }
 153                         cell++;
 154
 155                         glPopMatrix();
 156                 }
 157         }
 158
 159         glUseProgram(0);
 160 }
 161
 162 void game_reshape(int x, int y)
 163 {
 164         glViewport(0, 0, x, y);
 165         win_width = x;
 166         win_height = y;
 167         win_aspect = (float)x / (float)y;
 168 }
 169
 170 void game_keyboard(int key, int press)
 171 {
 172         if(press && key == 27) {
 173                 game_quit();
 174                 return;
 175         }
 176
 177         /* TODO key remapping */
 178         switch(key) {
 179         case 'w':
 180                 input_state[INP_FWD] = press;
 181                 if(press) {
 182                         move_player(&player, 0, 1);
 183                         prev_step = time_msec;
 184                 }
 185                 break;
 186
 187         case 'a':
 188                 input_state[INP_LEFT] = press;
 189                 if(press) {
 190                         move_player(&player, -1, 0);
 191                         prev_step = time_msec;
 192                 }
 193                 break;
 194
 195         case 's':
 196                 input_state[INP_BACK] = press;
 197                 if(press) {
 198                         move_player(&player, 0, -1);
 199                         prev_step = time_msec;
 200                 }
 201                 break;
 202
 203         case 'd':
 204                 input_state[INP_RIGHT] = press;
 205                 if(press) {
 206                         move_player(&player, 1, 0);
 207                         prev_step = time_msec;
 208                 }
 209                 break;
 210
 211         case 'q':
 212                 input_state[INP_LTURN] = press;
 213                 if(press) {
 214                         turn_player(&player, -1);
 215                         prev_turn = time_msec;
 216                 }
 217                 break;
 218
 219         case 'e':
 220                 input_state[INP_RTURN] = press;
 221                 if(press) {
 222                         turn_player(&player, 1);
 223                         prev_turn = time_msec;
 224                 }
 225                 break;
 226         }
 227 }
 228
 229 void game_mbutton(int bn, int press, int x, int y)
 230 {
 231         bnstate[bn] = press;
 232         mouse_x = x;
 233         mouse_y = y;
 234 }
 235
 236 void game_mmotion(int x, int y)
 237 {
 238         int dx = x - mouse_x;
 239         int dy = y - mouse_y;
 240         mouse_x = x;
 241         mouse_y = y;
 242
 243         if(!(dx | dy)) return;
 244
 245         if(bnstate[0]) {
 246                 player.theta += cgm_deg_to_rad(dx * 0.5f);
 247                 player.phi -= cgm_deg_to_rad(dy * 0.5f);
 248                 if(player.phi < -M_PI/2) player.phi = -M_PI/2;
 249                 if(player.phi > M_PI/2) player.phi = M_PI/2;
 250         }
 251         if(bnstate[2]) {
 252                 cam_dist += dy * 0.1;
 253                 if(cam_dist < 0) cam_dist = 0;
 254         }
 255 }