src/app/app.cpp

   1 #include "Application.hpp"
   2 #include "Assets.hpp"
   3 #include "Environment.hpp"
   4 #include "FrameCounter.hpp"
   5 #include "State.hpp"
   6 #include "StateControl.hpp"
   7 #include "TextureIndex.hpp"
   8
   9 #include "init.hpp"
  10 #include "../audio/Sound.hpp"
  11 #include "../graphics/ArrayTexture.hpp"
  12 #include "../graphics/Font.hpp"
  13 #include "../graphics/Texture.hpp"
  14 #include "../io/TokenStreamReader.hpp"
  15 #include "../model/shapes.hpp"
  16 #include "../world/BlockType.hpp"
  17 #include "../world/BlockTypeRegistry.hpp"
  18 #include "../world/Entity.hpp"
  19
  20 #include <fstream>
  21 #include <iostream>
  22 #include <stdexcept>
  23 #include <SDL_image.h>
  24
  25 using std::runtime_error;
  26 using std::string;
  27
  28
  29 namespace blank {
  30
  31 Application::Application(Environment &e)
  32 : env(e)
  33 , states() {
  34
  35 }
  36
  37 Application::~Application() {
  38         env.audio.StopAll();
  39 }
  40
  41
  42 void Application::RunN(size_t n) {
  43         Uint32 last = SDL_GetTicks();
  44         for (size_t i = 0; HasState() && i < n; ++i) {
  45                 Uint32 now = SDL_GetTicks();
  46                 int delta = now - last;
  47                 Loop(delta);
  48                 last = now;
  49         }
  50 }
  51
  52 void Application::RunT(size_t t) {
  53         Uint32 last = SDL_GetTicks();
  54         Uint32 finish = last + t;
  55         while (HasState() && last < finish) {
  56                 Uint32 now = SDL_GetTicks();
  57                 int delta = now - last;
  58                 Loop(delta);
  59                 last = now;
  60         }
  61 }
  62
  63 void Application::RunS(size_t n, size_t t) {
  64         for (size_t i = 0; HasState() && i < n; ++i) {
  65                 Loop(t);
  66         }
  67 }
  68
  69
  70 void Application::Run() {
  71         Uint32 last = SDL_GetTicks();
  72         env.window.GrabMouse();
  73         while (HasState()) {
  74                 Uint32 now = SDL_GetTicks();
  75                 int delta = now - last;
  76                 Loop(delta);
  77                 last = now;
  78         }
  79 }
  80
  81 void Application::Loop(int dt) {
  82         env.counter.EnterFrame();
  83         HandleEvents();
  84         if (!HasState()) return;
  85         Update(dt);
  86         env.state.Commit(*this);
  87         if (!HasState()) return;
  88         Render();
  89         env.counter.ExitFrame();
  90 }
  91
  92
  93 void Application::HandleEvents() {
  94         env.counter.EnterHandle();
  95         SDL_Event event;
  96         while (HasState() && SDL_PollEvent(&event)) {
  97                 Handle(event);
  98                 env.state.Commit(*this);
  99         }
 100         env.counter.ExitHandle();
 101 }
 102
 103 void Application::Handle(const SDL_Event &event) {
 104         switch (event.type) {
 105                 case SDL_WINDOWEVENT:
 106                         Handle(event.window);
 107                         break;
 108                 default:
 109                         GetState().Handle(event);
 110                         break;
 111         }
 112 }
 113
 114 void Application::Handle(const SDL_WindowEvent &event) {
 115         switch (event.event) {
 116                 case SDL_WINDOWEVENT_FOCUS_GAINED:
 117                         env.window.GrabMouse();
 118                         break;
 119                 case SDL_WINDOWEVENT_FOCUS_LOST:
 120                         env.window.ReleaseMouse();
 121                         break;
 122                 case SDL_WINDOWEVENT_RESIZED:
 123                         env.viewport.Resize(event.data1, event.data2);
 124                         break;
 125                 default:
 126                         break;
 127         }
 128 }
 129
 130 void Application::Update(int dt) {
 131         env.counter.EnterUpdate();
 132         env.audio.Update(dt);
 133         if (HasState()) {
 134                 GetState().Update(dt);
 135         }
 136         env.counter.ExitUpdate();
 137 }
 138
 139 void Application::Render() {
 140         // gl implementation may (and will probably) delay vsync blocking until
 141         // the first write after flipping, which is this clear call
 142         env.viewport.Clear();
 143         env.counter.EnterRender();
 144
 145         if (HasState()) {
 146                 GetState().Render(env.viewport);
 147         }
 148
 149         env.counter.ExitRender();
 150         env.window.Flip();
 151 }
 152
 153
 154 void Application::PushState(State *s) {
 155         if (!states.empty()) {
 156                 states.top()->OnPause();
 157         }
 158         states.emplace(s);
 159         ++s->ref_count;
 160         if (s->ref_count == 1) {
 161                 s->OnEnter();
 162         }
 163         s->OnResume();
 164 }
 165
 166 State *Application::PopState() {
 167         State *s = states.top();
 168         states.pop();
 169         s->OnPause();
 170         s->OnExit();
 171         if (!states.empty()) {
 172                 states.top()->OnResume();
 173         }
 174         return s;
 175 }
 176
 177 State *Application::SwitchState(State *s_new) {
 178         State *s_old = states.top();
 179         states.top() = s_new;
 180         --s_old->ref_count;
 181         ++s_new->ref_count;
 182         s_old->OnPause();
 183         if (s_old->ref_count == 0) {
 184                 s_old->OnExit();
 185         }
 186         if (s_new->ref_count == 1) {
 187                 s_new->OnEnter();
 188         }
 189         s_new->OnResume();
 190         return s_old;
 191 }
 192
 193 State &Application::GetState() {
 194         return *states.top();
 195 }
 196
 197 bool Application::HasState() const noexcept {
 198         return !states.empty();
 199 }
 200
 201
 202 void StateControl::Commit(Application &app) {
 203         while (!cue.empty()) {
 204                 Memo m(cue.front());
 205                 cue.pop();
 206                 switch (m.cmd) {
 207                         case PUSH:
 208                                 app.PushState(m.state);
 209                                 break;
 210                         case SWITCH:
 211                                 app.SwitchState(m.state);
 212                                 break;
 213                         case POP:
 214                                 app.PopState();
 215                                 break;
 216                         case POP_ALL:
 217                                 while (app.HasState()) {
 218                                         app.PopState();
 219                                 }
 220                                 break;
 221                 }
 222         }
 223 }
 224
 225
 226 Assets::Assets(const string &base)
 227 : fonts(base + "fonts/")
 228 , sounds(base + "sounds/")
 229 , textures(base + "textures/")
 230 , data(base + "data/")
 231 , large_ui_font(LoadFont("DejaVuSans", 24))
 232 , small_ui_font(LoadFont("DejaVuSans", 16)) {
 233
 234 }
 235
 236 namespace {
 237
 238 CuboidShape block_shape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f }});
 239 StairShape stair_shape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f }}, { 0.0f, 0.0f });
 240 CuboidShape slab_shape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.0f, 0.5f }});
 241
 242 }
 243
 244 void Assets::LoadBlockTypes(const std::string &set_name, BlockTypeRegistry &reg, TextureIndex &tex_index) const {
 245         string full = data + set_name + ".types";
 246         std::ifstream file(full);
 247         if (!file) {
 248                 throw std::runtime_error("failed to open block type file " + full);
 249         }
 250         TokenStreamReader in(file);
 251         string type_name;
 252         string name;
 253         string tex_name;
 254         string shape_name;
 255         while (in.HasMore()) {
 256                 in.ReadIdentifier(type_name);
 257                 in.Skip(Token::EQUALS);
 258                 BlockType type;
 259
 260                 // read block type
 261                 in.Skip(Token::ANGLE_BRACKET_OPEN);
 262                 while (in.Peek().type != Token::ANGLE_BRACKET_CLOSE) {
 263                         in.ReadIdentifier(name);
 264                         in.Skip(Token::EQUALS);
 265                         if (name == "visible") {
 266                                 type.visible = in.GetBool();
 267                         } else if (name == "texture") {
 268                                 in.ReadString(tex_name);
 269                                 type.texture = tex_index.GetID(tex_name);
 270                         } else if (name == "color") {
 271                                 in.ReadVec(type.color);
 272                         } else if (name == "outline") {
 273                                 in.ReadVec(type.outline_color);
 274                         } else if (name == "label") {
 275                                 in.ReadString(type.label);
 276                         } else if (name == "luminosity") {
 277                                 type.luminosity = in.GetInt();
 278                         } else if (name == "block_light") {
 279                                 type.block_light = in.GetBool();
 280                         } else if (name == "collision") {
 281                                 type.collision = in.GetBool();
 282                         } else if (name == "collide_block") {
 283                                 type.collide_block = in.GetBool();
 284                         } else if (name == "shape") {
 285                                 in.ReadIdentifier(shape_name);
 286                                 if (shape_name == "block") {
 287                                         type.shape = &block_shape;
 288                                         type.fill = {  true,  true,  true,  true,  true,  true };
 289                                 } else if (shape_name == "slab") {
 290                                         type.shape = &slab_shape;
 291                                         type.fill = { false,  true, false, false, false, false };
 292                                 } else if (shape_name == "stair") {
 293                                         type.shape = &stair_shape;
 294                                         type.fill = { false,  true, false, false, false,  true };
 295                                 } else {
 296                                         throw runtime_error("unknown block shape: " + shape_name);
 297                                 }
 298                         } else {
 299                                 throw runtime_error("unknown block property: " + name);
 300                         }
 301                         in.Skip(Token::SEMICOLON);
 302                 }
 303                 in.Skip(Token::ANGLE_BRACKET_CLOSE);
 304                 in.Skip(Token::SEMICOLON);
 305
 306                 reg.Add(type);
 307         }
 308 }
 309
 310 Font Assets::LoadFont(const string &name, int size) const {
 311         string full = fonts + name + ".ttf";
 312         return Font(full.c_str(), size);
 313 }
 314
 315 Sound Assets::LoadSound(const string &name) const {
 316         string full = sounds + name + ".wav";
 317         return Sound(full.c_str());
 318 }
 319
 320 Texture Assets::LoadTexture(const string &name) const {
 321         string full = textures + name + ".png";
 322         Texture tex;
 323         SDL_Surface *srf = IMG_Load(full.c_str());
 324         if (!srf) {
 325                 throw SDLError("IMG_Load");
 326         }
 327         tex.Bind();
 328         tex.Data(*srf);
 329         SDL_FreeSurface(srf);
 330         return tex;
 331 }
 332
 333 void Assets::LoadTexture(const string &name, ArrayTexture &tex, int layer) const {
 334         string full = textures + name + ".png";
 335         SDL_Surface *srf = IMG_Load(full.c_str());
 336         if (!srf) {
 337                 throw SDLError("IMG_Load");
 338         }
 339         tex.Bind();
 340         try {
 341                 tex.Data(layer, *srf);
 342         } catch (...) {
 343                 SDL_FreeSurface(srf);
 344                 throw;
 345         }
 346         SDL_FreeSurface(srf);
 347 }
 348
 349 void Assets::LoadTextures(const TextureIndex &index, ArrayTexture &tex) const {
 350         // TODO: where the hell should that size come from?
 351         tex.Reserve(16, 16, index.Size(), Format());
 352         for (const auto &entry : index.Entries()) {
 353                 LoadTexture(entry.first, tex, entry.second);
 354         }
 355 }
 356
 357
 358 TextureIndex::TextureIndex()
 359 : id_map() {
 360
 361 }
 362
 363 int TextureIndex::GetID(const string &name) {
 364         auto entry = id_map.find(name);
 365         if (entry == id_map.end()) {
 366                 auto result = id_map.emplace(name, Size());
 367                 return result.first->second;
 368         } else {
 369                 return entry->second;
 370         }
 371 }
 372
 373
 374 void FrameCounter::EnterFrame() noexcept {
 375         last_enter = SDL_GetTicks();
 376         last_tick = last_enter;
 377 }
 378
 379 void FrameCounter::EnterHandle() noexcept {
 380         Tick();
 381 }
 382
 383 void FrameCounter::ExitHandle() noexcept {
 384         current.handle = Tick();
 385 }
 386
 387 void FrameCounter::EnterUpdate() noexcept {
 388         Tick();
 389 }
 390
 391 void FrameCounter::ExitUpdate() noexcept {
 392         current.update = Tick();
 393 }
 394
 395 void FrameCounter::EnterRender() noexcept {
 396         Tick();
 397 }
 398
 399 void FrameCounter::ExitRender() noexcept {
 400         current.render = Tick();
 401 }
 402
 403 void FrameCounter::ExitFrame() noexcept {
 404         Uint32 now = SDL_GetTicks();
 405         current.total = now - last_enter;
 406         current.running = current.handle + current.update + current.render;
 407         current.waiting = current.total - current.running;
 408         Accumulate();
 409
 410         ++cur_frame;
 411         if (cur_frame >= NUM_FRAMES) {
 412                 Push();
 413                 cur_frame = 0;
 414                 changed = true;
 415         } else {
 416                 changed = false;
 417         }
 418 }
 419
 420 int FrameCounter::Tick() noexcept {
 421         Uint32 now = SDL_GetTicks();
 422         int delta = now - last_tick;
 423         last_tick = now;
 424         return delta;
 425 }
 426
 427 void FrameCounter::Accumulate() noexcept {
 428         sum.handle += current.handle;
 429         sum.update += current.update;
 430         sum.render += current.render;
 431         sum.running += current.running;
 432         sum.waiting += current.waiting;
 433         sum.total += current.total;
 434
 435         max.handle = std::max(current.handle, max.handle);
 436         max.update = std::max(current.update, max.update);
 437         max.render = std::max(current.render, max.render);
 438         max.running = std::max(current.running, max.running);
 439         max.waiting = std::max(current.waiting, max.waiting);
 440         max.total = std::max(current.total, max.total);
 441
 442         current = Frame<int>();
 443 }
 444
 445 void FrameCounter::Push() noexcept {
 446         peak = max;
 447         avg.handle = sum.handle * factor;
 448         avg.update = sum.update * factor;
 449         avg.render = sum.render * factor;
 450         avg.running = sum.running * factor;
 451         avg.waiting = sum.waiting * factor;
 452         avg.total = sum.total * factor;
 453
 454         sum = Frame<int>();
 455         max = Frame<int>();
 456 }
 457
 458 }