diff --git a/thermion_dart/native/include/RenderTicker.hpp b/thermion_dart/native/include/RenderTicker.hpp
index ae814f28..a92584db 100644
--- a/thermion_dart/native/include/RenderTicker.hpp
+++ b/thermion_dart/native/include/RenderTicker.hpp
@@ -36,13 +36,24 @@ namespace thermion
         RenderTicker(filament::Renderer *renderer) : mRenderer(renderer) { }
         ~RenderTicker();
         
+        /// @brief 
+        /// @param frameTimeInNanos 
         void render(
             uint64_t frameTimeInNanos
         );
+        
+        /// @brief 
+        /// @param swapChain 
+        /// @param view 
+        /// @param numViews 
         void setRenderable(filament::SwapChain *swapChain, filament::View **view, uint8_t numViews);
 
+        /// @brief 
+        /// @param animationManager 
         void addAnimationManager(AnimationManager* animationManager);
         
+        /// @brief 
+        /// @param animationManager 
         void removeAnimationManager(AnimationManager* animationManager);
 
 
diff --git a/thermion_dart/native/include/c_api/TAnimationManager.h b/thermion_dart/native/include/c_api/TAnimationManager.h
index b01374c8..ae8527c9 100644
--- a/thermion_dart/native/include/c_api/TAnimationManager.h
+++ b/thermion_dart/native/include/c_api/TAnimationManager.h
@@ -8,7 +8,7 @@ extern "C"
 {
 #endif
 
-	EMSCRIPTEN_KEEPALIVE TAnimationManager *AnimationManager_create(TEngine *tEngine);
+	EMSCRIPTEN_KEEPALIVE TAnimationManager *AnimationManager_create(TEngine *tEngine, TScene *tScene);
 
 	EMSCRIPTEN_KEEPALIVE void AnimationManager_addAnimationComponent(TAnimationManager *tAnimationManager, EntityId entityId);
 
diff --git a/thermion_dart/native/include/c_api/TEngine.h b/thermion_dart/native/include/c_api/TEngine.h
index edcbcda6..4028461d 100644
--- a/thermion_dart/native/include/c_api/TEngine.h
+++ b/thermion_dart/native/include/c_api/TEngine.h
@@ -27,7 +27,7 @@ EMSCRIPTEN_KEEPALIVE TEngine *Engine_create(
     bool disableHandleUseAfterFreeCheck
 );
 
-EMSCRIPTEN_KEEPALIVE TEngine *Engine_destroy(TEngine *tEngine);
+EMSCRIPTEN_KEEPALIVE void Engine_destroy(TEngine *tEngine);
 EMSCRIPTEN_KEEPALIVE TRenderer *Engine_createRenderer(TEngine *tEngine);
 EMSCRIPTEN_KEEPALIVE TSwapChain *Engine_createSwapChain(TEngine *tEngine, void *window, uint64_t flags);
 EMSCRIPTEN_KEEPALIVE TSwapChain *Engine_createHeadlessSwapChain(TEngine *tEngine, uint32_t width, uint32_t height, uint64_t flags);
diff --git a/thermion_dart/native/include/c_api/TLightManager.h b/thermion_dart/native/include/c_api/TLightManager.h
index 298a4eff..49e6659e 100644
--- a/thermion_dart/native/include/c_api/TLightManager.h
+++ b/thermion_dart/native/include/c_api/TLightManager.h
@@ -19,7 +19,7 @@ extern "C"
 
 	EMSCRIPTEN_KEEPALIVE void LightManager_setPosition(TLightManager *tLightManager, EntityId light, double x, double y, double z);
 	EMSCRIPTEN_KEEPALIVE void LightManager_setDirection(TLightManager *tLightManager, EntityId light, double x, double y, double z);
-	EMSCRIPTEN_KEEPALIVE int LightManager_createLight(TLightManager *tLightManager, TLightType tLightTtype);
+	EMSCRIPTEN_KEEPALIVE int LightManager_createLight(TEngine *tEngine, TLightManager *tLightManager, TLightType tLightTtype);
 	EMSCRIPTEN_KEEPALIVE void LightManager_destroyLight(TLightManager *tLightManager, EntityId entity);
 	EMSCRIPTEN_KEEPALIVE void LightManager_setColor(TLightManager *tLightManager, EntityId entity, float colorTemperature);
 	EMSCRIPTEN_KEEPALIVE void LightManager_setIntensity(TLightManager *tLightManager, EntityId entity, double intensity);
diff --git a/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h b/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
index e0957b0b..f8cc283d 100644
--- a/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
+++ b/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
@@ -17,7 +17,7 @@ namespace thermion
         EMSCRIPTEN_KEEPALIVE void RenderLoop_create();
         EMSCRIPTEN_KEEPALIVE void RenderLoop_destroy();
         EMSCRIPTEN_KEEPALIVE void RenderLoop_requestAnimationFrame(void (*onComplete));
-        EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos);
+        EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, void (*onComplete)());
         // EMSCRIPTEN_KEEPALIVE void RenderLoop_addTask(TRenderLoop* tRenderLoop, void (*task)());
 
         EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *));
@@ -75,7 +75,7 @@ namespace thermion
 
         EMSCRIPTEN_KEEPALIVE void Material_createInstanceRenderThread(TMaterial *tMaterial, void (*onComplete)(TMaterialInstance *));
 
-        EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, ToneMapping toneMapping);
+        EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, TToneMapping toneMapping);
         EMSCRIPTEN_KEEPALIVE void View_setBloomRenderThread(TView *tView, bool enabled, double strength);
         EMSCRIPTEN_KEEPALIVE void View_setCameraRenderThread(TView *tView, TCamera *tCamera, void (*callback)());
 
diff --git a/thermion_dart/native/include/scene/GeometrySceneAsset.hpp b/thermion_dart/native/include/scene/GeometrySceneAsset.hpp
index 02d42a8e..43ba6c8f 100644
--- a/thermion_dart/native/include/scene/GeometrySceneAsset.hpp
+++ b/thermion_dart/native/include/scene/GeometrySceneAsset.hpp
@@ -72,18 +72,6 @@ namespace thermion
             scene->remove(_entity);
         }
 
-        void setPriority(RenderableManager &rm, int priority) override
-        {
-            auto renderableInstance = rm.getInstance(_entity);
-            rm.setPriority(renderableInstance, priority);
-        }
-
-        void setLayer(RenderableManager &rm, int layer) override
-        {
-            auto renderableInstance = rm.getInstance(_entity);
-            rm.setLayerMask(renderableInstance, 0xFF, 1u << (uint8_t)layer);
-        }
-
         SceneAsset *getInstanceByEntity(utils::Entity entity) override
         {
             for (auto &instance : _instances)
diff --git a/thermion_dart/native/include/scene/Gizmo.hpp b/thermion_dart/native/include/scene/Gizmo.hpp
index 2c229b44..f4e500de 100644
--- a/thermion_dart/native/include/scene/Gizmo.hpp
+++ b/thermion_dart/native/include/scene/Gizmo.hpp
@@ -19,7 +19,6 @@
 #include <filament/IndexBuffer.h>
 #include <filament/InstanceBuffer.h>
 
-#include "c_api/ThermionDartApi.h"
 #include "scene/SceneAsset.hpp"
 
 namespace thermion
@@ -106,14 +105,6 @@ namespace thermion
             return utils::Entity::import(0);
         }
 
-        void setPriority(RenderableManager &rm, int mask) override
-        {
-        }
-
-        void setLayer(RenderableManager &rm, int layer) override
-        {
-        }
-
         void highlight(Gizmo::Axis axis);
         void unhighlight(Gizmo::Axis axis);
 
diff --git a/thermion_dart/native/include/scene/GltfSceneAssetInstance.hpp b/thermion_dart/native/include/scene/GltfSceneAssetInstance.hpp
index 78157e73..d99de6f8 100644
--- a/thermion_dart/native/include/scene/GltfSceneAssetInstance.hpp
+++ b/thermion_dart/native/include/scene/GltfSceneAssetInstance.hpp
@@ -133,32 +133,6 @@ namespace thermion
             return std::nullptr_t();
         }
 
-        void setPriority(RenderableManager &rm, int priority) override
-        {
-            const Entity *entities = _instance->getEntities();
-            for (int i = 0; i < _instance->getEntityCount(); i++)
-            {
-                if (rm.hasComponent(entities[i]))
-                {
-                    auto renderableInstance = rm.getInstance(entities[i]);
-                    rm.setPriority(renderableInstance, priority);
-                }
-            }
-        }
-
-        void setLayer(RenderableManager &rm, int layer) override
-        {
-            const Entity *entities = _instance->getEntities();
-            for (int i = 0; i < _instance->getEntityCount(); i++)
-            {
-                if (rm.hasComponent(entities[i]))
-                {
-                    auto renderableInstance = rm.getInstance(entities[i]);
-                    rm.setLayerMask(renderableInstance, 0xFF, 1u << (uint8_t)layer);
-                }
-            }
-        }
-
         const filament::Aabb getBoundingBox() const override {
             return _instance->getBoundingBox();
         }
diff --git a/thermion_dart/native/src/RenderTicker.cpp b/thermion_dart/native/src/RenderTicker.cpp
index 3d7df5ca..259fdfcd 100644
--- a/thermion_dart/native/src/RenderTicker.cpp
+++ b/thermion_dart/native/src/RenderTicker.cpp
@@ -49,21 +49,17 @@ namespace thermion
   void RenderTicker::setRenderable(SwapChain *swapChain, View **views, uint8_t numViews) {
     std::lock_guard lock(mMutex);
 
-    // Find if this swapChain already exists in our collection
     auto it = std::find_if(mRenderable.begin(), mRenderable.end(),
       [swapChain](const auto& pair) { return pair.first == swapChain; });
 
-    // Prepare the vector of views
     std::vector<View*> swapChainViews;
     for(int i = 0; i < numViews; i++) {
       swapChainViews.push_back(views[i]);
     }
     
     if (it != mRenderable.end()) {
-      // Update existing entry
       it->second = swapChainViews;
     } else {
-      // Add new entry
       mRenderable.emplace_back(swapChain, swapChainViews);
     }
   }
diff --git a/thermion_dart/native/src/c_api/TEngine.cpp b/thermion_dart/native/src/c_api/TEngine.cpp
index 62343ab6..e5049500 100644
--- a/thermion_dart/native/src/c_api/TEngine.cpp
+++ b/thermion_dart/native/src/c_api/TEngine.cpp
@@ -30,6 +30,7 @@
 #include <utils/NameComponentManager.h>
 
 #include "Log.hpp"
+#include "MathUtils.hpp"
 
 #ifdef __cplusplus
 namespace thermion
diff --git a/thermion_dart/native/src/c_api/TGltfAssetLoader.cpp b/thermion_dart/native/src/c_api/TGltfAssetLoader.cpp
index c4479937..e44dddf9 100644
--- a/thermion_dart/native/src/c_api/TGltfAssetLoader.cpp
+++ b/thermion_dart/native/src/c_api/TGltfAssetLoader.cpp
@@ -112,8 +112,8 @@ EMSCRIPTEN_KEEPALIVE TMaterialInstance *GltfAssetLoader_getMaterialInstance(TRen
 }
 
 EMSCRIPTEN_KEEPALIVE TMaterialProvider *GltfAssetLoader_getMaterialProvider(TGltfAssetLoader *tAssetLoader) {
-    auto *assetLoader = reinterpret_cast<gltfio::AssetLoader>(tAssetLoader);
-    auto materialProvider = assetLoader->getMaterialProvider();
+    auto *assetLoader = reinterpret_cast<gltfio::AssetLoader *>(tAssetLoader);
+    auto &materialProvider = assetLoader->getMaterialProvider();
     return reinterpret_cast<TMaterialProvider *>(&materialProvider);
 }
 
diff --git a/thermion_dart/native/src/c_api/TLightManager.cpp b/thermion_dart/native/src/c_api/TLightManager.cpp
index d004ca8d..0dd6eb34 100644
--- a/thermion_dart/native/src/c_api/TLightManager.cpp
+++ b/thermion_dart/native/src/c_api/TLightManager.cpp
@@ -48,7 +48,7 @@ EMSCRIPTEN_KEEPALIVE int LightManager_createLight(TEngine *tEngine, TLightManage
     filament::LightManager::Builder builder(lightType);
     auto entity = utils::EntityManager::create();
     auto result = builder.build(*engine, utils::Entity::import(entity));
-    if(result != filament::LightManager::Result::Success) { 
+    if(result != filament::LightManager::Builder::Result::Success) { 
         Log("Failed to create light");
     }
     return entity;
diff --git a/thermion_dart/native/src/c_api/TRenderTicker.cpp b/thermion_dart/native/src/c_api/TRenderTicker.cpp
index ea6447ea..833b7ef2 100644
--- a/thermion_dart/native/src/c_api/TRenderTicker.cpp
+++ b/thermion_dart/native/src/c_api/TRenderTicker.cpp
@@ -1,22 +1,23 @@
 #ifdef _WIN32
 #include "ThermionWin32.h"
 #endif
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#endif
 
 #include <thread>
 #include <functional>
 
-#ifdef __EMSCRIPTEN__
-#include <emscripten/emscripten.h>
-#endif
+#include <filament/LightManager.h>
 
-#include "filament/LightManager.h"
 #include "Log.hpp"
+#include "RenderTicker.hpp"
 
 using namespace thermion;
 
 extern "C"
 {
-#include "c_api/TRenderTicker.hpp"
+#include "c_api/TRenderTicker.h"
 
 EMSCRIPTEN_KEEPALIVE TRenderTicker *RenderTicker_create(TRenderer *tRenderer) {
     auto *renderer = reinterpret_cast<filament::Renderer *>(tRenderer);
@@ -24,7 +25,7 @@ EMSCRIPTEN_KEEPALIVE TRenderTicker *RenderTicker_create(TRenderer *tRenderer) {
     return reinterpret_cast<TRenderTicker *>(renderTicker);
 }
 
-EMSCRIPTEN_KEEPALIVE void RenderTicker_destroy(TRenderTicker *tRenderTicker,) {
+EMSCRIPTEN_KEEPALIVE void RenderTicker_destroy(TRenderTicker *tRenderTicker) {
     auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
     delete renderTicker;
 }
@@ -42,12 +43,14 @@ EMSCRIPTEN_KEEPALIVE void RenderTicker_removeAnimationManager(TRenderTicker *tRe
 }
 
 EMSCRIPTEN_KEEPALIVE void RenderTicker_render(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos) {
-    auto *renderTicker = reinterpret_cast<RenderTicker *>
+    auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
     renderTicker->render(frameTimeInNanos);
 }
 
-EMSCRIPTEN_KEEPALIVE void RenderTicker_setRenderable(TRenderTicker *tRenderTicker, TSwapChain *swapChain, TView **views, uint8_t numViews) {
-    auto *renderTicker = reinterpret_cast<RenderTicker *>
+EMSCRIPTEN_KEEPALIVE void RenderTicker_setRenderable(TRenderTicker *tRenderTicker, TSwapChain *tSwapChain, TView **tViews, uint8_t numViews) {
+    auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
+    auto *swapChain = reinterpret_cast<filament::SwapChain *>(tSwapChain);
+    auto *views = reinterpret_cast<View **>(tViews);
     renderTicker->setRenderable(swapChain, views, numViews);
 }
 
diff --git a/thermion_dart/native/src/c_api/TRenderableManager.cpp b/thermion_dart/native/src/c_api/TRenderableManager.cpp
index 1c839824..d09df6f4 100644
--- a/thermion_dart/native/src/c_api/TRenderableManager.cpp
+++ b/thermion_dart/native/src/c_api/TRenderableManager.cpp
@@ -119,16 +119,16 @@ namespace thermion
             const auto &entity = utils::Entity::import(entityId);
             auto renderableInstance = renderableManager->getInstance(entity);
             if (!renderableInstance.isValid()) {
-                return false;
+                return Aabb3 { };
             }
-            auto box = rm.getAxisAlignedBoundingBox(instance);
+            auto box = renderableManager.getAxisAlignedBoundingBox(renderableInstance);
             return Aabb3{box.center.x, box.center.y, box.center.z, box.halfExtent.x, box.halfExtent.y, box.halfExtent.z};            
         }
 
         EMSCRIPTEN_KEEPALIVE void RenderableManager_setVisibilityLayer(TRenderableManager *tRenderableManager, EntityId entityId, uint8_t layer) {
             auto *renderableManager = reinterpret_cast<filament::RenderableManager *>(tRenderableManager);
             const auto &entity = utils::Entity::import(entityId);
-            if (!renderableManager.hasComponent(entity)) {
+            if (!renderableManager->hasComponent(entity)) {
                 Log("Not renderable");
                 return;
             }
@@ -140,12 +140,12 @@ namespace thermion
             auto *renderableManager = reinterpret_cast<filament::RenderableManager *>(tRenderableManager);
             const auto &entity = utils::Entity::import(entityId);
             
-            if (!renderableManager.hasComponent(entity)) {
+            if (!renderableManager->hasComponent(entity)) {
                 Log("Not renderable");
                 return;
             }
             auto renderableInstance = renderableManager->getInstance(entity);
-            renderableManager->setPriority(renderableInstance, layer);
+            renderableManager->setPriority(renderableInstance, priority);
         }
 
     }
diff --git a/thermion_dart/native/src/c_api/TRenderer.cpp b/thermion_dart/native/src/c_api/TRenderer.cpp
index 669afdf8..82786336 100644
--- a/thermion_dart/native/src/c_api/TRenderer.cpp
+++ b/thermion_dart/native/src/c_api/TRenderer.cpp
@@ -26,7 +26,7 @@ namespace thermion
 
 #endif
 
-#include "c_api/ThermionDartApi.h"
+#include "c_api/TRenderer.h"
 
 EMSCRIPTEN_KEEPALIVE void Renderer_setClearOptions(TRenderer *tRenderer, double clearR, double clearG, double clearB, double clearA, uint8_t clearStencil, bool clear, bool discard) {
     auto *renderer = reinterpret_cast<filament::Renderer *>(tRenderer);
diff --git a/thermion_dart/native/src/c_api/TScene.cpp b/thermion_dart/native/src/c_api/TScene.cpp
index 9a1443d7..24eaff91 100644
--- a/thermion_dart/native/src/c_api/TScene.cpp
+++ b/thermion_dart/native/src/c_api/TScene.cpp
@@ -32,7 +32,7 @@ namespace thermion
         
         EMSCRIPTEN_KEEPALIVE void Scene_removeEntity(TScene* tScene, EntityId entityId) {
             auto *scene = reinterpret_cast<Scene *>(tScene);
-            scene->removeEntity(utils::Entity::import(entityId));
+            scene->remove(utils::Entity::import(entityId));
         }
 
         EMSCRIPTEN_KEEPALIVE void Scene_setSkybox(TScene* tScene, TSkybox *tSkybox) {
diff --git a/thermion_dart/native/src/c_api/TSceneManager.cpp b/thermion_dart/native/src/c_api/TSceneManager.cpp
index 52207631..20bef56b 100644
--- a/thermion_dart/native/src/c_api/TSceneManager.cpp
+++ b/thermion_dart/native/src/c_api/TSceneManager.cpp
@@ -1,265 +1,265 @@
-#include <filament/LightManager.h>
+// #include <filament/LightManager.h>
 
-#include "c_api/APIExport.h"
-#include "ResourceBuffer.hpp"
-#include "FilamentViewer.hpp"
-#include "Log.hpp"
+// #include "c_api/APIExport.h"
+// #include "ResourceBuffer.hpp"
+// #include "FilamentViewer.hpp"
+// #include "Log.hpp"
 
-using namespace thermion;
+// using namespace thermion;
 
-extern "C"
-{
+// extern "C"
+// {
 
-#include "c_api/TSceneManager.h"
+// #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 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_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 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 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_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_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 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 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 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 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_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 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 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 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 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 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);
+//     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);
-    }
+//         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 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_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 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 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 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 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_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_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_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_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 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 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 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));
-    }
-}
\ No newline at end of file
+//     EMSCRIPTEN_KEEPALIVE bool SceneManager_isGridEntity(TSceneManager *tSceneManager, EntityId entityId)
+//     {
+//         auto *sceneManager = reinterpret_cast<SceneManager *>(tSceneManager);
+//         return sceneManager->isGridEntity(utils::Entity::import(entityId));
+//     }
+// }
\ No newline at end of file
diff --git a/thermion_dart/native/src/c_api/TTexture.cpp b/thermion_dart/native/src/c_api/TTexture.cpp
index f750f947..05e88fb8 100644
--- a/thermion_dart/native/src/c_api/TTexture.cpp
+++ b/thermion_dart/native/src/c_api/TTexture.cpp
@@ -1,3 +1,5 @@
+#include <vector>
+
 #include "c_api/TTexture.h"
 
 #include <filament/Engine.h>
diff --git a/thermion_dart/native/src/c_api/TView.cpp b/thermion_dart/native/src/c_api/TView.cpp
index aa8d12c2..feb4df0f 100644
--- a/thermion_dart/native/src/c_api/TView.cpp
+++ b/thermion_dart/native/src/c_api/TView.cpp
@@ -5,7 +5,6 @@
 #include <filament/ColorGrading.h>
 #include <filament/Camera.h>
 
-#include "c_api/ThermionDartApi.h"
 #include "c_api/TView.h"
 #include "Log.hpp"
 
@@ -92,23 +91,23 @@ using namespace filament;
 #endif
     }
 
-    EMSCRIPTEN_KEEPALIVE void View_setToneMapping(TView *tView, TEngine *tEngine, ToneMapping toneMapping)
+    EMSCRIPTEN_KEEPALIVE void View_setToneMapping(TView *tView, TEngine *tEngine, TToneMapping tToneMapping)
     {
         auto view = reinterpret_cast<View *>(tView);
         auto engine = reinterpret_cast<Engine *>(tEngine);
 
         ToneMapper *tm;
-        switch (toneMapping)
+        switch (tToneMapping)
         {
-        case ToneMapping::ACES:
+        case TToneMapping::ACES:
             Log("Setting tone mapping to ACES");
             tm = new ACESToneMapper();
             break;
-        case ToneMapping::LINEAR:
+        case TToneMapping::LINEAR:
             Log("Setting tone mapping to Linear");
             tm = new LinearToneMapper();
             break;
-        case ToneMapping::FILMIC:
+        case TToneMapping::FILMIC:
             Log("Setting tone mapping to Filmic");
             tm = new FilmicToneMapper();
             break;
diff --git a/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp b/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
index 723701d5..ed80f706 100644
--- a/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
+++ b/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
@@ -10,15 +10,15 @@
 #include "c_api/TEngine.h"
 #include "c_api/TGltfAssetLoader.h"
 #include "c_api/TRenderer.h"
+#include "c_api/TRenderTicker.h"
 #include "c_api/TRenderTarget.h"
 #include "c_api/TScene.h"
 #include "c_api/TSceneAsset.h"
-#include "c_api/TSceneManager.h"
 #include "c_api/TTexture.h"
 #include "c_api/TView.h"
 #include "c_api/ThermionDartRenderThreadApi.h"
 
-#include "RenderTicker.hpp"
+
 #include "rendering/RenderLoop.hpp"
 #include "Log.hpp"
 
@@ -50,12 +50,12 @@ extern "C"
     }
   }
 
-  EMSCRIPTEN_KEEPALIVE void RenderLoop_requestAnimationFrame(void (*onComplete)) {
+  EMSCRIPTEN_KEEPALIVE void RenderLoop_requestAnimationFrame(void (*onComplete)()) {
     _rl->requestFrame(onComplete);
   }
 
   
-  EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, , uint64_t frameTimeInNanos, void (*onComplete)()) {
+  EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, void (*onComplete)()) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
@@ -65,11 +65,17 @@ extern "C"
     auto fut = _rl->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_createRenderThread(TBackend backend, void (*onComplete)(TEngine *)) {
+  EMSCRIPTEN_KEEPALIVE void Engine_createRenderThread(
+    TBackend backend,
+    void* platform,
+    void* sharedContext,
+    uint8_t stereoscopicEyeCount,
+    bool disableHandleUseAfterFreeCheck,
+    void (*onComplete)(TEngine *)) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
-        auto engine = Engine_create(backend);
+        auto engine = Engine_create(backend, platform, sharedContext, stereoscopicEyeCount, disableHandleUseAfterFreeCheck);
         onComplete(engine);
       });
     auto fut = _rl->add_task(lambda);
@@ -109,7 +115,7 @@ extern "C"
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
-        Engine_destroySwapChain(tEngine);
+        Engine_destroySwapChain(tEngine, tSwapChain);
         onComplete();
       });
     auto fut = _rl->add_task(lambda);
@@ -324,74 +330,6 @@ extern "C"
     auto fut = _rl->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Viewer_renderRenderThread(TViewer *viewer, TView *tView, TSwapChain *tSwapChain)
-  {
-    std::packaged_task<void()> lambda([=]() mutable
-                                      { _rl->doRender(); });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_createGridRenderThread(TSceneManager *tSceneManager, TMaterial *tMaterial, void (*callback)(TSceneAsset *))
-  {
-    std::packaged_task<void()> lambda([=]() mutable
-                                      {
-      auto *sceneAsset = SceneManager_createGrid(tSceneManager, tMaterial);
-      callback(sceneAsset); });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_loadGltfRenderThread(TSceneManager *sceneManager,
-                                                              const char *path,
-                                                              const char *relativeResourcePath,
-                                                              bool keepData,
-                                                              void (*callback)(TSceneAsset *))
-  {
-    std::packaged_task<void()> lambda([=]() mutable
-                                      {
-      auto entity = SceneManager_loadGltf(sceneManager, path, relativeResourcePath, keepData);
-      callback(entity); });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_loadGlbRenderThread(TSceneManager *sceneManager,
-                                                             const char *path,
-                                                             int numInstances,
-                                                             bool keepData,
-                                                             void (*callback)(TSceneAsset *))
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          auto asset = SceneManager_loadGlb(sceneManager, path, numInstances, keepData);
-          callback(asset);
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_createGeometryRenderThread(
-      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,
-      void (*callback)(TSceneAsset *))
-  {
-    std::packaged_task<void()> lambda(
-        [=]
-        {
-          auto *asset = SceneManager_createGeometry(sceneManager, vertices, numVertices, normals, numNormals, uvs, numUvs, indices, numIndices, primitiveType, materialInstances, materialInstanceCount, keepData);
-          callback(asset);
-        });
-    auto fut = _rl->add_task(lambda);
-  }
 
   EMSCRIPTEN_KEEPALIVE void SceneAsset_createGeometryRenderThread(
     TEngine *tEngine, 
@@ -442,109 +380,7 @@ extern "C"
     auto fut = _rl->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void SceneManager_destroyMaterialInstanceRenderThread(TSceneManager *tSceneManager, TMaterialInstance *tMaterialInstance, void (*callback)())
-  {
-    std::packaged_task<void()> lambda(
-        [=]
-        {
-          SceneManager_destroyMaterialInstance(tSceneManager, tMaterialInstance);
-          callback();
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_createUnlitMaterialInstanceRenderThread(TSceneManager *sceneManager, void (*callback)(TMaterialInstance *))
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          auto instance = SceneManager_createUnlitMaterialInstance(sceneManager);
-          callback(instance);
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_createUnlitFixedSizeMaterialInstanceRenderThread(TSceneManager *sceneManager, void (*callback)(TMaterialInstance *))
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          auto instance = SceneManager_createUnlitFixedSizeMaterialInstance(sceneManager);
-          callback(instance);
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_loadGlbFromBufferRenderThread(TSceneManager *sceneManager,
-                                                                       const uint8_t *const data,
-                                                                       size_t length,
-                                                                       int numInstances,
-                                                                       bool keepData,
-                                                                       int priority,
-                                                                       int layer,
-                                                                       bool loadResourcesAsync,
-                                                                       void (*callback)(TSceneAsset *))
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          auto *asset = SceneManager_loadGlbFromBuffer(sceneManager, data, length, numInstances, keepData, priority, layer, loadResourcesAsync);
-          callback(asset);
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void clear_background_image_render_thread(TViewer *viewer)
-  {
-    std::packaged_task<void()> lambda([=]
-                                      { clear_background_image(viewer); });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void set_background_image_render_thread(TViewer *viewer,
-                                                               const char *path,
-                                                               bool fillHeight, void (*callback)())
-  {
-    std::packaged_task<void()> lambda(
-        [=]
-        {
-          set_background_image(viewer, path, fillHeight);
-          callback();
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void set_background_image_position_render_thread(TViewer *viewer,
-                                                                        float x, float y,
-                                                                        bool clamp)
-  {
-    std::packaged_task<void()> lambda(
-        [=]
-        { set_background_image_position(viewer, x, y, clamp); });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void Viewer_loadSkyboxRenderThread(TViewer *viewer,
-                                                          const char *skyboxPath,
-                                                          void (*onComplete)())
-  {
-    std::packaged_task<void()> lambda([=]
-                                      {
-                                        Viewer_loadSkybox(viewer, skyboxPath);
-                                        onComplete(); });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void Viewer_removeSkyboxRenderThread(TViewer *viewer, void (*onComplete)())
-  {
-    std::packaged_task<void()> lambda([=]
-                                      { 
-                                        Viewer_removeSkybox(viewer); 
-                                        onComplete(); });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, thermion::ToneMapping toneMapping)
+  EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, TToneMapping toneMapping)
   {
     std::packaged_task<void()> lambda(
         [=]
@@ -575,124 +411,12 @@ extern "C"
     auto fut = _rl->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAllRenderThread(TSceneManager *tSceneManager, void (*callback)())
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          SceneManager_destroyAll(tSceneManager);
-          callback();
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE TGizmo *SceneManager_createGizmoRenderThread(
-      TSceneManager *tSceneManager,
-      TView *tView,
-      TScene *tScene,
-      TGizmoType tGizmoType,
-      void (*onComplete)(TGizmo *))
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          auto *gizmo = SceneManager_createGizmo(tSceneManager, tView, tScene, tGizmoType);
-          onComplete(gizmo);
-        });
-    auto fut = _rl->add_task(lambda);
-    return nullptr;
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_addLightRenderThread(
-      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,
-      void (*callback)(EntityId entityId))
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          auto light = SceneManager_addLight(tSceneManager, type, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, falloffRadius, spotLightConeInner, spotLightConeOuter, sunAngularRadius, sunHaloSize, sunHaloFallof, shadows);
-          callback(light);
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_removeLightRenderThread(TSceneManager *tSceneManager, EntityId entityId, void (*callback)())
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          SceneManager_removeLight(tSceneManager, entityId);
-          callback();
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssetRenderThread(TSceneManager *tSceneManager, TSceneAsset *tSceneAsset, void (*callback)())
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          SceneManager_destroyAsset(tSceneManager, tSceneAsset);
-          callback();
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_destroyAssetsRenderThread(TSceneManager *tSceneManager, void (*callback)())
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          SceneManager_destroyAssets(tSceneManager);
-          callback();
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_destroyLightsRenderThread(TSceneManager *tSceneManager, void (*callback)())
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          SceneManager_destroyLights(tSceneManager);
-          callback();
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void SceneManager_createCameraRenderThread(TSceneManager *tSceneManager, void (*callback)(TCamera *))
-  {
-    std::packaged_task<void()> lambda(
-        [=]() mutable
-        {
-          auto *camera = SceneManager_createCamera(tSceneManager);
-          callback(reinterpret_cast<TCamera *>(camera));
-        });
-    auto fut = _rl->add_task(lambda);
-  }
-
   EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *)) {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
         auto *animationManager = AnimationManager_create(tEngine, tScene);
-        callback(animationManager);
+        onComplete(animationManager);
       });
     auto fut = _rl->add_task(lambda);
   }