.gitlab-ci.yml

@@ -26,8 +26,8 @@ variables:
 .f34-ogl:
   image: git.fossgalaxy.com:8042/gamedev/containers/fedora:36-opengl
   before_script:
-    - dnf install -y pkgconfig\(dri\) pkgconfig\(glu\) pkgconfig\(x11\) pkgconfig\(xcursor\) pkgconfig\(xi\) pkgconfig\(xinerama\) pkgconfig\(xrandr\) doxygen
-    - dnf install -y glm-devel glfw-devel openal-soft-devel spdlog-devel freetype-devel yaml-cpp-devel assimp-devel bullet-devel gtest-devel gmock-devel
+    - dnf install -y pkgconfig\(dri\) pkgconfig\(glu\) pkgconfig\(x11\) pkgconfig\(xcursor\) pkgconfig\(xi\) pkgconfig\(xinerama\) pkgconfig\(xrandr\) pkgconfig\(lua\) doxygen
+    - dnf install -y glm-devel glfw-devel openal-soft-devel spdlog-devel freetype-devel yaml-cpp-devel assimp-devel gtest-devel gmock-devel
 
 ##
 # Build Targets check it builds on popular Linux Distributions
@@ -36,7 +36,7 @@ build:fedora:
   extends: .f34-ogl
   stage: build
   script:
-    - cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
+    - cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DFGGL_EXT_BULLET=OFF
     - cmake --build build
   artifacts:
     paths:
@@ -47,9 +47,9 @@ build:ubuntu:
   stage: build
   before_script:
     - apt update && apt install -y build-essential cmake
-    - apt install -y libglm-dev libglfw3-dev libopenal-dev libspdlog-dev libfreetype-dev libyaml-cpp-dev libassimp-dev libbullet-dev libbullet-extras-dev libgtest-dev libgmock-dev
+    - apt install -y libglm-dev libglfw3-dev libopenal-dev libspdlog-dev libfreetype-dev libyaml-cpp-dev libassimp-dev libbullet-extras-dev libgtest-dev libgmock-dev liblua5.2-dev
   script:
-    - cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
+    - cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DFGGL_EXT_BULLET=OFF -DFGGL_EXT_LUA=OFF
     - cmake --build build
 
 

CMakeLists.txt

@@ -8,6 +8,9 @@ option(FGGL_EXAMPLES "Should we build examples or just the library" ON)
 option(FGGL_TESTS "Should we enable the testing suite?" ON)
 option(FGGL_DOCS "Should we build documentation?" ON)
 
+option(FGGL_EXT_BULLET "Should we build the bullet module?" OFF)
+option(FGGL_EXT_LUA "Should we build the lua module?" ON)
+
 ##
 # Windows
 # When on windows, integrate vcpkg
@@ -31,8 +34,9 @@ project(fggl
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
 # vendor dependencies
+add_subdirectory( vendor/entt )
 add_subdirectory( vendor/imgui )
-add_subdirectory(vendor/glad)
+add_subdirectory( vendor/glad )
 
 # engine headers
 file(GLOB_RECURSE public_headers
@@ -44,9 +48,6 @@ add_subdirectory( fggl )
 target_compile_options( fggl PRIVATE -Wall -Wpedantic -Wextra -Wodr -fno-strict-aliasing -fno-strict-overflow )
 set_property(TARGET fggl PROPERTY INTERPROCEDURAL_OPTIMIZATION True)
 
-# vendor dependencies
-add_subdirectory( integrations/entt )
-
 # Unit Tests
 if (FGGL_TESTS)
 	include(CTest)
@@ -68,17 +69,20 @@ endif()
 ##
 
 # 3rd party integrations
-add_subdirectory( integrations/bullet )
-add_subdirectory( integrations/lua )
+if ( FGGL_EXT_BULLET )
+	add_subdirectory( integrations/bullet )
+endif()
+
+if ( FGGL_EXT_LUA )
+	add_subdirectory( integrations/lua )
+endif()
 
 # Tools
-add_subdirectory( tools/pack )
+# add_subdirectory( tools/pack )
 
 # Demo project
 if (FGGL_EXAMPLES)
-	add_subdirectory(demo)
-	target_compile_options( demo PRIVATE -Wall -Wextra -Wodr -Wdouble-promotion -fno-strict-aliasing -fno-strict-overflow )
-	set_property(TARGET demo PROPERTY INTERPROCEDURAL_OPTIMIZATION True)
+	add_subdirectory(demo EXCLUDE_FROM_ALL)
 endif()
 
 ##

README.md

@@ -12,6 +12,10 @@ On Ubuntu:
 sudo apt install build-essential cmake
 sudo apt install -y libglm-dev libglfw3-dev libopenal-dev libspdlog-dev libfreetype-dev libyaml-cpp-dev libassimp-dev libbullet-dev
 ```
+On Fedora:
+```bash
+sudo dnf install -y glm-devel glfw-devel openal-soft-devel spdlog-devel freetype-devel yaml-cpp-devel assimp-devel bullet-devel gcc gcc-c++ cmake gtest-devel doxygen lua lua-devel gmock gmock-devel
+```
 
 ### Building
 It's designed to be a fairly standard cmake project, so the standard cmake steps should work:

demo/CMakeLists.txt

@@ -10,8 +10,14 @@ add_executable(demo
         demo/grid.cpp
         demo/robot/programmer.cpp
         demo/models/viewer.cpp
+        demo/hexboard/board.cpp
+        demo/hexboard/camera.cpp
 )
 
+# set build flags
+target_compile_options( demo PRIVATE -Wall -Wextra -Wodr -Wdouble-promotion -fno-strict-aliasing -fno-strict-overflow )
+set_property(TARGET demo PROPERTY INTERPROCEDURAL_OPTIMIZATION True)
+
 target_include_directories(demo
         PRIVATE
             ${CMAKE_CURRENT_SOURCE_DIR}/include
@@ -19,7 +25,9 @@ target_include_directories(demo
 
 target_link_libraries( demo fggl )
 #target_link_libraries(demo fggl fgglbt)
-target_link_libraries( demo fggl-lua )
+if ( FGGL_EXT_LUA )
+    target_link_libraries( demo fggl-lua )
+endif()
 
 find_package(spdlog)
 target_link_libraries(demo spdlog::spdlog)

demo/data/.gitignore

+packs/

demo/data/gui.yaml

+---
+- define: label
+  attrs:
+    value: """
+- define: button
+  children:
+    - template: label
+- define: textinput
+  children:
+    - template: label
+- define: checkbox
+  attrs:
+    state: False
+- define: radio
+  attrs:
+    state: False
+- define: frame

demo/data/redbook/debug_frag.glsl

 /**
  * OpenGL RedBook Shader.
  * Examples 7.8, 7.9 and 7.10.
+ *
+ * Reflections are happening in camera space
  */
 #version 330 core
 
-in vec4 Position;
-in vec3 Normal;
-in vec4 Colour;
-in vec2 TexPos;
+in Vertex {
+    vec3 Position;
+    vec3 Normal;
+    vec3 Colour;
+    vec2 TexPos;
+};
 
 out vec4 FragColour;
 
+const float constant = 1.0;
+const float linear = 0.022;
+const float quadratic = 0.0019;
+
+float specPower = 0.5;
+const float shininess = 8;
+
 uniform sampler2D diffuseTexture;
+uniform sampler2D specularTexture;
+
+uniform mat4 MVMatrix;
+uniform vec3 viewerPos_ws;
+
+struct DirectionalLight {
+    vec3 direction;
+    vec3 ambient;
+    vec3 diffuse;
+    vec3 specular;
+};
+
+struct Material {
+    vec3 emission;
+    vec3 ambient;
+    vec3 diffuse;
+    vec3 specular;
+};
+
+uniform DirectionalLight light;
+uniform Material material;
+
+const int hasPos = 0;
+
+vec4 calcDirLight(DirectionalLight light, vec3 Normal, vec3 viewDir, vec4 specPx, vec4 diffPx) {
+    vec3 lightDir = normalize( ( vec4(light.direction, 1) * MVMatrix).xyz - Position.xyz );
+    vec4 ambient = 0.1 * vec4( light.ambient, 1);
+
+    vec3 reflectDir = reflect( -lightDir, Normal );
+    float spec = pow( max( dot(viewDir, reflectDir), 0.0), shininess);
+    vec4 specular = 1.0 * vec4( light.specular, 1) * specPower * (spec * specPx);
+
+    float diff = max( dot(Normal, lightDir), 0.0 );
+    vec4 diffuse = vec4(light.diffuse,1) * (diff * diffPx);
+
+    if ( hasPos == 1 ) {
+        vec3 lightPos = ( vec4(light.direction, 1) * MVMatrix).xyz;
+        float distance = length( lightPos - Position.xyz );
+        float att = 1.0 / (constant +
+            (linear * distance) +
+            (quadratic * (distance * distance)));
+
+        ambient *= att;
+        diffuse *= att;
+        specular *= att;
+    }
+
+    return (ambient + diffuse + specular);
+}
 
 void main() {
-    vec3 normalScale = 0.5 + (Normal / 2);
-    FragColour = Colour * vec4(normalScale, 1) * texture(diffuseTexture, TexPos);
+    vec3 viewDir = normalize(-Position);
+
+    vec4 diffPx = vec4(material.diffuse, 1);
+    vec4 specPx = vec4(material.specular, 1);
+    if ( hasPos != 1) {
+        diffPx *= texture(diffuseTexture, TexPos);
+        specPx *= texture(specularTexture, TexPos);
+    }
+
+    FragColour = vec4(Colour, 1);
+    FragColour *= calcDirLight(light, Normal, viewDir, specPx, diffPx);
 }
\ No newline at end of file

demo/data/redbook/debug_vert.glsl

@@ -4,6 +4,7 @@
  */
 #version 330 core
 
+
 layout (location = 0) in vec3 VertexPosition;
 layout (location = 1) in vec3 VertexNormal;
 layout (location = 2) in vec3 VertexColour;
@@ -13,15 +14,18 @@ uniform mat4 MVPMatrix;
 uniform mat4 MVMatrix;
 uniform mat3 NormalMatrix;
 
-out vec4 Position;
-out vec3 Normal;
-out vec4 Colour;
-out vec2 TexPos;
+out Vertex {
+    vec3 Position;
+    vec3 Normal;
+    vec3 Colour;
+    vec2 TexPos;
+};
 
 void main() {
-    Colour = vec4(VertexColour, 1);
-    Normal = NormalMatrix * VertexNormal;
+    Colour = VertexColour;
+    Normal = mat3(transpose(inverse(MVMatrix))) * VertexNormal;
     TexPos = VertexTex;
-    Position = MVMatrix * vec4(VertexPosition, 1);
+    Position = vec3(MVMatrix * vec4(VertexPosition, 1));
+
     gl_Position = MVPMatrix * vec4(VertexPosition, 1);
 }
\ No newline at end of file

demo/data/rollball.yml

@@ -89,6 +89,11 @@ prefabs:
         type: kinematic
         shape:
           type: box
+  - name: rb_light
+    components:
+      Transform:
+      gfx::phong::directional:
+        direction: [10, 5, 0]
 scene:
   - prefab: rb_wallX
     components:
@@ -124,5 +129,6 @@ scene:
         origin: [6, -0.5, -15]
   - prefab: rb_player
     name: "player"
+  - prefab: rb_light
 scripts:
   - "rollball.lua"
\ No newline at end of file

demo/demo/GameScene.cpp

@@ -24,12 +24,13 @@
 
 #include "GameScene.h"
 #include "fggl/entity/loader/loader.hpp"
+#include "fggl/mesh/components.hpp"
 
 camera_type cam_mode = cam_free;
 
 static void placeObject(fggl::entity::EntityManager& world, fggl::entity::EntityID floor, fggl::entity::EntityFactory* factory, fggl::util::GUID prototype, glm::vec3 targetPos) {
 	#ifndef NDEBUG
-		fggl::debug::trace("Creating object from prototype: {}", fggl::util::guidToString(prototype));
+		fggl::debug::trace("Creating object from prototype: {}", fggl::util::guid_to_string(prototype));
 	#endif
 
 	auto obj = factory->create(prototype, world);
@@ -128,7 +129,8 @@ static void setupBunkerPrototype(fggl::entity::EntityFactory* factory) {
 
 		// mesh
 		int nSections = 2;
-		fggl::data::Mesh mesh;
+		fggl::mesh::MultiMesh3D mesh;
+
 		for (int j=-(nSections/2); j<=nSections/2; j++) {
 			const auto shapeOffset = glm::vec3( 0.0f, 0.5f, (float)j * 1.0f );
 
@@ -140,37 +142,41 @@ static void setupBunkerPrototype(fggl::entity::EntityFactory* factory) {
 				glm::vec3( 1.0f, 0.0f, 0.0f) + shapeOffset,
 				glm::vec3( 0.0f, fggl::math::HALF_PI, 0.0f) );
 
-			fggl::data::make_cube( mesh, cubeMat );
-			fggl::data::make_slope( mesh, leftSlope );
-			fggl::data::make_slope( mesh, rightSlope );
+			fggl::data::make_cube( mesh.generate(), cubeMat);
+			fggl::data::make_slope( mesh.generate(), leftSlope );
+			fggl::data::make_slope( mesh.generate(), rightSlope );
 		}
-		mesh.removeDups();
+		//mesh.removeDups();
 
 		// generate mesh component data
 		// FIXME: find a better way to do this, avoid re-uploading the whole mesh.
 		fggl::entity::ComponentSpec procMesh{};
 		procMesh.set<std::string>("pipeline", "redbook/debug");
 
-		YAML::Node vertexData;
-		for (auto& vertex : mesh.vertexList()) {
-			YAML::Node vertexNode;
-			vertexNode["position"] = vertex.posititon;
-			vertexNode["normal"] = vertex.normal;
-			vertexNode["colour"] = vertex.colour;
-			vertexNode["texPos"] = vertex.texPos;
-			vertexData.push_back(vertexNode);
-		}
+		YAML::Node modelNode;
+		for (auto& submesh : mesh.meshes) {
+			YAML::Node vertexData;
+			for (auto& vertex : submesh.data) {
+				YAML::Node vertexNode;
+				vertexNode["position"] = vertex.position;
+				vertexNode["normal"] = vertex.normal;
+				vertexNode["colour"] = vertex.colour;
+				vertexNode["texPos"] = vertex.texPos;
+				vertexData.push_back(vertexNode);
+			}
 
-		YAML::Node indexData;
-		for (auto& index : mesh.indexList()) {
-			indexData.push_back(index);
-		}
+			YAML::Node indexData;
+			for (auto& index : submesh.indices) {
+				indexData.push_back(index);
+			}
 
-		YAML::Node meshData;
-		meshData["vertex"] = vertexData;
-		meshData["index"] = indexData;
-		procMesh.set("mesh", meshData);
-		bunkerSpec.addComp(fggl::data::StaticMesh::guid, procMesh);
+			YAML::Node meshNode;
+			meshNode["vertex"] = vertexData;
+			meshNode["index"] = indexData;
+			modelNode.push_back( meshNode );
+		}
+		procMesh.set("model", modelNode);
+		bunkerSpec.addComp(fggl::mesh::StaticMultiMesh3D::guid, procMesh);
 
 		factory->define(BUNKER_PROTOTYPE, bunkerSpec);
 	}

demo/demo/grid.cpp

@@ -21,6 +21,9 @@
 #include "fggl/assets/loader.hpp"
 #include "fggl/entity/gridworld/zone.hpp"
 
+#include "fggl/gui/model/parser.hpp"
+#include "fggl/gui/renderer/renderer.hpp"
+
 using namespace fggl::gfx::colours;
 
 namespace demo {
@@ -94,8 +97,8 @@ namespace demo {
 		auto& manager = area->entities();
 		{
 			player = manager.create();
-			auto& cellPos = manager.add<CellPos>(player);
-			auto& robotState = manager.add<RobotState>(player);
+			manager.add<CellPos>(player);
+			manager.add<RobotState>(player);
 		}
 
 		return player;
@@ -123,7 +126,7 @@ namespace demo {
 			fggl::math::vec2i size{32, 32};
 			auto btn = std::make_unique<fggl::gui::Button>(pos, size);
 			btn->label(action.name);
-			btn->addCallback([=](){
+			btn->addCallback([=, this](){
 				this->m_program.m_instructions.push_back({action.name, action.callback});
 			});
 			btnGrid->add(std::move(btn));
@@ -195,7 +198,7 @@ namespace demo {
 	constexpr float DRAW_HALF = DRAW_SIZE / 2.0F;
 	constexpr float WALL_HALF = 2.5F;
 
-	static void render_grid(fggl::gfx::Paint& paint, fggl::entity::grid::Area2D<255, 255>& grid) {
+	static void render_grid(fggl::gfx::Paint& paint, fggl::entity::grid::Area2D<255, 255>& grid, fggl::App& app) {
 		const fggl::math::vec2 wallOffsetNorth {0, -DRAW_HALF};
 		const fggl::math::vec2 wallOffsetWest {-DRAW_HALF, 0};
 
@@ -223,6 +226,35 @@ namespace demo {
 				}
 			}
 		}
+
+		// UI test
+		auto widgetFactory = app.service<fggl::gui::model::WidgetFactory>();
+
+		auto widget = widgetFactory->buildEmpty();
+		widget->set("position", fggl::math::vec2{200.0F, 100.F});
+		widget->set("size", fggl::math::vec2{500.0F, 300.F});
+		widget->set("colour", fggl::gfx::colours::BLANCHED_ALMOND);
+		fggl::gui::model::attr_box_set(*widget, "padding", 5.0F);
+
+		auto handle = widgetFactory->buildEmpty();
+		handle->set("border::bottom",5.0F);
+		handle->set("position", fggl::math::vec2{0.0F, 0.0F});
+		//handle->set("size", fggl::math::vec2{INFINITY, 50.0F});
+		handle->set("text", "hello, world!");
+		handle->set("colour", fggl::gfx::colours::ORANGE);
+		fggl::gui::model::attr_box_set(*handle, "padding", 5.0F);
+		widget->addChild(*handle);
+		delete handle;
+
+		auto content = widgetFactory->buildEmpty();
+		content->set("position", fggl::math::vec2{0.0F, 50.0F});
+		//content->set("size", fggl::gui::model::UNDEFINED_SIZE);
+		content->set("colour", fggl::gfx::colours::BURLYWOOD);
+		widget->addChild(*content);
+		delete content;
+
+		fggl::gui::renderer::layout(*widget);
+		fggl::gui::renderer::visit(*widget, paint);
 	}
 
 
@@ -325,7 +357,7 @@ namespace demo {
 
 	void GridScene::render(fggl::gfx::Graphics &gfx) {
 		fggl::gfx::Paint paint;
-		render_grid(paint, *m_grid);
+		render_grid(paint, *m_grid, owner());
 		render_objects(paint, *m_grid);
 
 		m_canvas.render(paint);

demo/demo/hexboard/board.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 10/12/22.
+//
+
+#include "hexboard/scene.hpp"
+
+namespace demo::hexboard {
+	constexpr float SCROLL_SPEED = 0.01F;
+	constexpr float HEX_SIZE = 64.0F;
+	constexpr std::array<fggl::grid::IntHex, 4> ISLAND_CENTERS {{
+																	{2, 3},
+																	{6, 7},
+																	{9, 10},
+																	{6, 3}
+	}};
+
+
+	Scene::Scene(fggl::App &app) : GameBase(app), m_board(nullptr), m_screen(1920.F, 1080.F) {
+	}
+
+	void Scene::activate() {
+		m_board = std::make_unique<fggl::grid::HexGrid>();
+		m_layout = std::make_unique<fggl::grid::Layout>( fggl::grid::Orientation::make_pointy(), HEX_SIZE );
+		//m_layout->m_origin = { 1920.0F * -0.5F, 1080.0F * -0.5F};
+
+		m_selections = std::make_unique<SelectionModel>();
+
+		const fggl::grid::TerrainType grass{
+			.data = std::make_shared<fggl::grid::MaterialData>()
+
+		};
+		grass.data->name = "grass";
+		grass.data->colour = {0.0F, 1.0F, 0.0};
+
+		for (auto islandPoint : ISLAND_CENTERS){
+			auto island = islandPoint.hexesInRange(2);
+			for (auto &hex : island) {
+				m_board->setTerrain(hex, grass);
+			}
+		}
+
+		m_camera = std::make_unique<Camera2D>();
+	}
+
+	void Scene::deactivate() {
+		m_board = nullptr;
+		m_selections = nullptr;
+		m_layout = nullptr;
+	}
+
+	void Scene::update(float delta) {
+		GameBase::update(delta);
+
+		// if the board is not set, abort
+		if ( m_board == nullptr ){
+			return;
+		}
+
+		// check if a button was pressed
+		auto& input = this->input();
+		{
+			const auto mouseNdc = fggl::input::mouse_axis(input.mouse);
+			const auto screenPos = ndc_to_screen(mouseNdc, m_screen);
+
+			// calculate what the user clicked on
+			auto worldPx = m_camera->unproject(screenPos);
+			m_selections->hover = fggl::grid::round2( m_layout->toGrid(worldPx) );
+
+			if (input.mouse.pressed(fggl::input::MouseButton::LEFT)) {
+				m_selections->selected = m_selections->hover;
+				m_camera->moveBy(mouseNdc * (m_screen * 0.5F) );
+			}
+
+			if ( input.mouse.down(fggl::input::MouseButton::RIGHT) ) {
+				if (input.mouse.pressed( fggl::input::MouseButton::RIGHT )) {
+					m_dragging = screenPos;
+				}
+
+				auto offset = screenPos - m_dragging.value();
+				m_camera->teleportBy(offset * SCROLL_SPEED);
+			} else if ( input.mouse.released(fggl::input::MouseButton::RIGHT) ) {
+				m_dragging = {};
+			}
+
+		}
+
+		m_camera->update(delta);
+
+		// flip y, because reasons
+		//auto offset = m_camera->getFocusLocation();
+		//m_layout->m_origin = -offset;
+	}
+
+	void Scene::drawGrid(fggl::gfx::Paint& paint) {
+		auto tiles = m_board->getAllTiles();
+		for ( const auto& tile : tiles ) {
+			auto terrain = m_board->getTerrain(tile);
+			if ( terrain.has_value() ) {
+				const auto& terrainData = terrain.value();
+				m_layout->paintHex(paint, tile, terrainData.colour, m_camera->getFocusLocation());
+			}
+		}
+	}
+
+	void Scene::drawSelections(fggl::gfx::Paint& paint) {
+		if ( m_selections == nullptr || m_dragging.has_value() ) {
+			return;
+		}
+
+		if ( m_selections->selected.has_value() ) {
+			m_layout->paintHex( paint, m_selections->selected.value(), fggl::gfx::colours::YELLOW, m_camera->getFocusLocation());
+		}
+
+		if ( m_selections->hover.has_value() ) {
+			m_layout->paintHex( paint, m_selections->hover.value(), fggl::gfx::colours::BLANCHED_ALMOND, m_camera->getFocusLocation());
+		}
+	}
+
+	void Scene::render(fggl::gfx::Graphics &gfx) {
+		// if the board is not set, abort
+		if ( m_board == nullptr ){
+			return;
+		}
+
+		// draw the grid
+		// FIXME don't hard-code the screen size
+		fggl::gfx::Paint paint;
+		drawGrid(paint);
+		drawSelections(paint);
+		gfx.draw2D(paint);
+	}
+
+
+
+} // namespace demo::hexboard
\ No newline at end of file

demo/demo/hexboard/camera.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 02/01/23.
+//
+
+#include "hexboard/camera.hpp"
+
+#include "fggl/math/fmath.hpp"
+
+#include <cmath>
+
+namespace demo::hexboard {
+
+	void Camera2D::update(float delta) {
+		m_location = fggl::math::smooth_add( m_location, m_target, m_scale );
+		if ( m_trauma > 0 ) {
+			m_trauma = std::max( m_trauma - TRAUMA_DECAY, 0.0F );
+		}
+	}
+
+}
\ No newline at end of file

demo/demo/main.cpp

@@ -39,34 +39,39 @@
 
 #include "fggl/data/assimp/module.hpp"
 #include "fggl/assets/module.hpp"
-#include "fggl/script/lua/module.hpp"
+#include "fggl/assets/packed/module.hpp"
+
+#if __has_include("fggl/script/lua/module.hpp")
+	#include "fggl/script/lua/module.hpp"
+#endif
 
 #include "GameScene.h"
 #include "rollball.hpp"
 #include "topdown.hpp"
 #include "grid.hpp"
 #include "models/viewer.hpp"
+#include "hexboard/scene.hpp"
 
 static void setup_menu(fggl::App& app) {
 	auto *menu = app.addState<fggl::scenes::BasicMenu>("menu");
 
 	// add some menu items for the game states
-	const std::array labels = {"terrain", "rollball", "Top Down", "Grid World", "Viewer"};
-	const std::array scenes = {"game", "rollball", "topdown", "gridworld", "viewer"};
+	const std::array labels = {"terrain", "rollball", "Top Down", "Grid World", "Viewer", "gridworld"};
+	const std::array scenes = {"game", "rollball", "topdown", "gridworld", "viewer", "hexboard"};
 
 	for (std::size_t i = 0; i < labels.size(); ++i) {
 		std::string sceneName = scenes.at(i);
 
 		menu->add(labels.at(i), [&app, sceneName]() {
 			auto* audio = app.service<fggl::audio::AudioService>();
-			audio->play("click.ogg", false);
+			audio->play("ui/click.ogg", false);
 			app.change_state(sceneName);
 		});
 	}
 
 	menu->add("quit", [&app]() {
-		auto* audio = app.service<fggl::audio::AudioService>();
-		audio->play("click.ogg", false);
+		//auto* audio = app.service<fggl::audio::AudioService>();
+		//audio->play("click.ogg", false);
 		app.running(false);
 	});
 }
@@ -82,8 +87,12 @@ int main(int argc, const char* argv[]) {
 	moduleManager.use<fggl::gfx::OpenGL4>();
 	moduleManager.use<fggl::display::GLFW>();
 	moduleManager.use<fggl::assets::AssetFolders>();
+	moduleManager.use<fggl::assets::PackedAssets>();
 	moduleManager.use<fggl::entity::ECS>();
-	moduleManager.use<fggl::script::Lua>();
+
+	#ifdef FGGL_HAS_LUA
+		moduleManager.use<fggl::script::Lua>();
+	#endif
 
 	// debug/testing use
 	moduleManager.use<fggl::data::AssimpLoader>();
@@ -98,6 +107,16 @@ int main(int argc, const char* argv[]) {
 	// create the application
 	fggl::App app( &moduleManager, "fggl-demo" );
 
+	// force asset loading
+	{
+		auto* assetFinder = app.service<fggl::assets::CheckinAdapted>();
+		assetFinder->discover("core");
+
+		auto* assets = app.service<fggl::assets::AssetManager>();
+		auto* loader = app.service<fggl::assets::Loader>();
+		loader->load("ui/click.ogg", fggl::audio::ASSET_CLIP_SHORT, assets);
+	}
+
 	auto* windowing = app.service<fggl::display::WindowService>();
 
 	// make a window for our application
@@ -113,6 +132,7 @@ int main(int argc, const char* argv[]) {
 	app.addState<demo::TopDown>("topdown");
 	app.addState<demo::GridScene>("gridworld");
 	app.addState<demo::Viewer>("viewer");
+	app.addState<demo::hexboard::Scene>("hexboard");
 
 	return app.run(argc, argv);
 }

demo/demo/models/viewer.cpp

@@ -28,16 +28,17 @@
 
 #include "fggl/gfx/phong.hpp"
 #include "fggl/gfx/camera.hpp"
+#include "fggl/gfx/paint.hpp"
 
 namespace demo {
 
-	static fggl::entity::EntityID build_model(fggl::entity::EntityManager& manager, fggl::assets::AssetManager *assets){
+	static fggl::entity::EntityID build_model(fggl::entity::EntityManager& manager, fggl::assets::AssetManager *assets, fggl::assets::AssetID assetRef){
 		auto model = manager.create();
 
 		manager.add<fggl::math::Transform>(model);
 		auto& mesh = manager.add<fggl::mesh::StaticMultiMesh3D>(model);
 
-		auto* meshData = assets->get<fggl::mesh::MultiMesh3D>("backpack/backpack.obj");
+		auto* meshData = assets->get<fggl::mesh::MultiMesh3D>( assetRef );
 		if ( meshData == nullptr ) {
 			fggl::debug::warning("loading model did not work!");
 		} else {
@@ -45,7 +46,7 @@ namespace demo {
 			mesh.pipeline = "redbook/debug";
 		}
 
-		auto& material = manager.add<fggl::gfx::PhongMaterial>(model);
+		manager.add<fggl::gfx::PhongMaterial>(model);
 
 		return model;
 	}
@@ -90,6 +91,17 @@ namespace demo {
 		cameraKeys.rotate_ccw = glfwGetKeyScancode(GLFW_KEY_E);
 	}
 
+	static void setup_lighting(fggl::entity::EntityManager& ecs) {
+		auto light = ecs.create();
+		ecs.add<fggl::math::Transform>(light);
+
+		auto& lightComp = ecs.add<fggl::gfx::DirectionalLight>(light);
+		lightComp.position = fggl::math::vec3( 10.0F, 5.0F, 0.0F );
+		lightComp.diffuse = fggl::gfx::colours::CORNSILK;
+		lightComp.ambient = fggl::gfx::colours::MIDNIGHT_BLUE;
+		lightComp.specular = fggl::gfx::colours::MIDNIGHT_BLUE;
+	}
+
 	Viewer::Viewer(fggl::App &app) : fggl::scenes::Game(app), m_model(fggl::entity::INVALID) {
 
 	}
@@ -97,21 +109,25 @@ namespace demo {
 	void Viewer::activate() {
 		Game::activate();
 
-		// force load required data
-		auto *loader = owner().service<fggl::assets::Loader>();
-		auto *manager = owner().service<fggl::assets::AssetManager>();
+		auto* assetFinder =  m_owner.service<fggl::assets::CheckinAdapted>();
+		assetFinder->discover("viewer");
 
-		loader->load("backpack/backpack.obj", fggl::data::models::ASSIMP_MODEL, manager);
+		// setup the assets we can select between
+		// TODO some form of introspection to automatically find declared/discovered assets of a given type
+		m_assets.clear();
+		m_assets.push_back( fggl::assets::make_asset_id_rt("viewer", "backpack/backpack.obj") );
+		m_assets.push_back( fggl::assets::make_asset_id_rt("viewer", "lowpoly_scifi/wallDoor_double.FBX") );
+		m_assets.push_back( fggl::assets::make_asset_id_rt("viewer", "lowpoly_scifi/wallDoor_double_end.FBX") );
+		m_assets.push_back( fggl::assets::make_asset_id_rt("viewer", "newell_teaset/teapot.obj") );
+		m_assets.push_back( fggl::assets::make_asset_id_rt("viewer", "humansanimatedpack/Paladin/Paladin.fbx") );
 
 		// create camera
 		setup_camera(world());
+		setup_lighting(world());
 
 		// setup model
-		m_model = build_model(world(), manager);
-
-		// asset loader
-
-		//loader->
+		m_model = fggl::entity::INVALID;
+		cycleAsset(0);
 	}
 
 	void Viewer::deactivate() {
@@ -125,6 +141,25 @@ namespace demo {
 		if ( input().keyboard.pressed(glfwGetKeyScancode(GLFW_KEY_F2)) ) {
 			m_debug = !m_debug;
 		}
+
+		if ( input().keyboard.pressed(glfwGetKeyScancode(GLFW_KEY_F3)) ) {
+			// trigger the asset cycle
+			m_lastAsset = (m_lastAsset + 1) % m_assets.size();
+			cycleAsset(m_lastAsset);
+		}
+	}
+
+	void Viewer::cycleAsset(uint64_t /*idx*/) {
+		auto *loader = owner().service<fggl::assets::Loader>();
+		auto *manager = owner().service<fggl::assets::AssetManager>();
+
+		auto nextAsset = m_assets[ m_lastAsset ];
+		loader->loadChain(nextAsset, manager);
+
+		if ( m_model != fggl::entity::INVALID) {
+			world().destroy(m_model);
+		}
+		m_model = build_model(world(), manager, nextAsset);
 	}
 
 	void Viewer::render(fggl::gfx::Graphics &gfx) {

demo/demo/robot/programmer.cpp

@@ -46,7 +46,6 @@ namespace demo::robot {
 	}
 
 	void Timeline::renderInstructions(fggl::gfx::Paint& paint) {
-		const auto size = this->size();
 		const fggl::math::vec2f barExtents{16, 16};
 
 		for ( auto track=0U; track < m_tracks.size(); ++track) {

demo/demo/rollball.cpp

@@ -48,7 +48,7 @@ static void setup_camera(fggl::entity::EntityManager& world) {
 	world.add<fggl::gfx::Camera>(prototype);
 }
 
-static fggl::entity::EntityID setup_environment(fggl::entity::EntityManager& world, fggl::entity::EntityFactory* factory, const fggl::math::vec2& size, demo::RollState& state) {
+static fggl::entity::EntityID setup_environment(fggl::entity::EntityManager& world, fggl::entity::EntityFactory* /*factory*/, const fggl::math::vec2& /*size*/, demo::RollState& state) {
 	// ensure the state is clean
 	state.closestPickup = fggl::entity::INVALID;
 	state.mode = demo::DebugMode::NORMAL;
@@ -81,14 +81,15 @@ namespace demo {
 		m_phys = physService->create(&world(), entFactory);
 
 		auto* scriptProvider = m_owner.service<fggl::script::ScriptProvider>();
-
-		m_scripts = scriptProvider->create();
-		m_scripts->setGlobal("state", this);
+		if ( scriptProvider != nullptr ) {
+			m_scripts = scriptProvider->create();
+			m_scripts->setGlobal("state", this);
+		}
 
 		// asset loader
 		auto* assetLoader = m_owner.service<fggl::assets::Loader>();
-		assetLoader->load("rollball.yml", fggl::entity::PROTOTYPE_ASSET, entFactory);
-		assetLoader->load("rollball.yml", fggl::entity::SCENE, this);
+		assetLoader->load("rollball.yml", fggl::entity::ENTITY_PROTOTYPE, entFactory);
+		assetLoader->loadChain( fggl::assets::make_asset_id_rt("core", "rollerball/rollball.yml"), this);
 
 		// collectable callbacks
 		/*auto* collectableCallbacks = world().get<fggl::phys::CollisionCallbacks>(prefabs.collectable);

demo/demo/topdown.cpp

@@ -20,6 +20,8 @@
 
 #include "fggl/data/storage.hpp"
 #include "fggl/gfx/camera.hpp"
+#include "fggl/gfx/phong.hpp"
+
 #include "fggl/input/camera_input.hpp"
 #include "fggl/entity/loader/loader.hpp"
 
@@ -50,6 +52,17 @@ namespace demo {
 		cameraKeys.rotate_ccw = glfwGetKeyScancode(GLFW_KEY_E);
 	}
 
+	static void setup_lighting(fggl::entity::EntityManager& ecs) {
+		auto light = ecs.create();
+		ecs.add<fggl::math::Transform>(light);
+
+		auto& lightComp = ecs.add<fggl::gfx::DirectionalLight>(light);
+		lightComp.position = fggl::math::vec3( 10.0F, 5.0F, 0.0F );
+		lightComp.diffuse = fggl::gfx::colours::CORNSILK;
+		lightComp.ambient = fggl::gfx::colours::MIDNIGHT_BLUE;
+		lightComp.specular = fggl::gfx::colours::MIDNIGHT_BLUE;
+	}
+
 	static void place_cover_boxes(fggl::entity::EntityFactory* factory, fggl::entity::EntityManager& world) {
 		std::array<fggl::math::vec3,8> boxPos = {{
 													 {-10.0F, 0.0F, -10.0F},
@@ -91,6 +104,7 @@ namespace demo {
 			}
 		}
 
+		setup_lighting(world);
 		place_cover_boxes(factory, world);
 	}
 
@@ -118,7 +132,7 @@ void TopDown::activate() {
 
 	fggl::debug::log(fggl::debug::Level::info, "TopDown::activate()");
 	auto* assetLoader = m_owner.service<fggl::assets::Loader>();
-	assetLoader->load("topdown.yml", fggl::entity::PROTOTYPE_ASSET);
+	assetLoader->load("topdown.yml", fggl::entity::ENTITY_PROTOTYPE);
 
 	auto* factory = m_owner.service<fggl::entity::EntityFactory>();
 	//fggl::ecs3::load_prototype_file(world(), *storage, "topdown.yml");

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