fggl/assets/types.cpp

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

fggl/audio/CMakeLists.txt

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

fggl/audio/fallback/CMakeLists.txt

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

fggl/audio/fallback/audio.cpp

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

fggl/audio/openal/CMakeLists.txt

+find_package(OpenAL CONFIG)
+if (NOT OpenAL_FOUND)
+    # ubuntu/debian openal-soft package doesn't seem to have a config file
+    # it's probably falling back to findOpenAL.cmake
+    message(STATUS "OpenAL-Soft config missing - falling back")
+    find_package(OpenAL REQUIRED)
+    target_link_libraries(fggl PUBLIC ${OPENAL_LIBRARY})
+    target_include_directories(fggl PUBLIC ${OPENAL_INCLUDE_DIR})
+else ()
+    # we're using target-based
+    message(STATUS "Using OpenAL-Soft config file")
+    if (TARGET OpenAL::OpenAL)
+        target_link_libraries(fggl PUBLIC OpenAL::OpenAL)
+    else ()
+        target_link_libraries(fggl PUBLIC OpenAL)
+    endif ()
+
+endif ()
+
+target_sources(fggl
+    PRIVATE
+        audio.cpp
+        module.cpp
+)
+

fggl/audio/openal/audio.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "fggl/audio/openal/audio.hpp"
+#include "fggl/assets/types.hpp"
+#include "fggl/assets/manager.hpp"
+
+#include "../../stb/stb_vorbis.h"
+
+namespace fggl::audio::openal {
+
+	auto load_vorbis(assets::Loader* /*loader*/, const assets::AssetID &guid, const assets::LoaderContext &data, void* userPtr) -> assets::AssetRefRaw {
+		auto *manager = static_cast<assets::AssetManager*>(userPtr);
+		auto filePath = data.assetPath;
+
+		// vorbis
+		auto* clip = new AudioClipShort();
+		clip->sampleCount = stb_vorbis_decode_filename( filePath.c_str(), &clip->channels, &clip->sampleRate, &clip->data);
+		debug::info("clip loaded: channels={}, sampleRate={}, sampleCount={}", clip->channels, clip->sampleRate, clip->sampleCount);
+
+		if ( clip->sampleCount == -1 ) {
+			return nullptr;
+		}
+
+		manager->set(guid, clip);
+		return nullptr;
+	}
+
+	auto load_vorbis_short(std::filesystem::path path, assets::MemoryBlock& /*block*/) -> bool {
+		// vorbis
+		auto* clip = new AudioClipShort();
+		clip->sampleCount = stb_vorbis_decode_filename( path.c_str(), &clip->channels, &clip->sampleRate, &clip->data);
+		debug::info("clip loaded: channels={}, sampleRate={}, sampleCount={}", clip->channels, clip->sampleRate, clip->sampleCount);
+
+		return clip->sampleCount != 1;
+	}
+
+	auto check_vorbis(const std::filesystem::path& path ) -> assets::AssetTypeID {
+		if ( path.extension() != ".ogg" ) {
+			return assets::INVALID_ASSET_TYPE;
+		}
+
+		auto* clip = new AudioClipShort();
+		clip->sampleCount = stb_vorbis_decode_filename( path.c_str(), &clip->channels, &clip->sampleRate, &clip->data);
+
+		if ( clip->sampleCount == -1 ) {
+			return assets::INVALID_ASSET_TYPE;
+		}
+
+		delete clip;
+		return ASSET_CLIP_SHORT;
+	}
+
+	void AudioSource::play(const AudioClipShort &clip, bool looping) {
+		check_error("pre play");
+
+		AudioType format = clip.channels == 1 ? AudioType::MONO_16 : AudioType::STEREO_16;
+		m_splat.setData(format, clip.data, clip.size(), clip.sampleRate);
+		check_error("saving to buffer");
+
+		play(m_splat, looping);
+		check_error("post play");
+	}
+
+	void AudioServiceOAL::play(const std::string &filename, bool looping) {
+		debug::info("beginning audio: {}", filename);
+
+		// load audio clip into temp storage
+		auto assetRef = assets::make_asset_id_rt("core", filename);
+		auto* clip = m_assets->get<AudioClipShort>(assetRef);
+		if ( clip == nullptr ) {
+			debug::warning("audio asset requested, but not loaded: {}", filename);
+			return;
+		}
+
+		play(*clip, looping);
+		debug::info("played audio: {}", filename);
+	}
+
+	void AudioServiceOAL::play(const AudioClipShort &clip, bool looping) {
+		if ( m_defaultSource == nullptr ){
+			return;
+		}
+
+		// play the audio on the default (non-positioned) source
+		m_defaultSource->play(clip, looping);
+	}
+
+	void AudioServiceOAL::release() {
+		m_defaultSource = nullptr;
+
+		alcMakeContextCurrent(nullptr);
+		alcDestroyContext(m_context);
+		alcCloseDevice(m_device);
+		m_context = nullptr;
+		m_device = nullptr;
+	}
+
+}
\ No newline at end of file

fggl/audio/openal/module.cpp

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

fggl/audio/types.cpp

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

fggl/data/assimp/CMakeLists.txt

+find_package(assimp CONFIG)
+if (MSVC)
+    target_link_libraries(${PROJECT_NAME} PUBLIC assimp::assimp)
+else ()
+    target_link_libraries(${PROJECT_NAME} PUBLIC assimp)
+endif ()
+
+target_sources(fggl
+        PRIVATE
+            module.cpp
+            image.cpp
+)
\ No newline at end of file

fggl/data/assimp/image.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 22/10/22.
+//
+
+#define STB_IMAGE_IMPLEMENTATION
+#include "../../stb/stb_image.h"

fggl/data/assimp/module.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 18/10/22.
+//
+
+#include "fggl/data/assimp/module.hpp"
+#include "fggl/debug/logging.hpp"
+#include "fggl/assets/manager.hpp"
+#include "fggl/mesh/mesh.hpp"
+
+#include "../../stb/stb_image.h"
+#include <assimp/Importer.hpp>
+#include <assimp/scene.h>
+#include <assimp/postprocess.h>
+
+#include <filesystem>
+
+namespace fggl::data::models {
+
+	constexpr auto convert(aiVector3D& vec) -> math::vec3 {
+		return {vec.x, vec.y, vec.z};
+	}
+
+	constexpr auto convert2(aiVector2D& vec) -> math::vec2 {
+		return {vec.x, vec.y};
+	}
+
+	constexpr auto convert2(aiVector3D& vec) -> math::vec2 {
+		return {vec.x, vec.y};
+	}
+
+	constexpr auto convert(aiColor3D& col) -> math::vec3 {
+		return {col.r, col.g, col.b};
+	}
+
+	static void process_mesh(mesh::Mesh3D& mesh, aiMesh* assimpMesh, const aiScene* scene, const std::vector<assets::AssetID>& assets) {
+		assert( assimpMesh != nullptr );
+		assert( scene != nullptr );
+
+		// process vertex data
+		for ( auto idx = 0U; idx < assimpMesh->mNumVertices; ++idx ) {
+			mesh::Vertex3D vertex{
+				.position = convert(assimpMesh->mVertices[idx]),
+				.normal = convert(assimpMesh->mNormals[idx])
+			};
+
+			if ( assimpMesh->mTextureCoords[0] != nullptr ) {
+				vertex.texPos = convert2( assimpMesh->mTextureCoords[0][idx] );
+			}
+
+			mesh.data.push_back(vertex);
+		}
+
+		// process faces (indexes)
+		for ( auto idx = 0U; idx < assimpMesh->mNumFaces; ++idx ) {
+			auto face = assimpMesh->mFaces[idx];
+			assert( face.mNumIndices == 3);
+
+			for ( auto vid = 0U; vid < face.mNumIndices; ++vid) {
+				mesh.indices.push_back( face.mIndices[vid] );
+			}
+		}
+
+		// process material
+		if ( assimpMesh->mMaterialIndex >= 0) {
+			mesh.material = assets[assimpMesh->mMaterialIndex];
+		}
+	}
+
+	static void process_node(mesh::MultiMesh3D& mesh, aiNode* node, const aiScene* scene, const std::vector<assets::AssetID>& assets) {
+		for ( auto idx = 0U; idx < node->mNumMeshes; ++idx ) {
+			auto *assimpMesh = scene->mMeshes[ node->mMeshes[idx] ];
+
+			// process assimp submesh
+			mesh::Mesh3D meshData;
+			process_mesh(meshData, assimpMesh, scene, assets);
+
+			mesh.meshes.push_back(meshData);
+		}
+
+		for ( auto idx = 0U; idx < node->mNumChildren; ++idx) {
+			process_node(mesh, node->mChildren[idx], scene, assets);
+		}
+	}
+
+	struct AssetStuff {
+		assets::Loader* loader;
+		assets::AssetManager* manager;
+
+		inline void checkLoaded(assets::AssetID asset) {
+			if (!manager->has(asset)) {
+				debug::info("triggered JIT upload for {}, use the chain loader", asset);
+				loader->load(asset);
+			}
+		}
+
+		inline auto isLoaded(assets::AssetID asset) const -> bool {
+			return manager->has(asset);
+		}
+
+		inline void set(assets::AssetID asset, auto* assetPtr) {
+			assert(assetPtr != nullptr);
+			manager->set(asset, assetPtr);
+		}
+
+	};
+
+	static auto process_texture( const aiTextureType type, const aiMaterial* assimpMat, AssetStuff& stuff, const assets::LoaderContext& config) -> std::vector<assets::AssetID> {
+		std::vector<assets::AssetID> matRefs;
+		matRefs.reserve( assimpMat->GetTextureCount(type) );
+
+		// iterate through things
+		for ( auto i = 0U ; i < assimpMat->GetTextureCount(type); ++i ) {
+			aiString texName;
+			assimpMat->GetTexture( type, i, &texName );
+			const auto texID = config.makeRef(texName.C_Str());
+
+			// trigger asset loading
+			stuff.checkLoaded( texID );
+
+			// assets
+			matRefs.push_back( texID );
+		}
+		return matRefs;
+	}
+
+	static auto process_mat_colour(const aiMaterial* mat, const char* name, int a1, int a2) -> math::vec3 {
+		aiColor3D col{0.0F, 0.0F, 0.0F};
+		mat->Get( name, a1, a2, col );
+		debug::info("read colour: {}, {}, {}, {}", name, col.r, col.g, col.b);
+
+		return convert(col);
+	}
+
+	static void process_material(const assets::AssetID& guid, aiMaterial* assimpMat, AssetStuff stuff, const assets::LoaderContext& config) {
+		auto* material = new mesh::Material();
+
+		debug::info("processing: {}", guid);
+
+		// for each material, calculate what it's name would be then request it
+		material->diffuseTextures = process_texture( aiTextureType_DIFFUSE, assimpMat, stuff, config );
+		material->normalTextures = process_texture( aiTextureType_NORMALS, assimpMat, stuff, config );
+		material->specularTextures = process_texture( aiTextureType_SPECULAR, assimpMat, stuff, config );
+
+		material->ambient = process_mat_colour( assimpMat, AI_MATKEY_COLOR_AMBIENT );
+		material->diffuse = process_mat_colour( assimpMat, AI_MATKEY_COLOR_DIFFUSE );
+		material->specular = process_mat_colour( assimpMat, AI_MATKEY_COLOR_SPECULAR );
+
+		stuff.set( guid, material );
+	}
+
+	auto load_assimp_model(assets::Loader* loader, const assets::AssetID& guid, const assets::LoaderContext& data, void* userPtr) -> assets::AssetRefRaw {
+//		auto *filePath = std::get<assets::AssetPath *>(data);
+		auto filePath = data.assetPath;
+
+		AssetStuff stuff {
+			.loader = loader,
+			.manager = (assets::AssetManager*)userPtr
+		};
+
+		if ( stuff.isLoaded(guid) ) {
+			// asset in DB, what do you want me to do?
+			return nullptr;
+		}
+
+		// assimp stuff
+		Assimp::Importer importer;
+
+		// import the scene from disk
+		const aiScene *scene = importer.ReadFile(filePath.c_str(), aiProcessPreset_TargetRealtime_Fast | aiProcess_FlipUVs);
+		if ( scene == nullptr || (scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE) != 0 || scene->mRootNode == nullptr ) {
+			debug::warning("unable to load required model asset");
+			return nullptr;
+		}
+
+		debug::debug("Processing assimp mesh, {} meshes, {} materials, {} textures", scene->mNumMeshes, scene->mNumMaterials, scene->mNumTextures);
+
+		// calculate the mapping from material => asset mappings
+		auto parentRel = std::filesystem::relative( filePath.parent_path(), filePath.parent_path().parent_path() );
+		std::vector<assets::AssetID> matAssets;
+		for ( auto idx = 0U; idx < scene->mNumMaterials; ++idx ) {
+			aiString matName = scene->mMaterials[idx]->GetName();
+			auto matRel = parentRel / matName.C_Str();
+			matAssets.push_back( assets::make_asset_id_rt( data.pack, matRel ) );
+		}
+
+		// now we can try importing the mesh data
+		auto* packedMesh = new mesh::MultiMesh3D();
+		process_node( *packedMesh, scene->mRootNode, scene, matAssets);
+
+		// now we try importing the materials
+		for (auto idx = 0U; idx < scene->mNumMaterials; ++idx ) {
+			process_material( matAssets[idx], scene->mMaterials[idx], stuff, data );
+		}
+
+		// FIXME asset loading system needs rework, this is bonkers.
+		stuff.set(guid, packedMesh);
+		return nullptr;
+	}
+
+	auto load_assimp_texture(assets::Loader* /*loader*/, const assets::AssetID& guid, const assets::LoaderContext& data, void* userPtr) -> assets::AssetRefRaw {
+		auto* manager = (assets::AssetManager*)userPtr;
+
+		if ( manager->has(guid) ) {
+			// already loaded.
+			return nullptr;
+		}
+
+		auto filePath = data.assetPath;
+		stbi_set_flip_vertically_on_load(1);
+
+		//load the texture data into memory
+		auto* image = new data::Texture2D();
+		image->data = stbi_load(filePath.c_str(), &image->size.x, &image->size.y, &image->channels, 3);
+
+		if ( image->data == nullptr ) {
+			debug::warning("error reading texture: {}", stbi_failure_reason());
+			return nullptr;
+		} else {
+			debug::info("image reports it loaded correctly, adding {} to database", guid);
+			manager->set(guid, image );
+		}
+
+		return nullptr;
+	}
+
+	auto load_tex_stb(const std::filesystem::path& filePath, assets::MemoryBlock& block) -> bool {
+		stbi_set_flip_vertically_on_load(1);
+
+		//load the texture data into memory
+		auto* image = new data::Texture2D();
+		image->data = stbi_load(filePath.c_str(), &image->size.x, &image->size.y, &image->channels, 3);
+
+		if ( image->data == nullptr ) {
+			debug::warning("error reading texture: {}", stbi_failure_reason());
+			delete image;
+			return false;
+		} else {
+			// TODO pass metadata to loader in a sensible way
+			block.size = image->channels * image->size.x * image->size.y;
+			block.data = (std::byte*)image->data;
+			delete image;
+			return true;
+		}
+	}
+
+	auto is_tex_stb(const std::filesystem::path& filePath) -> assets::AssetTypeID {
+		// detect jpgs
+		if ( filePath.extension() == ".jpg" || filePath.extension() == ".jpeg" ) {
+			return TEXTURE_RGBA;
+		}
+
+		// detect png
+		if ( filePath.extension() == ".png" ) {
+			return TEXTURE_RGBA;
+		}
+
+		return assets::INVALID_ASSET_TYPE;
+	}
+
+	auto is_model_assimp(const std::filesystem::path& filePath) -> assets::AssetTypeID {
+		auto ext = filePath.extension().string();
+		std::transform(ext.begin(), ext.end(), ext.begin(), ::tolower);
+
+		if ( ext == ".obj" || ext == ".fbx" ) {
+			return MODEL_MULTI3D;
+		}
+
+		return assets::INVALID_ASSET_TYPE;
+	}
+
+	auto extract_requirements(const std::string& packName, const std::filesystem::path& packRoot, assets::ResourceRecord& rr) -> bool {
+		Assimp::Importer importer;
+		const aiScene *scene = importer.ReadFile( rr.m_path, aiProcess_Triangulate | aiProcess_FlipUVs);
+		if ( !scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode ) {
+			debug::warning("unable to load required model asset");
+			return false;
+		}
+
+		// we want to find out about dependencies
+		auto baseDir = std::filesystem::relative( rr.m_path.parent_path(), packRoot );
+		for ( auto idx = 0U; idx < scene->mNumMaterials; ++idx) {
+			const auto *mat = scene->mMaterials[idx];
+
+			std::array matTypes { aiTextureType_DIFFUSE, aiTextureType_NORMALS, aiTextureType_SPECULAR };
+			for ( auto& matType : matTypes ) {
+				const auto diffCount = mat->GetTextureCount(matType);
+				for (auto idx2 = 0U; idx2 < diffCount; ++idx2) {
+					aiString texName;
+					mat->GetTexture(matType, idx2, &texName);
+
+					auto assetPath = baseDir / texName.C_Str();
+					auto assetRequired = assets::make_asset_id_rt(packName, assetPath);
+					rr.m_requires.push_back(assetRequired);
+				}
+			}
+
+		}
+
+		return true;
+	}
+
+	auto AssimpModule::factory(modules::ServiceName service, modules::Services &serviceManager) -> bool {
+		if ( service == MODEL_PROVIDER ) {
+			auto* assetLoader = serviceManager.get<assets::Loader>();
+			assetLoader->setFactory( MODEL_MULTI3D, load_assimp_model, assets::LoadType::PATH );
+			assetLoader->setFactory( TEXTURE_RGBA, load_assimp_texture, assets::LoadType::PATH );
+
+			// new loading system
+			auto* checkin = serviceManager.get<assets::CheckinAdapted>();
+			checkin->setLoader( MIME_JPG, load_tex_stb, is_tex_stb );
+			checkin->setLoader( MIME_PNG, load_tex_stb, is_tex_stb );
+
+			checkin->setLoader( MIME_OBJ, assets::NEEDS_CHECKIN, is_model_assimp );
+			checkin->setLoader( MIME_FBX, assets::NEEDS_CHECKIN, is_model_assimp );
+			checkin->setProcessor( MIME_OBJ, extract_requirements);
+			checkin->setProcessor( MIME_FBX, extract_requirements );
+			return false;
+		}
+		return false;
+	}
+
+} // namespace fggl::data

fggl/data/heightmap.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//
+// Created by webpigeon on 20/11/2021.
+//
+
+#include <fggl/data/model.hpp>
+#include <fggl/data/heightmap.hpp>
+
+// adapted from  https://www.mbsoftworks.sk/tutorials/opengl4/016-heightmap-pt1-random-terrain/
+
+namespace fggl::data {
+
+	void gridVertexNormals(data::Vertex *locations) {
+		const int sizeX = data::heightMaxX;
+		const int sizeY = data::heightMaxZ;
+		const int gridOffset = sizeX * sizeY;
+
+		// calculate normals for each triangle
+		auto *triNormals = new math::vec3[sizeX * sizeY * 2];
+		for (int i = 0; i < sizeX - 1; i++) {
+			for (int j = 0; j < sizeY - 1; j++) {
+				// calculate vertex
+				const auto &a = locations[i * sizeY + j].posititon;
+				const auto &b = locations[(i + 1) * sizeY + j].posititon;
+				const auto &c = locations[i * sizeY + (j + 1)].posititon;
+				const auto &d = locations[(i + 1) * sizeY + (j + 1)].posititon;
+
+				const auto normalA = glm::cross(b - a, a - d);
+				const auto normalB = glm::cross(d - c, c - b);
+
+				// store the normals
+				int idx1 = idx(i, j, sizeY);
+				int idx2 = idx1 + gridOffset;
+				triNormals[idx1] = glm::normalize(normalA);
+				triNormals[idx2] = glm::normalize(normalB);
+			}
+		}
+
+		// calculate normals for each vertex
+		for (int i = 0; i < sizeX; i++) {
+			for (int j = 0; j < sizeY; j++) {
+				const auto firstRow = (i == 0);
+				const auto firstCol = (j == 0);
+				const auto lastRow = (i == sizeX - 1);
+				const auto lastCol = (i == sizeY - 1);
+
+				auto finalNormal = glm::vec3(0.0F, 0.0F, 0.0F);
+
+				if (!firstRow && !firstCol) {
+					finalNormal += triNormals[idx(i - 1, j - 1, sizeY)];
+				}
+
+				if (!lastRow && !lastCol) {
+					finalNormal += triNormals[idx(i, j, sizeY)];
+				}
+
+				if (!firstRow && lastCol) {
+					finalNormal += triNormals[idx(i - 1, j, sizeY)];
+					finalNormal += triNormals[idx(i - 1, j, sizeY) + gridOffset];
+				}
+
+				if (!lastRow && !firstCol) {
+					finalNormal += triNormals[idx(i, j - 1, sizeY)];
+					finalNormal += triNormals[idx(i, j - 1, sizeY) + gridOffset];
+				}
+
+				locations[idx(i, j, sizeY)].normal =
+					glm::normalize(finalNormal) * -1.0F; //FIXME the normals seem wrong.
+			}
+		}
+		delete[] triNormals;
+	}
+
+	void generateHeightMesh(const data::HeightMap &heights, data::Mesh &mesh) {
+
+		// step 1: convert height data into vertex locations
+		const int numElms = data::heightMaxX * data::heightMaxZ;
+		std::array<data::Vertex, numElms> locations{};
+
+		// iterate the
+		for (std::size_t x = 0; x < data::heightMaxX; x++) {
+			for (std::size_t z = 0; z < data::heightMaxZ; z++) {
+				float level = heights.getValue(x, z);
+				auto xPos = float(x);
+				auto zPos = float(z);
+
+				std::size_t idx1 = idx(x, z, data::heightMaxZ);
+				locations[idx1].colour = fggl::math::vec3(1.0F, 1.0F, 1.0F);
+				locations[idx1].posititon = math::vec3(-0.5F + xPos, level, -0.5F - zPos);
+			}
+		}
+		gridVertexNormals(locations.data());
+
+		mesh.restartVertex = data::heightMaxZ * data::heightMaxX;
+
+		// populate mesh
+		for (auto i = 0; i < numElms; i++) {
+			mesh.pushVertex(locations[i]);
+		}
+
+		for (std::size_t x = 0; x < data::heightMaxX - 1; x++) {
+			for (std::size_t z = 0; z < data::heightMaxZ; z++) {
+				for (int k = 0; k < 2; k++) {
+					auto idx = (x + k) * data::heightMaxZ + z;
+					mesh.pushIndex(idx);
+				}
+			}
+			mesh.pushIndex(mesh.restartVertex);
+		}
+
+	}
+
+}

fggl/data/model.cpp

+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
 #include <fggl/data/model.hpp>
 
 #include <map>
 #include <stdexcept>
+#include <algorithm>
 
 using namespace fggl::data;
 
-Mesh::Mesh() : m_verts(0), m_index(0) {
+Mesh::Mesh() : restartVertex(Mesh::INVALID_IDX), m_verts(0), m_index(0) {
 }
 
 void Mesh::pushIndex(unsigned int idx) {
-	assert( idx < m_verts.size() );
+	assert(idx < m_verts.size() || idx == this->restartVertex);
 	m_index.push_back(idx);
 }
 
-unsigned int Mesh::pushVertex(Vertex vert) {
-	unsigned int idx = m_verts.size();
-	m_verts.push_back( vert );
+auto Mesh::pushVertex(Vertex vert) -> Mesh::IndexType {
+	auto idx = m_verts.size();
+	m_verts.push_back(vert);
 	return idx;
 }
 
-int Mesh::indexOf(Vertex vert) {
-	int i = 0;
-	for ( auto& vert_v : m_verts ) {
-		if ( vert.posititon == vert_v.posititon ) {
-			return i;
-		}
-		++i;
+auto Mesh::indexOf(Vertex term) -> Mesh::IndexType {
+	auto itr = std::find(m_verts.begin(), m_verts.end(), term);
+	if (itr == m_verts.end()) {
+		return INVALID_IDX;
 	}
-	return -1;
+	return itr - m_verts.begin();
 }
 
 void Mesh::removeDups() {
 	// lookups to make detecting duplicates easier
 	std::map<Vertex, unsigned int> mapping;
-	unsigned int nextID = 0;
 
 	// new data
-	std::vector< Vertex > newVerts;
-	std::vector< unsigned int > newIndexes;
-	newIndexes.reserve( m_index.size() ); // newIndex will be same size as oldIndex
+	std::vector<Vertex> newVerts;
+	std::vector<unsigned int> newIndexes;
+	newIndexes.reserve(m_index.size()); // newIndex will be same size as oldIndex
 
-	for ( auto& idx : m_index ) {
-		auto& vertex = m_verts[idx];
+	unsigned int nextID = 0;
+	for (auto &idx : m_index) {
+		auto &vertex = m_verts[idx];
 		auto newID = nextID;
+
+		// if the vertex is known, use the existing ID, else allocate a new ID
 		try {
-			newID = mapping.at( vertex );
-		} catch ( std::out_of_range& e ){
-			mapping[ vertex ] = newID;
-			newVerts.push_back( vertex );
+			newID = mapping.at(vertex);
+		} catch (std::out_of_range &e) {
+			mapping[vertex] = newID;
+			newVerts.push_back(vertex);
 			++nextID;
 		}
-		newIndexes.push_back( newID );
-	}
-
-	// FIXME must be faster way to do this...
-	m_verts.clear();
-	m_index.clear();
-
-	for ( auto& vert : newVerts ) {
-		m_verts.push_back( vert );
-	}
-
-	for ( auto& idx : newIndexes ) {
-		m_index.push_back( idx );
+		newIndexes.push_back(newID);
 	}
 
-	// ensure we're not wasting space
-	m_verts.shrink_to_fit();
-	m_index.shrink_to_fit();
-}
-
-Model::Model() {
-}
-
-Model::~Model() {
+	// assign the replacement lists
+	m_verts = newVerts;
+	m_index = newIndexes;
 }
 

fggl/data/module.cpp

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

fggl/data/procedural.cpp

-
-#include "procedural.hpp"
-#include "model.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/>.
+ */
+
+#include <cstddef>
+#include <fggl/data/procedural.hpp>
+#include <fggl/data/model.hpp>
 
 #include <glm/ext/matrix_transform.hpp>
-#include <glm/gtc/quaternion.hpp>
-#include <iostream>
+
+#include <array>
 
 #include <glm/geometric.hpp>
+#include "fggl/mesh/mesh.hpp"
 
 using namespace fggl::data;
 
 // from https://www.khronos.org/opengl/wiki/Calculating_a_Surface_Normal
-static glm::vec3 calcSurfaceNormal(glm::vec3 a, glm::vec3 b, glm::vec3 c) {
-	glm::vec3 u = b - a;
-	glm::vec3 v = c - a;
-	return glm::normalize( glm::cross( u, v ) );
+static auto calcSurfaceNormal(glm::vec3 vert1, glm::vec3 vert2, glm::vec3 vert3) -> glm::vec3 {
+	const glm::vec3 edge1 = vert2 - vert1;
+	const glm::vec3 edge2 = vert3 - vert1;
+	return glm::normalize(glm::cross(edge1, edge2));
 }
 
-static void computeNormals( fggl::data::Mesh& mesh, const int* idx, const int* colIdx, int nPoints) {
+static void computeNormalsDirect(fggl::mesh::Mesh3D &mesh, const fggl::data::Mesh::IndexType *colIdx, int nPoints) {
 
 	// we're assuming all the normals are zero...
-	// FIXME this will touch any vertex that appears in idx more than once mutliple times...
-	for ( int i=0; i<nPoints; i++ ) {
-		auto& vertex = mesh.vertex( colIdx[ idx[i] ] );
-		vertex.normal = glm::vec3(0.0f);
+	for (int i = 0; i < nPoints; i++) {
+		auto &vertex = mesh.data[colIdx[i]];
+		vertex.normal = glm::vec3(0.0F);
+	}
+
+	// We're assuming each vertex appears only once (because we're not indexed)
+	for (int i = 0; i < nPoints; i += 3) {
+		auto &v1 = mesh.data[colIdx[i]];
+		auto &v2 = mesh.data[colIdx[i + 1]];
+		auto &v3 = mesh.data[colIdx[i + 2]];
+
+		const glm::vec3 normal = glm::normalize(calcSurfaceNormal(v1.position, v2.position, v3.position));
+		v1.normal = normal;
+		v2.normal = normal;
+		v3.normal = normal;
 	}
+}
 
-	// each vertex normal should be the sum of the triangles it's part of.
-	for (int i=0; i<nPoints; i += 3) {
-		auto& v1 = mesh.vertex( colIdx[ idx[i] ] );
-		auto& v2 = mesh.vertex( colIdx[ idx[i + 1] ] );
-		auto& v3 = mesh.vertex( colIdx[ idx[i + 2] ] );
+static void compute_normals(fggl::mesh::Mesh3D &mesh,
+							const std::vector<Mesh::IndexType> &idxList, // source index
+							const std::vector<Mesh::IndexType> &idxMapping // source-to-mesh lookup
+) {
 
-		const glm::vec3 normal = calcSurfaceNormal( v1.posititon, v2.posititon, v3.posititon );
-//		v2.normal += calcSurfaceNormal( v2.posititon, v3.posititon, v1.posititon );
-//		v3.normal += calcSurfaceNormal( v3.posititon, v1.posititon, v2.posititon );
-		v1.normal += normal;
-		v2.normal += normal;
-		v3.normal += normal;
+	// clear the normals, so the summation below works correctly
+	for (auto vertexIndex : idxMapping) {
+		auto &vertex = mesh.data[vertexIndex];
+		vertex.normal = ILLEGAL_NORMAL;
+	}
 
+	// we need to calculate the contribution for each vertex
+	// this assumes IDXList describes a raw triangle list (ie, not quads and not a strip)
+	for (std::size_t i = 0; i < idxList.size(); i += 3) {
+		auto &v1 = mesh.data[ idxMapping[idxList[i]] ];
+		auto &v2 = mesh.data[ idxMapping[idxList[i + 1]] ];
+		auto &v3 = mesh.data[ idxMapping[idxList[i + 2]] ];
+
+		// calculate the normal and area (formula for area the math textbook)
+		float area = glm::length(glm::cross(v3.position - v2.position, v1.position - v3.position)) / 2;
+		auto faceNormal = calcSurfaceNormal(v1.position, v2.position, v3.position);
+
+		// weight the normal according to the area of the surface (bigger area = more impact)
+		v1.normal += area * faceNormal;
+		v2.normal += area * faceNormal;
+		v3.normal += area * faceNormal;
 	}
 
-	// each vertex should currently be the sum of every triangle it's part of
-	// so we need to normalize them
-	for (auto& vertex : mesh.vertexList() ) {
-		vertex.normal = glm::normalize( vertex.normal );
+	// re-normalise the normals
+	for (unsigned int vertexIndex : idxMapping) {
+		auto &vertex = mesh.data[vertexIndex];
+		vertex.normal = glm::normalize(vertex.normal);
 	}
 }
 
-static void computeNormalsDirect( fggl::data::Mesh& mesh, const int* colIdx, int nPoints) {
+static void populateMesh(fggl::mesh::Mesh3D &mesh, const fggl::math::mat4 transform,
+						 const int nIdx, const fggl::math::vec3 *pos, const Mesh::IndexType *idx) {
 
-	// we're assuming all the normals are zero...
-	for ( int i=0; i<nPoints; i++ ) {
-		auto& vertex = mesh.vertex( colIdx[i] );
-		vertex.normal = glm::vec3(0.0f);
+	auto *colIdx = new fggl::data::Mesh::IndexType[nIdx];
+
+	// generate mesh
+	for (int i = 0; i < nIdx; i++) {
+		glm::vec3 rawPos = transform * glm::vec4(pos[idx[i]], 1.0);
+		colIdx[i] = mesh.append(fggl::mesh::Vertex3D::from_pos(rawPos));
+		mesh.indices.push_back(colIdx[i]);
 	}
 
-	// We're assuming each vertex appears only once (because we're not indexed)
-	for (int i=0; i<nPoints; i += 3) {
-		auto& v1 = mesh.vertex( colIdx[ i ] );
-		auto& v2 = mesh.vertex( colIdx[ i + 1 ] );
-		auto& v3 = mesh.vertex( colIdx[ i + 2 ] );
+	computeNormalsDirect(mesh, colIdx, nIdx);
 
-		const glm::vec3 normal = glm::normalize( calcSurfaceNormal( v1.posititon, v2.posititon, v3.posititon ) );
-		v1.normal = normal;
-		v2.normal = normal;
-		v3.normal = normal;
-	}
+	delete[] colIdx;
 }
 
-fggl::data::Mesh fggl::data::make_triangle() {
-    constexpr fggl::math::vec3 pos[]{
-            {-0.5f, -0.5f, 0.0f},
-            {0.5f,  -0.5f, 0.0f},
-            {0.0f,  0.5f,  0.0f}
-    };
-
-    // add points
-    fggl::data::Mesh mesh;
-    for (auto po : pos) {
-        Vertex vert{};
-        vert.posititon = po;
-	vert.normal = glm::vec3(0.0f, 0.0f, 0.0f);
-        vert.colour = fggl::math::vec3(1.0f, 1.0f, 1.0f);
-        mesh.push(vert);
-    }
-
-    // mesh
-    for (int i = 0; i < 3; ++i) {
-        mesh.pushIndex(i);
-    }
-
-    return mesh;
+static void populateMesh(fggl::mesh::Mesh3D &mesh,
+						 const fggl::math::mat4 transform,
+						 const std::vector<fggl::math::vec3> &posList,
+						 const std::vector<fggl::data::Mesh::IndexType> &idxList) {
+
+	// tmp store the resulting mesh indexes (incase the mesh has multiple primatives)
+	std::vector<unsigned int> colIdx;
+	colIdx.reserve(posList.size());
+
+	// clion this thinks this loop is infinite, my assumption is it's gone bananas
+	for (std::size_t i = 0; i < posList.size(); ++i) {
+		glm::vec3 position = transform * fggl::math::vec4(posList[i], 1.0F);
+		auto vert = fggl::mesh::Vertex3D::from_pos(position);
+		colIdx[i] = mesh.append(vert);
+	}
+
+	// use the remapped indexes for the mesh
+	for (auto idx : idxList) {
+		mesh.indices.push_back(colIdx[idx]);
+	}
+
+	compute_normals(mesh, idxList, colIdx);
 }
 
-fggl::data::Mesh fggl::data::make_quad_xy() {
-	constexpr fggl::math::vec3 pos[] {
-		{-0.5f, -0.5f, 0.0f},
-		{ 0.5f, -0.5f, 0.0f},
-		{ 0.5f,  0.5f, 0.0f},
-		{-0.5f,  0.5f, 0.0f}
-	};
-	constexpr int idx[] {
-		0, 1, 3,
-		3, 1, 2
+namespace fggl::data {
+
+	static void quads2Tris(std::vector<Mesh::IndexType> &indexList, uint32_t stacks, uint32_t slices) {
+		const auto HORZ_SIZE = slices + 1;
+
+		for (uint32_t vertical = 0; vertical < stacks; vertical++) {
+			for (uint32_t horz = 0; horz < slices; horz++) {
+				const auto topLeft = vertical * HORZ_SIZE + horz;
+				const auto topRight = vertical * HORZ_SIZE + (horz + 1);
+				const auto bottomLeft = (vertical + 1) * HORZ_SIZE + horz;
+				const auto bottomRight = (vertical + 1) * HORZ_SIZE + (horz + 1);
+
+				indexList.push_back(topLeft);
+				indexList.push_back(bottomLeft);
+				indexList.push_back(topRight);
+
+				indexList.push_back(topRight);
+				indexList.push_back(bottomLeft);
+				indexList.push_back(bottomRight);
+			}
+		}
+	}
+
+	void make_sphere(fggl::mesh::Mesh3D &mesh, const math::mat4 &offset, uint32_t slices, uint32_t stacks) {
+
+		std::vector<math::vec3> positions;
+
+		float verticalAngularStride = math::PI / (float) stacks;
+		float horizontalAngularStride = math::TAU / (float) slices;
+
+		// calculate vertex positions
+		for (uint32_t vertical = 0; vertical < (stacks + 1); vertical++) {
+			float theta = (math::HALF_PI) - verticalAngularStride * (float) vertical;
+			for (uint32_t horz = 0; horz < (slices + 1); horz++) {
+				float phi = horizontalAngularStride * (float) horz;
+				math::vec3 position{
+					cosf(theta) * cosf(phi),
+					cosf(theta) * sinf(phi),
+					sinf(theta)
+				};
+				positions.push_back(position);
+			}
+		}
+
+		// combine the vertices into triangles
+		std::vector<Mesh::IndexType> indexList;
+		quads2Tris(indexList, stacks, slices);
+
+		populateMesh(mesh, offset, positions, indexList);
+	}
+
+} // namespace fggl::data
+
+
+auto fggl::data::make_triangle() -> fggl::data::Mesh {
+	constexpr fggl::math::vec3 pos[]{
+		{-0.5F, -0.5F, 0.0F},
+		{0.5F, -0.5F, 0.0F},
+		{0.0F, 0.5F, 0.0F}
 	};
 
+	// add points
 	fggl::data::Mesh mesh;
-	int colIdx[4];
-	for (int i = 0; i < 4; ++i){
-		Vertex vert{};
-		vert.posititon = pos[i];
-		vert.normal = glm::vec3(0.0f, 0.0f, 0.0f);
-		vert.colour = fggl::math::vec3(1.0f, 1.0f, 1.0f);
-		colIdx[ i ] = mesh.pushVertex(vert);
+	for (auto po : pos) {
+		mesh.push(Vertex::from_pos(po));
 	}
 
-	for( auto i : idx ) {
-		mesh.pushIndex( colIdx[ i ] );
+	// mesh
+	for (int i = 0; i < 3; ++i) {
+		mesh.pushIndex(i);
 	}
 
 	return mesh;
 }
 
-fggl::data::Mesh fggl::data::make_quad_xz() {
-	constexpr fggl::math::vec3 pos[] {
-		{-0.5f, 0.0f, -0.5f},
-		{ 0.5f, 0.0f, -0.5f},
-		{ 0.5f, 0.0f,  0.5f},
-		{-0.5f, 0.0f,  0.5f}
+auto fggl::data::make_quad_xy() -> fggl::data::Mesh {
+	constexpr fggl::math::vec3 pos[]{
+		{-0.5F, -0.5F, 0.0F},
+		{0.5F, -0.5F, 0.0F},
+		{0.5F, 0.5F, 0.0F},
+		{-0.5F, 0.5F, 0.0F}
 	};
-	constexpr int idx[] {
+	constexpr int idx[]{
 		0, 1, 3,
 		3, 1, 2
 	};
 
 	fggl::data::Mesh mesh;
-	int colIdx[4];
-	for (int i = 0; i < 4; ++i){
-		Vertex vert{};
-		vert.posititon = pos[i];
-		vert.normal = glm::vec3(0.0f, 0.0f, 0.0f);
-		vert.colour = fggl::math::vec3(1.0f, 1.0f, 1.0f);
-		colIdx[ i ] = mesh.pushVertex(vert);
+	std::array<int, 4> colIdx{};
+	for (int i = 0; i < 4; ++i) {
+		colIdx[i] = mesh.pushVertex(Vertex::from_pos(pos[i]));
 	}
 
-	for( auto i : idx ) {
-		mesh.pushIndex( colIdx[ i ] );
+	for (auto i : idx) {
+		mesh.pushIndex(colIdx[i]);
 	}
 
 	return mesh;
 }
 
+auto fggl::data::make_quad_xz() -> fggl::data::Mesh {
+	constexpr std::array<fggl::math::vec3, 4> pos{{
+													  {-0.5F, 0.0F, -0.5F},
+													  {0.5F, 0.0F, -0.5F},
+													  {0.5F, 0.0F, 0.5F},
+													  {-0.5F, 0.0F, 0.5F}
+												  }};
+	constexpr std::array<int, 6> idx{{
+										 0, 1, 3,
+										 3, 1, 2
+									 }};
 
-constexpr float HALF_PI = M_PI / 2.0f;
-static void populateMesh(fggl::data::Mesh& mesh, const fggl::math::mat4 transform, 
-		          int nIdx, const fggl::math::vec3* pos, const int* idx ) {
-	int colIdx[nIdx];
+	fggl::data::Mesh mesh;
+	std::array<int, 4> colIdx{};
+	for (int i = 0; i < 4; ++i) {
+		colIdx[i] = mesh.pushVertex(Vertex::from_pos(pos[i]));
+	}
 
-	// generate mesh
-	for (int i=0; i<nIdx; i++) {
-		glm::vec3 rawPos = transform * glm::vec4( pos[ idx[i] ], 1.0 );
-
-		Vertex vert{};
-		vert.posititon = rawPos;
-		vert.normal = glm::vec3(0.0f, 0.0f, 0.0f);
-		vert.colour = fggl::math::vec3(1.0f, 1.0f, 1.0f);
-		colIdx[ i ] = mesh.pushVertex( vert );
-		mesh.pushIndex( colIdx[i] );
+	for (auto i : idx) {
+		mesh.pushIndex(colIdx.at(i));
 	}
 
-	computeNormalsDirect( mesh, colIdx, nIdx );
+	return mesh;
 }
 
-
-fggl::data::Mesh fggl::data::make_cube(fggl::data::Mesh& mesh, const fggl::math::mat4& transform) {
-
+auto fggl::data::make_cube(fggl::mesh::Mesh3D &mesh, const fggl::math::mat4 &transform) -> fggl::mesh::Mesh3D {
 	// done as two loops, top loop is 0,1,2,3, bottom loop is 4,5,6,7
-	constexpr fggl::math::vec3 pos[] {
-		{-0.5,  0.5, -0.5}, // 0 TOP LOOP
-		{ 0.5,  0.5, -0.5}, // 1
-		{ 0.5,  0.5,  0.5}, // 2
-		{-0.5,  0.5,  0.5}, // 3
-		{-0.5, -0.5, -0.5}, // 4 BOTTOM LOOP
-		{ 0.5, -0.5, -0.5}, // 5
-		{ 0.5, -0.5,  0.5}, // 6
-		{-0.5, -0.5,  0.5}  // 7
-	};
-
-	constexpr int idx[] {
-		0, 3, 1, // top
-		3, 2, 1,
-		0, 1, 4, // side 0 - 1
-		5, 4, 1,
-		1, 2, 5, // side 1 - 2
-		2, 6, 5,
-		3, 7, 2, // side 2 - 3
-		2, 7, 6,
-		0, 4, 3, // side 3 - 0
-		4, 7, 3,
-		4, 5, 7, // bottom
-		7, 5, 6,
-	};
-
-	int nIdx = sizeof(idx) / sizeof(int);
-	populateMesh(mesh, transform, nIdx, pos, idx);
+	constexpr std::array<fggl::math::vec3, 8> pos{{
+													  {-0.5, 0.5, -0.5}, // 0 TOP LOOP
+													  {0.5, 0.5, -0.5}, // 1
+													  {0.5, 0.5, 0.5}, // 2
+													  {-0.5, 0.5, 0.5}, // 3
+													  {-0.5, -0.5, -0.5}, // 4 BOTTOM LOOP
+													  {0.5, -0.5, -0.5}, // 5
+													  {0.5, -0.5, 0.5}, // 6
+													  {-0.5, -0.5, 0.5}  // 7
+												  }};
+
+	constexpr std::array<Mesh::IndexType, 36> idx{{
+													  0, 3, 1, // top
+													  3, 2, 1,
+													  0, 1, 4, // side 0 - 1
+													  5, 4, 1,
+													  1, 2, 5, // side 1 - 2
+													  2, 6, 5,
+													  3, 7, 2, // side 2 - 3
+													  2, 7, 6,
+													  0, 4, 3, // side 3 - 0
+													  4, 7, 3,
+													  4, 5, 7, // bottom
+													  7, 5, 6,
+												  }};
+	populateMesh(mesh, transform, idx.size(), pos.data(), idx.data());
 	return mesh;
 }
 
-fggl::data::Mesh fggl::data::make_slope(fggl::data::Mesh& mesh, const fggl::math::mat4& transform) {
+auto fggl::data::make_slope(fggl::mesh::Mesh3D &mesh, const fggl::math::mat4 &transform) -> fggl::mesh::Mesh3D {
 
 	// done as two loops, top loop is 0,1,2,3, bottom loop is 4,5,6,7
 	// FIXME remove 2 and 3 and renumber the index list accordingly
-	constexpr fggl::math::vec3 pos[] {
-		{-0.5,  0.5, -0.5}, // 0 TOP LOOP
-		{ 0.5,  0.5, -0.5}, // 1
-		{ 0.5,  0.5,  0.5}, // 2
-		{-0.5,  0.5,  0.5}, // 3
+	constexpr fggl::math::vec3 pos[]{
+		{-0.5, 0.5, -0.5}, // 0 TOP LOOP
+		{0.5, 0.5, -0.5}, // 1
+		{0.5, 0.5, 0.5}, // 2
+		{-0.5, 0.5, 0.5}, // 3
 		{-0.5, -0.5, -0.5}, // 4 BOTTOM LOOP
-		{ 0.5, -0.5, -0.5}, // 5
-		{ 0.5, -0.5,  0.5}, // 6
-		{-0.5, -0.5,  0.5}  // 7
+		{0.5, -0.5, -0.5}, // 5
+		{0.5, -0.5, 0.5}, // 6
+		{-0.5, -0.5, 0.5}  // 7
 	};
 
-	constexpr int idx[] {
+	constexpr Mesh::IndexType idx[]{
 		0, 7, 1, // ramp
 		7, 6, 1,
 		0, 1, 4, // side 0 - 1
@@ -239,22 +316,22 @@ fggl::data::Mesh fggl::data::make_slope(fggl::data::Mesh& mesh, const fggl::math
 	return mesh;
 }
 
-fggl::data::Mesh fggl::data::make_ditch(fggl::data::Mesh& mesh, const fggl::math::mat4& transform) {
+auto fggl::data::make_ditch(fggl::mesh::Mesh3D &mesh, const fggl::math::mat4 &transform) -> fggl::mesh::Mesh3D {
 
 	// done as two loops, top loop is 0,1,2,3, bottom loop is 4,5,6,7
 	// FIXME remove 2 and renumber the index list accordingly
-	constexpr fggl::math::vec3 pos[] {
-		{-0.5,  0.5, -0.5}, // 0 TOP LOOP
-		{ 0.5,  0.5, -0.5}, // 1
-		{ 0.5,  0.5,  0.5}, // 2
-		{-0.5,  0.5,  0.5}, // 3
+	constexpr fggl::math::vec3 pos[]{
+		{-0.5, 0.5, -0.5}, // 0 TOP LOOP
+		{0.5, 0.5, -0.5}, // 1
+		{0.5, 0.5, 0.5}, // 2
+		{-0.5, 0.5, 0.5}, // 3
 		{-0.5, -0.5, -0.5}, // 4 BOTTOM LOOP
-		{ 0.5, -0.5, -0.5}, // 5
-		{ 0.5, -0.5,  0.5}, // 6
-		{-0.5, -0.5,  0.5}  // 7
+		{0.5, -0.5, -0.5}, // 5
+		{0.5, -0.5, 0.5}, // 6
+		{-0.5, -0.5, 0.5}  // 7
 	};
 
-	constexpr int idx[] {
+	constexpr Mesh::IndexType idx[]{
 		0, 3, 1, // top
 		3, 6, 1,
 		0, 1, 4, // side 0 - 1
@@ -272,21 +349,21 @@ fggl::data::Mesh fggl::data::make_ditch(fggl::data::Mesh& mesh, const fggl::math
 	return mesh;
 }
 
-fggl::data::Mesh fggl::data::make_point(fggl::data::Mesh& mesh, const fggl::math::mat4& transform) {
+auto fggl::data::make_point(fggl::mesh::Mesh3D &mesh, const fggl::math::mat4 &transform) -> fggl::mesh::Mesh3D {
 
 	// done as two loops, top loop is 0,1,2,3, bottom loop is 4,5,6,7
-	constexpr fggl::math::vec3 pos[] {
-		{-0.5,  0.5, -0.5}, // 0 TOP LOOP
-		{ 0.5,  0.5, -0.5}, // 1
-		{ 0.5,  0.5,  0.5}, // 2
-		{-0.5,  0.5,  0.5}, // 3
+	constexpr fggl::math::vec3 pos[]{
+		{-0.5, 0.5, -0.5}, // 0 TOP LOOP
+		{0.5, 0.5, -0.5}, // 1
+		{0.5, 0.5, 0.5}, // 2
+		{-0.5, 0.5, 0.5}, // 3
 		{-0.5, -0.5, -0.5}, // 4 BOTTOM LOOP
-		{ 0.5, -0.5, -0.5}, // 5
-		{ 0.5, -0.5,  0.5}, // 6
-		{-0.5, -0.5,  0.5}  // 7
+		{0.5, -0.5, -0.5}, // 5
+		{0.5, -0.5, 0.5}, // 6
+		{-0.5, -0.5, 0.5}  // 7
 	};
 
-	constexpr int idx[] {
+	constexpr Mesh::IndexType idx[]{
 		0, 7, 5, // top
 		7, 6, 5,
 		0, 5, 4, // side 0 - 1
@@ -394,7 +471,7 @@ Mesh fggl::data::make_cube() {
 
 	// triagulate the quads
 	quadsToTris(cube, vertIndex, cubeIndexes, nQuads);
-	computeNormals(cube);
+	compute_normals(cube);
 
 	return cube;
 }*/

fggl/data/procedural.hpp

-
-#include "model.hpp"
-
-namespace fggl::data {
-
-	constexpr math::mat4 OFFSET_NONE(1.0f);
-
-	Mesh make_triangle();
-
-	// quads
-	Mesh make_quad_xy();
-	Mesh make_quad_xz();
-
-	// simple shapes
-	Mesh make_cube(Mesh& mesh, const math::mat4& offset);
-	inline Mesh make_cube(Mesh& mesh) {
-		return make_cube(mesh, OFFSET_NONE);
-	}
-
-	// blockout shapes
-	Mesh make_slope(Mesh& mesh, const math::mat4& offset);
-	inline Mesh make_slope(Mesh& mesh) {
-		return make_slope(mesh, OFFSET_NONE);
-	}
-
-	Mesh make_ditch(Mesh& mesh, const math::mat4& offset);
-	inline Mesh make_ditch(Mesh& mesh) {
-		return make_ditch(mesh, OFFSET_NONE);
-	}
-
-	Mesh make_point(Mesh& mesh, const math::mat4& offset);
-	inline Mesh make_point(Mesh& mesh) {
-		return make_point(mesh, OFFSET_NONE);
-	}
-}

fggl/data/procedure.hpp

-#ifndef FGGL_DATA_FS_H
-#define FGGL_DATA_FS_H
-
-namespace fggl::data {
-
-	class DataRegistry {
-
-		public:
-			DataRegistry();
-			~DataRegistry();
-
-			
-	};
-
-}
-
-#endif

fggl/data/storage.hpp

-#ifndef FGGL_DATA_STORAGE_H
-#define FGGL_DATA_STORAGE_H
-
-#include <iostream>
-#include <string>
-#include <filesystem>
-
-namespace fggl::data {
-
-	template<typename T>
-	bool fggl_serialize(std::filesystem::path& data, const T* out);
-
-	template<typename T>
-	bool fggl_deserialize(std::filesystem::path& data, T* out);
-
-	enum StorageType {Data, User, Cache};
-	class Storage {
-
-		public:
-			template<typename T>
-			bool load(StorageType pool, const std::string& name, T* out) {
-				auto path = resolvePath(pool, name);
-				if ( !std::filesystem::exists(path) ) {
-					std::cerr << "path " << path << " does not exist! " << std::endl;
-					return false;
-				}
-				return fggl_deserialize<T>(path, out);
-			}
-
-			template<typename T>
-			void save(StorageType pool, const std::string& name, const T* out) {
-				auto path = resolvePath(pool, name);
-				fggl_serialize<T>(path, out);
-			}
-
-			inline std::filesystem::path resolvePath(StorageType pool, const std::string& name) {
-				std::filesystem::path path;
-
-				switch ( pool ) {
-					case Data:
-						path = std::filesystem::current_path() / "data";
-						break;
-					case User:
-						path = "./user-data/";
-						break;
-					case Cache:
-						path = "/tmp/fggl/";
-						break;
-				}
-
-				if ( !std::filesystem::exists(path) ) {
-					std::filesystem::create_directories(path);
-				}
-				
-				return path / name;
-			}
-	};
-
-}
-
-#endif

fggl/debug/CMakeLists.txt

-
 target_sources(fggl
-    PRIVATE
-	debug.cpp
-)
+        PRIVATE
+            debug.cpp
+            debug_draw.cpp
+            logging.cpp
+        )
+
+# spdlog for cleaner logging
+find_package(spdlog)
+target_link_libraries(fggl PRIVATE spdlog::spdlog)
 
-target_link_libraries(fggl imgui)
+add_subdirectory(imgui)
\ No newline at end of file

fggl/debug/debug.cpp

-#include "debug.h"
+/*
+ * This file is part of FGGL.
+ *
+ * FGGL is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any
+ * later version.
+ *
+ * FGGL is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along with FGGL.
+ * If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <fggl/debug/debug.h>
+
+#include "imgui.h"
+#include "imgui/include/imgui_impl_glfw.h"
+#include "imgui/include/imgui_impl_opengl3.h"
 
-#include <imgui.h>
-#include <backends/imgui_impl_glfw.h>
-#include <backends/imgui_impl_opengl3.h>
-
-using fggl::gfx::Window;
 using fggl::debug::DebugUI;
 
-DebugUI::DebugUI(std::shared_ptr<Window> win) : m_visible(false) {
+DebugUI::DebugUI(std::shared_ptr<fggl::display::glfw::Window> &win) : m_visible(false) {
 	IMGUI_CHECKVERSION();
 	ImGui::CreateContext();
 
-    ImGuiIO& io = ImGui::GetIO();
-    io.IniFilename = nullptr;
+	ImGuiIO &io = ImGui::GetIO();
+	io.IniFilename = nullptr;
 
-    ImGui_ImplGlfw_InitForOpenGL(win->handle(), true);
+	ImGui_ImplGlfw_InitForOpenGL(win->handle(), true);
 	ImGui_ImplOpenGL3_Init("#version 130");
 }
 
@@ -32,13 +45,14 @@ void DebugUI::frameStart() {
 }
 
 void DebugUI::draw() {
-    for ( auto& [name, data] : m_windows) {
-        if ( data.m_visible ) {
-            data.m_callback( &data.m_visible );
-        }
-    }
+	for (auto &[name, data] : m_windows) {
+		if (data.m_visible) {
+			data.m_callback(&data.m_visible);
+		}
+	}
 
 	ImGui::Render();
-	if ( m_visible )
+	if (m_visible) {
 		ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+	}
 }