demo/include/hexboard/scene.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 10/12/22.
+//
+
+#ifndef FGGL_DEMO_INCLUDE_HEXBOARD_SCENE_H
+#define FGGL_DEMO_INCLUDE_HEXBOARD_SCENE_H
+
+#include <memory>
+#include <optional>
+
+#include "fggl/scenes/game.hpp"
+#include "fggl/grid/hexgrid.hpp"
+#include "fggl/grid/layout.hpp"
+
+#include "camera.hpp"
+
+namespace demo::hexboard {
+
+	struct SelectionModel {
+		std::optional<fggl::grid::IntHex> selected;
+		std::optional<fggl::grid::IntHex> hover;
+	};
+
+	class Scene : public fggl::scenes::GameBase {
+		public:
+			explicit Scene(fggl::App& app);
+
+			void activate() override;
+			void deactivate() override;
+
+			void update(float delta) override;
+			void render(fggl::gfx::Graphics& gfx) override;
+
+		private:
+			std::unique_ptr<fggl::grid::HexGrid> m_board;
+			std::unique_ptr<fggl::grid::Layout> m_layout;
+			std::unique_ptr<SelectionModel> m_selections;
+			std::unique_ptr<Camera2D> m_camera;
+
+			fggl::math::vec2 m_screen;
+			std::optional<fggl::math::vec2> m_dragging;
+
+			void drawGrid(fggl::gfx::Paint&);
+			void drawSelections(fggl::gfx::Paint&);
+	};
+
+} // namespace demo::hexboard
+
+#endif //FGGL_DEMO_INCLUDE_HEXBOARD_SCENE_H

demo/include/models/viewer.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 18/10/22.
+//
+
+#ifndef FGGL_DEMO_INCLUDE_MODELS_VIEWER_HPP
+#define FGGL_DEMO_INCLUDE_MODELS_VIEWER_HPP
+
+#include "fggl/scenes/game.hpp"
+#include "fggl/assets/types.hpp"
+
+namespace demo {
+
+	class Viewer : public fggl::scenes::Game {
+
+		public:
+			explicit Viewer(fggl::App& app);
+
+			void activate() override;
+			void deactivate() override;
+
+			void update(float dt) override;
+			void render(fggl::gfx::Graphics& gfx) override;
+
+		private:
+			fggl::entity::EntityID m_model = fggl::entity::INVALID;
+			std::vector< fggl::assets::AssetID> m_assets;
+			uint64_t m_lastAsset = 0;
+			bool m_debug = false;
+
+			void cycleAsset(uint64_t asset);
+
+	};
+}
+
+#endif //FGGL_DEMO_INCLUDE_MODELS_VIEWER_HPP

demo/include/robot/programmer.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 04/09/22.
+//
+
+#ifndef FGGL_DEMO_INCLUDE_ROBOT_PROGRAMMER_HPP
+#define FGGL_DEMO_INCLUDE_ROBOT_PROGRAMMER_HPP
+
+#include <functional>
+
+#include "fggl/gui/containers.hpp"
+
+namespace demo::robot {
+
+	struct Instruction {
+		const char* name;
+		std::function<void(void)> m_func;
+	};
+
+	struct Program {
+		std::vector<Instruction> m_instructions;
+		uint32_t m_currInstruction;
+		bool playing = false;
+
+		inline std::size_t size() {
+			return m_instructions.size();
+		}
+
+		inline void step() {
+			m_instructions[ m_currInstruction ].m_func();
+			m_currInstruction++;
+		}
+
+		inline void stop() {
+			playing = false;
+			m_currInstruction = 0;
+		}
+	};
+
+	class Timeline : public fggl::gui::Panel {
+		public:
+			explicit Timeline(Program& program);
+
+			void update(float deltaTime) override;
+			void render(fggl::gfx::Paint& paint) override;
+
+		protected:
+			void renderInstructions(fggl::gfx::Paint& paint);
+
+		private:
+			std::vector<std::reference_wrapper<Program>> m_tracks;
+	};
+
+}
+
+#endif //FGGL_DEMO_INCLUDE_ROBOT_PROGRAMMER_HPP

demo/include/rollball.hpp

+/*
+ * ${license.title}
+ * Copyright (C) 2022 ${license.owner}
+ * ${license.mailto}
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+//
+// Created by webpigeon on 23/04/22.
+//
+
+#ifndef DEMO_ROLLBALL_HPP
+#define DEMO_ROLLBALL_HPP
+
+#include "fggl/scenes/game.hpp"
+#include "fggl/phys/service.hpp"
+#include "fggl/script/engine.hpp"
+
+namespace demo {
+
+	enum class DebugMode {
+			NORMAL = 0,
+			DISTANCE = 1,
+			VISION = 2
+	};
+
+	struct RollState {
+		fggl::entity::EntityID player = fggl::entity::INVALID;
+		fggl::entity::EntityID closestPickup;
+		DebugMode mode = DebugMode::NORMAL;
+		std::vector<fggl::entity::EntityID> collectables;
+		float time = 0.0f;
+	};
+
+	class RollBall : public fggl::scenes::Game {
+
+		public:
+
+			explicit RollBall(fggl::App& app);
+
+			void activate() override;
+			void deactivate() override;
+
+			void update(float dt) override;
+			void render(fggl::gfx::Graphics& gfx) override;
+
+		private:
+			constexpr static fggl::math::vec3 HINT_COLOUR{0.5f, 0.0f, 0.0f};
+			RollState state;
+			fggl::phys::PhysicsEngine* m_phys;
+			fggl::script::ScriptEngine* m_scripts;
+			fggl::math::vec3 cameraOffset = {-15.0F, 15.0F, 0.0F};
+
+			void closestPickup(fggl::entity::EntityManager& world);
+			void spinCubes(fggl::entity::EntityManager& world, float dt);
+	};
+
+}
+
+#endif //DEMO_ROLLBALL_HPP

demo/include/topdown.hpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 03/07/22.
+//
+
+#ifndef DEMO_TOPDOWN_HPP
+#define DEMO_TOPDOWN_HPP
+
+#include "fggl/scenes/game.hpp"
+
+namespace demo {
+
+	class TopDown : public fggl::scenes::Game {
+
+		public:
+			explicit TopDown(fggl::App& app);
+			void activate() override;
+
+			void update(float dt) override;
+			void render(fggl::gfx::Graphics& gfx) override;
+
+		private:
+			constexpr static fggl::math::vec3 HINT_COLOUR{0.5f, 0.0f, 0.0f};
+			fggl::math::vec3 cameraOffset = {-15.0F, 15.0F, 0.0F};
+
+			void pick_object();
+
+	};
+
+}
+
+#endif //DEMO_TOPDOWN_HPP

demo/main.cpp

-#include <filesystem>
-#include <iostream>
-
-#include <utility>
-#include <fggl/gfx/window.hpp>
-#include <fggl/gfx/camera.hpp>
-#include <fggl/input/camera_input.h>
-
-#include <fggl/gfx/compat.hpp>
-#include <fggl/gfx/ogl/compat.hpp>
-
-#include <fggl/data/procedural.hpp>
-#include <fggl/data/storage.hpp>
-#include <fggl/util/chrono.hpp>
-#include <fggl/util/service.h>
-#include <fggl/ecs3/ecs.hpp>
-
-#include <fggl/debug/debug.h>
-#include <fggl/scenes/Scene.h>
-
-// FIXME: imgui and perlinNoise shouldn't form part of our public API >.<
-#include <imgui.h>
-#include <PerlinNoise.hpp>
-
-constexpr bool showNormals = false;
-
-// prototype of resource discovery
-void discover(const std::filesystem::path& base) {
-
-	std::vector< std::filesystem::path > contentPacks;
-	for ( auto& item : std::filesystem::directory_iterator(base) ) {
-
-		// content pack detection
-		if ( std::filesystem::is_directory( item ) ) {
-			auto manifest = item.path() / "manifest.yml";
-			if ( std::filesystem::exists( manifest ) ) {
-				contentPacks.push_back( item.path() );
-			}
-		}
-		
-	}
-
-	// what did we find?
-	std::cerr << "found pack(s): " << std::endl;
-	for ( auto& pack : contentPacks ) {
-		std::cerr << pack << std::endl;
-	}
-
-}
-
-enum camera_type { cam_free, cam_arcball };
-camera_type cam_mode = cam_free;
-
-//TODO proper input system
-using InputManager = std::shared_ptr<fggl::input::Input>;
-
-void process_camera(fggl::ecs3::World& ecs, const InputManager& input) {
-    auto cameras = ecs.findMatching<fggl::gfx::Camera>();
-    fggl::ecs3::entity_t cam = cameras[0];
-
-	auto camTransform = ecs.get<fggl::math::Transform>(cam);
-	auto camComp = ecs.get<fggl::gfx::Camera>(cam);
-
-	const glm::vec3 dir = ( camTransform->origin() - camComp->target );
-	const glm::vec3 forward = glm::normalize( dir );
-
-	// scroll wheel
-	glm::vec3 motion(0.0f);
-	float delta = input->mouse.axis( fggl::input::MouseAxis::SCROLL_Y );
-	if ( (glm::length( dir ) < 25.0f && delta < 0.0f) || (glm::length( dir ) > 2.5f && delta > 0.0f) )
-		motion -= (forward * delta);
-	camTransform->origin( camTransform->origin() + motion );
-
-	if ( cam_mode == cam_arcball || input->mouse.button( fggl::input::MouseButton::MIDDLE ) ) { 
-		fggl::input::process_arcball(ecs, *input, cam);
-	} else if ( cam_mode == cam_free ) {
-		fggl::input::process_freecam(ecs, *input, cam);
-	}
-	fggl::input::process_edgescroll( ecs, *input, cam );
-}
-
-void placeObject(fggl::ecs3::World& world, fggl::ecs::entity_t parent, fggl::ecs::entity_t prototype, glm::vec3 targetPos) {
-    auto obj = world.copy(prototype);
-    auto result = world.get<fggl::math::Transform>(obj);
-
-    int xPos = (int)targetPos.x;
-    int zPos = (int)targetPos.z * -1;
-
-    // figure out the floor height
-    auto heightMap = world.get<fggl::data::HeightMap>(parent);
-    targetPos.y = heightMap->getValue(xPos, zPos); // TODO should really be the gradient at the required point
-
-    result->origin( targetPos );
-}
-
-class MenuScene : public fggl::scenes::Scene {
-
-public:
-    explicit MenuScene(InputManager inputs) : m_inputs(std::move(inputs)) {}
-    ~MenuScene() override = default;
-
-    void setup() override {
-    }
-
-    void cleanup() override {
-
-    }
-
-    void update() override {
-        bool leftMouse = m_inputs->mouse.button(fggl::input::MouseButton::LEFT);
-        if (leftMouse) {
-            auto scenes = fggl::util::ServiceLocator::instance().providePtr<fggl::scenes::SceneManager>();
-            scenes->activate("game");
-        }
-    }
-
-    void render() override {
-
-    }
-
-private:
-    InputManager m_inputs;
-
-};
-
-class GameScene : public fggl::scenes::Scene {
-public:
-    explicit GameScene(fggl::ecs3::World& world, InputManager inputs) : m_world(world), m_inputs(std::move(inputs)) { };
-    ~GameScene() override = default;
-
-    void setup() override {
-        auto types = m_world.types();
-
-        // create camera using strings
-        {
-            auto prototype = m_world.create(false);
-            m_world.add(prototype, types.find(fggl::math::Transform::name));
-            m_world.add(prototype, types.find(fggl::gfx::Camera::name));
-            m_world.add(prototype, types.find(fggl::input::FreeCamKeys::name));
-
-            auto camTf = m_world.get<fggl::math::Transform>(prototype);
-            camTf->origin( glm::vec3(10.0f, 3.0f, 10.0f) );
-
-            auto cameraKeys = m_world.get<fggl::input::FreeCamKeys>(prototype);
-            cameraKeys->forward = glfwGetKeyScancode(GLFW_KEY_W);
-            cameraKeys->backward = glfwGetKeyScancode(GLFW_KEY_S);
-            cameraKeys->left = glfwGetKeyScancode(GLFW_KEY_A);
-            cameraKeys->right = glfwGetKeyScancode(GLFW_KEY_D);
-            cameraKeys->rotate_cw = glfwGetKeyScancode(GLFW_KEY_Q);
-            cameraKeys->rotate_ccw = glfwGetKeyScancode(GLFW_KEY_E);
-        }
-
-        fggl::ecs3::entity_t terrain;
-        {
-            terrain = m_world.create(false);
-            m_world.add(terrain, types.find(fggl::math::Transform::name));
-
-            auto camTf = m_world.get<fggl::math::Transform>(terrain);
-            camTf->origin( glm::vec3(0.0f, 0.0f, 0.0f) );
-
-            //auto terrainData = m_world.get<fggl::data::HeightMap>(terrain);
-            fggl::data::HeightMap terrainData{};
-            terrainData.clear();
-
-            const siv::PerlinNoise::seed_type seed = 123456u;
-            const siv::PerlinNoise perlin{ seed };
-
-            for (int y = 0; y < 255; ++y) {
-                for (int x = 0; x < 255; ++x) {
-                    const double noise = perlin.octave2D_11( (x * 0.01), (y * 0.01) , 4) * 10.f;
-                    terrainData.heightValues[x * 255 +y] = (float)noise;
-                }
-            }
-            m_world.set<fggl::data::HeightMap>(terrain, &terrainData);
-        }
-
-        // create foundation object
-        fggl::ecs3::entity_t foundation;
-        {
-            foundation = m_world.create(true);
-            m_world.add(foundation, types.find(fggl::math::Transform::name));
-
-            // plot rendering
-            fggl::data::Mesh mesh;
-            fggl::data::make_cube(mesh);
-            mesh.removeDups();
-
-            // add mesh as a component
-            constexpr char shader[] = "phong";
-            fggl::gfx::StaticMesh staticMesh{mesh, shader};
-            m_world.set<fggl::gfx::StaticMesh>(foundation, &staticMesh);
-        }
-
-        // create building prototype
-        fggl::ecs3::entity_t bunker;
-        {
-            bunker = m_world.create(true);
-            m_world.add(bunker, types.find(fggl::math::Transform::name));
-
-            // mesh
-            int nSections = 2;
-            constexpr float HALF_PI = M_PI / 2.0f;
-            constexpr char shader[] = "phong";
-
-            fggl::data::Mesh mesh;
-            for (int j=-(nSections/2); j<=nSections/2; j++) {
-                const auto shapeOffset = glm::vec3( 0.0f, 0.5f, (float)j * 1.0f );
-
-                const auto cubeMat = glm::translate( fggl::math::mat4( 1.0f ) , shapeOffset );
-                const auto leftSlope = fggl::math::modelMatrix(
-                        glm::vec3(-1.0f, 0.0f, 0.0f) + shapeOffset,
-                        glm::vec3( 0.0f, -HALF_PI, 0.0f) );
-                const auto rightSlope = fggl::math::modelMatrix(
-                        glm::vec3( 1.0f, 0.0f, 0.0f) + shapeOffset,
-                        glm::vec3( 0.0f, HALF_PI, 0.0f) );
-
-                fggl::data::make_cube( mesh, cubeMat );
-                fggl::data::make_slope( mesh, leftSlope );
-                fggl::data::make_slope( mesh, rightSlope );
-            }
-            mesh.removeDups();
-
-            fggl::gfx::StaticMesh staticMesh{mesh, shader};
-            m_world.set<fggl::gfx::StaticMesh>(bunker, &staticMesh);
-        }
-
-        for (int i=0; i<3; ++i) {
-            glm::vec3 location(i * 6.5f + 1.0f, 0.0f, -7.0f);
-            placeObject(m_world, terrain, foundation, location);
-        }
-
-        int nCubes = 3;
-        for ( int i=0; i<nCubes; i++ ) {
-            glm::vec3 location;
-            location.x = i * 6.f + 1.0f;
-            location.z = -5.0f + 1.0f;
-            placeObject(m_world, terrain, bunker, location);
-        }
-    }
-
-    void cleanup() override {
-
-    }
-
-    void update() override {
-        process_camera(m_world, m_inputs);
-
-        // JWR - this doesn't really seem like it belongs in the game scene...
-        if ( m_inputs->keyboard.pressed(glfwGetKeyScancode(GLFW_KEY_F10)) ) {
-            auto dbgui = fggl::util::ServiceLocator::instance().providePtr<fggl::debug::DebugUI>();
-            dbgui->visible( !dbgui->visible() );
-        }
-    }
-
-    void render() override {
-        debugInspector();
-    }
-
-    // entity inspector
-    void debugInspector() {
-        auto types = m_world.types();
-
-        ImGui::Begin("Entities");
-        auto entityItr = m_world.all();
-        for (auto& entity : entityItr) {
-            std::string label = "entity-" + std::to_string(entity);
-            if ( ImGui::TreeNode(label.c_str()) ){
-                auto entComp = m_world.getComponents(entity);
-                for ( auto comp : entComp ){
-                    auto meta = types.meta(comp);
-                    ImGui::Text("%s (%d) - %lu bytes", meta->name(), comp, meta->size());
-                }
-                ImGui::TreePop();
-            }
-        }
-        ImGui::End();
-    };
-
-private:
-    fggl::ecs3::World& m_world;
-    InputManager m_inputs;
-};
-
-void gamepadDebug(bool* visible) {
-    auto inputs = fggl::util::ServiceLocator::instance().providePtr<fggl::input::Input>();
-        auto &gamepads = inputs->gamepads;
-        ImGui::Begin("GamePad", visible);
-        for (int i = 0; i < 16; i++) {
-            std::string title = gamepads.name(i);
-
-            bool present = gamepads.present(i);
-            if (ImGui::TreeNode(title.c_str())) {
-                ImGui::Text("present: %s", present ? "yes" : "no");
-
-                if (present) {
-
-                    if (ImGui::TreeNode("buttons##2")) {
-                        for (auto &btn: fggl::input::GamepadButtonsMicrosoft) {
-                            ImGui::Text("%s: %i %i %i", btn.name,
-                                        gamepads.button(i, btn.id),
-                                        gamepads.buttonPressed(i, btn.id),
-                                        gamepads.buttonReleased(i, btn.id)
-                            );
-                        }
-                        ImGui::TreePop();
-                    }
-
-                    if (ImGui::TreeNode("axes##2")) {
-                        for (auto &axis: fggl::input::GamepadAxes) {
-                            ImGui::Text("%s: %f %f", axis.name,
-                                        gamepads.axis(i, axis.id),
-                                        gamepads.axisDelta(i, axis.id)
-                            );
-
-                        }
-                        ImGui::TreePop();
-                    }
-
-                }
-
-                ImGui::TreePop();
-                ImGui::Separator();
-            }
-
-        }
-        ImGui::End();
-}
-
-int main(int argc, char* argv[]) {
-    auto& locator = fggl::util::ServiceLocator::instance();
-
-    // setup ECS Types
-    fggl::ecs3::TypeRegistry types;
-    types.make<fggl::math::Transform>();
-    fggl::ecs3::ModuleManager modules(types);
-
-    // setup ECS
-    fggl::ecs3::World ecs(types);
-
-    // input management
-    auto inputs = std::make_shared<fggl::input::Input>();
-    locator.supply<fggl::input::Input>(inputs);
-
-    // window
-    auto glfwModule = modules.load<fggl::gfx::ecsGlfwModule>(inputs);
-    auto window = glfwModule->createWindow("Demo Game");
-	window->fullscreen( true );
-
-	// storage API
-    auto storage = std::make_shared<fggl::data::Storage>();
-    locator.supply<fggl::data::Storage>(storage);
-	//discover( storage.resolvePath(fggl::data::Data, "../../packs") );
-
-	// Opengl APIs
-    auto glModule = modules.load<fggl::gfx::ecsOpenGLModule>(window, storage);
-	fggl::gfx::loadPipeline(glModule, "unlit", false);
-	fggl::gfx::loadPipeline(glModule, "phong", false);
-	fggl::gfx::loadPipeline(glModule, "normals", false);
-
-	// debug layer
-	std::shared_ptr<fggl::debug::DebugUI> debug = std::make_shared<fggl::debug::DebugUI>(window);
-    locator.supply<fggl::debug::DebugUI>(debug);
-    debug->addWindow("gamepad", gamepadDebug);
-    //debug->addWindow("imgui-demo", ImGui::ShowDemoWindow);
-    //debug->addWindow("imgui-about", ImGui::ShowAboutWindow);
-    //debug->addWindow("imgui-help", [](bool* val) { ImGui::ShowUserGuide(); } );
-	debug->visible(true);
-
-    // Scene management
-    auto scenes = std::make_shared<fggl::scenes::SceneManager>();
-    locator.supply<fggl::scenes::SceneManager>(scenes);
-    scenes->create("main_menu", std::make_shared<MenuScene>(inputs));
-    scenes->create("game", std::make_shared<GameScene>(ecs, inputs));
-    scenes->activate("main_menu");
-
-    // Main game/event loop
-	fggl::util::Timer time{};
-	time.frequency( glfwGetTimerFrequency() );
-	time.setup( glfwGetTimerValue() );
-
-	while( !window->closeRequested() ) {
-		//
-		// Setup setup
-		//
-		time.tick( glfwGetTimerValue() );
-		inputs->frame( time.delta() );
-
-		glfwModule->context.pollEvents();
-		debug->frameStart();
-
-		//
-		// update step
-		//
-        scenes->update();
-
-        // render the scene
-        window->activate();
-        glModule->ogl.clear();
-
-        // allow the scene to do stuff, then actually render
-        scenes->render();
-        fggl::gfx::renderMeshes(glModule, ecs, time.delta());
-
-        debug->draw();
-        window->swap();
-    }
-
-	return 0;
-}

docs/CMakeLists.txt

+set(DOXYGEN_EXTRACT_ALL YES)
+set(DOXYGEN_BUILDIN_STL_SUPPORT YES)
+
+doxygen_add_docs(docs
+	WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}/include"
+)

docs/Doxyfile.in

@@ -979,7 +979,7 @@ EXCLUDE_PATTERNS       =
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories use the pattern */test/*
 
-EXCLUDE_SYMBOLS        =
+EXCLUDE_SYMBOLS        = "YAML" "glm" "dd"
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or directories
 # that contain example code fragments that are included (see the \include

fggl/CMakeLists.txt

+# headers
+file(GLOB_RECURSE HEADER_LIST CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/include/fggl/**.hpp")
+
+# the fggl library itself
+# Should be shared linkage for legal reasons (LGPL)
+add_library(fggl ${HEADER_LIST})
+
+target_link_libraries(fggl PUBLIC entt)
+
+# we need to tell people using the library about our headers
+target_include_directories(fggl
+        PUBLIC
+        $<BUILD_INTERFACE:${CMAKE_SOURCE_DIR}/include>
+        $<INSTALL_INTERFACE:include>
+        )
+
+# users of this library need at least C++20
+target_compile_features(fggl PUBLIC cxx_std_20)
+
+# IDE support for nice header files
+source_group(
+        TREE "${PROJECT_SOURCE_DIR}/include"
+        PREFIX "Header Files"
+        FILES ${HEADER_LIST}
+)
+
+# Generation of configuration header
 configure_file(FgglConfig.h.in FgglConfig.h)
 
 # clang tidy
 find_program(CLANG_TIDY_FOUND clang-tidy)
-if ( CLANG_TIDY_FOUND )
-	set(CMAKE_CXX_CLANG_TIDY clang-tidy -checks=*,-llvmlibc-*,-fuchsia-*,-cppcoreguidelines-*,-android-*,-llvm-*,-altera-*,-modernize-use-trailing-return-type)
-endif()
+if (CLANG_TIDY_FOUND)
+    set(CMAKE_CXX_CLANG_TIDY clang-tidy -checks=*,-llvmlibc-*,-fuchsia-*,-cppcoreguidelines-*,-android-*,-llvm-*,-altera-*,-modernize-use-trailing-return-type)
+endif ()
+
+# the important stuff everything else uses
+add_subdirectory(math)
+add_subdirectory(util)
+add_subdirectory(grid)
+
+add_subdirectory(assets)
+add_subdirectory(phys)
 
 target_sources(${PROJECT_NAME}
-  PRIVATE
-    fggl.cpp
-    ecs/ecs.cpp
-    data/model.cpp
-    data/procedural.cpp
-    data/heightmap.cpp
-    ecs3/fast/Container.cpp
-    ecs3/prototype/world.cpp
-    scenes/Scene.cpp
-    ecs3/module/module.cpp
-    input/camera_input.cpp
-    data/heightmap.cpp
+        PRIVATE
+        app.cpp
+
+        data/model.cpp
+        data/procedural.cpp
+        data/heightmap.cpp
+        data/module.cpp
+
+        scenes/menu.cpp
+        scenes/game.cpp
+
+        input/input.cpp
+        input/mouse.cpp
+        input/camera_input.cpp
 )
 
-# spdlog for cleaner logging
-find_package(spdlog REQUIRED)
-target_link_libraries(${PROJECT_NAME} spdlog::spdlog)
+# GUI support
+add_subdirectory(gui)
+
+# yaml-cpp for configs and storage
+find_package(yaml-cpp)
+target_link_libraries(fggl PUBLIC yaml-cpp)
+
+# model loading
+add_subdirectory(data/assimp)
 
 # Graphics backend
 add_subdirectory(gfx)
-target_link_libraries(${PROJECT_NAME} glfw)
+add_subdirectory(audio)
+
+# physics integration
 
 # Debug backend
 add_subdirectory(debug)
 
+# platform integrations
+add_subdirectory(platform)
+add_subdirectory(entity)
 
+##
+# begin windows support
+##
+if (MSVC)
+    target_compile_options(${PROJECT_NAME} PUBLIC "/ZI")
+    target_link_options(${PROJECT_NAME} PUBLIC "/INCREMENTAL")
+endif ()

fggl/FgglConfig.h.in

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 // the configured options and settings for Tutorial
 #define FGGL_VERSION_MAJOR @FGGL_VERSION_MAJOR@
 #define FGGL_VERSION_MINOR @FGGL_VERSION_MINOR@

fggl/app.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <cstdlib>
+
+#include <spdlog/spdlog.h>
+#include <fggl/app.hpp>
+
+namespace fggl {
+
+	App::App(modules::Manager *services, const Identifer &name) : App::App(services, name, name) {
+	}
+
+	App::App(modules::Manager *services, const Identifer & /*name*/, const Identifer & /*folder*/ ) :
+		m_running(true),
+		m_window(nullptr),
+		m_states(),
+		m_subsystems(services) {}
+
+	auto App::run(int /*argc*/, const char **/*argv*/) -> int {
+		auto *windowing = m_subsystems->get<display::WindowService>();
+
+		{
+			// activate the first state
+			auto &state = m_states.active();
+			m_expectedScene = m_states.activeID();
+			state.activate();
+		}
+
+		auto lastTime = glfwGetTime();
+
+		while (m_running) {
+			auto currTime = glfwGetTime();
+			auto delta = currTime - lastTime;
+			lastTime = currTime;
+
+			// trigger a state change if expected
+			if (m_expectedScene != m_states.activeID()) {
+				auto result = m_states.change(m_expectedScene);
+				if (!result) {
+					m_expectedScene = m_states.activeID();
+				}
+			}
+
+			// process window events
+			if (windowing != nullptr) {
+				windowing->pollEvents();
+			}
+			//m_modules->onUpdate();
+
+			auto &state = m_states.active();
+			state.update((float)delta);
+
+			// window rendering to frame buffer
+			if (m_window != nullptr) {
+				//	m_modules->onFrameStart();
+				m_window->frameStart();
+
+				// get draw instructions
+				auto &graphics = m_window->graphics();
+				state.render(graphics);
+
+				m_window->frameEnd();
+				//  m_modules->onFrameEnd();
+
+				m_running = m_running && !m_window->wantClose();
+			}
+		}
+
+		{
+			// shutdown last state
+			auto &state = m_states.active();
+			state.deactivate();
+		}
+
+		return EXIT_SUCCESS;
+	}
+
+} //namespace fggl
+

fggl/assets/CMakeLists.txt

+target_sources(fggl PRIVATE
+        module.cpp
+        types.cpp
+        packed/module.cpp
+)
\ No newline at end of file

fggl/assets/module.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 20/08/22.
+//
+
+#include "fggl/assets/module.hpp"
+
+namespace fggl::assets {
+
+	auto AssetFolders::factory(modules::ServiceName service, modules::Services &services) -> bool {
+		if (service == Loader::service) {
+			auto *storage = services.get<data::Storage>();
+			auto *checkin = services.get<CheckinAdapted>();
+			services.create<Loader>(storage, checkin);
+			return true;
+		}
+		if (service == AssetManager::service) {
+			services.create<AssetManager>();
+			return true;
+		}
+		return false;
+	}
+
+} // namespace fggl::assets
\ No newline at end of file

fggl/assets/packed/module.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 20/08/22.
+//
+
+#include "fggl/assets/packed/module.hpp"
+
+namespace fggl::assets {
+
+	auto PackedAssets::factory(modules::ServiceName service, modules::Services &services) -> bool {
+		if (service == RawCheckin::service) {
+			services.create<RawCheckin>();
+			return true;
+		}
+		if (service == CheckinAdapted::service) {
+			auto* storage = services.get<data::Storage>();
+			auto* rawCheckin = services.get<RawCheckin>();
+			services.create<CheckinAdapted>(storage, rawCheckin);
+			return true;
+		}
+		return false;
+	}
+
+} // namespace fggl::assets
\ No newline at end of file

fggl/assets/pipeline/loader.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 19/11/22.
+//
+
+#include <stack>
+#include <vector>
+#include <memory>
+#include <set>
+#include <map>
+#include <concepts>
+
+#include "fggl/util/guid.hpp"
+
+namespace fggl::assets {
+
+	using AssetName = util::OpaqueName<uint64_t, struct AssetRefStruct>;
+
+	/**
+	 * The base class representing an asset.
+	 *
+	 * This can be combined with the templated version.
+	 */
+	class Asset {
+		public:
+			Asset(AssetName name) : m_name(name) {}
+			virtual ~Asset() = default;
+
+			inline void release() {
+				releaseImpl();
+			}
+
+			bool operator==(const Asset& asset) const {
+				return m_name == asset.m_name;
+			}
+
+			bool operator!=(const Asset& asset) const {
+				return m_name != asset.m_name;
+			}
+
+		private:
+			AssetName m_name;
+			virtual void releaseImpl() = 0;
+	};
+
+	/**
+	 * Wrapper for types that cannot extend Asset themselves.
+	 *
+	 * @tparam T the asset to wrap
+	 */
+	template<typename T>
+	class AssetBox : public Asset {
+		public:
+			AssetBox(T* ptr) : m_ptr(ptr) {}
+
+			~AssetBox() override {
+				release();
+			}
+
+			T* ptr() {
+				return m_ptr;
+			}
+
+		private:
+			T* m_ptr;
+
+			void releaseImpl() override {
+				delete m_ptr;
+				m_ptr = nullptr;
+			}
+
+	};
+
+	/**
+	 * Asset Library.
+	 *
+	 * The currently usable set of assets loaded into the engine.
+	 */
+	class AssetLibrary {
+		public:
+			void load(AssetName name);
+			void unload(AssetName name);
+
+			template<typename T>
+			requires std::derived_from<T, Asset>
+			void store(AssetName name, T* ptr) {
+				m_assets[name] = std::make_unique<T>(ptr);
+			}
+
+			template<typename T>
+			requires std::derived_from<T, Asset>
+			void get(AssetName name) const {
+				Asset* asset = m_assets.at(name).get();
+				return dynamic_cast<T>(asset);
+			}
+
+			inline Asset* get(AssetName name) const {
+				return m_assets.at( name ).get();
+			}
+
+		private:
+			std::map<AssetName, std::unique_ptr<Asset>> m_assets;
+
+	};
+
+	struct AssetRecord {
+		AssetName id;
+		std::vector<AssetName> dependencies;
+
+		bool hasDepends(AssetName name) const;
+		void addDepend(AssetName name);
+	};
+
+	class AssetGraph {
+		public:
+			AssetGraph(AssetLibrary* loader);
+
+			/**
+			 *
+			 *
+			 * @param name
+			 */
+			void require(AssetName& name) {
+				if ( m_loaded.find(name) != m_loaded.end() ) {
+					return;
+				}
+				m_required.push(name);
+			}
+
+			/**
+			 *
+			 *
+			 * @return
+			 */
+			 [[nodiscard]]
+			inline bool isLoadComplete() const {
+				return m_required.empty();
+			}
+
+			/**
+			 *
+			 *
+			 * @param name
+			 * @return
+			 */
+			 [[nodiscard]]
+			inline bool isLoaded(AssetName name) const {
+				return m_loaded.find(name) != m_loaded.end();
+			}
+
+			/**
+			 *
+			 * @param name
+			 * @param description
+			 */
+			void addDependency(AssetName& name, AssetName& description) {
+				auto& assets = m_assets.at(name);
+				assets.addDepend(description);
+			}
+
+			/**
+			 *
+			 * @param name
+			 * @param dependency
+			 * @return
+			 */
+			[[nodiscard]]
+			bool hasDependency(AssetName& name , AssetName& dependency) const {
+				try {
+					auto &assets = m_assets.at(name);
+					return assets.hasDepends(dependency);
+				} catch ( std::out_of_range& ) {
+					return false;
+				}
+			}
+
+			/**
+			 *
+			 */
+			void process() {
+				auto asset = m_required.top();
+				m_loader->load( asset );
+				m_required.pop();
+			}
+
+			/**
+			 *
+			 */
+			void finishLoading() {
+				while ( !m_loaded.empty() ) {
+					process();
+				}
+			}
+
+		private:
+			std::stack<AssetName> m_required;
+			std::set<AssetName> m_loaded;
+			std::map<AssetName, AssetRecord> m_assets;
+			AssetLibrary* m_loader;
+	};
+
+} // namespace fggl::assets
\ No newline at end of file

fggl/assets/types.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 20/11/22.
+//
+
+#include "fggl/assets/types.hpp"
+
+namespace fggl::assets {
+	auto make_asset_id_rt(const std::string &pack, const std::string &path, const std::string &view) -> AssetID {
+		auto fullPath = pack + ":" + path;
+		if (!view.empty()) {
+			fullPath += "[" + view + "]";
+		}
+
+		#ifndef NDEBUG
+		util::intern_string(fullPath.c_str());
+		#endif
+
+		auto hash = util::hash_fnv1a_64(fullPath.c_str());
+		return AssetID::make(hash);
+	}
+
+	auto asset_from_user(const std::string &input, const std::string &pack) -> AssetID {
+
+		if (input.find(':') != std::string::npos ) {
+			// probably fully qualified
+			#ifndef NDEBUG
+			util::intern_string(input.c_str());
+			#endif
+			auto hash = util::hash_fnv1a_64(input.c_str());
+			return AssetID::make(hash);
+		}
+
+		// probably local
+		return make_asset_id_rt(pack, input);
+	}
+
+}
\ No newline at end of file

fggl/audio/CMakeLists.txt

+target_sources(fggl
+        PRIVATE
+        types.cpp
+        )
+
+add_subdirectory(openal)
+add_subdirectory(fallback)
\ No newline at end of file

fggl/audio/fallback/CMakeLists.txt

+target_sources(fggl
+    PRIVATE
+        audio.cpp
+)

fggl/audio/fallback/audio.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 05/11/22.
+//
+
+#include "fggl/audio/null_audio.hpp"
+
+namespace fggl::audio {
+
+	void NullAudioService::play(const std::string &, bool) {
+	}
+
+	void NullAudioService::play(const fggl::audio::AudioClipShort &, bool) {
+	}
+
+	auto NullAudio::factory(modules::ServiceName service, modules::Services &services) -> bool{
+		if (service == SERVICE_AUDIO_PLAYBACK) {
+			services.bind<audio::AudioService, audio::NullAudioService>();
+			return true;
+		}
+		return false;
+	}
+
+} // namespace fggl::audio
\ No newline at end of file