971 lines
34 KiB
C++
971 lines
34 KiB
C++
// #include <memory>
|
|
// #include <string>
|
|
// #include <sstream>
|
|
// #include <thread>
|
|
// #include <vector>
|
|
// #include <unordered_set>
|
|
// #include <stack>
|
|
|
|
// #include <filament/Engine.h>
|
|
// #include <filament/TransformManager.h>
|
|
// #include <filament/Texture.h>
|
|
// #include <filament/RenderableManager.h>
|
|
// #include <filament/Viewport.h>
|
|
// #include <filament/Frustum.h>
|
|
|
|
// #include <utils/EntityManager.h>
|
|
|
|
// #include <gltfio/Animator.h>
|
|
// #include <gltfio/AssetLoader.h>
|
|
// #include <gltfio/FilamentAsset.h>
|
|
// #include <gltfio/ResourceLoader.h>
|
|
// #include <gltfio/TextureProvider.h>
|
|
// #include <gltfio/math.h>
|
|
// #include <gltfio/materials/uberarchive.h>
|
|
// #include <imageio/ImageDecoder.h>
|
|
|
|
// #include "material/FileMaterialProvider.hpp"
|
|
// #include "material/UnlitMaterialProvider.hpp"
|
|
// #include "material/unlit.h"
|
|
// #include "material/gizmo.h"
|
|
|
|
// #include "StreamBufferAdapter.hpp"
|
|
|
|
// #include "Log.hpp"
|
|
|
|
// #include "scene/SceneManager.hpp"
|
|
// #include "scene/CustomGeometry.hpp"
|
|
// #include "scene/GeometrySceneAsset.hpp"
|
|
// #include "scene/GltfSceneAsset.hpp"
|
|
// #include "scene/Gizmo.hpp"
|
|
// #include "scene/SceneAsset.hpp"
|
|
// #include "scene/GeometrySceneAssetBuilder.hpp"
|
|
// #include "TextureProjection.hpp"
|
|
|
|
// #include "resources/translation_gizmo_glb.h"
|
|
// #include "resources/rotation_gizmo_glb.h"
|
|
|
|
// extern "C"
|
|
// {
|
|
// #include "material/image.h"
|
|
// #include "material/unlit_fixed_size.h"
|
|
// }
|
|
|
|
// namespace thermion
|
|
// {
|
|
|
|
// using namespace std::chrono;
|
|
// using namespace image;
|
|
// using namespace utils;
|
|
// using namespace filament;
|
|
// using namespace filament::gltfio;
|
|
// using std::unique_ptr;
|
|
|
|
// SceneManager::SceneManager(const ResourceLoaderWrapperImpl *const resourceLoaderWrapper,
|
|
// Engine *engine,
|
|
// Scene *scene,
|
|
// const char *uberArchivePath,
|
|
// Camera *mainCamera)
|
|
// : _resourceLoaderWrapper(resourceLoaderWrapper),
|
|
// _engine(engine),
|
|
// _scene(scene),
|
|
// _mainCamera(mainCamera)
|
|
// {
|
|
|
|
// _stbDecoder = createStbProvider(_engine);
|
|
// _ktxDecoder = createKtx2Provider(_engine);
|
|
|
|
// _gltfResourceLoader = new ResourceLoader({.engine = _engine,
|
|
// .normalizeSkinningWeights = true});
|
|
// if (uberArchivePath)
|
|
// {
|
|
// auto uberdata = resourceLoaderWrapper->load(uberArchivePath);
|
|
// if (!uberdata.data)
|
|
// {
|
|
// Log("Failed to load ubershader material. This is fatal.");
|
|
// }
|
|
// _ubershaderProvider = gltfio::createUbershaderProvider(_engine, uberdata.data, uberdata.size);
|
|
// resourceLoaderWrapper->free(uberdata);
|
|
// }
|
|
// else
|
|
// {
|
|
// _ubershaderProvider = gltfio::createUbershaderProvider(
|
|
// _engine, UBERARCHIVE_DEFAULT_DATA, UBERARCHIVE_DEFAULT_SIZE);
|
|
// }
|
|
|
|
// _unlitMaterialProvider = new UnlitMaterialProvider(_engine, UNLIT_PACKAGE, UNLIT_UNLIT_SIZE);
|
|
|
|
// utils::EntityManager &em = utils::EntityManager::get();
|
|
|
|
// _ncm = new NameComponentManager(em);
|
|
|
|
// _assetLoader = AssetLoader::create({_engine, _ubershaderProvider, _ncm, &em});
|
|
|
|
// _gltfResourceLoader->addTextureProvider("image/ktx2", _ktxDecoder);
|
|
// _gltfResourceLoader->addTextureProvider("image/png", _stbDecoder);
|
|
// _gltfResourceLoader->addTextureProvider("image/jpeg", _stbDecoder);
|
|
|
|
// auto &tm = _engine->getTransformManager();
|
|
|
|
// _collisionComponentManager = std::make_unique<CollisionComponentManager>(tm);
|
|
|
|
// _animationManager = std::make_unique<AnimationManager>(_engine, _scene);
|
|
|
|
// _unlitFixedSizeMaterial =
|
|
// Material::Builder()
|
|
// .package(UNLIT_FIXED_SIZE_UNLIT_FIXED_SIZE_DATA, UNLIT_FIXED_SIZE_UNLIT_FIXED_SIZE_SIZE)
|
|
// .build(*_engine);
|
|
|
|
// _gizmoMaterial =
|
|
// Material::Builder()
|
|
// .package(GIZMO_GIZMO_DATA, GIZMO_GIZMO_SIZE)
|
|
// .build(*_engine);
|
|
// }
|
|
|
|
// SceneManager::~SceneManager()
|
|
// {
|
|
// TRACE("Destroying cameras");
|
|
// for (auto camera : _cameras)
|
|
// {
|
|
// auto entity = camera->getEntity();
|
|
// _engine->destroyCameraComponent(entity);
|
|
// _engine->getEntityManager().destroy(entity);
|
|
// }
|
|
// TRACE("Cameras destroyed");
|
|
|
|
// destroyAll();
|
|
// TRACE("Destroyed all assets");
|
|
|
|
// _engine->destroy(_unlitFixedSizeMaterial);
|
|
// _engine->destroy(_gizmoMaterial);
|
|
// TRACE("Destroyed materials");
|
|
// _cameras.clear();
|
|
|
|
// _grid = nullptr;
|
|
|
|
// _gltfResourceLoader->asyncCancelLoad();
|
|
// _ubershaderProvider->destroyMaterials();
|
|
|
|
// _animationManager = std::nullptr_t();
|
|
// _collisionComponentManager = std::nullptr_t();
|
|
// delete _ncm;
|
|
|
|
// delete _gltfResourceLoader;
|
|
// delete _stbDecoder;
|
|
// delete _ktxDecoder;
|
|
// delete _ubershaderProvider;
|
|
// TRACE("Destroying asset loader");
|
|
// AssetLoader::destroy(&_assetLoader);
|
|
// TRACE("Destroyed asset loader");
|
|
// }
|
|
|
|
// SceneAsset *SceneManager::createGrid(Material *material)
|
|
// {
|
|
// if (!_grid)
|
|
// {
|
|
// if (!material)
|
|
// {
|
|
// material = Material::Builder()
|
|
// .package(GRID_PACKAGE, GRID_GRID_SIZE)
|
|
// .build(*_engine);
|
|
// }
|
|
|
|
// _grid = std::make_unique<GridOverlay>(*_engine, material);
|
|
// }
|
|
// return _grid.get();
|
|
// }
|
|
|
|
// bool SceneManager::isGridEntity(utils::Entity entity)
|
|
// {
|
|
// if (!_grid)
|
|
// {
|
|
// TRACE("No grid");
|
|
// return false;
|
|
// }
|
|
// if (entity == _grid->getEntity())
|
|
// {
|
|
// TRACE("%d is a grid entity.", entity);
|
|
// return true;
|
|
// }
|
|
// for (int i = 0; i < _grid->getChildEntityCount(); i++)
|
|
// {
|
|
// if (entity == _grid->getChildEntities()[i])
|
|
// {
|
|
// TRACE("%d is a child entity of grid.", entity);
|
|
// return true;
|
|
// }
|
|
// }
|
|
// return false;
|
|
// }
|
|
|
|
// Gizmo *SceneManager::createGizmo(View *view, Scene *scene, GizmoType type)
|
|
// {
|
|
// TRACE("Creating gizmo type %d", type);
|
|
// Gizmo *raw;
|
|
// switch (type)
|
|
// {
|
|
// case GizmoType::TRANSLATION:
|
|
// if (!_translationGizmoGlb)
|
|
// {
|
|
// TRACE("Translation gizmo source not found, loading");
|
|
// _translationGizmoGlb = loadGlbFromBuffer(TRANSLATION_GIZMO_GLB_TRANSLATION_GIZMO_DATA, TRANSLATION_GIZMO_GLB_TRANSLATION_GIZMO_SIZE, 100, true, 4, 0, false, false);
|
|
// }
|
|
// raw = new Gizmo(_translationGizmoGlb, _engine, view, scene, _unlitFixedSizeMaterial);
|
|
// TRACE("Built translation gizmo");
|
|
// break;
|
|
// case GizmoType::ROTATION:
|
|
// if (!_rotationGizmoGlb)
|
|
// {
|
|
// TRACE("Rotation gizmo source not found, loading");
|
|
// _rotationGizmoGlb = loadGlbFromBuffer(ROTATION_GIZMO_GLB_ROTATION_GIZMO_DATA, ROTATION_GIZMO_GLB_ROTATION_GIZMO_SIZE, 100, true, 4, 0, false, false);
|
|
// }
|
|
// raw = new Gizmo(_rotationGizmoGlb, _engine, view, scene, _unlitFixedSizeMaterial);
|
|
// TRACE("Built rotation gizmo");
|
|
// break;
|
|
// }
|
|
|
|
// _sceneAssets.push_back(std::unique_ptr<Gizmo>(raw));
|
|
// return raw;
|
|
// }
|
|
|
|
// int SceneManager::getInstanceCount(EntityId entityId)
|
|
// {
|
|
// auto entity = utils::Entity::import(entityId);
|
|
// for (auto &asset : _sceneAssets)
|
|
// {
|
|
// if (asset->getEntity() == entity)
|
|
// {
|
|
// return asset->getInstanceCount();
|
|
// }
|
|
// }
|
|
// return -1;
|
|
// }
|
|
|
|
// void SceneManager::getInstances(EntityId entityId, EntityId *out)
|
|
// {
|
|
// auto entity = utils::Entity::import(entityId);
|
|
// for (auto &asset : _sceneAssets)
|
|
// {
|
|
// if (asset->getEntity() == entity)
|
|
// {
|
|
// for (int i = 0; i < asset->getInstanceCount(); i++)
|
|
// {
|
|
// out[i] = Entity::smuggle(asset->getInstanceAt(i)->getEntity());
|
|
// }
|
|
// return;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// SceneAsset *SceneManager::loadGltf(const char *uri,
|
|
// const char *relativeResourcePath,
|
|
// int numInstances,
|
|
// bool keepData)
|
|
// {
|
|
// if (numInstances < 1)
|
|
// {
|
|
// return std::nullptr_t();
|
|
// }
|
|
|
|
// ResourceBuffer rbuf = _resourceLoaderWrapper->load(uri);
|
|
|
|
// std::vector<FilamentInstance *> instances(numInstances);
|
|
|
|
// FilamentAsset *asset = _assetLoader->createInstancedAsset((uint8_t *)rbuf.data, rbuf.size, instances.data(), numInstances);
|
|
|
|
// if (!asset)
|
|
// {
|
|
// Log("Unable to load glTF asset at %d", uri);
|
|
// return std::nullptr_t();
|
|
// }
|
|
|
|
// const char *const *const resourceUris = asset->getResourceUris();
|
|
// const size_t resourceUriCount = asset->getResourceUriCount();
|
|
|
|
// std::vector<ResourceBuffer> resourceBuffers;
|
|
|
|
// for (size_t i = 0; i < resourceUriCount; i++)
|
|
// {
|
|
// std::string uri = std::string(relativeResourcePath) + std::string("/") + std::string(resourceUris[i]);
|
|
// ResourceBuffer buf = _resourceLoaderWrapper->load(uri.c_str());
|
|
|
|
// resourceBuffers.push_back(buf);
|
|
|
|
// ResourceLoader::BufferDescriptor b(buf.data, buf.size);
|
|
// _gltfResourceLoader->addResourceData(resourceUris[i], std::move(b));
|
|
// }
|
|
|
|
// #ifdef __EMSCRIPTEN__
|
|
// if (!_gltfResourceLoader->asyncBeginLoad(asset))
|
|
// {
|
|
// Log("Unknown error loading glTF asset");
|
|
// _resourceLoaderWrapper->free(rbuf);
|
|
// for (auto &rb : resourceBuffers)
|
|
// {
|
|
// _resourceLoaderWrapper->free(rb);
|
|
// }
|
|
// return 0;
|
|
// }
|
|
// while (_gltfResourceLoader->asyncGetLoadProgress() < 1.0f)
|
|
// {
|
|
// _gltfResourceLoader->asyncUpdateLoad();
|
|
// }
|
|
// #else
|
|
// // load resources synchronously
|
|
// if (!_gltfResourceLoader->loadResources(asset))
|
|
// {
|
|
// Log("Unknown error loading glTF asset");
|
|
// _resourceLoaderWrapper->free(rbuf);
|
|
// for (auto &rb : resourceBuffers)
|
|
// {
|
|
// _resourceLoaderWrapper->free(rb);
|
|
// }
|
|
// return std::nullptr_t();
|
|
// }
|
|
// #endif
|
|
|
|
// auto sceneAsset = std::make_unique<GltfSceneAsset>(
|
|
// asset,
|
|
// _assetLoader,
|
|
// _engine,
|
|
// _ncm);
|
|
// auto filamentInstance = asset->getInstance();
|
|
// size_t entityCount = filamentInstance->getEntityCount();
|
|
|
|
// _scene->addEntities(filamentInstance->getEntities(), entityCount);
|
|
|
|
// for (auto &rb : resourceBuffers)
|
|
// {
|
|
// _resourceLoaderWrapper->free(rb);
|
|
// }
|
|
// _resourceLoaderWrapper->free(rbuf);
|
|
|
|
// auto lights = asset->getLightEntities();
|
|
// _scene->addEntities(lights, asset->getLightEntityCount());
|
|
|
|
// sceneAsset->createInstance();
|
|
|
|
// auto entityId = Entity::smuggle(sceneAsset->getEntity());
|
|
|
|
// auto *raw = sceneAsset.get();
|
|
|
|
// _sceneAssets.push_back(std::move(sceneAsset));
|
|
|
|
// Log("Loaded glTF asset from uri: %s", uri);
|
|
|
|
// return raw;
|
|
// }
|
|
|
|
// void SceneManager::setVisibilityLayer(EntityId entityId, int layer)
|
|
// {
|
|
// utils::Entity entity = utils::Entity::import(entityId);
|
|
// for (auto &asset : _sceneAssets)
|
|
// {
|
|
// if (asset->getEntity() == entity)
|
|
// {
|
|
// asset->setLayer(_engine->getRenderableManager(), layer);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// SceneAsset *SceneManager::loadGlbFromBuffer(const uint8_t *data, size_t length, int numInstances, bool keepData, int priority, int layer, bool loadResourcesAsync, bool addToScene)
|
|
// {
|
|
// auto &rm = _engine->getRenderableManager();
|
|
|
|
// std::vector<FilamentInstance *> instances(numInstances);
|
|
|
|
// FilamentAsset *asset = _assetLoader->createInstancedAsset((const uint8_t *)data, length, instances.data(), numInstances);
|
|
|
|
// Log("Created glTF asset with %d instances.", numInstances);
|
|
|
|
// if (!asset)
|
|
// {
|
|
// Log("Unknown error loading GLB asset.");
|
|
// return std::nullptr_t();
|
|
// }
|
|
// #ifdef __EMSCRIPTEN__
|
|
// if (!_gltfResourceLoader->asyncBeginLoad(asset))
|
|
// {
|
|
// Log("Unknown error loading glb asset");
|
|
// return 0;
|
|
// }
|
|
// while (_gltfResourceLoader->asyncGetLoadProgress() < 1.0f)
|
|
// {
|
|
// _gltfResourceLoader->asyncUpdateLoad();
|
|
// }
|
|
// #else
|
|
// if (loadResourcesAsync)
|
|
// {
|
|
// if (!_gltfResourceLoader->asyncBeginLoad(asset))
|
|
// {
|
|
// Log("Unknown error loading glb asset");
|
|
// return 0;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// if (!_gltfResourceLoader->loadResources(asset))
|
|
// {
|
|
// Log("Unknown error loading glb asset");
|
|
// return 0;
|
|
// }
|
|
// }
|
|
// #endif
|
|
|
|
// auto sceneAsset = std::make_unique<GltfSceneAsset>(
|
|
// asset,
|
|
// _assetLoader,
|
|
// _engine,
|
|
// _ncm);
|
|
|
|
// auto sceneAssetInstance = sceneAsset->createInstance();
|
|
// if (addToScene)
|
|
// {
|
|
// sceneAssetInstance->addAllEntities(_scene);
|
|
// }
|
|
// sceneAssetInstance->setPriority(_engine->getRenderableManager(), priority);
|
|
// sceneAssetInstance->setLayer(_engine->getRenderableManager(), layer);
|
|
|
|
// auto *raw = sceneAsset.get();
|
|
|
|
// _sceneAssets.push_back(std::move(sceneAsset));
|
|
|
|
// return raw;
|
|
// }
|
|
|
|
// SceneAsset *SceneManager::createInstance(SceneAsset *asset, MaterialInstance **materialInstances, size_t materialInstanceCount)
|
|
// {
|
|
// std::lock_guard lock(_mutex);
|
|
|
|
// auto instance = asset->createInstance(materialInstances, materialInstanceCount);
|
|
// if (instance)
|
|
// {
|
|
// instance->addAllEntities(_scene);
|
|
// }
|
|
// else
|
|
// {
|
|
// Log("Failed to create instance");
|
|
// }
|
|
// return instance;
|
|
// }
|
|
|
|
// SceneAsset *SceneManager::loadGlb(const char *uri, int numInstances, bool keepData)
|
|
// {
|
|
// ResourceBuffer rbuf = _resourceLoaderWrapper->load(uri);
|
|
// auto entity = loadGlbFromBuffer((const uint8_t *)rbuf.data, rbuf.size, numInstances, keepData);
|
|
// _resourceLoaderWrapper->free(rbuf);
|
|
// return entity;
|
|
// }
|
|
|
|
// bool SceneManager::removeFromScene(EntityId entityId)
|
|
// {
|
|
// _scene->remove(Entity::import(entityId));
|
|
// return true;
|
|
// }
|
|
|
|
// bool SceneManager::addToScene(EntityId entityId)
|
|
// {
|
|
// _scene->addEntity(Entity::import(entityId));
|
|
// return true;
|
|
// }
|
|
|
|
// void SceneManager::destroyAll()
|
|
// {
|
|
|
|
// destroyLights();
|
|
// destroyAssets();
|
|
// std::lock_guard lock(_mutex);
|
|
|
|
// for (auto *materialInstance : _materialInstances)
|
|
// {
|
|
// _engine->destroy(materialInstance);
|
|
// }
|
|
// _materialInstances.clear();
|
|
// }
|
|
|
|
// void SceneManager::destroy(SceneAsset *asset)
|
|
// {
|
|
|
|
// std::lock_guard lock(_mutex);
|
|
|
|
// auto entity = asset->getEntity();
|
|
// _collisionComponentManager->removeComponent(entity);
|
|
// _animationManager->removeAnimationComponent(utils::Entity::smuggle(entity));
|
|
// for (int i = 0; i < asset->getChildEntityCount(); i++)
|
|
// {
|
|
// auto childEntity = asset->getChildEntities()[i];
|
|
// _collisionComponentManager->removeComponent(childEntity);
|
|
// _animationManager->removeAnimationComponent(utils::Entity::smuggle(childEntity));
|
|
// }
|
|
// asset->removeAllEntities(_scene);
|
|
// if (asset->isInstance())
|
|
// {
|
|
// asset->destroyInstance(asset);
|
|
// }
|
|
// else
|
|
// {
|
|
// auto it = std::remove_if(_sceneAssets.begin(), _sceneAssets.end(), [=](auto &sceneAsset)
|
|
// { return sceneAsset.get() == asset; });
|
|
// _sceneAssets.erase(it, _sceneAssets.end());
|
|
// }
|
|
// }
|
|
|
|
// utils::Entity SceneManager::addLight(
|
|
// LightManager::Type t,
|
|
// float colour,
|
|
// float intensity,
|
|
// float posX,
|
|
// float posY,
|
|
// float posZ,
|
|
// float dirX,
|
|
// float dirY,
|
|
// float dirZ,
|
|
// float falloffRadius,
|
|
// float spotLightConeInner,
|
|
// float spotLightConeOuter,
|
|
// float sunAngularRadius,
|
|
// float sunHaloSize,
|
|
// float sunHaloFallof,
|
|
// bool shadows)
|
|
// {
|
|
// auto light = EntityManager::get().create();
|
|
|
|
// // LightManager::ShadowOptions shadowOptions;
|
|
// // shadowOptions.stable = true;
|
|
|
|
// auto result = LightManager::Builder(t)
|
|
// .color(Color::cct(colour))
|
|
// .intensity(intensity)
|
|
// .falloff(falloffRadius)
|
|
// .spotLightCone(spotLightConeInner, spotLightConeOuter)
|
|
// .sunAngularRadius(sunAngularRadius)
|
|
// .sunHaloSize(sunHaloSize)
|
|
// .sunHaloFalloff(sunHaloFallof)
|
|
// .position(filament::math::float3(posX, posY, posZ))
|
|
// .direction(filament::math::float3(dirX, dirY, dirZ))
|
|
// // .shadowOptions(shadowOptions)
|
|
// .castShadows(shadows)
|
|
// .build(*_engine, light);
|
|
// if (result != LightManager::Builder::Result::Success)
|
|
// {
|
|
// Log("ERROR : failed to create light");
|
|
// }
|
|
// else
|
|
// {
|
|
// _scene->addEntity(light);
|
|
// _lights.push_back(light);
|
|
// TRACE("Created light");
|
|
// }
|
|
|
|
// return light;
|
|
// }
|
|
|
|
// void SceneManager::removeLight(utils::Entity entity)
|
|
// {
|
|
// auto removed = remove(_lights.begin(), _lights.end(), entity);
|
|
// _scene->remove(entity);
|
|
// EntityManager::get().destroy(1, &entity);
|
|
// }
|
|
|
|
// void SceneManager::destroyLights()
|
|
// {
|
|
// std::lock_guard lock(_mutex);
|
|
|
|
// _scene->removeEntities(_lights.data(), _lights.size());
|
|
// EntityManager::get().destroy(_lights.size(), _lights.data());
|
|
// _lights.clear();
|
|
// }
|
|
|
|
// void SceneManager::destroyAssets()
|
|
// {
|
|
// std::lock_guard lock(_mutex);
|
|
|
|
// for (auto &asset : _sceneAssets)
|
|
// {
|
|
// asset->removeAllEntities(_scene);
|
|
// for(int i = 0; i < asset->getInstanceCount(); i++) {
|
|
// asset->getInstanceAt(i)->removeAllEntities(_scene);
|
|
// }
|
|
// }
|
|
|
|
// _sceneAssets.clear();
|
|
// }
|
|
|
|
|
|
// void SceneManager::addCollisionComponent(EntityId entityId, void (*onCollisionCallback)(const EntityId entityId1, const EntityId entityId2), bool affectsTransform)
|
|
// {
|
|
// std::lock_guard lock(_mutex);
|
|
// utils::Entity entity = utils::Entity::import(entityId);
|
|
// for (auto &asset : _sceneAssets)
|
|
// {
|
|
// auto *instance = reinterpret_cast<GltfSceneAssetInstance *>(asset->getInstanceByEntity(entity));
|
|
// if (instance)
|
|
// {
|
|
// auto collisionInstance = _collisionComponentManager->addComponent(instance->getInstance()->getRoot());
|
|
// _collisionComponentManager->elementAt<0>(collisionInstance) = instance->getInstance()->getBoundingBox();
|
|
// _collisionComponentManager->elementAt<1>(collisionInstance) = onCollisionCallback;
|
|
// _collisionComponentManager->elementAt<2>(collisionInstance) = affectsTransform;
|
|
// return;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// void SceneManager::removeCollisionComponent(EntityId entityId)
|
|
// {
|
|
// std::lock_guard lock(_mutex);
|
|
// utils::Entity entity = utils::Entity::import(entityId);
|
|
// _collisionComponentManager->removeComponent(entity);
|
|
// }
|
|
|
|
// void SceneManager::testCollisions(EntityId entityId)
|
|
// {
|
|
// utils::Entity entity = utils::Entity::import(entityId);
|
|
// for (auto &asset : _sceneAssets)
|
|
// {
|
|
// auto *instance = reinterpret_cast<GltfSceneAssetInstance *>(asset->getInstanceByEntity(entity));
|
|
// if (instance)
|
|
// {
|
|
// const auto &tm = _engine->getTransformManager();
|
|
// auto transformInstance = tm.getInstance(entity);
|
|
// auto worldTransform = tm.getWorldTransform(transformInstance);
|
|
// auto aabb = instance->getInstance()->getBoundingBox();
|
|
// aabb = aabb.transform(worldTransform);
|
|
// _collisionComponentManager->collides(entity, aabb);
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// void SceneManager::update()
|
|
// {
|
|
// _animationManager->update();
|
|
// _updateTransforms();
|
|
// }
|
|
|
|
// void SceneManager::_updateTransforms()
|
|
// {
|
|
// std::lock_guard lock(_mutex);
|
|
|
|
// // auto &tm = _engine->getTransformManager();
|
|
// // tm.openLocalTransformTransaction();
|
|
|
|
// // for (const auto &[entityId, transformUpdate] : _transformUpdates)
|
|
// // {
|
|
// // const auto &pos = _instances.find(entityId);
|
|
|
|
// // bool isCollidable = true;
|
|
// // Entity entity;
|
|
// // filament::TransformManager::Instance transformInstance;
|
|
// // filament::math::mat4f transform;
|
|
// // Aabb boundingBox;
|
|
// // if (pos == _instances.end())
|
|
// // {
|
|
// // isCollidable = false;
|
|
// // entity = Entity::import(entityId);
|
|
// // }
|
|
// // else
|
|
// // {
|
|
// // const auto *instance = pos->second;
|
|
// // entity = instance->getRoot();
|
|
// // boundingBox = instance->getBoundingBox();
|
|
// // }
|
|
|
|
// // transformInstance = tm.getInstance(entity);
|
|
// // transform = tm.getTransform(transformInstance);
|
|
|
|
// // if (isCollidable)
|
|
// // {
|
|
// // auto transformedBB = boundingBox.transform(transform);
|
|
|
|
// // auto collisionAxes = _collisionComponentManager->collides(entity, transformedBB);
|
|
|
|
// // if (collisionAxes.size() == 1)
|
|
// // {
|
|
// // // auto globalAxis = collisionAxes[0];
|
|
// // // globalAxis *= norm(relativeTranslation);
|
|
// // // auto newRelativeTranslation = relativeTranslation + globalAxis;
|
|
// // // translation -= relativeTranslation;
|
|
// // // translation += newRelativeTranslation;
|
|
// // // transform = composeMatrix(translation, rotation, scale);
|
|
// // }
|
|
// // else if (collisionAxes.size() > 1)
|
|
// // {
|
|
// // // translation -= relativeTranslation;
|
|
// // // transform = composeMatrix(translation, rotation, scale);
|
|
// // }
|
|
// // }
|
|
// // tm.setTransform(transformInstance, transformUpdate);
|
|
// // }
|
|
// // tm.commitLocalTransformTransaction();
|
|
// // _transformUpdates.clear();
|
|
// }
|
|
|
|
// void SceneManager::queueRelativePositionUpdateFromViewportVector(View *view, EntityId entityId, float viewportCoordX, float viewportCoordY)
|
|
// {
|
|
// // Get the camera and viewport
|
|
// const auto &camera = view->getCamera();
|
|
// const auto &vp = view->getViewport();
|
|
|
|
// // Convert viewport coordinates to NDC space
|
|
// float ndcX = (2.0f * viewportCoordX) / vp.width - 1.0f;
|
|
// float ndcY = 1.0f - (2.0f * viewportCoordY) / vp.height;
|
|
|
|
// // Get the current position of the entity
|
|
// auto &tm = _engine->getTransformManager();
|
|
// auto entity = Entity::import(entityId);
|
|
// auto transformInstance = tm.getInstance(entity);
|
|
// auto currentTransform = tm.getTransform(transformInstance);
|
|
|
|
// // get entity model origin in camera space
|
|
// auto entityPositionInCameraSpace = camera.getViewMatrix() * currentTransform * filament::math::float4{0.0f, 0.0f, 0.0f, 1.0f};
|
|
// // get entity model origin in clip space
|
|
// auto entityPositionInClipSpace = camera.getProjectionMatrix() * entityPositionInCameraSpace;
|
|
// auto entityPositionInNdcSpace = entityPositionInClipSpace / entityPositionInClipSpace.w;
|
|
|
|
// // Viewport coords in NDC space (use entity position in camera space Z to project onto near plane)
|
|
// math::float4 ndcNearPlanePos = {ndcX, ndcY, -1.0f, 1.0f};
|
|
// math::float4 ndcFarPlanePos = {ndcX, ndcY, 0.99f, 1.0f};
|
|
// math::float4 ndcEntityPlanePos = {ndcX, ndcY, entityPositionInNdcSpace.z, 1.0f};
|
|
|
|
// // Get viewport coords in clip space
|
|
// math::float4 nearPlaneInClipSpace = Camera::inverseProjection(camera.getProjectionMatrix()) * ndcNearPlanePos;
|
|
// auto nearPlaneInCameraSpace = nearPlaneInClipSpace / nearPlaneInClipSpace.w;
|
|
// math::float4 farPlaneInClipSpace = Camera::inverseProjection(camera.getProjectionMatrix()) * ndcFarPlanePos;
|
|
// auto farPlaneInCameraSpace = farPlaneInClipSpace / farPlaneInClipSpace.w;
|
|
// math::float4 entityPlaneInClipSpace = Camera::inverseProjection(camera.getProjectionMatrix()) * ndcEntityPlanePos;
|
|
// auto entityPlaneInCameraSpace = entityPlaneInClipSpace / entityPlaneInClipSpace.w;
|
|
// auto entityPlaneInWorldSpace = camera.getModelMatrix() * entityPlaneInCameraSpace;
|
|
// }
|
|
|
|
// void SceneManager::queueTransformUpdates(EntityId *entities, math::mat4 *transforms, int numEntities)
|
|
// {
|
|
// std::lock_guard lock(_mutex);
|
|
|
|
// for (int i = 0; i < numEntities; i++)
|
|
// {
|
|
// auto entity = entities[i];
|
|
// const auto &pos = _transformUpdates.find(entity);
|
|
// if (pos == _transformUpdates.end())
|
|
// {
|
|
// _transformUpdates.emplace(entity, transforms[i]);
|
|
// }
|
|
// auto curr = _transformUpdates[entity];
|
|
// _transformUpdates[entity] = curr;
|
|
// }
|
|
// }
|
|
|
|
// Aabb3 SceneManager::getRenderableBoundingBox(EntityId entityId)
|
|
// {
|
|
// auto &rm = _engine->getRenderableManager();
|
|
// auto instance = rm.getInstance(Entity::import(entityId));
|
|
// if (!instance.isValid())
|
|
// {
|
|
// return Aabb3{};
|
|
// }
|
|
// auto box = rm.getAxisAlignedBoundingBox(instance);
|
|
// return Aabb3{box.center.x, box.center.y, box.center.z, box.halfExtent.x, box.halfExtent.y, box.halfExtent.z};
|
|
// }
|
|
|
|
// Aabb2 SceneManager::getScreenSpaceBoundingBox(View *view, EntityId entityId)
|
|
// {
|
|
// const auto &camera = view->getCamera();
|
|
// const auto &viewport = view->getViewport();
|
|
|
|
// auto &tcm = _engine->getTransformManager();
|
|
// auto &rcm = _engine->getRenderableManager();
|
|
|
|
// // Get the projection and view matrices
|
|
// math::mat4 projMatrix = camera.getProjectionMatrix();
|
|
// math::mat4 viewMatrix = camera.getViewMatrix();
|
|
// math::mat4 vpMatrix = projMatrix * viewMatrix;
|
|
|
|
// auto entity = Entity::import(entityId);
|
|
|
|
// auto renderable = rcm.getInstance(entity);
|
|
// auto worldTransform = tcm.getWorldTransform(tcm.getInstance(entity));
|
|
|
|
// // Get the axis-aligned bounding box in model space
|
|
// Box aabb = rcm.getAxisAlignedBoundingBox(renderable);
|
|
|
|
// auto min = aabb.getMin();
|
|
// auto max = aabb.getMax();
|
|
|
|
// // Transform the 8 corners of the AABB to clip space
|
|
// std::array<math::float4, 8> corners = {
|
|
// worldTransform * math::float4(min.x, min.y, min.z, 1.0f),
|
|
// worldTransform * math::float4(max.x, min.y, min.z, 1.0f),
|
|
// worldTransform * math::float4(min.x, max.y, min.z, 1.0f),
|
|
// worldTransform * math::float4(max.x, max.y, min.z, 1.0f),
|
|
// worldTransform * math::float4(min.x, min.y, max.z, 1.0f),
|
|
// worldTransform * math::float4(max.x, min.y, max.z, 1.0f),
|
|
// worldTransform * math::float4(min.x, max.y, max.z, 1.0f),
|
|
// worldTransform * math::float4(max.x, max.y, max.z, 1.0f)};
|
|
|
|
// // Project corners to clip space and convert to viewport space
|
|
// float minX = std::numeric_limits<float>::max();
|
|
// float minY = std::numeric_limits<float>::max();
|
|
// float maxX = std::numeric_limits<float>::lowest();
|
|
// float maxY = std::numeric_limits<float>::lowest();
|
|
|
|
// for (const auto &corner : corners)
|
|
// {
|
|
|
|
// math::float4 clipSpace = vpMatrix * corner;
|
|
|
|
// // Check if the point is behind the camera
|
|
// if (clipSpace.w <= 0)
|
|
// {
|
|
// continue; // Skip this point
|
|
// }
|
|
|
|
// // Perform perspective division
|
|
// math::float3 ndcSpace = clipSpace.xyz / clipSpace.w;
|
|
|
|
// // Clamp NDC coordinates to [-1, 1] range
|
|
// ndcSpace.x = std::max(-1.0f, std::min(1.0f, ndcSpace.x));
|
|
// ndcSpace.y = std::max(-1.0f, std::min(1.0f, ndcSpace.y));
|
|
|
|
// // Convert NDC to viewport space
|
|
// float viewportX = (ndcSpace.x * 0.5f + 0.5f) * viewport.width;
|
|
// float viewportY = (1.0f - (ndcSpace.y * 0.5f + 0.5f)) * viewport.height; // Flip Y-axis
|
|
|
|
// minX = std::min(minX, viewportX);
|
|
// minY = std::min(minY, viewportY);
|
|
// maxX = std::max(maxX, viewportX);
|
|
// maxY = std::max(maxY, viewportY);
|
|
// }
|
|
|
|
// return Aabb2{minX, minY, maxX, maxY};
|
|
// }
|
|
|
|
// static filament::gltfio::MaterialKey getDefaultUnlitMaterialConfig(int numUvs)
|
|
// {
|
|
// filament::gltfio::MaterialKey config;
|
|
// memset(&config, 0, sizeof(config));
|
|
|
|
// config.unlit = false;
|
|
// config.doubleSided = false;
|
|
// config.useSpecularGlossiness = false;
|
|
// config.alphaMode = filament::gltfio::AlphaMode::OPAQUE;
|
|
// config.hasBaseColorTexture = numUvs > 0;
|
|
// config.baseColorUV = 0;
|
|
// config.hasVertexColors = false;
|
|
|
|
// return config;
|
|
// }
|
|
|
|
// SceneAsset *SceneManager::createGeometry(
|
|
// float *vertices,
|
|
// uint32_t numVertices,
|
|
// float *normals,
|
|
// uint32_t numNormals,
|
|
// float *uvs,
|
|
// uint32_t numUvs,
|
|
// uint16_t *indices,
|
|
// uint32_t numIndices,
|
|
// filament::RenderableManager::PrimitiveType primitiveType,
|
|
// filament::MaterialInstance **materialInstances,
|
|
// size_t materialInstanceCount,
|
|
// bool keepData)
|
|
// {
|
|
// utils::Entity entity;
|
|
|
|
// auto builder = GeometrySceneAssetBuilder(_engine)
|
|
// .vertices(vertices, numVertices)
|
|
// .indices(indices, numIndices)
|
|
// .primitiveType(primitiveType);
|
|
|
|
// if (normals)
|
|
// {
|
|
// builder.normals(normals, numNormals);
|
|
// }
|
|
|
|
// if (uvs)
|
|
// {
|
|
// builder.uvs(uvs, numUvs);
|
|
// }
|
|
|
|
// builder.materials(materialInstances, materialInstanceCount);
|
|
|
|
// auto sceneAsset = builder.build();
|
|
|
|
// if (!sceneAsset)
|
|
// {
|
|
// Log("Failed to create geometry");
|
|
// return std::nullptr_t();
|
|
// }
|
|
|
|
// sceneAsset->addAllEntities(_scene);
|
|
// auto *raw = sceneAsset.get();
|
|
// _sceneAssets.push_back(std::move(sceneAsset));
|
|
// return raw;
|
|
// }
|
|
|
|
// void SceneManager::destroy(filament::MaterialInstance *instance)
|
|
// {
|
|
// auto it = std::find(_materialInstances.begin(), _materialInstances.end(), instance);
|
|
// if (it != _materialInstances.end())
|
|
// {
|
|
// _materialInstances.erase(it);
|
|
// }
|
|
// _engine->destroy(instance);
|
|
// }
|
|
|
|
// MaterialInstance *SceneManager::createUnlitFixedSizeMaterialInstance()
|
|
// {
|
|
// auto instance = _unlitFixedSizeMaterial->createInstance();
|
|
// instance->setParameter("scale", 1.0f);
|
|
// return instance;
|
|
// }
|
|
|
|
// MaterialInstance *SceneManager::createUnlitMaterialInstance()
|
|
// {
|
|
// UvMap uvmap;
|
|
// auto instance = _unlitMaterialProvider->createMaterialInstance(nullptr, &uvmap);
|
|
// instance->setParameter("baseColorFactor", filament::math::float4{1.0f, 1.0f, 1.0f, 1.0f});
|
|
// instance->setParameter("baseColorIndex", -1);
|
|
// instance->setParameter("uvScale", filament::math::float2{1.0f, 1.0f});
|
|
// _materialInstances.push_back(instance);
|
|
// return instance;
|
|
// }
|
|
|
|
// Camera *SceneManager::createCamera()
|
|
// {
|
|
// auto entity = EntityManager::get().create();
|
|
// auto camera = _engine->createCamera(entity);
|
|
// _cameras.push_back(camera);
|
|
// return camera;
|
|
// }
|
|
|
|
// void SceneManager::destroyCamera(Camera *camera)
|
|
// {
|
|
// auto entity = camera->getEntity();
|
|
// _engine->destroyCameraComponent(entity);
|
|
// _engine->getEntityManager().destroy(entity);
|
|
// auto it = std::find(_cameras.begin(), _cameras.end(), camera);
|
|
// if (it != _cameras.end())
|
|
// {
|
|
// _cameras.erase(it);
|
|
// }
|
|
// }
|
|
|
|
// size_t SceneManager::getCameraCount()
|
|
// {
|
|
// return _cameras.size() + 1;
|
|
// }
|
|
|
|
// Camera *SceneManager::getCameraAt(size_t index)
|
|
// {
|
|
// if (index == 0)
|
|
// {
|
|
// return _mainCamera;
|
|
// }
|
|
// if (index - 1 > _cameras.size() - 1)
|
|
// {
|
|
// return nullptr;
|
|
// }
|
|
// return _cameras[index - 1];
|
|
// }
|
|
|
|
|
|
// } // namespace thermion
|