demo/include/hexboard/board.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_BOARD_HPP
+#define FGGL_DEMO_INCLUDE_HEXBOARD_BOARD_HPP
+
+#include <cstdint>
+
+namespace demo::hexboard {
+
+	constexpr uint64_t NO_SELECTION{0};
+
+	struct SelectionModel {
+		uint64_t m_hover = NO_SELECTION;
+	};
+
+} // namespace demo::hexboard
+
+#endif //FGGL_DEMO_INCLUDE_HEXBOARD_BOARD_HPP

demo/include/hexboard/camera.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 02/01/23.
+//
+
+#ifndef FGGL_DEMO_INCLUDE_HEXBOARD_CAMERA_HPP
+#define FGGL_DEMO_INCLUDE_HEXBOARD_CAMERA_HPP
+
+#include "fggl/math/types.hpp"
+
+namespace demo::hexboard {
+
+	constexpr float TRAUMA_DECAY = 0.01F;
+	constexpr float TRAUMA_LARGE = 0.5F;
+	constexpr float TRAUMA_SMALL = 0.1F;
+
+	constexpr float SPEED_SLOW = 0.01F;
+	constexpr float SPEED_MEDIUM = 0.1F;
+	constexpr float SPEED_FAST = 0.5F;
+
+	constexpr fggl::math::vec2 ndc_to_screen(fggl::math::vec2 ndcPos, fggl::math::vec2 screenSize) {
+		return fggl::math::vec2(
+			fggl::math::rescale_ndc(ndcPos.x, 0, screenSize.x),
+			fggl::math::rescale_ndc(ndcPos.y, 0, screenSize.y)
+		);
+	}
+
+	/**
+	 * A 2D 'juiced' camera for grid worlds.
+	 *
+	 * This camera is based on HexBoard, and the GDC talk around this concept. Many of the ideas implemented here
+	 * come from that source.
+	 *
+	 * @see https://www.youtube.com/watch?v=tu-Qe66AvtY
+	 */
+	class Camera2D {
+		public:
+			using Point = fggl::math::vec2;
+
+			/**
+			 * Apply active camera effects.
+			 *
+			 * This method must be called once per frame of the camera's visual effects are to be animated.
+			 *
+			 * @param delta the amount of time that has passed
+			 */
+			void update(float delta);
+
+			inline fggl::math::vec2 unproject(fggl::math::vec2 screenPos) const {
+				auto location = screenPos;
+				location.x += 1920/2.0F;
+				location.y += 1080/2.0F;
+				return location + m_location;
+//				return screenPos + m_location;
+			}
+
+			inline fggl::math::vec2 project(fggl::math::vec2 worldPos) const {
+				return worldPos - m_location;
+			}
+
+			/**
+			 * Move the camera to a new location.
+			 *
+			 * This will apply any movement effects the camera has applied to it. As a result movement to the location
+			 * will not be instantaneous.
+			 *
+			 * @param newTarget the new target location
+			 */
+			inline void moveTo(Point newTarget) {
+				m_target = newTarget;
+			}
+
+			/**
+			 * Move the camera by a defined amount.
+			 *
+			 * This will apply any movement effects the camera has applied to it. As a result movement to the location
+			 * will not be instantaneous.
+			 *
+			 * @param delta the amount to add to the target, negative values will subject from the target location
+			 */
+			inline void moveBy(Point delta) {
+				m_target += delta;
+			}
+
+			/**
+			 * Instantaneously move the camera to a new location.
+			 *
+			 * @param the new camera location
+			 */
+			inline void teleportTo(Point newTarget) {
+				m_location = newTarget;
+				m_target = newTarget;
+			}
+
+			/**
+			 * Instantaneously adjust the camera location.
+			 *
+			 * @param delta the amount to adjust the camera location by
+			 */
+			inline void teleportBy(Point delta) {
+				m_location += delta;
+				m_target = m_location;
+			}
+
+			/**
+			 * Get the current view offset of this camera.
+			 *
+			 * @return the current location this camera is pointing at
+			 */
+			inline Point getFocusLocation() const {
+				auto offset = m_location;
+				offset.x += 1920/2.0F;
+				offset.y += 1080/2.0F;
+				return -offset;
+			}
+
+		private:
+			Point m_location;
+			Point m_target;
+			float m_trauma;
+			float m_scale = SPEED_MEDIUM;
+
+	};
+
+}
+
+#endif //FGGL_DEMO_INCLUDE_HEXBOARD_CAMERA_HPP

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 <memory>
-#include <utility>
-
-#include <fggl/app.hpp>
-#include <fggl/scenes/menu.hpp>
-
-#include <fggl/gfx/atlas.hpp>
-#include <fggl/gfx/window.hpp>
-#include <fggl/gfx/camera.hpp>
-
-#include "fggl/gfx/ogl/renderer.hpp"
-#include "fggl/gfx/ogl/compat.hpp"
-#include "fggl/gfx/compat.hpp"
-
-#include <fggl/data/heightmap.h>
-#include <fggl/data/procedural.hpp>
-#include <fggl/data/storage.hpp>
-#include <fggl/util/chrono.hpp>
-#include <fggl/util/service.h>
-
-#include <fggl/ecs3/types.hpp>
-#include <fggl/ecs3/ecs.hpp>
-
-#include <fggl/input/camera_input.h>
-
-#include <fggl/debug/debug.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.down( 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 GameScene : public fggl::AppState {
-public:
-    explicit GameScene(fggl::App& app) : fggl::AppState(app), m_world(nullptr), m_sceneTime(nullptr), m_inputs(nullptr) { };
-    //~GameScene() override = default;
-
-    void activate() override {
-        auto& locator = fggl::util::ServiceLocator::instance();
-        m_inputs = locator.providePtr<fggl::input::Input>();
-
-		// setup the world using the global type registry
-		// FIXME: type registry probably doesn't need to be application-global - will make savegame/mod support complicated
-        m_world = std::make_unique<fggl::ecs3::World>( *m_owner.registry() );
-
-        m_sceneTime = std::make_unique<fggl::util::Timer>();
-        m_sceneTime->frequency( glfwGetTimerFrequency() );
-        m_sceneTime->setup( glfwGetTimerValue() );
-
-        setup();
-    }
-
-    void setup() {
-        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);
-			if ( camTf != nullptr) {
-				camTf->origin(glm::vec3(10.0f, 3.0f, 10.0f));
-			}
-
-            auto cameraKeys = m_world->get<fggl::input::FreeCamKeys>(prototype);
-			if ( cameraKeys != nullptr ) {
-				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::data::StaticMesh staticMesh{mesh, shader};
-            m_world->set<fggl::data::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::data::StaticMesh staticMesh{mesh, shader};
-            m_world->set<fggl::data::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 deactivate() 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(fggl::gfx::Paint& paint) override {
-        //debugInspector();
-        //fggl::gfx::renderMeshes(glModule, *m_world, m_sceneTime->delta());
-    }
-
-	fggl::ecs3::World* world() override {
-		return m_world.get();
-	}
-
-    // 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:
-    std::unique_ptr<fggl::ecs3::World> m_world;
-    std::unique_ptr<fggl::util::Timer> m_sceneTime;
-    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, const char* argv[]) {
-    fggl::App app( "fggl-demo" );
-
-    // FIXME: janky API(s)
-    auto& locator = fggl::util::ServiceLocator::instance();
-	auto inputs = locator.supply<fggl::input::Input>(std::make_shared<fggl::input::Input>());
-	auto storage = locator.supply<fggl::data::Storage>(std::make_shared<fggl::data::Storage>());
-	locator.supply<fggl::ecs3::TypeRegistry>(std::make_shared<fggl::ecs3::TypeRegistry>());
-
-    // Would be nice to not take args like this, it messes with lifetimes
-    auto& windowing = app.use<fggl::gfx::ecsGlfwModule>(inputs);
-
-    // -- should not be our problem - this is a broken api
-    auto window = windowing.createWindow("Demo Game");
-    window->make_graphics<fggl::gfx::OpenGL4>();
-    window->fullscreen( true );
-    app.setWindow( std::move(window) );
-
-	// load a bunch of modules to provide game functionality
-	//app.use<fggl::ecs3::ecsTypes>();
-	app.use<fggl::gfx::SceneUtils>();
-
-	// atlas testing
-	std::vector< fggl::gfx::ImageAtlas<char>::SubImage > images;
-	auto *atlas = fggl::gfx::ImageAtlas<char>::pack(images);
-
-	// and now our states
-    auto *menu = app.add_state<fggl::scenes::BasicMenu>("menu");
-
-    menu->add("start", [&app]() { app.change_state("game"); });
-	menu->add("options", [&app]() { app.change_state("game"); });
-	menu->add("quit", [&app]() { app.running(false); });
-
-	// game state
-    app.add_state<GameScene>("game");
-
-	return app.run(argc, argv);
-}

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")
 
-# Config mode dependencies
-find_package(fmt CONFIG)
-find_package(spdlog CONFIG)
-find_package(glfw3 CONFIG)
+# 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
-    app.cpp
-    ecs/ecs.cpp
-    data/model.cpp
-    data/procedural.cpp
-    data/heightmap.cpp
-    ecs3/fast/Container.cpp
-    ecs3/prototype/world.cpp
-    scenes/Scene.cpp
-    scenes/menu.cpp
-    ecs3/module/module.cpp
-    input/camera_input.cpp
-    input/input.cpp
-    input/mouse.cpp
-    data/heightmap.cpp
-	gui/widget.cpp
-	gui/widgets.cpp
-	gui/containers.cpp
-	math/triangulation.cpp
-	math/shapes.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 )
-target_link_libraries(${PROJECT_NAME} PRIVATE 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} PUBLIC 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 <memory>
 
 #include <spdlog/spdlog.h>
-
 #include <fggl/app.hpp>
-#include <fggl/ecs3/types.hpp>
-#include <fggl/ecs3/module/module.h>
-#include <fggl/util/service.h>
 
 namespace fggl {
 
-    App::App(const Identifer& name) : App::App( name, name ) {
-    }
+	App::App(modules::Manager *services, const Identifer &name) : App::App(services, name, name) {
+	}
 
-    App::App(const Identifer& name, const Identifer& folder ) :
-        m_running(true),
-        m_types(std::make_unique<ecs3::TypeRegistry>()),
-        m_modules(std::make_unique<ecs3::ModuleManager>(*m_types)),
+	App::App(modules::Manager *services, const Identifer & /*name*/, const Identifer & /*folder*/ ) :
+		m_running(true),
 		m_window(nullptr),
-        m_states() {}
-
-    int App::run(int argc, const char** argv) {
-
-        {
-            // activate the first state
-            auto& state = m_states.active();
-            state.activate();
-        }
-
-        while ( m_running ) {
-            auto& state = m_states.active();
-
-            m_modules->onUpdate();
-            state.update();
+		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();
+				}
+			}
 
-            // window rendering to frame buffer
-            if ( m_window != nullptr ) {
-                m_modules->onFrameStart();
-                m_window->frameStart();
+			// process window events
+			if (windowing != nullptr) {
+				windowing->pollEvents();
+			}
+			//m_modules->onUpdate();
 
-                // get draw instructions
-                fggl::gfx::Paint paint;
-                state.render(paint);
+			auto &state = m_states.active();
+			state.update((float)delta);
 
-                // execute draw instructions
-                auto& graphics = m_window->graphics();
-                graphics.draw2D( paint );
+			// window rendering to frame buffer
+			if (m_window != nullptr) {
+				//	m_modules->onFrameStart();
+				m_window->frameStart();
 
-				ecs3::World* world = state.world();
-				if ( world != nullptr ) {
-					graphics.drawScene(*world);
-				}
+				// get draw instructions
+				auto &graphics = m_window->graphics();
+				state.render(graphics);
 
-                m_window->frameEnd();
-                m_modules->onFrameEnd();
+				m_window->frameEnd();
+				//  m_modules->onFrameEnd();
 
 				m_running = m_running && !m_window->wantClose();
-            }
-        }
+			}
+		}
 
-        {
-            // shutdown last state
-            auto& state = m_states.active();
-            state.deactivate();
-        }
+		{
+			// shutdown last state
+			auto &state = m_states.active();
+			state.deactivate();
+		}
 
-        return EXIT_SUCCESS;
-    }
+		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/audio/CMakeLists.txt

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