simple preloader

diff --git a/src/app/PreloadState.cpp b/src/app/PreloadState.cpp
new file mode 100644 (file)
index 0000000..c56e4fe
--- /dev/null
+++ b/src/app/PreloadState.cpp
@@ -0,0 +1,39 @@
+#include "PreloadState.hpp"
+
+#include "Environment.hpp"
+#include "../world/ChunkLoader.hpp"
+
+#include <iostream>
+
+
+namespace blank {
+
+PreloadState::PreloadState(Environment &env, ChunkLoader &loader)
+: env(env)
+, loader(loader)
+, per_update(256) {
+
+}
+
+
+void PreloadState::Handle(const SDL_Event &) {
+}
+
+void PreloadState::Update(int dt) {
+       loader.LoadN(per_update);
+       if (loader.ToLoad() == 0) {
+               std::cout << "preload: populating VBOs" << std::endl;
+               for (auto &chunk : loader.Loaded()) {
+                       chunk.CheckUpdate();
+               }
+               std::cout << "preload: complete" << std::endl;
+               env.state.Pop();
+       }
+}
+
+void PreloadState::Render(Viewport &) {
+       // TODO: make a nice progress bar or some other fancy shit
+       std::cout << "preload: " << loader.ToLoad() << " chunks remaining" << std::endl;
+}
+
+}

diff --git a/src/app/PreloadState.hpp b/src/app/PreloadState.hpp
new file mode 100644 (file)
index 0000000..2c85f98
--- /dev/null
+++ b/src/app/PreloadState.hpp
@@ -0,0 +1,33 @@
+#ifndef BLANK_APP_PRELOADSTATE_HPP_
+#define BLANK_APP_PRELOADSTATE_HPP_
+
+#include "State.hpp"
+
+#include <cstddef>
+
+
+namespace blank {
+
+class ChunkLoader;
+class Environment;
+
+class PreloadState
+: public State {
+
+public:
+       PreloadState(Environment &, ChunkLoader &);
+
+       void Handle(const SDL_Event &) override;
+       void Update(int dt) override;
+       void Render(Viewport &) override;
+
+private:
+       Environment &env;
+       ChunkLoader &loader;
+       std::size_t per_update;
+
+};
+
+}
+
+#endif

diff --git a/src/app/WorldState.hpp b/src/app/WorldState.hpp
index 38922ff59c43f2e5dbaa59803ec42ca2fbe339f8..e4edd121cc664fa45e4fa713628891dbe724ab32 100644 (file)
--- a/src/app/WorldState.hpp
+++ b/src/app/WorldState.hpp
@@ -25,6 +25,8 @@ public:
        void Update(int dt) override;
        void Render(Viewport &) override;
 
+       World &GetWorld() noexcept { return world; }
+
 private:
        Environment &env;
        World world;

diff --git a/src/app/runtime.cpp b/src/app/runtime.cpp
index 37cca50a4ef54229861245df31ba861c8ea6b3d0..eaeea8dd85c5c8940074fb4792e50e58271ec3e8 100644 (file)
--- a/src/app/runtime.cpp
+++ b/src/app/runtime.cpp
@@ -1,5 +1,6 @@
 #include "Application.hpp"
 #include "Environment.hpp"
+#include "PreloadState.hpp"
 #include "Runtime.hpp"
 #include "WorldState.hpp"
 
@@ -176,8 +177,11 @@ int Runtime::Execute() {
 
        Application app(env);
 
-       WorldState state(env, config.interface, config.world);
-       app.PushState(&state);
+       WorldState world_state(env, config.interface, config.world);
+       app.PushState(&world_state);
+
+       PreloadState preloader(env, world_state.GetWorld().Loader());
+       app.PushState(&preloader);
 
        switch (mode) {
                default:

diff --git a/src/world/ChunkLoader.hpp b/src/world/ChunkLoader.hpp
index c9fb8aa2f574e1721ef568ce2be95604f31ff2b0..6a8c2c19ac30d2143d42f85f01512d68c63af531 100644 (file)
--- a/src/world/ChunkLoader.hpp
+++ b/src/world/ChunkLoader.hpp
@@ -39,6 +39,10 @@ public:
        void Rebase(const Chunk::Pos &);
        void Update(int dt);
 
+       std::size_t ToLoad() const noexcept { return to_generate.size(); }
+       void LoadOne();
+       void LoadN(std::size_t n);
+
 private:
        Chunk &Generate(const Chunk::Pos &pos);
        // link given chunk to all loaded neighbors

diff --git a/src/world/World.hpp b/src/world/World.hpp
index 10710fbd6667a2dc8ac957d8068dae4564a392ab..da02b1f25902f42dc4ba8774900005a57e9f071c 100644 (file)
--- a/src/world/World.hpp
+++ b/src/world/World.hpp
@@ -48,7 +48,8 @@ public:
        bool Intersection(const Entity &e, std::vector<WorldCollision> &);
        void Resolve(Entity &e, std::vector<WorldCollision> &);
 
-       BlockTypeRegistry &BlockTypes() { return blockType; }
+       BlockTypeRegistry &BlockTypes() noexcept { return blockType; }
+       ChunkLoader &Loader() noexcept { return chunks; }
 
        Entity &Player() { return *player; }
        Entity &AddEntity() { entities.emplace_back(); return entities.back(); }

diff --git a/src/world/chunk.cpp b/src/world/chunk.cpp
index 190fe3d7b9e4c4aa25d4fbaf6745845c97b0565b..77899e79d5da360506502ae8954e54bf56648a3c 100644 (file)
--- a/src/world/chunk.cpp
+++ b/src/world/chunk.cpp
@@ -842,9 +842,20 @@ void ChunkLoader::Update(int dt) {
        // check if a chunk generation is scheduled for this frame
        // and if there's a chunk waiting to be generated
        gen_timer.Update(dt);
-       if (!gen_timer.Hit() || to_generate.empty()) {
-               return;
+       if (gen_timer.Hit()) {
+               LoadOne();
+       }
+}
+
+void ChunkLoader::LoadN(std::size_t n) {
+       std::size_t end = std::min(n, ToLoad());
+       for (std::size_t i = 0; i < end; ++i) {
+               LoadOne();
        }
+}
+
+void ChunkLoader::LoadOne() {
+       if (to_generate.empty()) return;
 
        // take position of next chunk in queue
        Chunk::Pos pos(to_generate.front());