fggl/gfx/ogl4/models.cpp

@@ -17,17 +17,19 @@
 //
 
 #include "fggl/gfx/ogl4/models.hpp"
+#include "fggl/gfx/ogl4/meshes.hpp"
+
 #include "fggl/data/heightmap.hpp"
+#include "fggl/data/texture.hpp"
 
+#include "fggl/debug/logging.hpp"
 #include "fggl/gfx/camera.hpp"
 #include "fggl/gfx/phong.hpp"
 
-#include <spdlog/spdlog.h>
-
 namespace fggl::gfx::ogl4 {
 
-	static std::shared_ptr<ogl::ArrayBuffer> setupArrayBuffer(std::shared_ptr<ogl::VertexArray> &vao,
-															  std::vector<data::Vertex> &data) {
+	static auto setup_array_buffer(std::shared_ptr<ogl::VertexArray> &vao,
+															  const std::vector<data::Vertex> &data) -> std::shared_ptr<ogl::ArrayBuffer> {
 		auto buff = std::make_shared<ogl::ArrayBuffer>();
 		buff->write(data.size() * sizeof(data::Vertex), data.data(), ogl::BufUsage::STATIC_DRAW);
 
@@ -42,18 +44,19 @@ namespace fggl::gfx::ogl4 {
 		return buff;
 	}
 
-	static std::shared_ptr<ogl::ElementBuffer> setupIndexBuffer(std::shared_ptr<ogl::VertexArray> &vao,
-																std::vector<uint32_t> &data) {
+
+	static auto setup_index_buffer(std::shared_ptr<ogl::VertexArray> &vao,
+																const std::vector<uint32_t> &data) -> std::shared_ptr<ogl::ElementBuffer> {
 		auto elementBuffer = std::make_shared<ogl::ElementBuffer>();
 		elementBuffer->write(data.size() * sizeof(uint32_t),
 							 data.data(), ogl::BufUsage::STATIC_DRAW);
 		return elementBuffer;
 	}
 
-	static void setupComponent(StaticModel &modelComp, std::shared_ptr<ogl::Shader> &shader, data::Mesh &mesh) {
+	static void setup_component(StaticModel &modelComp, std::shared_ptr<ogl::Shader> &shader, data::Mesh &mesh) {
 		auto vao = std::make_shared<ogl::VertexArray>();
-		auto meshBuffer = setupArrayBuffer(vao, mesh.vertexList());
-		auto elementBuffer = setupIndexBuffer(vao, mesh.indexList());
+		auto meshBuffer = setup_array_buffer(vao, mesh.vertexList());
+		auto elementBuffer = setup_index_buffer(vao, mesh.indexList());
 
 		// set up the element attributes
 		modelComp.vao = vao;
@@ -61,186 +64,184 @@ namespace fggl::gfx::ogl4 {
 		modelComp.elements = elementBuffer;
 		modelComp.pipeline = shader;
 		modelComp.elementCount = mesh.indexCount();
-		modelComp.drawType = ogl::Primative::TRIANGLE;
+		modelComp.drawType = ogl::Primitive::TRIANGLE;
 	}
 
-	void StaticModelRenderer::resolveModels(entity::EntityManager &world) {
-		// FIXME: this needs something reactive or performance will suck.
-		auto renderables = world.find<data::StaticMesh>();
-		for (const auto &renderable : renderables) {
-			auto *currModel = world.tryGet<StaticModel>(renderable);
-			if (currModel != nullptr) {
-				continue;
-			}
-
-			auto &meshComp = world.get<data::StaticMesh>(renderable);
-			auto &modelComp = world.add<StaticModel>(renderable);
-
-			auto shader = m_phong;
-			try {
-				shader = std::make_shared<ogl::Shader>(m_shaders->get(meshComp.pipeline));
-			} catch (std::out_of_range &e) {
-				debug::log(debug::Level::warning, "Could not find shader: {}", meshComp.pipeline);
-			}
+	auto StaticModelRenderer::uploadMesh(assets::AssetID guid, const data::Mesh &mesh, bool allowCache) -> StaticModel* {
+		assert( m_assets != nullptr );
 
-			setupComponent(modelComp, shader, meshComp.mesh);
-			debug::log(debug::Level::info, "Added static mesh to {}", (uint64_t) renderable);
+		// if the asset has already been uploaded, we don't need to do anything
+		if ( allowCache && m_assets->has(guid) ) {
+			m_assets->require(guid);
+			return m_assets->get<StaticModel>(guid);
 		}
 
-		// terrain
-		auto terrain = world.find<data::HeightMap>();
-		for (auto &renderable : terrain) {
-			auto currModel = world.tryGet<StaticModel>(renderable);
-			if (currModel != nullptr) {
-				continue;
-			}
+		// the asset does not exist, we need to upload it
+		auto* modelAsset = new StaticModel();
+		modelAsset->vao = std::make_shared<ogl::VertexArray>();
+		modelAsset->vertexData = setup_array_buffer(modelAsset->vao, mesh.vertexList());
+		modelAsset->elements = setup_index_buffer(modelAsset->vao, mesh.indexList());
+		modelAsset->elementCount = mesh.indexCount();
+		modelAsset->drawType = ogl::Primitive::TRIANGLE;
+
+		// if caching is enabled, then use the cache
+		if ( allowCache ) {
+			m_assets->set(guid, modelAsset);
+		}
 
-			auto &heightmap = world.get<data::HeightMap>(renderable);
-			data::Mesh heightMapMesh{};
-			data::generateHeightMesh(heightmap, heightMapMesh);
+		return modelAsset;
+	}
 
-			auto &modelComp = world.add<StaticModel>(renderable);
-			setupComponent(modelComp, m_phong, heightMapMesh);
+	/*MeshData* StaticModelRenderer::uploadMesh(assets::AssetGUID guid, const mesh::Mesh3D &mesh, bool allowCache) {
+		assert( m_assets != nullptr );
 
-			// we know this is a triangle strip with a restart vertex...
-			// FIXME the model should be telling us this...
-			modelComp.drawType = ogl::Primative::TRIANGLE_STRIP;
-			modelComp.restartIndex = heightMapMesh.restartVertex;
+		// if the asset has already been uploaded, we don't need to do anything
+		if ( allowCache && m_assets->has(guid) ) {
+			m_assets->require(guid);
+			return m_assets->get<MeshData>(guid);
+		}
 
-			// no active model, we need to resolve/load one.
-			//spdlog::info("looks like heightmap, {} needs a static mesh", renderable);
+		// the asset does not exist, we need to upload it
+		auto* modelAsset = new MeshData();
+		modelAsset->vao = std::make_shared<ogl::VertexArray>();
+		modelAsset->vertexData = setupArrayBuffer(modelAsset->vao, mesh.data);
+		modelAsset->elements = setupIndexBuffer(modelAsset->vao, mesh.indices);
+		modelAsset->elementCount = mesh.indices.size();
+		modelAsset->drawInfo.mode = ogl::Primitive::TRIANGLE;
+
+		// if caching is enabled, then use the cache
+		if ( allowCache ) {
+			m_assets->set(guid, modelAsset);
 		}
-	}
 
-	void StaticModelRenderer::renderModelsForward(const entity::EntityManager &world) {
+		return modelAsset;
+	}*/
 
-		// fetch cameras we will need to render with
-		auto cameras = world.find<gfx::Camera>();
+	auto StaticModelRenderer::uploadMesh2(const assets::AssetID& meshName, const data::Mesh &mesh) -> StaticModelGPU* {
+		assert( m_assets != nullptr );
 
-		// if there are no cameras, we can't do anything...
-		if (cameras.empty()) {
-			spdlog::warn("asked to render static models, but there were no cameras");
-			return;
+		if ( m_assets->has(meshName) ) {
+			// we've already uploaded it...
+			return m_assets->get<StaticModelGPU>(meshName);
 		}
 
-		// perform a rendering pass for each camera (will usually only be one...)
-		for (const auto &cameraEnt : cameras) {
-			//TODO should be clipping this to only visible objects
+		auto* modelAsset = new StaticModelGPU();
+		modelAsset->vao = std::make_shared<ogl::VertexArray>();
+		modelAsset->vertices = setup_array_buffer(modelAsset->vao, mesh.vertexList());
+		modelAsset->elements = setup_index_buffer(modelAsset->vao, mesh.indexList());
+		modelAsset->elementCount = mesh.indexCount();
+		modelAsset->drawType = ogl::Primitive::TRIANGLE;
 
-			// enable required OpenGL state
-			glEnable(GL_CULL_FACE);
-			glCullFace(GL_BACK);
+		return m_assets->set(meshName, modelAsset);
+	}
 
-			// enable depth testing
-			glEnable(GL_DEPTH_TEST);
+	#ifdef FGGL_ALLOW_DEFERRED_UPLOAD
+		static void setup_meshes(entity::EntityManager& world, ShaderCache* shaders, assets::AssetManager* manager) {
+			auto entsWithModels = world.find<mesh::StaticMesh3D>();
+			for ( const auto& mesher : entsWithModels ) {
 
-			// set-up camera matrices
-			const auto &camTransform = world.get<math::Transform>(cameraEnt);
-			const auto &camComp = world.get<gfx::Camera>(cameraEnt);
+				// check if this entity already has a mesh...
+				const auto* currModel = world.tryGet<StaticMesh>(mesher);
+				if ( currModel != nullptr ) {
+					continue;
+				}
 
-			const math::mat4 projectionMatrix =
-				glm::perspective(camComp.fov, camComp.aspectRatio, camComp.nearPlane, camComp.farPlane);
-			const math::mat4 viewMatrix = glm::lookAt(camTransform.origin(), camComp.target, camTransform.up());
+				// figure out the requirements
+				auto& rawMesh = world.get<mesh::StaticMesh3D>(mesher);
+				if ( rawMesh.guid != util::make_guid("__NO_CACHE__") ){
+					// TODO support fetching of loaded meshes
+					debug::warning("multiple entities sharing a mesh has not been implemented yet...");
+				}
 
-			// TODO lighting needs to not be this...
-			math::vec3 lightPos{0.0f, 10.0f, 0.0f};
-			std::shared_ptr<ogl::Shader> shader = nullptr;
+				auto& entityMesh = world.add<StaticMesh>(mesher);
+				entityMesh.pipeline = shaders->get( rawMesh.pipeline );
+				entityMesh.mesh = upload_mesh( rawMesh.mesh, manager );
 
-			auto renderables = world.find<StaticModel>();
-			for (const auto &entity : renderables) {
+			}
+		}
 
-				// ensure that the model pipeline actually exists...
-				const auto &model = world.get<StaticModel>(entity);
-				if (model.pipeline == nullptr) {
-					spdlog::warn("shader was null, aborting render");
+		static void setup_multi_meshes(entity::EntityManager& world, ShaderCache* shaders, assets::AssetManager* manager) {
+			auto entsWithModels = world.find<mesh::StaticMultiMesh3D>();
+			for ( const auto& mesher : entsWithModels ) {
+
+				// check if this entity already has a mesh...
+				const auto* currModel = world.tryGet<StaticMultiMesh>(mesher);
+				if ( currModel != nullptr ) {
 					continue;
 				}
 
-				// check if we switched shaders
-				if (shader != model.pipeline) {
-					// new shader - need to re-send the view and projection matrices
-					shader = model.pipeline;
-					shader->use();
-					if (shader->hasUniform("projection")) {
-						shader->setUniformMtx(shader->uniform("view"), viewMatrix);
-						shader->setUniformMtx(shader->uniform("projection"), projectionMatrix);
-					}
+				// figure out the requirements
+				auto& multiMesh = world.get<mesh::StaticMultiMesh3D>(mesher);
+				if ( multiMesh.guid != util::make_guid("__NO_CACHE__") ){
+					// TODO support fetching of loaded meshes
+					debug::warning("multiple entities sharing a mesh has not been implemented yet...");
 				}
 
-				// set model transform
-				const auto &transform = world.get<math::Transform>(entity);
-				shader->setUniformMtx(shader->uniform("MVPMatrix"), projectionMatrix * viewMatrix * transform.model());
-				shader->setUniformMtx(shader->uniform("MVMatrix"), viewMatrix * transform.model());
-
-				auto normalMatrix = glm::mat3(glm::transpose(inverse(transform.model())));
-				shader->setUniformMtx(shader->uniform("NormalMatrix"), normalMatrix);
-
-				// setup lighting mode
-				if (shader->hasUniform("lights[0].isEnabled")) {
-					bool local = true;
-
-					shader->setUniformI(shader->uniform("lights[0].isEnabled"), 1);
-					shader->setUniformI(shader->uniform("lights[0].isLocal"), local);
-					shader->setUniformI(shader->uniform("lights[0].isSpot"), 0);
-
-					shader->setUniformF(shader->uniform("lights[0].constantAttenuation"), 5.0f);
-					shader->setUniformF(shader->uniform("lights[0].linearAttenuation"), 0.0f);
-					shader->setUniformF(shader->uniform("lights[0].quadraticAttenuation"), 0.0f);
-
-					shader->setUniformF(shader->uniform("Strength"), 0.6F);
-
-					if (!local) {
-						lightPos = glm::normalize(lightPos);
-						auto viewDir = glm::normalize(camTransform.origin() - transform.origin());
-						auto halfVector = glm::normalize(lightPos + viewDir);
-						shader->setUniformF(shader->uniform("lights[0].halfVector"), halfVector);
-						shader->setUniformF(shader->uniform("EyeDirection"), viewDir);
-						shader->setUniformF(shader->uniform("lights[0].position"), lightPos);
-					} else {
-						auto camModelView = (viewMatrix * camTransform.model() * math::vec4(0.0f, 0.0f, 0.0f, 1.0f));
-						auto modelModelView = (viewMatrix * transform.model() * math::vec4(0.0f, 0.0f, 0.0f, 1.0f));
-						math::vec3 viewDir = glm::normalize(camModelView - modelModelView);
-						shader->setUniformF(shader->uniform("EyeDirection"), viewDir);
-
-						shader->setUniformF(shader->uniform("lights[0].position"),
-											math::vec3(viewMatrix * math::vec4(lightPos, 1.0f)));
-					}
-
-					shader->setUniformF(shader->uniform("lights[0].ambient"), {0.0f, 0.5f, 0.0f});
-					shader->setUniformF(shader->uniform("lights[0].colour"), {0.5f, 0.5f, 0.5f});
-				}
+				auto& entityMesh = world.add<StaticMultiMesh>(mesher);
+				entityMesh.pipeline = shaders->get( multiMesh.pipeline );
+				entityMesh.meshes = upload_multi_mesh(multiMesh.mesh, manager);
+				//entityMesh.material = setup_material( multiMesh.mesh.materials[0], manager);
+			}
+		}
 
-				// material detection with fallback
-				const auto &material = world.get<PhongMaterial>(entity);
+		void StaticModelRenderer::resolveModels(entity::EntityManager &world) {
+			// new mesh formats
+			setup_meshes(world, m_shaders, m_assets);
+			setup_multi_meshes(world, m_shaders, m_assets);
 
-				if (shader->hasUniform("materials[0].ambient")) {
-					shader->setUniformF(shader->uniform("materials[0].emission"), material.emission);
-					shader->setUniformF(shader->uniform("materials[0].ambient"), material.ambient);
-					shader->setUniformF(shader->uniform("materials[0].diffuse"), material.diffuse);
-					shader->setUniformF(shader->uniform("materials[0].specular"), material.specular);
-					shader->setUniformF(shader->uniform("materials[0].shininess"), material.shininess);
+			// terrain
+			auto terrain = world.find<data::HeightMap>();
+			for (const auto &renderable : terrain) {
+				auto *currModel = world.tryGet<StaticModel>(renderable);
+				if (currModel != nullptr) {
+					continue;
 				}
 
-				if (shader->hasUniform("lightPos")) {
-					shader->setUniformF(shader->uniform("lightPos"), lightPos);
-				}
+				auto &heightmap = world.get<data::HeightMap>(renderable);
+				data::Mesh heightMapMesh{};
+				data::generateHeightMesh(heightmap, heightMapMesh);
 
-				auto vao = model.vao;
-				vao->bind();
+				auto &modelComp = world.add<StaticModel>(renderable);
+				setup_component(modelComp, m_phong, heightMapMesh);
 
-				model.vertexData->bind();
-				if (model.restartIndex != NO_RESTART_IDX) {
-					glEnable(GL_PRIMITIVE_RESTART);
-					glPrimitiveRestartIndex(model.restartIndex);
-				}
+				// we know this is a triangle strip with a restart vertex...
+				// FIXME the model should be telling us this...
+				modelComp.drawType = ogl::Primitive::TRIANGLE_STRIP;
+				modelComp.restartIndex = heightMapMesh.restartVertex;
 
-				auto *elements = model.elements.get();
-				vao->drawElements(*elements, model.drawType, model.elementCount);
-				if (model.restartIndex != NO_RESTART_IDX) {
-					glDisable(GL_PRIMITIVE_RESTART);
-				}
+				// no active model, we need to resolve/load one.
+				debug::info("looks like {} needs a static mesh", (uint64_t)renderable);
 			}
+		}
+	#endif
+
 
+	void StaticModelRenderer::renderModelsForward(const entity::EntityManager &world, bool debugMode) {
+
+		// fetch cameras we will need to render with
+		auto cameras = world.find<gfx::Camera>();
+
+		// if there are no cameras, we can't do anything...
+		if (cameras.empty()) {
+			debug::warning("asked to render static models, but there were no cameras");
+			return;
+		}
+
+		// perform a rendering pass for each camera (will usually only be one...)
+		for (const auto &cameraEnt : cameras) {
+			//TODO should be clipping this to only visible objects
+			//forward_camera_pass(cameraEnt, world);
+
+			forward_pass<ogl4::StaticMesh>(cameraEnt, world, m_assets);
+			forward_pass<ogl4::StaticMultiMesh>(cameraEnt, world, m_assets);
+
+			// enable rendering normals
+			if ( debugMode ) {
+				auto normalShader = m_shaders->get("normals");
+				forward_pass_normals<StaticMesh>(cameraEnt, world, normalShader);
+				forward_pass_normals<StaticMultiMesh>(cameraEnt, world, normalShader);
+				//forward_normal_pass(cameraEnt, world, normalShader);
+			}
 		}
 	}
 

fggl/gfx/ogl4/module.cpp

@@ -18,8 +18,10 @@
 
 #include "fggl/gfx/ogl4/module.hpp"
 #include "fggl/gfx/phong.hpp"
+#include "fggl/mesh/components.hpp"
 #include "fggl/data/procedural.hpp"
 
+#include "fggl/assets/loader.hpp"
 #include <string>
 
 namespace fggl::gfx {
@@ -29,51 +31,123 @@ namespace fggl::gfx {
 	constexpr const char *SHAPE_SPHERE{"sphere"};
 	constexpr const char *SHAPE_BOX{"box"};
 
-	static void process_shape(const YAML::Node &node, data::Mesh &mesh) {
-		auto transform = data::OFFSET_NONE;
-
-		auto offset = node["offset"].as<math::vec3>(math::VEC3_ZERO);
-		transform = glm::translate(transform, offset);
-
-		auto scale = node["scale"].as<math::vec3>(math::VEC3_ONES);
-		transform = glm::scale(transform, scale);
-		debug::debug("scale: {}, {}, {}", scale.x, scale.y, scale.z);
-
-		// now the shape itself
-		auto type = node["type"].as<std::string>();
-		if (type == SHAPE_BOX) {
-			data::make_cube(mesh, transform);
-		} else if (type == SHAPE_SPHERE) {
-			auto stacks = node["stacks"].as<uint32_t>(DEFAULT_STACKS);
-			auto slices = node["slices"].as<uint32_t>(DEFAULT_SLICES);
-			data::make_sphere(mesh, transform, stacks, slices);
-		} else {
-			debug::log(debug::Level::warning, "unknown shape type requested: {}", type);
+	namespace {
+		void process_shape(const YAML::Node &node, mesh::Mesh3D &mesh) {
+			auto transform = data::OFFSET_NONE;
+
+			auto offset = node["offset"].as<math::vec3>(math::VEC3_ZERO);
+			transform = glm::translate(transform, offset);
+
+			auto scale = node["scale"].as<math::vec3>(math::VEC3_ONES);
+			transform = glm::scale(transform, scale);
+			debug::debug("scale: {}, {}, {}", scale.x, scale.y, scale.z);
+
+			// now the shape itself
+			auto type = node["type"].as<std::string>();
+			if (type == SHAPE_BOX) {
+				data::make_cube(mesh, transform);
+			} else if (type == SHAPE_SPHERE) {
+				auto stacks = node["stacks"].as<uint32_t>(DEFAULT_STACKS);
+				auto slices = node["slices"].as<uint32_t>(DEFAULT_SLICES);
+				data::make_sphere(mesh, transform, stacks, slices);
+			} else {
+				debug::log(debug::Level::warning, "unknown shape type requested: {}", type);
+			}
 		}
 	}
 
-	void attach_mesh(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id) {
-		auto &meshComp = manager.add<data::StaticMesh>(id);
-		meshComp.pipeline = spec.get<std::string>("pipeline", "");
 
+	void attach_mesh(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id, modules::Services &services) {
+
+		// check for the asset service
+		auto* assetService = services.get<assets::AssetManager>();
+		auto* assetLoader = services.get<assets::Loader>();
+		if ( assetService == nullptr || assetLoader == nullptr ) {
+			// no asset service, give up
+			return;
+		}
+
+		// asset is a procedural mesh description
 		if (spec.has("shape")) {
-			// procedural mesh
-			data::Mesh mesh;
-			if (spec.config["shape"].IsSequence()) {
-				for (const auto &node : spec.config["shape"]) {
-					process_shape(node, mesh);
+			auto pipeline = spec.get<std::string>("pipeline", "");
+
+			// check if we had previously loaded this asset
+			/*const auto shapeName = spec.get<std::string>("shape_id", "");
+			if ( !shapeName.empty() ) {
+				meshAsset = assetService->get<data::Mesh>(shapeName);
+			}*/
+
+			// we've not loaded this before - generate mesh
+			if ( true ) {
+
+				// procedural meshes are build as static meshes first
+				if (spec.config["shape"].IsSequence()) {
+					mesh::MultiMesh3D* multiMesh;
+
+					for (const auto &node : spec.config["shape"]) {
+						auto* meshAsset = new mesh::Mesh3D();
+						process_shape(node, *meshAsset);
+						multiMesh->meshes.push_back(*meshAsset);
+						delete meshAsset;
+					}
+
+					#ifdef FGGL_ALLOW_DEFERRED_UPLOAD
+						// the graphics stack can detect static meshes without a rendering proxy at runtime and fix it but this
+						// requires loading the whole model into the ECS (and should be removed in the future). instead we should
+						// be triggering the upload at this point (if needed).
+						auto &entityMesh = manager.add<mesh::StaticMultiMesh3D>(id);
+						entityMesh.mesh = *multiMesh;
+						entityMesh.pipeline = pipeline;
+						debug::warning("HACKY: Triggered proc mesh - using deferred upload");
+					#endif
+
+				} else {
+					auto* meshAsset = new mesh::Mesh3D();
+					process_shape(spec.config["shape"], *meshAsset);
+
+					#ifdef FGGL_ALLOW_DEFERRED_UPLOAD
+						// the graphics stack can detect static meshes without a rendering proxy at runtime and fix it but this
+						// requires loading the whole model into the ECS (and should be removed in the future). instead we should
+						// be triggering the upload at this point (if needed).
+						auto &entityMesh = manager.add<mesh::StaticMesh3D>(id);
+						entityMesh.mesh = *meshAsset;
+						entityMesh.pipeline = pipeline;
+						debug::warning("HACKY: Triggered proc mesh - using deferred upload");
+					#endif
 				}
-			} else {
-				process_shape(spec.config["shape"], mesh);
+
+				//assetService->set(shapeName, meshTmp);
 			}
-			mesh.removeDups();
-			meshComp.mesh = mesh;
+
+			// TODO we need to trigger an upload to the GPU (somehow)
+
+			return;
+		}
+
+		// asset is a model from the resource cache
+		if ( spec.has("model") ) {
+			// figure out what model we want
+			auto assetStr = spec.get<std::string>("model", "");
+			auto assetId = assets::asset_from_user( assetStr );
+
+			auto* asset = assetService->get<ogl4::StaticModel>(assetId);
+
+			if ( asset == nullptr ) {
+				// the asset is not loaded/does not exist
+				debug::error("requested model {} but it was not loaded.", assetStr);
+				return;
+			}
+
+			// copy the asset to the model
+			auto& model = manager.add<ogl4::StaticModel>(id);
+			model = *asset;
 		}
 	}
 
 	void attach_material(const entity::ComponentSpec &spec,
 						 entity::EntityManager &manager,
-						 const entity::EntityID &id) {
+						 const entity::EntityID &id,
+						 modules::Services& /*services*/ ) {
 		auto &mat = manager.add<gfx::PhongMaterial>(id);
 		mat.ambient = spec.get<math::vec3>("ambient", gfx::DEFAULT_AMBIENT);
 		mat.diffuse = spec.get<math::vec3>("diffuse", gfx::DEFAULT_DIFFUSE);
@@ -81,22 +155,40 @@ namespace fggl::gfx {
 		mat.shininess = spec.get<float>("ambient", gfx::DEFAULT_SHININESS);
 	}
 
-	void attach_light(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id) {
-		auto &light = manager.add<gfx::Light>(id);
+	void attach_light_directional(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id, modules::Services& /*services*/) {
+		auto &light = manager.add<gfx::DirectionalLight>(id);
+		light.position = spec.get<math::vec3>("direction", -math::UP);
+		light.ambient = spec.get<math::vec3>("ambient", gfx::colours::WHITE);
+		light.specular = spec.get<math::vec3>("specular", gfx::colours::WHITE);
+		light.diffuse = spec.get<math::vec3>("diffuse", gfx::colours::WHITE);
 	}
 
-	bool OpenGL4::factory(modules::ModuleService service, modules::Services &services) {
+	void attach_light_point(const entity::ComponentSpec &spec, entity::EntityManager &manager, const entity::EntityID &id, modules::Services& /*services*/) {
+		auto &light = manager.add<gfx::PointLight>(id);
+		light.position = spec.get<math::vec3>("position", math::VEC3_ZERO);
+
+		light.constant = spec.get<float>("constant", 1.0F);
+		light.linear = spec.get<float>("linear", 0.0014F);
+		light.quadratic = spec.get<float>("quadratic", 0.000007F);
+	}
+
+	auto OpenGL4::factory(modules::ServiceName service, modules::Services &services) -> bool {
 		if (service == WindowGraphics::service) {
 			// setup the thing responsible for graphics
 			auto *storage = services.get<data::Storage>();
 			auto *fontLibrary = services.get<gui::FontLibrary>();
-			services.bind<WindowGraphics, ogl4::WindowGraphics>(storage, fontLibrary);
+			auto *assets = services.get<assets::AssetManager>();
+			services.bind<WindowGraphics, ogl4::WindowGraphics>(storage, fontLibrary, assets);
 
 			// register as responsible for creating rendering components
 			auto *entityFactory = services.get<entity::EntityFactory>();
 			entityFactory->bind(data::StaticMesh::guid, attach_mesh);
+			entityFactory->bind(mesh::StaticMesh3D::guid, attach_mesh);
+			entityFactory->bind(mesh::StaticMultiMesh3D::guid, attach_mesh);
 			entityFactory->bind(gfx::PhongMaterial::guid, attach_material);
-			entityFactory->bind(gfx::Light::guid, attach_light);
+
+			entityFactory->bind(gfx::DirectionalLight::guid, attach_light_directional);
+			entityFactory->bind(gfx::PointLight::guid, attach_light_point);
 
 			return true;
 		}

fggl/gfx/ogl4/setup.cpp

@@ -20,8 +20,8 @@
 
 namespace fggl::gfx::ogl4 {
 
-	Graphics *WindowGraphics::create(display::Window &window) {
-		return new OpenGL4Backend(m_storage, m_fonts);
+	auto WindowGraphics::create(display::Window &window) -> Graphics * {
+		return new OpenGL4Backend(m_storage, m_fonts, m_assets, (GlFunctionLoader)glfwGetProcAddress);
 	}
 
 }
\ No newline at end of file

fggl/gfx/window.cpp

@@ -21,7 +21,6 @@
 #include <string>
 #include <stdexcept>
 #include <GLFW/glfw3.h>
-#include <spdlog/spdlog.h>
 
 namespace fggl::display::glfw {
 
@@ -34,37 +33,37 @@ namespace fggl::display::glfw {
 		fgglWindow->framesize(width, height);
 	}
 
-	static void fggl_input_cursor(GLFWwindow *window, double x, double y) {
+	static void fggl_input_cursor(GLFWwindow *window, double xPos, double yPos) {
 		auto &input = GlfwInputManager::instance();
 		auto *fgglWin = static_cast<Window *>(glfwGetWindowUserPointer(window));
 
 		#ifndef FGGL_INPUT_SCREEN_COORDS
 		// convert to nice ranges...
-		x = (x / fgglWin->width() * 2) - 1.0; // [-1, 1]
-		y = (y / fgglWin->height() * 2) - 1.0; // [-1, 1]
+		xPos = (xPos / fgglWin->width() * 2) - 1.0; // [-1, 1]
+		yPos = (yPos / fgglWin->height() * 2) - 1.0; // [-1, 1]
 		#endif
 
 		// inform the input system
-		input.onMouseMove(x, y);
+		input.onMouseMove(xPos, yPos);
 	}
 
-	static void fggl_input_scroll(GLFWwindow *window, double x, double y) {
+	static void fggl_input_scroll(GLFWwindow */*window*/, double xPos, double yPos) {
 		auto &input = GlfwInputManager::instance();
-		input.onMouseScroll(x, y);
+		input.onMouseScroll(xPos, yPos);
 	}
 
-	static void fggl_input_mouse_btn(GLFWwindow *window, int btn, int action, int mods) {
+	static void fggl_input_mouse_btn(GLFWwindow */*window*/, int btn, int action, int /*mods*/) {
 		auto &input = GlfwInputManager::instance();
 		input.onMouseButton(btn, action == GLFW_PRESS);
 	}
 
-	static void fggl_input_keyboard(GLFWwindow *window, int key, int scancode, int action, int mods) {
+	static void fggl_input_keyboard(GLFWwindow */*window*/, int /*key*/, int scancode, int action, int /*mods*/) {
 		auto &input = GlfwInputManager::instance();
 		input.onKeyEvent(scancode, action == GLFW_PRESS || action == GLFW_REPEAT);
 	}
 
 	static void fggl_update_joystick(fggl::input::GamepadInput &input, int jid) {
-		bool isGamepad = glfwJoystickIsGamepad(jid);
+		bool isGamepad = (glfwJoystickIsGamepad(jid) == GLFW_TRUE);
 
 		if (isGamepad) {
 			if (!input.present(jid)) {
@@ -99,7 +98,7 @@ namespace fggl::display::glfw {
 
 		auto &gamepadCtl = input.gamepads();
 		for (int jid = 0; jid < GLFW_JOYSTICK_LAST; jid++) {
-			if (glfwJoystickPresent(jid)) {
+			if (glfwJoystickPresent(jid) == GLFW_TRUE) {
 				fggl_update_joystick(gamepadCtl, jid);
 			} else {
 				gamepadCtl.setActive(jid, false);
@@ -144,7 +143,7 @@ namespace fggl::display::glfw {
 
 	GlfwContext::~GlfwContext() {
 		glfwTerminate();
-		spdlog::debug("[glfw] context terminated");
+		debug::trace("[glfw] context terminated");
 	}
 
 	void GlfwContext::pollEvents() {
@@ -157,7 +156,9 @@ namespace fggl::display::glfw {
 
 	Window::Window(std::shared_ptr<GlfwContext> context, gfx::WindowGraphics *graphics)
 		: m_context(std::move(context)), m_window(nullptr), m_framesize() {
-		spdlog::debug("[glfw] creating window");
+
+		// don't iconify when focus is lost.
+		glfwWindowHint( GLFW_AUTO_ICONIFY, GLFW_FALSE );
 
 		// FIXME - this ties the graphics API before window creation
 		auto graphicsConfig = graphics->config();
@@ -184,12 +185,15 @@ namespace fggl::display::glfw {
 
 		// bind the graphics API
 		glfwMakeContextCurrent(m_window);
-		m_graphics = std::unique_ptr<gfx::Graphics>(graphics->create(*this));
-
-		spdlog::debug("[glfw] window creation complete");
+		m_graphics = graphics->createMain(*this);
 	}
 
 	Window::~Window() {
+		if ( m_graphics != nullptr ) {
+			delete m_graphics;
+			m_graphics = nullptr;
+		}
+
 		if (m_window != nullptr) {
 			// prevent dangling pointers
 			glfwSetWindowUserPointer(m_window, nullptr);
@@ -215,14 +219,14 @@ namespace fggl::display::glfw {
 		glfwMakeContextCurrent(m_window);
 	}
 
-	fggl::math::vec2i Window::frameSize() const {
+	auto Window::frameSize() const -> fggl::math::vec2i {
 		assert(m_window != nullptr);
 		math::vec2i size;
 		glfwGetFramebufferSize(m_window, &size.x, &size.y);
 		return size;
 	}
 
-	bool Window::wantClose() const {
+	auto Window::wantClose() const -> bool {
 		assert(m_window != nullptr);
 		return glfwWindowShouldClose(m_window) == GLFW_TRUE;
 	}

fggl/grid/CMakeLists.txt

+target_sources( fggl
+    PRIVATE
+        hexagon.cpp
+)
\ No newline at end of file

fggl/grid/hexagon.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 "fggl/grid/hexagon.hpp"
+
+namespace fggl::grid {
+
+	std::vector<IntHex> lineTo(const IntHex& start, const IntHex& end) {
+		const int distance = start.distance(end);
+		std::vector<IntHex> line;
+		for (auto i=0; i < distance; ++i) {
+			line.push_back( round2(hexLerp(start, end, 1.0F/distance * i)) );
+		}
+		return line;
+	}
+
+} // namespace fggl:grid

fggl/gui/CMakeLists.txt

+target_sources( ${PROJECT_NAME}
+    PRIVATE
+        widget.cpp
+        widgets.cpp
+        containers.cpp
+        fonts.cpp
+
+        model/parser.cpp
+        model/structure.cpp
+        renderer/renderer.cpp
+)
+
+find_package(Freetype)
+target_link_libraries(${PROJECT_NAME} PUBLIC Freetype::Freetype)
+

fggl/gui/containers.cpp

@@ -17,7 +17,7 @@
 
 namespace fggl::gui {
 
-	Widget *Container::getChildAt(const math::vec2 &point) {
+	auto Container::getChildAt(const math::vec2 &point) -> Widget * {
 		for (auto &child : m_children) {
 			if (child->contains(point)) {
 				return child->getChildAt(point);
@@ -27,7 +27,7 @@ namespace fggl::gui {
 		return nullptr;
 	}
 
-	bool Container::contains(const math::vec2 &point) {
+	auto Container::contains(const math::vec2 &point) -> bool {
 		return true;
 	}
 
@@ -42,6 +42,84 @@ namespace fggl::gui {
 		m_dirty = true;
 	}
 
+	void Container::onMouseOver(math::vec2 pos) {
+		Widget::onMouseOver(pos);
+		auto* childHover = getChildAt(pos);
+
+		for ( auto& child : m_children) {
+			if ( child.get() != childHover ) {
+				child->onExit(pos);
+			}
+		}
+
+		if ( childHover != nullptr ) {
+			childHover->onMouseOver(pos);
+		}
+	}
+
+	void Container::onEnter(math::vec2i pos) {
+		Widget::onEnter(pos);
+		for ( auto& child : m_children ) {
+			if ( child->contains(pos)) {
+				child->onEnter(pos);
+			}
+		}
+	}
+
+	void Container::onExit(math::vec2i pos) {
+		Widget::onExit(pos);
+		for ( auto& child : m_children) {
+			child->onExit(pos);
+		}
+	}
+
+	GridBox::GridBox(uint32_t rows, uint32_t cols, uint32_t padx, uint32_t pady) : m_rows(rows), m_cols(cols), m_padding(padx, pady) {}
+
+	void GridBox::layout() {
+		assert( m_rows != 0 || m_cols != 0 );
+
+		if ( m_rows == 0 ) {
+			int rows = m_children.size() / m_cols;
+
+			// figure out the width and heights
+			auto* widths = new float[m_cols]{0.0F};
+			auto* heights = new float[rows]{0.0F};
+			for ( auto idx = 0U; idx < m_children.size(); ++idx) {
+				auto& child = m_children[idx];
+				int col = idx % m_cols;
+				int row = idx / m_cols;
+
+				widths[col] = std::max( child->size().x, widths[col] );
+				heights[row] = std::max( child->size().y, heights[row] );
+			}
+
+			// populate the grid
+			fggl::math::vec2i pos{0, 0};
+			unsigned int row = 0;
+			unsigned int col = 0;
+			for ( auto& child : m_children ) {
+				fggl::math::vec2i size{ widths[col], heights[row] };
+				child->size(pos, size);
+				child->layout();
+
+				// next iter
+				pos.x += size.x + m_padding.x;
+				col++;
+				if ( col == m_cols ) {
+					col = 0;
+					row++;
+					pos.x = 0;
+					pos.y += size.y + m_padding.y;
+				}
+			}
+
+			// cleanup variables
+			delete[] widths;
+			delete[] heights;
+		}
+	}
+
+
 	/*
 	Box::Box( LayoutAxis axis ) : m_axis( axis ) {}
 	
@@ -70,7 +148,7 @@ namespace fggl::gui {
 	void Panel::render(gfx::Paint &paint) {
 		// background painting time
 		gfx::Path2D background(topLeft());
-		background.colour(math::vec3(32.0f / 255.0f, 74.0F / 255.0F, 135.0F / 255.0F));
+		background.colour(math::vec3(32.0F / 255.0F, 74.0F / 255.0F, 135.0F / 255.0F));
 		draw_box(background, topLeft(), bottomRight());
 		paint.fill(background);
 

fggl/gui/fonts.cpp

@@ -25,19 +25,19 @@ namespace fggl::gui {
 
 	FontLibrary::FontLibrary(data::Storage *storage) : m_context(nullptr), m_storage(storage) {
 		FT_Init_FreeType(&m_context);
+		m_defaultFont = getFont(DEFAULT_FONT_NAME);
 	}
 
 	FontLibrary::~FontLibrary() {
 		// free all fonts
-		for (auto &face : m_cache) {
-			face.second = nullptr;
-		}
+		m_defaultFont = nullptr;
+		m_cache.clear();
 
 		// shut the library down
 		FT_Done_FreeType(m_context);
 	}
 
-	GlyphMetrics &FontFace::populateMetrics(char letter) {
+	auto FontFace::populateMetrics(char letter) -> GlyphMetrics & {
 		if (FT_Load_Char(m_face, letter, FT_LOAD_RENDER)) {
 			// something bad happened
 			return m_metrics['?'];
@@ -54,7 +54,7 @@ namespace fggl::gui {
 		return it.first->second;
 	}
 
-	void FontFace::texture(char letter, int &width, int &height, void **buff) {
+	void FontFace::texture(char letter, int &width, int &height, unsigned char **buff) {
 		if (FT_Load_Char(m_face, letter, FT_LOAD_RENDER)) {
 			// something bad happened
 			return;

fggl/gui/model/parser.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 11/03/23.
+//
+
+#include "fggl/gui/model/parser.hpp"
+#include <yaml-cpp/yaml.h>
+
+namespace fggl::gui::model {
+
+	Widget* YamlToWidgetTree(WidgetFactory& factory, const YAML::Node& config) {
+		Widget* root;
+		if ( config["template"] ) {
+			root = factory.build( config["template"].as<std::string>());
+		} else {
+			root = factory.buildEmpty();
+		}
+
+		// deal with attrs
+		for ( auto attr : config["attrs"] ) {
+			root->set(attr.first.as<std::string>(), attr.second.as<std::string>());
+		}
+
+		// deal with child nodes
+		for ( auto child : config["children"] ) {
+			Widget* childWidget = YamlToWidgetTree(factory, child);
+			root->addChild(*childWidget);
+		}
+
+		// are we a template definition?
+		if ( config["define"] ) {
+			factory.push( config["define"].as<std::string>(), std::move(*root) );
+			return factory.getTemplate( config["define"].as<std::string>() );
+		}
+
+		return root;
+	}
+
+	inline Widget* parseFile(WidgetFactory& factory, const std::string& path) {
+		YAML::Node root = YAML::LoadFile(path);
+		if ( !root ){
+			return nullptr;
+		}
+		return YamlToWidgetTree(factory, root);
+	}
+
+}
\ No newline at end of file

fggl/gui/model/structure.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 11/03/23.
+//
+
+#include "fggl/gui/model/structure.hpp"
+#include "fggl/gui/fonts.hpp"
+
+#include <algorithm>
+#include <utility>
+#include <string>
+
+namespace fggl::gui::model {
+
+	math::vec2 calcTextBounds(const std::string& value, std::shared_ptr<FontFace> face) {
+		if ( face == nullptr ){
+			debug::warning("No preferred font sent, cowardly refusing to process text");
+			return {};
+		}
+
+		math::vec2 max{0, 0};
+		for (auto letter : value) {
+			auto metrics = face->metrics(letter);
+
+			max.x += metrics.size.x + (metrics.advance >> 6);
+			max.y = std::max(max.y, metrics.size.y);
+		}
+		return max;
+	}
+
+	inline math::vec2 calcBoxContrib(const Widget& widget, const std::string& name) {
+		return math::vec2{
+			widget.get_or_default<float>( name + "::left") + widget.get_or_default<float>(name + "::right"),
+			widget.get_or_default<float>( name + "::top" ) + widget.get_or_default<float>( name + "::bottom" )
+		};
+	}
+
+	void Widget::calcPrefSize(std::shared_ptr<FontFace> face) {
+		if ( !m_dirty ){
+			return;
+		}
+
+		auto padding = calcBoxContrib( *this, "padding");
+		auto border = calcBoxContrib( *this, "border");
+		auto content = math::vec2{0,0};
+
+		if (hasAttr("text")) {
+			content += calcTextBounds( get<std::string>("text"), std::move(face) );
+		}
+
+		m_cachedSize = padding + content + content;
+		debug::info("my preferred size is: ({}, {})", m_cachedSize.x, m_cachedSize.y);
+
+		m_dirty = false;
+	}
+
+}
\ No newline at end of file

fggl/gui/renderer/renderer.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 11/03/23.
+//
+
+#include "fggl/gui/renderer/renderer.hpp"
+
+namespace fggl::gui::renderer {
+
+	constexpr int PADDING = 15;
+
+	void draw_box(gfx::Path2D &path, glm::vec2 topLeft, glm::vec2 bottomRight) {
+		path.moveTo({topLeft.x, topLeft.y});
+		path.pathTo({bottomRight.x, topLeft.y});
+		path.pathTo({bottomRight.x, bottomRight.y});
+		path.pathTo({topLeft.x, bottomRight.y});
+		path.pathTo({topLeft.x, topLeft.y});
+	}
+
+	void draw_border_patch(gfx::Paint& paint, Box& bounds, Box& size, math::vec3 colour) {
+		gfx::Path2D path({0,0});
+
+		path.colour(colour);
+		// draw edges
+		draw_box(path, {bounds.left + size.left, bounds.top}, {bounds.right - size.right, bounds.top + size.top} );
+		draw_box(path, {bounds.right - size.right, bounds.top + size.top}, {bounds.right, bounds.bottom - size.bottom} );
+		draw_box(path, {bounds.left + size.left, bounds.bottom - size.bottom}, {bounds.right - size.right, bounds.bottom} );
+		draw_box(path, {bounds.left, bounds.top + size.top}, {bounds.left + size.left, bounds.bottom - size.bottom} );
+
+		// draw-corners
+		draw_box(path, {bounds.left, bounds.top}, {bounds.left + size.left, bounds.top + size.top} );
+		draw_box(path, {bounds.right - size.right, bounds.top}, {bounds.right, bounds.top + size.top} );
+		draw_box(path, {bounds.left, bounds.bottom - size.bottom}, {bounds.left + size.left, bounds.bottom} );
+		draw_box(path, {bounds.right - size.right, bounds.bottom - size.bottom}, {bounds.right, bounds.bottom});
+		paint.fill(path);
+	}
+
+	void draw_border_solid(gfx::Paint& paint, Box& bounds, Box& size, math::vec3 colour) {
+		gfx::Path2D path({0,0});
+
+		path.colour(colour);
+		// draw edges
+		draw_box(path, {bounds.left, bounds.top}, {bounds.right, bounds.top + size.top} );
+		draw_box(path, {bounds.right - size.right, bounds.top + size.top}, {bounds.right, bounds.bottom - size.bottom} );
+		draw_box(path, {bounds.left, bounds.bottom - size.bottom}, {bounds.right, bounds.bottom} );
+		draw_box(path, {bounds.left, bounds.top + size.top}, {bounds.left + size.left, bounds.bottom - size.bottom} );
+
+		paint.fill(path);
+	}
+
+	void draw_background_solid(gfx::Paint& paint, Box& bounds, math::vec3 colour) {
+		gfx::Path2D path({0,0});
+		path.colour(colour);
+		draw_box(path, {bounds.left, bounds.top}, {bounds.right, bounds.bottom} );
+		paint.fill(path);
+	}
+
+	void layout(model::Widget& current) {
+		if ( current.isLeaf() ) {
+			// if the widget has a defined size, use that
+			if ( current.hasAttr("size") && !current.hasAttr("text") ) {
+				return;
+			}
+
+			// else, use the model's preferred size
+			auto preferred = current.preferredSize();
+			if ( preferred.has_value() ) {
+				current.set<math::vec2>("size", preferred.value() );
+			}
+		} else {
+			auto topPad = current.get_or_default<float>("border:top") + current.get_or_default<float>("padding::top");
+			auto leftPad = current.get_or_default<float>("border::left") + current.get_or_default<float>("padding::left");
+
+			math::vec2 size = {topPad, leftPad};
+
+			// layout all children
+			for ( auto& child : current ) {
+				layout(child);
+
+				auto childSize = child.get_or_default<math::vec2>("size");
+				size.x = std::max( childSize.x, size.x );
+				size.y += childSize.y;
+
+				child.set<math::vec2>("position", {leftPad, size.y});
+			}
+
+			// set our size based on that
+			current.set<math::vec2>("size", size );
+		}
+	}
+
+	void visit(const model::Widget& root, gfx::Paint& paint, Box offset) {
+		// get border size
+		auto border = get_box(root, "border");
+
+		// calculate box bounds
+		auto pos = get_vec2(root, "position");
+		auto size = get_vec2(root, "size");
+
+		auto bounds = getBounds(pos, size);
+		bounds.top += offset.top;
+		bounds.left += offset.left;
+
+		// deal with right hand size bounds
+		//bounds.right = std::min( size.x, offset.width() );
+		//bounds.right += offset.left;
+
+		// deal with bottom bounds
+		//bounds.bottom = std::min( size.y, offset.height() );
+		//bounds.bottom += offset.top;
+
+		auto background = bounds.trim(border);
+
+		draw_background_solid(paint, background, get_vec3_rgb(root, "colour"));
+		draw_border_patch(paint, bounds, border, get_vec3_rgb(root, "border::colour"));
+
+		auto padding = get_box(root, "padding");
+		background = background.trim(padding);
+
+		if ( root.hasAttr("text") ) {
+			auto text = root.get<std::string>("text");
+			paint.text(text, {background.left, background.top + PADDING});
+		}
+
+		for (const auto& child : root) {
+			visit(child, paint, background);
+		}
+	}
+
+} // namespace fggl::gui:;renderer
\ No newline at end of file

fggl/gui/widget.cpp

@@ -20,9 +20,9 @@
 
 namespace fggl::gui {
 
-	void buttonBorder(gfx::Path2D &path, glm::vec2 pos, glm::vec2 size) {
+	void button_border(gfx::Path2D &path, glm::vec2 pos, glm::vec2 size) {
 		// outer box
-		path.colour({1.0f, 0.0f, 0.0f});
+		path.colour({1.0F, 0.0F, 0.0F});
 		path.pathTo({pos.x + size.x, pos.y});
 		path.pathTo({pos.x + size.x, pos.y + size.y});
 		path.pathTo({pos.x, pos.y + size.y});
@@ -32,7 +32,7 @@ namespace fggl::gui {
 		math::vec2 innerTop{pos.x + 5, pos.y + 5};
 		math::vec2 innerBottom{pos.x + size.x - 5, pos.y + size.y - 5};
 
-		path.colour({1.0f, 1.0f, 0.0f});
+		path.colour({1.0F, 1.0F, 0.0F});
 		path.moveTo({innerTop.x, innerTop.y});
 		path.pathTo({innerBottom.x, innerTop.y});
 		path.pathTo({innerBottom.x, innerBottom.y});
@@ -52,7 +52,7 @@ namespace fggl::gui {
 		const auto bottomRight{topLeft + size};
 
 		// background
-		path.colour({0.5f, 0.5f, 0.5f});
+		path.colour({0.5F, 0.5F, 0.5F});
 		draw_box(path, topLeft, bottomRight);
 
 		// fill
@@ -65,13 +65,13 @@ namespace fggl::gui {
 		innerBottom.x = innerTop.x + barWidth;
 
 		// draw the bar
-		path.colour({0.8f, 0.0f, 0.0f});
+		path.colour({0.8F, 0.0F, 0.0F});
 		draw_box(path, innerTop, innerBottom);
 
 		// part of the bar that's not filled in
 		math::vec2 emptyTop{innerBottom.x, innerTop.y};
 		math::vec2 emptyBottom{trueBottom, innerBottom.y};
-		path.colour({0.4f, 0.0f, 0.0f});
+		path.colour({0.4F, 0.0F, 0.0F});
 		draw_box(path, emptyTop, emptyBottom);
 	}
 
@@ -90,7 +90,7 @@ namespace fggl::gui {
 
 		math::vec2 selectorTop{innerTop.x + selectorValue - (selectorWidth / 2), topLeft.y};
 		math::vec2 selectorBottom{selectorTop.x + selectorWidth, bottomRight.y};
-		path.colour({1.0f, 1.0f, 1.0f});
+		path.colour({1.0F, 1.0F, 1.0F});
 		draw_box(path, selectorTop, selectorBottom);
 	}
 
@@ -101,18 +101,18 @@ namespace fggl::gui {
 		math::vec2 innerTop{pos.x + 5, pos.y + 5};
 		math::vec2 innerBottom{pos.x + size.x - 5, pos.y + size.y - 5};
 
-		math::vec3 baseColour{0.5f, 0.5f, 0.5f};
+		math::vec3 baseColour{0.5F, 0.5F, 0.5F};
 
 		if (active) {
-			baseColour *= 1.2f;
+			baseColour *= 1.2F;
 		}
 
 		if (pressed) {
-			baseColour *= 0.8f;
+			baseColour *= 0.8F;
 		}
 
-		math::vec3 lightColour{baseColour * 1.2f};
-		math::vec3 darkColour{baseColour * 0.8f};
+		math::vec3 lightColour{baseColour * 1.2F};
+		math::vec3 darkColour{baseColour * 0.8F};
 		if (pressed) {
 			// flip light and dark for selected buttons
 			auto tmp = darkColour;

fggl/gui/widgets.cpp

@@ -23,8 +23,7 @@
 
 namespace fggl::gui {
 
-	Button::Button(math::vec2 pos, math::vec2 size) : Widget(pos, size), m_label(pos, size), m_hover(false),
-													  m_active(false) {}
+	Button::Button(math::vec2 pos, math::vec2 size) : Widget(pos, size), m_label(pos, size), m_active(false) {}
 
 	void Button::render(gfx::Paint &paint) {
 		gfx::Path2D path{topLeft()};
@@ -39,19 +38,11 @@ namespace fggl::gui {
 		if (m_active) {
 			for (auto &callback : m_callbacks) {
 				callback();
-				m_active = false;
 			}
+			m_active = false;
 		}
 	}
 
-	void Button::onEnter() {
-		m_hover = true;
-	}
-
-	void Button::onExit() {
-		m_hover = false;
-	}
-
 	void Button::addCallback(Callback cb) {
 		m_callbacks.push_back(cb);
 	}
@@ -60,7 +51,11 @@ namespace fggl::gui {
 		m_label.text(value);
 	}
 
-	std::string Button::label() const {
+	void Button::layout() {
+		m_label.size(topLeft(), size());
+	}
+
+	auto Button::label() const -> std::string {
 		return m_label.text();
 	}
 

fggl/input/camera_input.cpp

@@ -27,10 +27,10 @@ namespace fggl::input {
 		// see https://asliceofrendering.com/camera/2019/11/30/ArcballCamera/
 		auto &camTransform = ecs.get<fggl::math::Transform>(cam);
 		auto &camComp = ecs.get<fggl::gfx::Camera>(cam);
-		auto &mouse = input.mouse;
+		const auto &mouse = input.mouse;
 
-		glm::vec4 position(camTransform.origin(), 1.0f);
-		glm::vec4 pivot(camComp.target, 1.0f);
+		glm::vec4 position(camTransform.origin(), 1.0F);
+		glm::vec4 pivot(camComp.target, 1.0F);
 		glm::mat4 view = glm::lookAt(camTransform.origin(), camComp.target, camTransform.up());
 		glm::vec3 viewDir = -glm::transpose(view)[2];
 		glm::vec3 rightDir = glm::transpose(view)[0];
@@ -41,12 +41,12 @@ namespace fggl::input {
 		float yAngle = (-mouse.axisDelta(fggl::input::MouseAxis::Y)) * deltaAngleY;
 
 		// rotate the camera around the pivot on the first axis
-		glm::mat4x4 rotationMatrixX(1.0f);
+		glm::mat4x4 rotationMatrixX(1.0F);
 		rotationMatrixX = glm::rotate(rotationMatrixX, xAngle, fggl::math::UP);
 		position = (rotationMatrixX * (position - pivot)) + pivot;
 
-		// rotate the camera aroud the pivot on the second axis
-		glm::mat4x4 rotationMatrixY(1.0f);
+		// rotate the camera around the pivot on the second axis
+		glm::mat4x4 rotationMatrixY(1.0F);
 		rotationMatrixY = glm::rotate(rotationMatrixY, yAngle, rightDir);
 		glm::vec3 finalPos = (rotationMatrixY * (position - pivot)) + pivot;
 
@@ -66,17 +66,17 @@ namespace fggl::input {
 
 		glm::vec3 motion(0.0F);
 		float delta = input.mouse.axis(fggl::input::MouseAxis::SCROLL_Y);
-		if ((glm::length(dir) < maxZoom && delta < 0.0f) || (glm::length(dir) > minZoom && delta > 0.0f)) {
+		if ((glm::length(dir) < maxZoom && delta < 0.0F) || (glm::length(dir) > minZoom && delta > 0.0F)) {
 			motion -= (forward * delta);
 			camTransform.origin(camTransform.origin() + motion);
 		}
 	}
 
 	void process_freecam(entity::EntityManager &ecs, const Input &input, entity::EntityID cam) {
-		float rotationValue = 0.0f;
-		glm::vec3 translation(0.0f);
+		float rotationValue = 0.0F;
+		glm::vec3 translation(0.0F);
 
-		auto &keyboard = input.keyboard;
+		const auto &keyboard = input.keyboard;
 		auto &settings = ecs.get<FreeCamKeys>(cam);
 
 		// calculate rotation (user input)
@@ -107,24 +107,24 @@ namespace fggl::input {
 		auto camTransform = ecs.get<fggl::math::Transform>(cam);
 		auto camComp = ecs.get<fggl::gfx::Camera>(cam);
 
-		glm::vec4 position(camTransform.origin(), 1.0f);
-		glm::vec4 pivot(camComp.target, 1.0f);
+		glm::vec4 position(camTransform.origin(), 1.0F);
+		glm::vec4 pivot(camComp.target, 1.0F);
 
 		// apply movement
-		if (translation != glm::vec3(0.0f)) {
+		if (translation != glm::vec3(0.0F)) {
 			const auto rotation = (position - pivot);
 			const float angle = atan2f(rotation.x, rotation.z);
 			const auto rotationMat = glm::rotate(MAT_IDENTITY, angle, fggl::math::UP);
 
-			auto deltaMove = (rotationMat * glm::vec4(translation, 1.0f)) * PAN_SPEED;
-			deltaMove.w = 0.0f;
+			auto deltaMove = (rotationMat * glm::vec4(translation, 1.0F)) * PAN_SPEED;
+			deltaMove.w = 0.0F;
 
 			position += deltaMove;
 			pivot += deltaMove;
 		}
 
 		// apply rotation
-		if (rotationValue != 0.0f) {
+		if (rotationValue != 0.0F) {
 			glm::mat4 rotation = glm::rotate(MAT_IDENTITY, rotationValue, fggl::math::UP);
 			position = (rotation * (position - pivot)) + pivot;
 		}
@@ -134,24 +134,24 @@ namespace fggl::input {
 	}
 
 	void process_edgescroll(entity::EntityManager &ecs, const Input &input, entity::EntityID cam) {
-		glm::vec3 translation(0.0f);
+		glm::vec3 translation(0.0F);
 
-		auto &mouse = input.mouse;
+		const auto &mouse = input.mouse;
 
 		// calculate movement (user input)
-		if (mouse.axis(MouseAxis::Y) < 0.9f) {
+		if (mouse.axis(MouseAxis::Y) < 0.9F) {
 			translation -= fggl::math::RIGHT;
 		}
 
-		if (mouse.axis(MouseAxis::Y) > -0.9f) {
+		if (mouse.axis(MouseAxis::Y) > -0.9F) {
 			translation += fggl::math::RIGHT;
 		}
 
-		if (mouse.axis(MouseAxis::X) > -0.9f) {
+		if (mouse.axis(MouseAxis::X) > -0.9F) {
 			translation += fggl::math::FORWARD;
 		}
 
-		if (mouse.axis(MouseAxis::X) < 0.9f) {
+		if (mouse.axis(MouseAxis::X) < 0.9F) {
 			translation -= fggl::math::FORWARD;
 		}
 
@@ -159,17 +159,17 @@ namespace fggl::input {
 		auto &camTransform = ecs.get<fggl::math::Transform>(cam);
 		auto &camComp = ecs.get<fggl::gfx::Camera>(cam);
 
-		glm::vec4 position(camTransform.origin(), 1.0f);
-		glm::vec4 pivot(camComp.target, 1.0f);
+		glm::vec4 position(camTransform.origin(), 1.0F);
+		glm::vec4 pivot(camComp.target, 1.0F);
 
 		// apply movement
-		if (translation != glm::vec3(0.0f)) {
+		if (translation != glm::vec3(0.0F)) {
 			const auto rotation = (position - pivot);
 			const float angle = atan2f(rotation.x, rotation.z);
 			const auto rotationMat = glm::rotate(MAT_IDENTITY, angle, fggl::math::UP);
 
-			auto deltaMove = (rotationMat * glm::vec4(translation, 1.0f)) * PAN_SPEED;
-			deltaMove.w = 0.0f;
+			auto deltaMove = (rotationMat * glm::vec4(translation, 1.0F)) * PAN_SPEED;
+			deltaMove.w = 0.0F;
 
 			position += deltaMove;
 			pivot += deltaMove;

fggl/math/shapes.cpp

@@ -22,22 +22,12 @@ namespace fggl::math::phs3d {
 		max = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
 	}
 
-	void AABB::add(const math::vec3 &p) {
-		if (p.x < min.x)
-			min.x = p.x;
-		if (p.x > max.x)
-			max.x = p.x;
-		if (p.y < min.y)
-			min.y = p.y;
-		if (p.y > min.y)
-			max.y = p.y;
-		if (p.z < min.z)
-			min.z = p.z;
-		if (p.z > max.z)
-			max.z = p.z;
+	void AABB::add(const math::vec3 &point) {
+		min = minElm(min, point);
+		max = maxElm(max, point);
 	}
 
-	AABB AABB::fromPoints(const std::vector<math::vec3> &points) {
+	auto AABB::fromPoints(const std::vector<math::vec3> &points) -> AABB {
 		AABB box;
 		for (const auto &point : points) {
 			box.add(point);
@@ -52,7 +42,7 @@ namespace fggl::math::phs3d {
 		// this feels like something that should be vectorizable...
 		for (int i = 0; i < 3; i++) {
 			for (int j = 0; j < 3; j++) {
-				if (m[i][j] > 0.0f) {
+				if (m[i][j] > 0.0F) {
 					min[j] += m[i][j] * other.min[j];
 					max[j] += m[i][j] * other.max[j];
 				} else {
@@ -63,7 +53,7 @@ namespace fggl::math::phs3d {
 		}
 	}
 
-	Plane Plane::fromPoints(const math::vec3 p1, const math::vec3 p2, const math::vec3 p3) {
+	auto Plane::fromPoints(const math::vec3 p1, const math::vec3 p2, const math::vec3 p3) -> Plane {
 		const auto e3 = p2 - p1;
 		const auto e1 = p3 - p2;
 		auto normal = glm::normalize(glm::cross(e3, e1));
@@ -71,7 +61,7 @@ namespace fggl::math::phs3d {
 		return {normal, d};
 	}
 
-	static math::vec3 bestFitNormal(const std::vector<math::vec3> &points) {
+	static auto bestFitNormal(const std::vector<math::vec3> &points) -> math::vec3 {
 		assert(!points.empty());
 
 		math::vec3 result;
@@ -90,9 +80,9 @@ namespace fggl::math::phs3d {
 		return glm::normalize(result);
 	};
 
-	static float bestFitD(const std::vector<math::vec3> &points, glm::vec3 normal) {
+	static auto bestFitD(const std::vector<math::vec3> &points, glm::vec3 normal) -> float {
 		math::vec3 sum;
-		for (auto &point : points) {
+		for (const auto &point : points) {
 			sum += point;
 		}
 		sum *= 1.0F / points.size();
@@ -108,7 +98,7 @@ namespace fggl::math::phs3d {
 		const char b;
 	};
 
-	static bary_axis baryCalcAxis(const math::vec3 &normal) {
+	static auto baryCalcAxis(const math::vec3 &normal) -> bary_axis {
 		if ((fabs(normal.x) >= fabs(normal.y)) && (fabs(normal.x) >= fabs(normal.z))) {
 			// discard x
 			return {Y, Z};
@@ -121,7 +111,7 @@ namespace fggl::math::phs3d {
 		}
 	}
 
-	bool Triangle::CartToBarycentric(const math::vec3 &cart, Barycentric &outVal) {
+	auto Triangle::CartToBarycentric(const math::vec3 &cart, Barycentric &outVal) -> bool {
 		// everything is const because I'm paying the compiler is smarter than me...
 
 		const auto d1 = v[1] - v[0];
@@ -144,19 +134,19 @@ namespace fggl::math::phs3d {
 		const float v4 = cart[ax.b] - v[2][ax.b];
 
 		const float denom = v1 * u2 - v2 * u1;
-		if (denom == 0.0f) {
+		if (denom == 0.0F) {
 			return false;
 		}
 
 		// finally, we can work it out
-		const float oneOverDenom = 1.0f / denom;
+		const float oneOverDenom = 1.0F / denom;
 		outVal.b[0] = (v4 * u2 - v2 * u4) * oneOverDenom;
 		outVal.b[1] = (v1 * u3 - v3 * u1) * oneOverDenom;
-		outVal.b[2] = 1.0f - outVal.b[0] - outVal.b[1];
+		outVal.b[2] = 1.0F - outVal.b[0] - outVal.b[1];
 		return true;
 	}
 
-	bool Triangle::CartToBarycentric2(const math::vec3 &cart, Barycentric &outVal) {
+	auto Triangle::CartToBarycentric2(const math::vec3 &cart, Barycentric &outVal) -> bool {
 		const auto e1 = v[2] - v[1];
 		const auto e2 = v[0] - v[2];
 		const auto e3 = v[1] - v[0];
@@ -167,7 +157,7 @@ namespace fggl::math::phs3d {
 
 		const auto normal = glm::normalize(glm::cross(e1, e2));
 		const auto denom = glm::dot(glm::cross(e1, e2), normal);
-		assert(denom != 0.0f);
+		assert(denom != 0.0F);
 
 		outVal.b[0] = glm::dot(glm::cross(e1, d3), normal) / denom;
 		outVal.b[1] = glm::dot(glm::cross(e2, d1), normal) / denom;

fggl/math/triangulation.cpp

@@ -13,7 +13,6 @@
  */
 
 #include "fggl/math/triangulation.hpp"
-#include <iostream>
 
 namespace fggl::math {
 
@@ -29,7 +28,7 @@ namespace fggl::math {
 
 		// deal with the indices
 		const auto nTris = polygon.size() - 2;
-		for (auto i = 0u; i < nTris; i++) {
+		for (auto i = 0U; i < nTris; i++) {
 			mesh.add_index(firstIdx);
 			mesh.add_index(prevIdx);
 

fggl/phys/null.cpp

@@ -20,7 +20,7 @@
 
 namespace fggl::phys {
 
-	bool NullPhysics::factory(modules::ModuleService serviceName, modules::Services &serviceManager) {
+	auto NullPhysics::factory(modules::ServiceName serviceName, modules::Services &serviceManager) -> bool {
 		if (serviceName == phys::PhysicsProvider::service) {
 			serviceManager.bind<phys::PhysicsProvider, NullPhysicsProvider>();
 			return true;

fggl/platform/linux/paths.cpp

@@ -25,34 +25,36 @@
 
 namespace fggl::platform {
 
-	inline static std::filesystem::path get_user_path(const char *env, const char *fallback) {
-		const char *path = std::getenv(env);
-		if (path != nullptr) {
-			return {path};
+	namespace {
+		inline auto get_user_path(const char *env, const char *fallback) -> std::filesystem::path {
+			const char *path = std::getenv(env);
+			if (path != nullptr) {
+				return {path};
+			}
+			return {fallback};
 		}
-		return {fallback};
-	}
 
-	static std::vector<std::filesystem::path> get_path_list(const char *env, const char *folderName) {
-		const char *pathList = std::getenv(env);
-		std::vector<std::filesystem::path> paths;
-		if (pathList) {
-			std::string pathListStr(pathList);
-			std::string::size_type pos = 0;
-			while (pos < pathListStr.size()) {
-				std::string::size_type nextPos = pathListStr.find(':', pos);
-				if (nextPos == std::string::npos) {
-					nextPos = pathListStr.size();
+		auto get_path_list(const char *env, const char *folderName) -> std::vector<std::filesystem::path> {
+			const char *pathList = std::getenv(env);
+			std::vector<std::filesystem::path> paths;
+			if (pathList) {
+				std::string pathListStr(pathList);
+				std::string::size_type pos = 0;
+				while (pos < pathListStr.size()) {
+					std::string::size_type nextPos = pathListStr.find(':', pos);
+					if (nextPos == std::string::npos) {
+						nextPos = pathListStr.size();
+					}
+					std::string path = pathListStr.substr(pos, nextPos - pos);
+					paths.push_back(std::filesystem::path(path) / folderName);
+					pos = nextPos + 1;
 				}
-				std::string path = pathListStr.substr(pos, nextPos - pos);
-				paths.push_back(std::filesystem::path(path) / folderName);
-				pos = nextPos + 1;
 			}
+			return paths;
 		}
-		return paths;
 	}
 
-	EnginePaths calc_engine_paths(const char *base) {
+	auto calc_engine_paths(const char *base) -> EnginePaths {
 		auto dataDirs = get_path_list(ENV_DATA_DIRS, base);
 		if (dataDirs.empty()) {
 			for (const auto &defaultDir : DEFAULT_DATA_DIRS) {
@@ -76,7 +78,7 @@ namespace fggl::platform {
 		};
 	}
 
-	std::filesystem::path locate_data(const EnginePaths &paths, const std::filesystem::path &relPath) {
+	auto locate_data(const EnginePaths &paths, const std::filesystem::path &relPath) -> std::filesystem::path {
 		auto userPath = paths.userData / relPath;
 		if (std::filesystem::exists(userPath)) {
 			return userPath;
@@ -98,11 +100,11 @@ namespace fggl::platform {
 			return debugPath;
 		}
 
-		// if the file existed, it shoudl exist in the user space
+		// if the file existed, it should exist in the user space
 		return userPath;
 	}
 
-	std::filesystem::path locate_config(const EnginePaths &paths, const std::filesystem::path &relPath) {
+	auto locate_config(const EnginePaths &paths, const std::filesystem::path &relPath) -> std::filesystem::path {
 		auto userPath = paths.userConfig / relPath;
 		if (std::filesystem::exists(userPath)) {
 			return userPath;
@@ -120,7 +122,7 @@ namespace fggl::platform {
 		return userPath;
 	}
 
-	std::filesystem::path locate_cache(const EnginePaths &paths, const std::filesystem::path &relPath) {
+	auto locate_cache(const EnginePaths &paths, const std::filesystem::path &relPath) -> std::filesystem::path {
 		auto userPath = paths.userCache / relPath;
 		if (std::filesystem::exists(userPath)) {
 			return userPath;

fggl/scenes/game.cpp

@@ -24,6 +24,20 @@
 
 namespace fggl::scenes {
 
+	GameBase::GameBase(fggl::App& app) : AppState(app) {
+		m_input = app.service<input::Input>();
+	}
+
+	void GameBase::update(float /*dt*/) {
+		// detect the user quitting
+		if (m_input != nullptr) {
+			bool escapePressed = m_input->keyboard.pressed(glfwGetKeyScancode(GLFW_KEY_ESCAPE));
+			if (escapePressed) {
+				m_owner.change_state(m_previous);
+			}
+		}
+	}
+
 	Game::Game(fggl::App &app) : AppState(app) {
 		m_input = app.service<input::Input>();
 	}
@@ -45,7 +59,7 @@ namespace fggl::scenes {
 		m_world.reset();
 	}
 
-	void Game::update() {
+	void Game::update(float /*dt*/) {
 		assert(m_world && "called game update, but there was no world - was activate called?");
 
 		if (m_input != nullptr) {
@@ -53,18 +67,23 @@ namespace fggl::scenes {
 			if (escapePressed) {
 				m_owner.change_state(m_previous);
 			}
+
+			if ( m_input->keyboard.pressed(glfwGetKeyScancode(GLFW_KEY_F2)) ) {
+				m_debug = !m_debug;
+			}
 		}
 
 		if (m_phys != nullptr) {
 			m_phys->step();
 		}
 
+		// debug render toggle
 		//m_world->reapEntities();
 	}
 
 	void Game::render(fggl::gfx::Graphics &gfx) {
 		if (m_world != nullptr) {
-			gfx.drawScene(*m_world);
+			gfx.drawScene(*m_world, m_debug);
 		}
 	}