X-Git-Url: http://git.localhorst.tv/?a=blobdiff_plain;f=src%2Fapp%2Fapp.cpp;h=8f3801c3893709a0bc0c92ee652158e25c40c6fd;hb=65dbb0391afb6867bd9b388c6351b947a022abad;hp=86c90d83f043d644f83a25fcfecc2b8ce99a0872;hpb=79bff420037f150bd6efd2eef08bd06afafeb068;p=blank.git

diff --git a/src/app/app.cpp b/src/app/app.cpp
index 86c90d8..8f3801c 100644
--- a/src/app/app.cpp
+++ b/src/app/app.cpp
@@ -1,54 +1,47 @@
 #include "Application.hpp"
 #include "Assets.hpp"
+#include "Environment.hpp"
 #include "FrameCounter.hpp"
+#include "State.hpp"
+#include "StateControl.hpp"
+#include "TextureIndex.hpp"
 
 #include "init.hpp"
 #include "../audio/Sound.hpp"
+#include "../graphics/ArrayTexture.hpp"
 #include "../graphics/Font.hpp"
+#include "../graphics/Texture.hpp"
+#include "../io/TokenStreamReader.hpp"
+#include "../model/shapes.hpp"
 #include "../world/BlockType.hpp"
+#include "../world/BlockTypeRegistry.hpp"
 #include "../world/Entity.hpp"
 
+#include <fstream>
 #include <iostream>
 #include <stdexcept>
+#include <SDL_image.h>
 
+using std::runtime_error;
 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(Window &win, const Config &config)
-: window(win)
-, viewport()
-, assets(get_asset_path())
-, audio()
-, counter()
-, world(config.world)
-, interface(config.interface, assets, audio, counter, world)
-, spawner(world)
-, running(false) {
-	viewport.VSync(config.vsync);
+Application::Application(Environment &e)
+: env(e)
+, states() {
+
 }
 
 Application::~Application() {
-	audio.StopAll();
+	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);
@@ -59,7 +52,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);
@@ -68,17 +61,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);
@@ -87,60 +79,48 @@ void Application::Run() {
 }
 
 void Application::Loop(int dt) {
-	counter.EnterFrame();
+	env.counter.EnterFrame();
 	HandleEvents();
+	if (!HasState()) return;
 	Update(dt);
+	env.state.Commit(*this);
+	if (!HasState()) return;
 	Render();
-	counter.ExitFrame();
+	env.counter.ExitFrame();
 }
 
 
 void Application::HandleEvents() {
-	counter.EnterHandle();
+	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_WINDOWEVENT:
+			Handle(event.window);
+			break;
+		default:
+			GetState().Handle(event);
+			break;
 	}
-	counter.ExitHandle();
 }
 
 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:
-			viewport.Resize(event.data1, event.data2);
+			env.viewport.Resize(event.data1, event.data2);
 			break;
 		default:
 			break;
@@ -148,39 +128,180 @@ void Application::Handle(const SDL_WindowEvent &event) {
 }
 
 void Application::Update(int dt) {
-	counter.EnterUpdate();
-	interface.Update(dt);
-	spawner.Update(dt);
-	world.Update(dt);
-
-	glm::mat4 trans = world.Player().Transform(Chunk::Pos(0, 0, 0));
-	glm::vec3 dir(trans * glm::vec4(0.0f, 0.0f, -1.0f, 0.0f));
-	glm::vec3 up(trans * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f));
-	audio.Position(world.Player().Position());
-	audio.Velocity(world.Player().Velocity());
-	audio.Orientation(dir, up);
-
-	counter.ExitUpdate();
+	env.counter.EnterUpdate();
+	if (HasState()) {
+		GetState().Update(dt);
+	}
+	env.counter.ExitUpdate();
 }
 
 void Application::Render() {
 	// gl implementation may (and will probably) delay vsync blocking until
 	// the first write after flipping, which is this clear call
-	viewport.Clear();
-	counter.EnterRender();
+	env.viewport.Clear();
+	env.counter.EnterRender();
+
+	if (HasState()) {
+		GetState().Render(env.viewport);
+	}
+
+	env.counter.ExitRender();
+	env.window.Flip();
+}
+
 
-	world.Render(viewport);
-	interface.Render(viewport);
+void Application::PushState(State *s) {
+	if (!states.empty()) {
+		states.top()->OnPause();
+	}
+	states.emplace(s);
+	++s->ref_count;
+	if (s->ref_count == 1) {
+		s->OnEnter();
+	}
+	s->OnResume();
+}
+
+State *Application::PopState() {
+	State *s = states.top();
+	states.pop();
+	s->OnPause();
+	s->OnExit();
+	if (!states.empty()) {
+		states.top()->OnResume();
+	}
+	return s;
+}
 
-	counter.ExitRender();
-	window.Flip();
+State *Application::SwitchState(State *s_new) {
+	State *s_old = states.top();
+	states.top() = s_new;
+	--s_old->ref_count;
+	++s_new->ref_count;
+	s_old->OnPause();
+	if (s_old->ref_count == 0) {
+		s_old->OnExit();
+	}
+	if (s_new->ref_count == 1) {
+		s_new->OnEnter();
+	}
+	s_new->OnResume();
+	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/")
-, sounds(base + "sounds/") {
+, sounds(base + "sounds/")
+, textures(base + "textures/")
+, data(base + "data/")
+, large_ui_font(LoadFont("DejaVuSans", 24))
+, small_ui_font(LoadFont("DejaVuSans", 16)) {
+
+}
+
+namespace {
+
+CuboidShape block_shape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f }});
+StairShape stair_shape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f }}, { 0.0f, 0.0f });
+CuboidShape slab_shape({{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.0f, 0.5f }});
+
+}
+
+void Assets::LoadBlockTypes(const std::string &set_name, BlockTypeRegistry &reg, TextureIndex &tex_index) const {
+	string full = data + set_name + ".types";
+	std::ifstream file(full);
+	if (!file) {
+		throw std::runtime_error("failed to open block type file " + full);
+	}
+	TokenStreamReader in(file);
+	string type_name;
+	string name;
+	string tex_name;
+	string shape_name;
+	while (in.HasMore()) {
+		in.ReadIdentifier(type_name);
+		in.Skip(Token::EQUALS);
+		BlockType type;
+
+		// read block type
+		in.Skip(Token::ANGLE_BRACKET_OPEN);
+		while (in.Peek().type != Token::ANGLE_BRACKET_CLOSE) {
+			in.ReadIdentifier(name);
+			in.Skip(Token::EQUALS);
+			if (name == "visible") {
+				type.visible = in.GetBool();
+			} else if (name == "texture") {
+				in.ReadString(tex_name);
+				type.texture = tex_index.GetID(tex_name);
+			} else if (name == "color") {
+				in.ReadVec(type.color);
+			} else if (name == "label") {
+				in.ReadString(type.label);
+			} else if (name == "luminosity") {
+				type.luminosity = in.GetInt();
+			} else if (name == "block_light") {
+				type.block_light = in.GetBool();
+			} else if (name == "collision") {
+				type.collision = in.GetBool();
+			} else if (name == "collide_block") {
+				type.collide_block = in.GetBool();
+			} else if (name == "shape") {
+				in.ReadIdentifier(shape_name);
+				if (shape_name == "block") {
+					type.shape = &block_shape;
+					type.fill = {  true,  true,  true,  true,  true,  true };
+				} else if (shape_name == "slab") {
+					type.shape = &slab_shape;
+					type.fill = { false,  true, false, false, false, false };
+				} else if (shape_name == "stair") {
+					type.shape = &stair_shape;
+					type.fill = { false,  true, false, false, false,  true };
+				} else {
+					throw runtime_error("unknown block shape: " + shape_name);
+				}
+			} else {
+				throw runtime_error("unknown block property: " + name);
+			}
+			in.Skip(Token::SEMICOLON);
+		}
+		in.Skip(Token::ANGLE_BRACKET_CLOSE);
+		in.Skip(Token::SEMICOLON);
 
+		reg.Add(type);
+	}
 }
 
 Font Assets::LoadFont(const string &name, int size) const {
@@ -193,6 +314,59 @@ Sound Assets::LoadSound(const string &name) const {
 	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 Assets::LoadTextures(const TextureIndex &index, ArrayTexture &tex) const {
+	// TODO: where the hell should that size come from?
+	tex.Reserve(16, 16, index.Size(), Format());
+	for (const auto &entry : index.Entries()) {
+		LoadTexture(entry.first, tex, entry.second);
+	}
+}
+
+
+TextureIndex::TextureIndex()
+: id_map() {
+
+}
+
+int TextureIndex::GetID(const string &name) {
+	auto entry = id_map.find(name);
+	if (entry == id_map.end()) {
+		auto result = id_map.emplace(name, Size());
+		return result.first->second;
+	} else {
+		return entry->second;
+	}
+}
+
 
 void FrameCounter::EnterFrame() noexcept {
 	last_enter = SDL_GetTicks();