X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fapp%2Fapp.cpp;h=f3c9115faedf3b50c96002efe1c231ee0e0547ed;hb=39df551265bff648c1ac166043bb4b046122cc8d;hp=9e83cd416b229cb18fce4c4f40ec94b38d678c3f;hpb=55dbd6b35a39888f245e247d2e140f141f918178;p=blank.git diff --git a/src/app/app.cpp b/src/app/app.cpp index 9e83cd4..f3c9115 100644 --- a/src/app/app.cpp +++ b/src/app/app.cpp @@ -1,69 +1,41 @@ #include "Application.hpp" #include "Assets.hpp" - +#include "Environment.hpp" +#include "FrameCounter.hpp" +#include "State.hpp" +#include "StateControl.hpp" + +#include "init.hpp" +#include "../audio/Sound.hpp" +#include "../graphics/ArrayTexture.hpp" #include "../graphics/Font.hpp" +#include "../graphics/Texture.hpp" #include "../world/BlockType.hpp" #include "../world/Entity.hpp" #include #include +#include using std::string; -namespace { - -string get_asset_path() { - char *base = SDL_GetBasePath(); - string assets(base); - assets += "assets/"; - SDL_free(base); - return assets; -} - -} - namespace blank { -Application::Application(const Config &config) -: init_sdl() -, init_img() -, init_ttf() -, init_gl(config.doublebuf, config.multisampling) -, window() -, ctx(window.CreateContext()) -, init_glew() -, assets(get_asset_path()) -, chunk_prog() -, entity_prog() -, sprite_prog() -, cam() -, world(config.world) -, interface(config.interface, assets, world) -, test_controller(MakeTestEntity(world)) -, running(false) { - if (config.vsync) { - GLContext::EnableVSync(); - } +Application::Application(Environment &e) +: env(e) +, states() { - glClearColor(0.0, 0.0, 0.0, 1.0); } -Entity &Application::MakeTestEntity(World &world) { - Entity &e = world.AddEntity(); - e.Name("test"); - e.Position({ 0.0f, 0.0f, 0.0f }); - e.Bounds({ { -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f } }); - e.WorldCollidable(true); - e.SetShape(world.BlockTypes()[1].shape, { 1.0f, 1.0f, 0.0f }); - e.AngularVelocity(glm::quat(glm::vec3{ 0.00001f, 0.000006f, 0.000013f })); - return e; +Application::~Application() { + env.audio.StopAll(); } void Application::RunN(size_t n) { Uint32 last = SDL_GetTicks(); - for (size_t i = 0; i < n; ++i) { + for (size_t i = 0; HasState() && i < n; ++i) { Uint32 now = SDL_GetTicks(); int delta = now - last; Loop(delta); @@ -74,7 +46,7 @@ void Application::RunN(size_t n) { void Application::RunT(size_t t) { Uint32 last = SDL_GetTicks(); Uint32 finish = last + t; - while (last < finish) { + while (HasState() && last < finish) { Uint32 now = SDL_GetTicks(); int delta = now - last; Loop(delta); @@ -83,17 +55,16 @@ void Application::RunT(size_t t) { } void Application::RunS(size_t n, size_t t) { - for (size_t i = 0; i < n; ++i) { + for (size_t i = 0; HasState() && i < n; ++i) { Loop(t); } } void Application::Run() { - running = true; Uint32 last = SDL_GetTicks(); - window.GrabMouse(); - while (running) { + env.window.GrabMouse(); + while (HasState()) { Uint32 now = SDL_GetTicks(); int delta = now - last; Loop(delta); @@ -102,86 +73,133 @@ void Application::Run() { } void Application::Loop(int dt) { + env.counter.EnterFrame(); HandleEvents(); + if (!HasState()) return; Update(dt); + env.state.Commit(*this); + if (!HasState()) return; Render(); + env.counter.ExitFrame(); } void Application::HandleEvents() { + env.counter.EnterHandle(); SDL_Event event; - while (SDL_PollEvent(&event)) { - switch (event.type) { - case SDL_KEYDOWN: - interface.HandlePress(event.key); - break; - case SDL_KEYUP: - interface.HandleRelease(event.key); - break; - case SDL_MOUSEBUTTONDOWN: - interface.HandlePress(event.button); - break; - case SDL_MOUSEBUTTONUP: - interface.HandleRelease(event.button); - break; - case SDL_MOUSEMOTION: - interface.Handle(event.motion); - break; - case SDL_MOUSEWHEEL: - interface.Handle(event.wheel); - break; - case SDL_QUIT: - running = false; - break; - case SDL_WINDOWEVENT: - Handle(event.window); - break; - default: - break; - } + while (HasState() && SDL_PollEvent(&event)) { + Handle(event); + env.state.Commit(*this); + } + env.counter.ExitHandle(); +} + +void Application::Handle(const SDL_Event &event) { + switch (event.type) { + case SDL_QUIT: + env.state.PopAll(); + break; + case SDL_WINDOWEVENT: + Handle(event.window); + break; + default: + GetState().Handle(event); + break; } } void Application::Handle(const SDL_WindowEvent &event) { switch (event.event) { case SDL_WINDOWEVENT_FOCUS_GAINED: - window.GrabMouse(); + env.window.GrabMouse(); break; case SDL_WINDOWEVENT_FOCUS_LOST: - window.ReleaseMouse(); + env.window.ReleaseMouse(); break; case SDL_WINDOWEVENT_RESIZED: - cam.Viewport(event.data1, event.data2); - interface.Handle(event); + env.viewport.Resize(event.data1, event.data2); break; default: - interface.Handle(event); break; } } void Application::Update(int dt) { - interface.Update(dt); - test_controller.Update(dt); - world.Update(dt); + env.counter.EnterUpdate(); + if (HasState()) { + GetState().Update(dt); + } + env.counter.ExitUpdate(); } void Application::Render() { - GLContext::Clear(); + // gl implementation may (and will probably) delay vsync blocking until + // the first write after flipping, which is this clear call + env.viewport.Clear(); + env.counter.EnterRender(); - chunk_prog.SetProjection(cam.Projection()); - entity_prog.SetProjection(cam.Projection()); + if (HasState()) { + GetState().Render(env.viewport); + } - world.Render(chunk_prog, entity_prog); + env.counter.ExitRender(); + env.window.Flip(); +} - interface.Render(entity_prog, sprite_prog); - window.Flip(); +void Application::PushState(State *s) { + states.emplace(s); +} + +State *Application::PopState() { + State *s = states.top(); + states.pop(); + return s; +} + +State *Application::SwitchState(State *s_new) { + State *s_old = states.top(); + states.top() = s_new; + return s_old; +} + +State &Application::GetState() { + return *states.top(); +} + +bool Application::HasState() const noexcept { + return !states.empty(); +} + + +void StateControl::Commit(Application &app) { + while (!cue.empty()) { + Memo m(cue.front()); + cue.pop(); + switch (m.cmd) { + case PUSH: + app.PushState(m.state); + break; + case SWITCH: + app.SwitchState(m.state); + break; + case POP: + app.PopState(); + break; + case POP_ALL: + while (app.HasState()) { + app.PopState(); + } + break; + } + } } Assets::Assets(const string &base) -: fonts(base + "fonts/") { +: fonts(base + "fonts/") +, sounds(base + "sounds/") +, textures(base + "textures/") { } @@ -190,4 +208,123 @@ Font Assets::LoadFont(const string &name, int size) const { return Font(full.c_str(), size); } +Sound Assets::LoadSound(const string &name) const { + string full = sounds + name + ".wav"; + return Sound(full.c_str()); +} + +Texture Assets::LoadTexture(const string &name) const { + string full = textures + name + ".png"; + Texture tex; + SDL_Surface *srf = IMG_Load(full.c_str()); + if (!srf) { + throw SDLError("IMG_Load"); + } + tex.Bind(); + tex.Data(*srf); + SDL_FreeSurface(srf); + return tex; +} + +void Assets::LoadTexture(const string &name, ArrayTexture &tex, int layer) const { + string full = textures + name + ".png"; + SDL_Surface *srf = IMG_Load(full.c_str()); + if (!srf) { + throw SDLError("IMG_Load"); + } + tex.Bind(); + try { + tex.Data(layer, *srf); + } catch (...) { + SDL_FreeSurface(srf); + throw; + } + SDL_FreeSurface(srf); +} + + +void FrameCounter::EnterFrame() noexcept { + last_enter = SDL_GetTicks(); + last_tick = last_enter; +} + +void FrameCounter::EnterHandle() noexcept { + Tick(); +} + +void FrameCounter::ExitHandle() noexcept { + current.handle = Tick(); +} + +void FrameCounter::EnterUpdate() noexcept { + Tick(); +} + +void FrameCounter::ExitUpdate() noexcept { + current.update = Tick(); +} + +void FrameCounter::EnterRender() noexcept { + Tick(); +} + +void FrameCounter::ExitRender() noexcept { + current.render = Tick(); +} + +void FrameCounter::ExitFrame() noexcept { + Uint32 now = SDL_GetTicks(); + current.total = now - last_enter; + current.running = current.handle + current.update + current.render; + current.waiting = current.total - current.running; + Accumulate(); + + ++cur_frame; + if (cur_frame >= NUM_FRAMES) { + Push(); + cur_frame = 0; + changed = true; + } else { + changed = false; + } +} + +int FrameCounter::Tick() noexcept { + Uint32 now = SDL_GetTicks(); + int delta = now - last_tick; + last_tick = now; + return delta; +} + +void FrameCounter::Accumulate() noexcept { + sum.handle += current.handle; + sum.update += current.update; + sum.render += current.render; + sum.running += current.running; + sum.waiting += current.waiting; + sum.total += current.total; + + max.handle = std::max(current.handle, max.handle); + max.update = std::max(current.update, max.update); + max.render = std::max(current.render, max.render); + max.running = std::max(current.running, max.running); + max.waiting = std::max(current.waiting, max.waiting); + max.total = std::max(current.total, max.total); + + current = Frame(); +} + +void FrameCounter::Push() noexcept { + peak = max; + avg.handle = sum.handle * factor; + avg.update = sum.update * factor; + avg.render = sum.render * factor; + avg.running = sum.running * factor; + avg.waiting = sum.waiting * factor; + avg.total = sum.total * factor; + + sum = Frame(); + max = Frame(); +} + }