src/tacos.cpp

   1 #include "app/assets.hpp"
   2 #include "app/config.hpp"
   3 #include "app/init.hpp"
   4 #include "app/keymap.hpp"
   5 #include "graphics/camera.hpp"
   6 #include "graphics/shader.hpp"
   7 #include "graphics/viewport.hpp"
   8 #include "graphics/window.hpp"
   9 #include "rand/SimplexNoise.hpp"
  10 #include "world/Floor.hpp"
  11
  12 #include <iostream>
  13 #include <GL/glew.h>
  14 #include <glm/glm.hpp>
  15 #include <glm/gtc/matrix_transform.hpp>
  16
  17 using namespace tacos;
  18
  19 int main(int argc, char *argv[]) {
  20         Config config;
  21         config.ReadArgs(argc, argv);
  22
  23         Init init(config);
  24         AssetLoader asset_loader(config);
  25         Window window(1440, 900);
  26         Viewport viewport(1440, 900);
  27
  28         Keymap keymap;
  29         keymap.LoadDefault();
  30
  31         constexpr float noise_scale = 1.0f/64.0f;
  32         constexpr float height_scale = 5.0f;
  33
  34         // === test ===
  35         Shader floor_vert(asset_loader.LoadVertexShader("floor"));
  36         Shader floor_frag(asset_loader.LoadFragmentShader("floor"));
  37         Program floor_program;
  38         floor_program.Attach(floor_vert);
  39         floor_program.Attach(floor_frag);
  40         floor_program.Link();
  41         GLint mv_location = floor_program.UniformLocation("MV");
  42         GLint mvp_location = floor_program.UniformLocation("MVP");
  43
  44         Floor floor(64, 50);
  45         SimplexNoise noise(0);
  46         for (int z = 0; z < floor.Depth(); ++z) {
  47                 for (int x = 0; x < floor.Width(); ++x) {
  48                         floor.SetElevation(x, z, noise(glm::vec3(x * noise_scale, 0.0f, z * noise_scale)) * height_scale);
  49                 }
  50         }
  51         floor.GenerateVertices();
  52
  53         Camera camera;
  54         camera.Warp(glm::vec3(20.0f, 0.0f, 20.0f));
  55
  56         glm::mat4 M;
  57         glm::mat4 V;
  58         glm::mat4 MV;
  59         glm::mat4 MVP;
  60
  61         constexpr float cam_speed = 15.0f; // units per second
  62         constexpr float cam_rot_speed = 2.0f; // radians per second
  63
  64         glm::vec3 cam_fwd(0.0f);
  65         glm::vec3 cam_rev(0.0f);
  66         float cam_near = 0.0f;
  67         float cam_far = 0.0f;
  68         glm::vec2 cam_rot_ccw(0.0f);
  69         glm::vec2 cam_rot_cw(0.0f);
  70
  71         floor_program.Use();
  72
  73         bool running = true;
  74         Uint32 last = SDL_GetTicks();
  75         SDL_Event event;
  76         while (running) {
  77                 Uint32 now = SDL_GetTicks();
  78                 // handle
  79                 while (SDL_PollEvent(&event)) {
  80                         switch (event.type) {
  81                                 case SDL_KEYDOWN:
  82                                         switch (keymap.Lookup(event.key)) {
  83                                                 case Keymap::CAMERA_RIGHT:
  84                                                         cam_fwd.x = 1.0f;
  85                                                         break;
  86                                                 case Keymap::CAMERA_LEFT:
  87                                                         cam_rev.x = 1.0f;
  88                                                         break;
  89                                                 case Keymap::CAMERA_UP:
  90                                                         cam_fwd.y = 1.0f;
  91                                                         break;
  92                                                 case Keymap::CAMERA_DOWN:
  93                                                         cam_rev.y = 1.0f;
  94                                                         break;
  95                                                 case Keymap::CAMERA_BACK:
  96                                                         cam_fwd.z = 1.0f;
  97                                                         break;
  98                                                 case Keymap::CAMERA_FORWARD:
  99                                                         cam_rev.z = 1.0f;
 100                                                         break;
 101                                                 case Keymap::CAMERA_NEARER:
 102                                                         cam_near = 1.0f;
 103                                                         break;
 104                                                 case Keymap::CAMERA_FARTHER:
 105                                                         cam_far = 1.0f;
 106                                                         break;
 107                                                 case Keymap::CAMERA_PITCH_CCW:
 108                                                         cam_rot_ccw.x = 1.0f;
 109                                                         break;
 110                                                 case Keymap::CAMERA_PITCH_CW:
 111                                                         cam_rot_cw.x = 1.0f;
 112                                                         break;
 113                                                 case Keymap::CAMERA_YAW_CCW:
 114                                                         cam_rot_ccw.y = 1.0f;
 115                                                         break;
 116                                                 case Keymap::CAMERA_YAW_CW:
 117                                                         cam_rot_cw.y = 1.0f;
 118                                                         break;
 119                                                 case Keymap::EXIT:
 120                                                         running = false;
 121                                                         break;
 122                                                 default:
 123                                                 case Keymap::NONE:
 124                                                         break;
 125                                         }
 126                                         break;
 127                                 case SDL_KEYUP:
 128                                         switch (keymap.Lookup(event.key)) {
 129                                                 case Keymap::CAMERA_RIGHT:
 130                                                         cam_fwd.x = 0.0f;
 131                                                         break;
 132                                                 case Keymap::CAMERA_LEFT:
 133                                                         cam_rev.x = 0.0f;
 134                                                         break;
 135                                                 case Keymap::CAMERA_UP:
 136                                                         cam_fwd.y = 0.0f;
 137                                                         break;
 138                                                 case Keymap::CAMERA_DOWN:
 139                                                         cam_rev.y = 0.0f;
 140                                                         break;
 141                                                 case Keymap::CAMERA_BACK:
 142                                                         cam_fwd.z = 0.0f;
 143                                                         break;
 144                                                 case Keymap::CAMERA_FORWARD:
 145                                                         cam_rev.z = 0.0f;
 146                                                         break;
 147                                                 case Keymap::CAMERA_NEARER:
 148                                                         cam_near = 0.0f;
 149                                                         break;
 150                                                 case Keymap::CAMERA_FARTHER:
 151                                                         cam_far = 0.0f;
 152                                                         break;
 153                                                 case Keymap::CAMERA_PITCH_CCW:
 154                                                         cam_rot_ccw.x = 0.0f;
 155                                                         break;
 156                                                 case Keymap::CAMERA_PITCH_CW:
 157                                                         cam_rot_cw.x = 0.0f;
 158                                                         break;
 159                                                 case Keymap::CAMERA_YAW_CCW:
 160                                                         cam_rot_ccw.y = 0.0f;
 161                                                         break;
 162                                                 case Keymap::CAMERA_YAW_CW:
 163                                                         cam_rot_cw.y = 0.0f;
 164                                                         break;
 165                                                 default:
 166                                                 case Keymap::NONE:
 167                                                         break;
 168                                         }
 169                                         break;
 170                                 case SDL_QUIT:
 171                                         running = false;
 172                                         break;
 173                                 case SDL_WINDOWEVENT:
 174                                         if (event.window.event == SDL_WINDOWEVENT_RESIZED) {
 175                                                 viewport.Resize(event.window.data1, event.window.data2);
 176                                         }
 177                                         break;
 178                                 default:
 179                                         break;
 180                         }
 181                 }
 182
 183                 // update
 184                 float dt = (now - last) * 0.001f;
 185                 camera.Move((cam_fwd - cam_rev) * cam_speed * dt);
 186                 camera.BackOff((cam_far - cam_near) * cam_speed * dt);
 187                 camera.Rotate((cam_rot_ccw - cam_rot_cw) * cam_rot_speed * dt);
 188
 189                 // render
 190                 V = camera.View();
 191                 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 192                 for (int z = 0; z < floor.VAODepth(); ++z) {
 193                         for (int x = 0; x < floor.VAOWidth(); ++x) {
 194                                 M = glm::translate(glm::mat4(1.0f), floor.VAOPosition(x, z));
 195                                 MV = camera.View() * M;
 196                                 MVP = viewport.Perspective() * MV;
 197                                 floor_program.Uniform(mv_location, MV);
 198                                 floor_program.Uniform(mvp_location, MVP);
 199                                 floor.DrawVAO(x, z);
 200                         }
 201                 }
 202                 window.Flip();
 203
 204                 last = now;
 205         }
 206
 207         return 0;
 208 }