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