maobo/cup_edit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

remove old SceneManager references

Browse Source
This commit is contained in:
Nick Fisher
2025-03-28 15:49:51 +08:00
parent b083c62bd4
commit 99217499f9
3 changed files with 0 additions and 715 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
thermion_dart/native/include/c_api/TSceneManager_HBAK
View File

@@ -1,88 +0,0 @@
// #pragma once
// #include "APIBoundaryTypes.h"
// #include "MathUtils.hpp"
// #include "TCamera.h"
// #include "TMaterialInstance.h"
// #ifdef __cplusplus
// extern "C"
// {
// #endif
// EMSCRIPTEN_KEEPALIVE TGizmo *SceneManager_createGizmo(TSceneManager *tSceneManager, TView *tView, TScene *tScene, TGizmoType tGizmoType);
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGeometry(
// TSceneManager *sceneManager,
// float *vertices,
// int numVertices,
// float *normals,
// int numNormals,
// float *uvs,
// int numUvs,
// uint16_t *indices,
// int numIndices,
// int primitiveType,
// TMaterialInstance **materialInstances,
// int materialInstanceCount,
// bool keepData);
// EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUbershaderMaterialProvider(TSceneManager *sceneManager);
// EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUnlitMaterialProvider(TSceneManager *sceneManager);
// EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitMaterialInstance(TSceneManager *sceneManager);
// EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitFixedSizeMaterialInstance(TSceneManager *sceneManager);
// EMSCRIPTEN_KEEPALIVE void SceneManager_queueTransformUpdates(TSceneManager *sceneManager, EntityId *entities, const double *const transforms, int numEntities);
// EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_findCameraByName(TSceneManager *tSceneManager, EntityId entity, const char *name);
// EMSCRIPTEN_KEEPALIVE void SceneManager_setVisibilityLayer(TSceneManager *tSceneManager, EntityId entity, int layer);
// EMSCRIPTEN_KEEPALIVE TScene *SceneManager_getScene(TSceneManager *tSceneManager);
// EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_createCamera(TSceneManager *sceneManager);
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyCamera(TSceneManager *sceneManager, TCamera *camera);
// EMSCRIPTEN_KEEPALIVE size_t SceneManager_getCameraCount(TSceneManager *sceneManager);
// EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraAt(TSceneManager *sceneManager, size_t index);
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyMaterialInstance(TSceneManager *sceneManager, TMaterialInstance *instance);
// EMSCRIPTEN_KEEPALIVE Aabb3 SceneManager_getRenderableBoundingBox(TSceneManager *tSceneManager, EntityId entity);
// EMSCRIPTEN_KEEPALIVE int SceneManager_addToScene(TSceneManager *tSceneManager, EntityId entity);
// EMSCRIPTEN_KEEPALIVE int SceneManager_removeFromScene(TSceneManager *tSceneManager, EntityId entity);
// EMSCRIPTEN_KEEPALIVE void SceneManager_transformToUnitCube(TSceneManager *sceneManager, EntityId asset);
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlbFromBuffer(TSceneManager *tSceneManager, const uint8_t *const, size_t length, int numInstances, bool keepData, int priority, int layer, bool loadResourcesAsync);
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlb(TSceneManager *sceneManager, const char *assetPath, int numInstances, bool keepData);
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGltf(TSceneManager *sceneManager, const char *assetPath, const char *relativePath, bool keepData);
// EMSCRIPTEN_KEEPALIVE EntityId SceneManager_addLight(
// TSceneManager *tSceneManager,
// uint8_t type,
// 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);
// EMSCRIPTEN_KEEPALIVE void SceneManager_removeLight(TSceneManager *tSceneManager, EntityId entityId);
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyLights(TSceneManager *tSceneManager);
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAsset(TSceneManager *tSceneManager, TSceneAsset *sceneAsset);
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssets(TSceneManager *tSceneManager);
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAll(TSceneManager *tSceneManager);
// EMSCRIPTEN_KEEPALIVE TAnimationManager *SceneManager_getAnimationManager(TSceneManager *tSceneManager);
// EMSCRIPTEN_KEEPALIVE TNameComponentManager *SceneManager_getNameComponentManager(TSceneManager *tSceneManager);
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGrid(TSceneManager *tSceneManager, TMaterial *tMaterial);
// EMSCRIPTEN_KEEPALIVE bool SceneManager_isGridEntity(TSceneManager *tSceneManager, EntityId entityId);
// #ifdef __cplusplus
// }
// #endif

362
thermion_dart/native/include/scene/SceneManager.hpp
View File

@@ -1,362 +0,0 @@
#pragma once
#include <mutex>
#include <vector>
#include <memory>
#include <map>
#include <set>
#include <filament/Camera.h>
#include <filament/IndexBuffer.h>
#include <filament/InstanceBuffer.h>
#include <filament/LightManager.h>
#include <filament/Scene.h>
#include <filament/View.h>
#include <gltfio/AssetLoader.h>
#include <gltfio/FilamentAsset.h>
#include <gltfio/FilamentInstance.h>
#include <gltfio/ResourceLoader.h>
#include <utils/NameComponentManager.h>
#include "tsl/robin_map.h"
#include "AnimationManager.hpp"
#include "CustomGeometry.hpp"
#include "Gizmo.hpp"
#include "GridOverlay.hpp"
#include "ResourceBuffer.hpp"
#include "SceneAsset.hpp"
#include "components/CollisionComponentManager.hpp"
namespace thermion
{
typedef int32_t EntityId;
using namespace filament;
using namespace filament::gltfio;
using namespace utils;
using std::string;
using std::unique_ptr;
using std::vector;
class SceneManager
{
public:
SceneManager(
const ResourceLoaderWrapperImpl *const loader,
Engine *engine,
Scene *scene,
const char *uberArchivePath,
Camera *mainCamera);
~SceneManager();
enum LAYERS
{
DEFAULT_ASSETS = 0,
BACKGROUND = 6,
OVERLAY = 7,
};
enum GizmoType {
TRANSLATION,
ROTATION
};
////
/// @brief Load the glTF file from the specified path and adds all entities to the scene.
/// @param uri the path to the asset. Should be either asset:// (representing a Flutter asset), or file:// (representing a filesystem file).
/// @param relativeResourcePath the (relative) path to the asset's resources.
/// @return the glTF entity.
///
SceneAsset* loadGltf(const char *uri, const char *relativeResourcePath, int numInstances = 1, bool keepData = false);
////
/// @brief Load the GLB from the specified path, optionally creating multiple instances.
/// @param uri the path to the asset. Should be either asset:// (representing a Flutter asset), or file:// (representing a filesystem file).
/// @param numInstances the number of instances to create. Must be at least 1.
/// @return an Entity representing the FilamentAsset associated with the loaded FilamentAsset.
///
SceneAsset* loadGlb(const char *uri, int numInstances, bool keepData);
/// @brief
/// @param data
/// @param length
/// @param numInstances
/// @param keepData
/// @param priority
/// @param layer
/// @param loadResourcesAsync
/// @return
SceneAsset* loadGlbFromBuffer(const uint8_t *data, size_t length, int numInstances = 1, bool keepData = false, int priority = 4, int layer = 0, bool loadResourcesAsync = false, bool addToScene = true);
/// @brief Destroys all assets and instances.
///
utils::Entity addLight(
filament::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);
/// @brief Removes/destroys the light.
///
void removeLight(utils::Entity entity);
///
/// Creates an instance of the given entity.
/// This may return an instance from a pool of inactive instances; see [remove] for more information.
/// If [materialInstances] is provided, these wil
///
SceneAsset* createInstance(SceneAsset* asset, MaterialInstance **materialInstances = nullptr, size_t materialInstanceCount = 0);
/// @brief Removes the asset (and all its child entities) from the scene and "destroys" all resources.
/// If the asset is not an instance, the asset will be deleted.
/// If the asset is an instance, [remove] is not guaranted to delete the asset. It may be returned to a pool of inactive instances.
/// From the user's perspective, this can be considered as destroyed.
/// @param entity
void destroy(SceneAsset* entity);
/// @brief Destroys all lights.
///
void destroyLights();
/// @brief Destroys all assets and instances.
///
void destroyAssets();
/// @brief Destroys all assets/instances, scenes, materials, etc.
///
void destroyAll();
/// @brief
/// @param entityId
void transformToUnitCube(EntityId entityId);
/// @brief
/// @param entities
/// @param transforms
/// @param numEntities
void queueTransformUpdates(EntityId *entities, math::mat4 *transforms, int numEntities);
/// @brief
/// @param entity
/// @param viewportCoordX
/// @param viewportCoordY
/// @param x
/// @param y
/// @param z
void queueRelativePositionUpdateWorldAxis(EntityId entity, float viewportCoordX, float viewportCoordY, float x, float y, float z);
/// @brief
/// @param view
/// @param entityId
/// @param viewportCoordX
/// @param viewportCoordY
void queueRelativePositionUpdateFromViewportVector(View *view, EntityId entityId, float viewportCoordX, float viewportCoordY);
const utils::Entity *getCameraEntities(EntityId e);
size_t getCameraEntityCount(EntityId e);
const utils::Entity *getLightEntities(EntityId e) noexcept;
size_t getLightEntityCount(EntityId e) noexcept;
/// @brief
void update();
/// @brief
/// @param entity
/// @return
bool removeFromScene(EntityId entity);
/// @brief
/// @param entity
/// @return
bool addToScene(EntityId entity);
/// @brief
/// @param entity
/// @param onCollisionCallback
/// @param affectsCollidingTransform
void addCollisionComponent(EntityId entity, void (*onCollisionCallback)(const EntityId entityId1, const EntityId entityId2), bool affectsCollidingTransform);
/// @brief
/// @param entityId
///
///
void removeCollisionComponent(EntityId entityId);
/// @brief
/// @param entity
void testCollisions(EntityId entity);
/// @brief returns the number of instances of the FilamentAsset represented by the given entity.
/// @param entityId
/// @return the number of instances
int getInstanceCount(EntityId entityId);
/// @brief returns an array containing all instances of the FilamentAsset represented by the given entity.
/// @param entityId
void getInstances(EntityId entityId, EntityId *out);
///
/// Sets the draw priority for the given entity. See RenderableManager.h for more details.
///
void setPriority(EntityId entity, int priority);
/// @brief returns the 2D min/max viewport coordinates of the bounding box for the specified enitty;
/// @param out a pointer large enough to store four floats (the min/max coordinates of the bounding box)
/// @return
///
Aabb2 getScreenSpaceBoundingBox(View *view, EntityId entity);
/// @brief returns the 3D bounding box of the renderable instance for the given entity.
/// @return the bounding box
///
Aabb3 getRenderableBoundingBox(EntityId entity);
///
/// Creates an entity with the specified geometry/material/normals and adds to the scene.
/// If [keepData] is true, stores
///
SceneAsset *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 = RenderableManager::PrimitiveType::TRIANGLES,
MaterialInstance **materialInstances = nullptr,
size_t materialInstanceCount = 0,
bool keepData = false);
gltfio::MaterialProvider *const getUnlitMaterialProvider()
{
return _unlitMaterialProvider;
}
gltfio::MaterialProvider *const getUbershaderMaterialProvider()
{
return _ubershaderProvider;
}
/// @brief
/// @param materialInstance
void destroy(MaterialInstance *materialInstance);
/// @brief
/// @return
MaterialInstance *createUnlitFixedSizeMaterialInstance();
/// @brief
/// @return
MaterialInstance *createUnlitMaterialInstance();
/// @brief
/// @param entityId
/// @param layer
void setVisibilityLayer(EntityId entityId, int layer);
/// @brief
/// @return
Camera *createCamera();
/// @brief
/// @param camera
void destroyCamera(Camera *camera);
/// @brief
/// @return
size_t getCameraCount();
/// @brief
/// @param index
/// @return
Camera *getCameraAt(size_t index);
/// @brief
/// @param view
/// @param scene
/// @return
Gizmo *createGizmo(View *view, Scene *scene, GizmoType type);
/// @brief
/// @return
Scene *getScene()
{
return _scene;
}
/// @brief
/// @return
AnimationManager *getAnimationManager() {
return _animationManager.get();
}
/// @brief
/// @return
NameComponentManager *getNameComponentManager() {
return _ncm;
}
SceneAsset *createGrid(Material *material);
bool isGridEntity(utils::Entity entity);
private:
gltfio::AssetLoader *_assetLoader = nullptr;
const ResourceLoaderWrapperImpl *const _resourceLoaderWrapper;
Engine *_engine = nullptr;
Scene *_scene = nullptr;
Camera *_mainCamera;
gltfio::MaterialKey _defaultUnlitConfig;
gltfio::MaterialProvider *_ubershaderProvider = nullptr;
gltfio::MaterialProvider *_unlitMaterialProvider = nullptr;
gltfio::ResourceLoader *_gltfResourceLoader = nullptr;
gltfio::TextureProvider *_stbDecoder = nullptr;
gltfio::TextureProvider *_ktxDecoder = nullptr;
std::mutex _mutex;
std::vector<MaterialInstance *> _materialInstances;
Material *_unlitFixedSizeMaterial = nullptr;
Material *_gizmoMaterial = nullptr;
SceneAsset *_translationGizmoGlb;
SceneAsset *_rotationGizmoGlb;
utils::NameComponentManager *_ncm;
tsl::robin_map<EntityId, math::mat4> _transformUpdates;
std::vector<Camera *> _cameras;
std::vector<utils::Entity> _lights;
std::vector<std::unique_ptr<SceneAsset>> _sceneAssets;
std::vector<std::unique_ptr<Gizmo>> _gizmos;
std::unique_ptr<AnimationManager> _animationManager = std::nullptr_t();
std::unique_ptr<CollisionComponentManager> _collisionComponentManager = std::nullptr_t();
std::unique_ptr<GridOverlay> _grid = std::nullptr_t();
void _updateTransforms();
};
}

265
thermion_dart/native/src/c_api/TSceneManager.cpp
View File

@@ -1,265 +0,0 @@
// #include <filament/LightManager.h>
// #include "c_api/APIExport.h"
// #include "ResourceBuffer.hpp"
// #include "FilamentViewer.hpp"
// #include "Log.hpp"
// using namespace thermion;
// extern "C"
// {
// #include "c_api/TSceneManager.h"
// EMSCRIPTEN_KEEPALIVE TScene *SceneManager_getScene(TSceneManager *tSceneManager)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return reinterpret_cast<TScene *>(sceneManager->getScene());
// }
// EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUnlitMaterialProvider(TSceneManager *tSceneManager)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto provider = sceneManager->getUnlitMaterialProvider();
// return reinterpret_cast<TMaterialProvider *>(provider);
// }
// EMSCRIPTEN_KEEPALIVE TMaterialProvider *SceneManager_getUbershaderMaterialProvider(TSceneManager *tSceneManager)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto provider = sceneManager->getUbershaderMaterialProvider();
// return reinterpret_cast<TMaterialProvider *>(provider);
// }
// EMSCRIPTEN_KEEPALIVE TGizmo *SceneManager_createGizmo(TSceneManager *tSceneManager, TView *tView, TScene *tScene, TGizmoType tGizmoType)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *scene = reinterpret_cast<Scene *>(tScene);
// auto *view = reinterpret_cast<View *>(tView);
// auto gizmo = sceneManager->createGizmo(view, scene, static_cast<SceneManager::GizmoType>(tGizmoType));
// return reinterpret_cast<TGizmo *>(gizmo);
// }
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlb(TSceneManager *tSceneManager, const char *assetPath, int numInstances, bool keepData)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *asset = sceneManager->loadGlb(assetPath, numInstances, keepData);
// return reinterpret_cast<TSceneAsset *>(asset);
// }
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGltf(TSceneManager *tSceneManager,
// const char *assetPath,
// const char *relativeResourcePath,
// bool keepData)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *asset = sceneManager->loadGltf(assetPath, relativeResourcePath, 1, keepData);
// return reinterpret_cast<TSceneAsset *>(asset);
// }
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_loadGlbFromBuffer(TSceneManager *tSceneManager, const uint8_t *const data, size_t length, int numInstances, bool keepData, int priority, int layer, bool loadResourcesAsync)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *asset = sceneManager->loadGlbFromBuffer((const uint8_t *)data, length, numInstances, keepData, priority, layer, loadResourcesAsync);
// return reinterpret_cast<TSceneAsset *>(asset);
// }
// EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraByName(TSceneManager *tSceneManager, EntityId entityId, const char *name)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return nullptr;
// }
// EMSCRIPTEN_KEEPALIVE Aabb3 SceneManager_getRenderableBoundingBox(TSceneManager *tSceneManager, EntityId entity)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return sceneManager->getRenderableBoundingBox(entity);
// }
// EMSCRIPTEN_KEEPALIVE void SceneManager_setVisibilityLayer(TSceneManager *tSceneManager, EntityId entity, int layer)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->setVisibilityLayer(entity, layer);
// }
// EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitMaterialInstance(TSceneManager *sceneManager)
// {
// auto *instance = ((SceneManager *)sceneManager)->createUnlitMaterialInstance();
// return reinterpret_cast<TMaterialInstance *>(instance);
// }
// EMSCRIPTEN_KEEPALIVE TMaterialInstance *SceneManager_createUnlitFixedSizeMaterialInstance(TSceneManager *sceneManager)
// {
// auto *instance = ((SceneManager *)sceneManager)->createUnlitFixedSizeMaterialInstance();
// return reinterpret_cast<TMaterialInstance *>(instance);
// }
// EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_createCamera(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return reinterpret_cast<TCamera *>(sceneManager->createCamera());
// }
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyCamera(TSceneManager *tSceneManager, TCamera *tCamera)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *camera = reinterpret_cast<Camera *>(tCamera);
// sceneManager->destroyCamera(camera);
// }
// EMSCRIPTEN_KEEPALIVE size_t SceneManager_getCameraCount(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return sceneManager->getCameraCount();
// }
// EMSCRIPTEN_KEEPALIVE TCamera *SceneManager_getCameraAt(TSceneManager *tSceneManager, size_t index)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *camera = sceneManager->getCameraAt(index);
// return reinterpret_cast<TCamera *>(camera);
// }
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGeometry(
// TSceneManager *tSceneManager,
// float *vertices,
// int numVertices,
// float *normals,
// int numNormals,
// float *uvs,
// int numUvs,
// uint16_t *indices,
// int numIndices,
// int primitiveType,
// TMaterialInstance **tMaterialInstances,
// int materialInstanceCount,
// bool keepData)
// {
// auto sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto castedNumVertices = static_cast<uint32_t>(numVertices);
// auto castedNumNormals = static_cast<uint32_t>(numNormals);
// auto castedNumUvs = static_cast<uint32_t>(numUvs);
// auto castedNumIndices = static_cast<uint32_t>(numIndices);
// auto castedPrimitiveType = static_cast<filament::RenderableManager::PrimitiveType>(primitiveType);
// auto materialInstances = reinterpret_cast<MaterialInstance **>(tMaterialInstances);
// auto *asset = sceneManager->createGeometry(
// vertices,
// castedNumVertices,
// normals,
// castedNumNormals,
// uvs,
// castedNumUvs,
// indices,
// castedNumIndices,
// castedPrimitiveType,
// materialInstances,
// materialInstanceCount,
// keepData);
// return reinterpret_cast<TSceneAsset *>(asset);
// }
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyMaterialInstance(TSceneManager *sceneManager, TMaterialInstance *instance)
// {
// ((SceneManager *)sceneManager)->destroy(reinterpret_cast<MaterialInstance *>(instance));
// }
// EMSCRIPTEN_KEEPALIVE int SceneManager_removeFromScene(TSceneManager *sceneManager, EntityId entityId)
// {
// return ((SceneManager *)sceneManager)->removeFromScene(entityId);
// }
// EMSCRIPTEN_KEEPALIVE int SceneManager_addToScene(TSceneManager *sceneManager, EntityId entityId)
// {
// return ((SceneManager *)sceneManager)->addToScene(entityId);
// }
// EMSCRIPTEN_KEEPALIVE void SceneManager_transformToUnitCube(TSceneManager *sceneManager, EntityId entityId)
// {
// ((SceneManager *)sceneManager)->transformToUnitCube(entityId);
// }
// EMSCRIPTEN_KEEPALIVE TAnimationManager *SceneManager_getAnimationManager(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *animationManager = sceneManager->getAnimationManager();
// return reinterpret_cast<TAnimationManager *>(animationManager);
// }
// EMSCRIPTEN_KEEPALIVE EntityId SceneManager_addLight(
// TSceneManager *tSceneManager,
// uint8_t type,
// 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 *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto entity = sceneManager->addLight(
// (LightManager::Type)type, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, falloffRadius, spotLightConeInner, spotLightConeOuter, sunAngularRadius, sunHaloSize, sunHaloFallof, shadows);
// return Entity::smuggle(entity);
// }
// EMSCRIPTEN_KEEPALIVE void SceneManager_removeLight(TSceneManager *tSceneManager, EntityId entityId)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->removeLight(utils::Entity::import(entityId));
// }
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAll(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->destroyAll();
// }
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAsset(TSceneManager *tSceneManager, TSceneAsset *tSceneAsset)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *sceneAsset = reinterpret_cast<SceneAsset *>(tSceneAsset);
// sceneManager->destroy(sceneAsset);
// }
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyLights(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->destroyLights();
// }
// EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssets(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// sceneManager->destroyAssets();
// }
// EMSCRIPTEN_KEEPALIVE TNameComponentManager *SceneManager_getNameComponentManager(TSceneManager *tSceneManager)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return reinterpret_cast<TNameComponentManager *>(sceneManager->getNameComponentManager());
// }
// EMSCRIPTEN_KEEPALIVE TSceneAsset *SceneManager_createGrid(TSceneManager *tSceneManager, TMaterial *tMaterial)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// auto *material = reinterpret_cast<Material *>(tMaterial);
// auto *grid = sceneManager->createGrid(material);
// return reinterpret_cast<TSceneAsset *>(grid);
// }
// EMSCRIPTEN_KEEPALIVE bool SceneManager_isGridEntity(TSceneManager *tSceneManager, EntityId entityId)
// {
// auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
// return sceneManager->isGridEntity(utils::Entity::import(entityId));
// }
// }