refactoring

2025-03-21 14:56:20 +08:00
parent 1177a71f73
commit 255c0edd49
38 changed files with 1521 additions and 1207 deletions
--- a/thermion_dart/lib/src/filament/src/asset.dart
+++ b/thermion_dart/lib/src/filament/src/asset.dart
@@ -32,6 +32,11 @@ abstract class ThermionAsset {
  ///
  Future<List<ThermionEntity>> getChildEntities();

+  ///
+  ///
+  ///
+  Future<List<String?>> getChildEntityNames();
+
  ///
  ///
  ///
@@ -91,6 +96,21 @@ abstract class ThermionAsset {
  ///
  Future setReceiveShadows(bool castShadows);

+  ///
+  ///
+  ///
+  Future<bool> isCastShadowsEnabled({ThermionEntity? entity});
+
+  ///
+  ///
+  ///
+  Future<bool> isReceiveShadowsEnabled({ThermionEntity? entity});
+
+  ///
+  ///
+  ///
+  Future transformToUnitCube();
+
  ///
  /// All renderable entities are assigned a layer mask.
  ///
--- a/thermion_dart/lib/src/filament/src/filament_app.dart
+++ b/thermion_dart/lib/src/filament/src/filament_app.dart
@@ -241,7 +241,7 @@ abstract class FilamentApp<T> {
  ///
  ///
  ///
-  Future<ThermionAsset> loadGlbFromBuffer(Uint8List data, T animationManager,
+  Future<ThermionAsset> loadGltfFromBuffer(Uint8List data, T animationManager,
      {int numInstances = 1,
      bool keepData = false,
      int priority = 4,
--- a/thermion_dart/lib/src/viewer/src/ffi/src/background_image.dart
+++ b/thermion_dart/lib/src/viewer/src/ffi/src/background_image.dart
@@ -31,8 +31,8 @@ class BackgroundImage extends ThermionAsset {
  Future destroy() async {
    Scene_removeEntity(scene.scene, entity);

-    await texture!.dispose();
-    await sampler!.dispose();
+    await texture?.dispose();
+    await sampler?.dispose();
    await mi.destroy();
  }

@@ -63,6 +63,10 @@ class BackgroundImage extends ThermionAsset {
    await mi.setParameterFloat4("backgroundColor", r, g, b, a);
  }

+  Future hideImage() async { 
+    await mi.setParameterInt("showImage", 0);
+  }
+
  ///
  ///
  ///
@@ -317,4 +321,25 @@ class BackgroundImage extends ThermionAsset {
    // TODO: implement updateBoneMatrices
    throw UnimplementedError();
  }
+
+  @override
+  Future<List<String>> getChildEntityNames() async {
+    return [];
+  }
+
+  @override
+  Future<bool> isCastShadowsEnabled({ThermionEntity? entity}) async {
+    return false;
+  }
+
+  @override
+  Future<bool> isReceiveShadowsEnabled({ThermionEntity? entity}) async {
+    return false;
+  }
+
+  @override
+  Future transformToUnitCube() {
+    // TODO: implement transformToUnitCube
+    throw UnimplementedError();
+  }
 }
--- a/thermion_dart/lib/src/viewer/src/ffi/src/callbacks.dart
+++ b/thermion_dart/lib/src/viewer/src/ffi/src/callbacks.dart
@@ -21,7 +21,7 @@ Future<void> withVoidCallback2(Function() func) async {
    completer.complete();
  };
  final nativeCallable = NativeCallable<Void Function()>.listener(callback);
-  RenderLoop_addTask(nativeCallable.nativeFunction);
+  RenderThread_addTask(nativeCallable.nativeFunction);
  await completer.future;
  nativeCallable.close();
 }
--- a/thermion_dart/lib/src/viewer/src/ffi/src/ffi_asset.dart
+++ b/thermion_dart/lib/src/viewer/src/ffi/src/ffi_asset.dart
@@ -63,6 +63,24 @@ class FFIAsset extends ThermionAsset {
    return children;
  }

+  ///
+  ///
+  ///
+  @override
+  Future<List<String?>> getChildEntityNames() async {
+    final childEntities = await getChildEntities();
+    var names = <String?>[];
+    for (final entity in childEntities) {
+      var name = NameComponentManager_getName(app.nameComponentManager, entity);
+      if (name == nullptr) {
+        names.add(null);
+      } else {
+        names.add(name.cast<Utf8>().toDartString());
+      }
+    }
+    return names;
+  }
+
  ///
  ///
  ///
@@ -392,14 +410,16 @@ class FFIAsset extends ThermionAsset {
  ///
  ///
  ///
-  Future<bool> isCastShadowsEnabled(ThermionEntity entity) async {
+  Future<bool> isCastShadowsEnabled({ThermionEntity? entity}) async {
+    entity ??= this.entity;
    return RenderableManager_isShadowCaster(app.renderableManager, entity);
  }

  ///
  ///
  ///
-  Future<bool> isReceiveShadowsEnabled(ThermionEntity entity) async {
+  Future<bool> isReceiveShadowsEnabled({ThermionEntity? entity}) async {
+    entity ??= this.entity;
    return RenderableManager_isShadowReceiver(app.renderableManager, entity);
  }

--- a/thermion_dart/lib/src/viewer/src/ffi/src/ffi_filament_app.dart
+++ b/thermion_dart/lib/src/viewer/src/ffi/src/ffi_filament_app.dart
@@ -70,8 +70,8 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
      await FilamentApp.instance!.destroy();
    }

-    RenderLoop_destroy();
-    RenderLoop_create();
+    RenderThread_destroy();
+    RenderThread_create();

    final engine = await withPointerCallback<TEngine>((cb) =>
        Engine_createRenderThread(
@@ -95,6 +95,8 @@ class FFIFilamentApp extends FilamentApp<Pointer> {

    final renderTicker = RenderTicker_create(renderer);

+    RenderThread_setRenderTicker(renderTicker);
+
    final nameComponentManager = NameComponentManager_create();

    FilamentApp.instance = FFIFilamentApp(
@@ -110,30 +112,34 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
        config.resourceLoader);
  }

-  final _views = <FFISwapChain, List<FFIView>>{};
-  final _viewMappings = <FFIView, FFISwapChain>{};
+  final _swapChains = <FFISwapChain, List<FFIView>>{};
+  final viewsPtr = calloc<Pointer<TView>>(255);

  ///
  ///
  ///
  Future setRenderable(covariant FFIView view, bool renderable) async {
-    final swapChain = _viewMappings[view]!;
-    if (renderable && !_views[swapChain]!.contains(view)) {
-      _views[swapChain]!.add(view);
-    } else if (!renderable && _views[swapChain]!.contains(view)) {
-      _views[swapChain]!.remove(view);
-    }
+    await view.setRenderable(renderable);
+    await _updateRenderableSwapChains();
+  }

-    final views = calloc<Pointer<TView>>(255);
-    for (final swapChain in _views.keys) {
-      var numViews = _views[swapChain]!.length;
-      for (int i = 0; i < numViews; i++) {
-        views[i] = _views[swapChain]![i].view;
+  Future _updateRenderableSwapChains() async {
+    for (final swapChain in _swapChains.keys) {
+      final views = _swapChains[swapChain];
+      if (views == null) {
+        continue;
+      }
+
+      int numRenderable = 0;
+      for (final view in views) {
+        if (view.renderable) {
+          viewsPtr[numRenderable] = view.view;
+          numRenderable++;
+        }
      }
      RenderTicker_setRenderable(
-          renderTicker, swapChain.swapChain, views, numViews);
+          renderTicker, swapChain.swapChain, viewsPtr, numRenderable);
    }
-    calloc.free(views);
  }

  @override
@@ -143,6 +149,7 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
    if (hasStencilBuffer) {
      flags |= TSWAP_CHAIN_CONFIG_HAS_STENCIL_BUFFER;
    }
+    print("swapchain flags $flags");
    final swapChain = await withPointerCallback<TSwapChain>((cb) =>
        Engine_createHeadlessSwapChainRenderThread(
            this.engine, width, height, flags, cb));
@@ -173,6 +180,7 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
      Engine_destroySwapChainRenderThread(
          engine, (swapChain as FFISwapChain).swapChain, callback);
    });
+    _swapChains.remove(swapChain);
  }

  ///
@@ -180,17 +188,21 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
  ///
  @override
  Future destroy() async {
-    for (final swapChain in _views.keys) {
-      for (final view in _views[swapChain]!) {
+    for (final swapChain in _swapChains.keys) {
+      if (_swapChains[swapChain] == null) {
+        continue;
+      }
+      for (final view in _swapChains[swapChain]!) {
        await setRenderable(view, false);
      }
    }
-    for (final swapChain in _views.keys) {
+    for (final swapChain in _swapChains.keys.toList()) {
      await destroySwapChain(swapChain);
    }
-    RenderLoop_destroy();
+    RenderThread_destroy();
    RenderTicker_destroy(renderTicker);
    Engine_destroy(engine);
+    calloc.free(viewsPtr);
  }

  ///
@@ -440,8 +452,24 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
  ///
  @override
  Future render() async {
-    await withVoidCallback(
-        (cb) => RenderTicker_renderRenderThread(renderTicker, 0, cb));
+    // await withVoidCallback(
+    //     (cb) => RenderTicker_renderRenderThread(renderTicker, 0, cb));
+    final swapchain = _swapChains.keys.first;
+    final view = _swapChains[swapchain]!.first;
+    await withBoolCallback((cb) {
+      Renderer_beginFrameRenderThread(renderer, swapchain.swapChain, 0, cb);
+    });
+    await withVoidCallback((cb) {
+      Renderer_renderRenderThread(
+        renderer,
+        view.view,
+        cb,
+      );
+    });
+
+    await withVoidCallback((cb) {
+      Renderer_endFrameRenderThread(renderer, cb);
+    });
  }

  ///
@@ -450,11 +478,11 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
  @override
  Future register(
      covariant FFISwapChain swapChain, covariant FFIView view) async {
-    _viewMappings[view] = swapChain;
-    if (!_views.containsKey(swapChain)) {
-      _views[swapChain] = [];
+    if (!_swapChains.containsKey(swapChain)) {
+      _swapChains[swapChain] = [];
    }
-    _views[swapChain]!.add(view);
+    _swapChains[swapChain]!.add(view);
+    await _updateRenderableSwapChains();
  }

  final _hooks = <Future Function()>[];
@@ -493,7 +521,7 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
      completer.complete(true);
    });

-    RenderLoop_requestAnimationFrame(callback.nativeFunction.cast());
+    RenderThread_requestAnimationFrame(callback.nativeFunction.cast());

    try {
      await completer.future.timeout(Duration(seconds: 1));
@@ -572,15 +600,20 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
  Future<Uint8List> capture(covariant FFIView view,
      {bool captureRenderTarget = false}) async {
    final viewport = await view.getViewport();
-    final swapChain = _viewMappings[view];
+    final swapChain = _swapChains.keys
+        .firstWhere((x) => _swapChains[x]?.contains(view) == true);
    final out = Uint8List(viewport.width * viewport.height * 4);

    await withVoidCallback((cb) {
      Engine_flushAndWaitRenderThead(engine, cb);
    });

+    var fence = await withPointerCallback<TFence>((cb) {
+      Engine_createFenceRenderThread(engine, cb);
+    });
+
    await withBoolCallback((cb) {
-      Renderer_beginFrameRenderThread(renderer, swapChain!.swapChain, 0, cb);
+      Renderer_beginFrameRenderThread(renderer, swapChain.swapChain, 0, cb);
    });
    await withVoidCallback((cb) {
      Renderer_renderRenderThread(
@@ -607,9 +640,14 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
    await withVoidCallback((cb) {
      Renderer_endFrameRenderThread(renderer, cb);
    });
+
    await withVoidCallback((cb) {
-      Engine_flushAndWaitRenderThead(engine, cb);
+      Engine_destroyFenceRenderThread(engine, fence, cb);
    });
+
+    // await withVoidCallback((cb) {
+    //   Engine_flushAndWaitRenderThead(engine, cb);
+    // });
    return out;
  }

@@ -623,7 +661,7 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
  ///
  ///
  ///
-  Future<ThermionAsset> loadGlbFromBuffer(
+  Future<ThermionAsset> loadGltfFromBuffer(
      Uint8List data, Pointer animationManager,
      {int numInstances = 1,
      bool keepData = false,
@@ -631,7 +669,7 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
      int layer = 0,
      String? relativeResourcePath,
      bool loadResourcesAsync = false}) async {
-    if (relativeResourcePath != null && !relativeResourcePath!.endsWith("/")) {
+    if (relativeResourcePath != null && !relativeResourcePath.endsWith("/")) {
      relativeResourcePath = "$relativeResourcePath/";
    }
    var gltfResourceLoader = await withPointerCallback<TGltfResourceLoader>(
@@ -648,7 +686,6 @@ class FFIFilamentApp extends FilamentApp<Pointer> {

    var resourceUris = SceneAsset_getResourceUris(asset);
    var resourceUriCount = SceneAsset_getResourceUriCount(asset);
-
    final resources = <FinalizableUint8List>[];

    for (int i = 0; i < resourceUriCount; i++) {
--- a/thermion_dart/lib/src/viewer/src/ffi/src/ffi_material.dart
+++ b/thermion_dart/lib/src/viewer/src/ffi/src/ffi_material.dart
@@ -202,7 +202,7 @@ class FFIMaterialInstance extends MaterialInstance {
      completer.complete();
    };
    final nativeCallable = NativeCallable<Void Function()>.listener(func);
-    RenderLoop_addTask(nativeCallable.nativeFunction);
+    RenderThread_addTask(nativeCallable.nativeFunction);
    await completer.future;
  }
 }
--- a/thermion_dart/lib/src/viewer/src/ffi/src/ffi_view.dart
+++ b/thermion_dart/lib/src/viewer/src/ffi/src/ffi_view.dart
@@ -11,6 +11,9 @@ class FFIView extends View {
  final Pointer<TView> view;
  final FFIFilamentApp app;

+  bool _renderable = false;
+  bool get renderable => _renderable;
+
  FFIRenderTarget? renderTarget;

  FFIView(this.view, this.app) {
@@ -20,8 +23,19 @@ class FFIView extends View {
    }
  }

+  Future setRenderable(bool renderable) async {
+    this._renderable = renderable;
+  }
+
  @override
  Future setViewport(int width, int height) async {
+    // var width_logbase2 = log(width) / ln2;
+    // var height_logbase2 = log(height) / ln2;
+    // var newWidth = pow(2.0, width_logbase2.ceil());
+    // var newHeight = pow(2.0, height_logbase2.ceil());
+    // print("old: ${width}x${height} new: ${height}x${newHeight}");
+    // width = newWidth.toInt();
+    // height = newHeight.toInt();
    View_setViewport(view, width, height);
  }

@@ -80,8 +94,7 @@ class FFIView extends View {

  @override
  Future setToneMapper(ToneMapper mapper) async {
-    await withVoidCallback((cb) => 
-    View_setToneMappingRenderThread(
+    await withVoidCallback((cb) => View_setToneMappingRenderThread(
        view, app.engine, TToneMapping.values[mapper.index], cb));
  }

--- a/thermion_dart/lib/src/viewer/src/ffi/src/thermion_dart.g.dart
+++ b/thermion_dart/lib/src/viewer/src/ffi/src/thermion_dart.g.dart
@@ -473,6 +473,22 @@ external TViewport View_getViewport(
  ffi.Pointer<TView> view,
 );

+@ffi.Native<ffi.Void Function(ffi.Pointer<TView>, ffi.UnsignedInt)>(
+    symbol: "View_setBlendMode", isLeaf: true)
+external void _View_setBlendMode(
+  ffi.Pointer<TView> view,
+  int blendMode,
+);
+
+void View_setBlendMode(
+  ffi.Pointer<TView> view,
+  TBlendMode blendMode,
+) =>
+    _View_setBlendMode(
+      view,
+      blendMode.value,
+    );
+
@ffi.Native<ffi.Void Function(ffi.Pointer<TView>, ffi.Uint32, ffi.Uint32)>(
    isLeaf: true)
 external void View_setViewport(
@@ -1494,18 +1510,30 @@ external void RenderTicker_setRenderable(
 );

@ffi.Native<ffi.Void Function()>(isLeaf: true)
-external void RenderLoop_create();
+external void RenderThread_create();

@ffi.Native<ffi.Void Function()>(isLeaf: true)
-external void RenderLoop_destroy();
+external void RenderThread_destroy();

@ffi.Native<
    ffi.Void Function(
        ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>>)>(isLeaf: true)
-external void RenderLoop_requestAnimationFrame(
+external void RenderThread_requestAnimationFrame(
  ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>> onComplete,
 );

+@ffi.Native<ffi.Void Function(ffi.Pointer<TRenderTicker>)>(isLeaf: true)
+external void RenderThread_setRenderTicker(
+  ffi.Pointer<TRenderTicker> tRenderTicker,
+);
+
+@ffi.Native<
+    ffi.Void Function(
+        ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>>)>(isLeaf: true)
+external void RenderThread_addTask(
+  ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>> task,
+);
+
@ffi.Native<
    ffi.Void Function(ffi.Pointer<TRenderTicker>, ffi.Uint64,
        ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>>)>(isLeaf: true)
@@ -1515,13 +1543,6 @@ external void RenderTicker_renderRenderThread(
  ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>> onComplete,
 );

-@ffi.Native<
-    ffi.Void Function(
-        ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>>)>(isLeaf: true)
-external void RenderLoop_addTask(
-  ffi.Pointer<ffi.NativeFunction<ffi.Void Function()>> task,
-);
-
@ffi.Native<
    ffi.Void Function(
        ffi.Pointer<TEngine>,
@@ -3212,6 +3233,13 @@ external ffi.Pointer<TAnimationManager> AnimationManager_create(
  ffi.Pointer<TScene> tScene,
 );

+@ffi.Native<ffi.Void Function(ffi.Pointer<TAnimationManager>, ffi.Uint64)>(
+    isLeaf: true)
+external void AnimationManager_update(
+  ffi.Pointer<TAnimationManager> tAnimationManager,
+  int frameTimeInNanos,
+);
+
@ffi.Native<ffi.Void Function(ffi.Pointer<TAnimationManager>, EntityId)>(
    isLeaf: true)
 external void AnimationManager_addAnimationComponent(
@@ -3951,6 +3979,20 @@ enum TQualityLevel {
      };
 }

+enum TBlendMode {
+  OPAQUE(0),
+  TRANSLUCENT(1);
+
+  final int value;
+  const TBlendMode(this.value);
+
+  static TBlendMode fromValue(int value) => switch (value) {
+        0 => OPAQUE,
+        1 => TRANSLUCENT,
+        _ => throw ArgumentError("Unknown value for TBlendMode: $value"),
+      };
+}
+
 typedef PickCallback = ffi.Pointer<ffi.NativeFunction<PickCallbackFunction>>;
 typedef PickCallbackFunction = ffi.Void Function(
    ffi.Uint32 requestId,
--- a/thermion_dart/lib/src/viewer/src/ffi/src/thermion_viewer_ffi.dart
+++ b/thermion_dart/lib/src/viewer/src/ffi/src/thermion_viewer_ffi.dart
@@ -33,8 +33,6 @@ class ThermionViewerFFI extends ThermionViewer {

  late final FFIFilamentApp app;

-  final FFIRenderTarget? renderTarget;
-
  late final FFIView view;
  late final FFIScene scene;
  late final Pointer<TAnimationManager> animationManager;
@@ -43,7 +41,7 @@ class ThermionViewerFFI extends ThermionViewer {
  ///
  ///
  ///
-  ThermionViewerFFI({required this.loadAssetFromUri, this.renderTarget}) {
+  ThermionViewerFFI({required this.loadAssetFromUri}) {
    if (FilamentApp.instance == null) {
      throw Exception("FilamentApp has not been created");
    }
@@ -56,7 +54,7 @@ class ThermionViewerFFI extends ThermionViewer {
  ///
  ///
  ///
-  Future setViewport(double width, double height) async {
+  Future setViewport(int width, int height) async {
    await view.setViewport(width.toInt(), height.toInt());

    for (final camera in _cameras) {
@@ -69,12 +67,12 @@ class ThermionViewerFFI extends ThermionViewer {
        far = kFar;
      }

-      var aspect = width / height;
+      var aspect = width.toDouble() / height.toDouble();
      var focalLength = await camera.getFocalLength();
      if (focalLength.abs() < 0.1) {
        focalLength = kFocalLength;
      }
-      camera.setLensProjection(
+      await camera.setLensProjection(
          near: near, far: far, aspect: aspect, focalLength: focalLength);
    }
  }
@@ -85,6 +83,14 @@ class ThermionViewerFFI extends ThermionViewer {
        await withPointerCallback<TView>(
            (cb) => Engine_createViewRenderThread(app.engine, cb)),
        app);
+    await view.setFrustumCullingEnabled(true);
+    View_setBlendMode(view.view, TBlendMode.TRANSLUCENT);
+    View_setShadowsEnabled(view.view, false);
+    View_setStencilBufferEnabled(view.view, false);
+    View_setAntiAliasing(view.view, false, false, false);
+    View_setDitheringEnabled(view.view, false);
+    View_setRenderQuality(view.view, TQualityLevel.MEDIUM);
+    await FilamentApp.instance!.setClearColor(1.0, 0.0, 0.0, 1.0);
    scene = FFIScene(Engine_createScene(app.engine));
    await view.setScene(scene);
    final camera = FFICamera(
@@ -92,12 +98,10 @@ class ThermionViewerFFI extends ThermionViewer {
            (cb) => Engine_createCameraRenderThread(app.engine, cb)),
        app);
    _cameras.add(camera);
+    await camera.setLensProjection();

    await view.setCamera(camera);

-    if (renderTarget != null) {
-      await view.setRenderTarget(renderTarget);
-    }
    animationManager = await withPointerCallback<TAnimationManager>((cb) =>
        AnimationManager_createRenderThread(app.engine, scene.scene, cb));

@@ -180,9 +184,13 @@ class ThermionViewerFFI extends ThermionViewer {
  ///
  ///
  @override
-  Future clearBackgroundImage() async {
-    await _backgroundImage?.destroy();
-    _backgroundImage = null;
+  Future clearBackgroundImage({bool destroy = false}) async {
+    if (destroy) {
+      await _backgroundImage?.destroy();
+      _backgroundImage = null;
+    } else {
+      _backgroundImage?.hideImage();
+    }
  }

  ///
@@ -335,7 +343,7 @@ class ThermionViewerFFI extends ThermionViewer {
  ///
  @override
  Future destroyLights() async {
-    for (final light in _lights) {
+    for (final light in _lights.toList()) {
      await removeLight(light);
    }
  }
@@ -347,37 +355,45 @@ class ThermionViewerFFI extends ThermionViewer {
  ///
  ///
  @override
-  Future<ThermionAsset> loadGlb(String path,
-      {int numInstances = 1, bool keepData = false, String? relativeResourcePath}) async {
+  Future<ThermionAsset> loadGltf(String path,
+      {bool addToScene = true,
+      int numInstances = 1,
+      bool keepData = false,
+      String? relativeResourcePath}) async {
    final data = await loadAssetFromUri(path);

-    return loadGlbFromBuffer(data,
-        numInstances: numInstances, keepData: keepData, relativeResourcePath: relativeResourcePath);
+    return loadGltfFromBuffer(data,
+        addToScene: addToScene,
+        numInstances: numInstances,
+        keepData: keepData,
+        relativeResourcePath: relativeResourcePath);
  }

  ///
  ///
  ///
  @override
-  Future<ThermionAsset> loadGlbFromBuffer(Uint8List data,
-      {int numInstances = 1,
+  Future<ThermionAsset> loadGltfFromBuffer(Uint8List data,
+      {bool addToScene = true,
+      int numInstances = 1,
      bool keepData = false,
      int priority = 4,
      int layer = 0,
      bool loadResourcesAsync = false,
      String? relativeResourcePath}) async {
-    var asset = await FilamentApp.instance!.loadGlbFromBuffer(data, animationManager,
+    var asset = await FilamentApp.instance!.loadGltfFromBuffer(
+        data, animationManager,
        numInstances: numInstances,
        keepData: keepData,
        priority: priority,
        layer: layer,
        loadResourcesAsync: loadResourcesAsync,
-        relativeResourcePath:relativeResourcePath
-        ) as FFIAsset;
-   
-    _assets.add(asset);
+        relativeResourcePath: relativeResourcePath) as FFIAsset;

-    await scene.add(asset);
+    _assets.add(asset);
+    if (addToScene) {
+      await scene.add(asset);
+    }

    return asset;
  }
@@ -424,6 +440,8 @@ class ThermionViewerFFI extends ThermionViewer {
  @override
  Future setPostProcessing(bool enabled) async {
    View_setPostProcessing(view.view, enabled);
+    await withVoidCallback(
+        (cb) => Engine_flushAndWaitRenderThead(app.engine, cb));
  }

  ///
@@ -655,7 +673,8 @@ class ThermionViewerFFI extends ThermionViewer {
  @override
  Future<ThermionAsset> createGeometry(Geometry geometry,
      {List<MaterialInstance>? materialInstances,
-      bool keepData = false}) async {
+      bool keepData = false,
+      bool addToScene = true}) async {
    var assetPtr = await withPointerCallback<TSceneAsset>((callback) {
      var ptrList = Int64List(materialInstances?.length ?? 0);
      if (materialInstances != null && materialInstances.isNotEmpty) {
@@ -688,7 +707,9 @@ class ThermionViewerFFI extends ThermionViewer {
    }

    var asset = FFIAsset(assetPtr, app, animationManager);
-
+    if (addToScene) {
+      await scene.add(asset);
+    }
    return asset;
  }

--- a/thermion_dart/lib/src/viewer/src/thermion_viewer_base.dart
+++ b/thermion_dart/lib/src/viewer/src/thermion_viewer_base.dart
@@ -71,7 +71,7 @@ abstract class ThermionViewer {
  ///
  /// Removes the background image.
  ///
-  Future clearBackgroundImage();
+  Future clearBackgroundImage({bool destroy = false});

  ///
  /// Sets the color for the background plane (positioned at the maximum depth, i.e. behind all other objects including the skybox).
@@ -128,10 +128,11 @@ abstract class ThermionViewer {
  /// If you want to be able to call [createInstance] at a later time, you must pass true for [keepData].
  /// If [keepData] is false, the source glTF data will be released and [createInstance] will throw an exception.
  ///
-  Future<ThermionAsset> loadGlb(String path,
-      {int numInstances = 1,
+  Future<ThermionAsset> loadGltf(String path,
+      { bool addToScene=true,
+        int numInstances = 1,
      bool keepData = false,
-      String relativeResourcePath});
+      String? relativeResourcePath});

  ///
  /// Load the .glb asset from the specified buffer, adding all entities to the scene.
@@ -142,7 +143,7 @@ abstract class ThermionViewer {
  /// be loaded asynchronously (so expect some material/texture pop-in);
  ///
  ///
-  Future<ThermionAsset> loadGlbFromBuffer(Uint8List data,
+  Future<ThermionAsset> loadGltfFromBuffer(Uint8List data,
      {int numInstances = 1,
      bool keepData = false,
      int priority = 4,
@@ -177,6 +178,11 @@ abstract class ThermionViewer {
  ///
  Future setViewFrustumCulling(bool enabled);

+  ///
+  /// Sets the viewport sizes and updates all cameras to use the new aspect ratio. 
+  ///
+  Future setViewport(int width, int height);
+
  ///
  /// Set the world space position for [lightEntity] to the given coordinates.
  ///
@@ -230,7 +236,7 @@ abstract class ThermionViewer {
  ///
  ///
  Future<ThermionAsset> createGeometry(Geometry geometry,
-      {List<MaterialInstance>? materialInstances, bool keepData = false});
+      {List<MaterialInstance>? materialInstances, bool keepData = false, bool addToScene=true});

  ///
  /// The gizmo for translating/rotating objects. Only one gizmo can be active for a given view.
--- a/thermion_dart/lib/src/viewer/src/thermion_viewer_stub.dart
+++ b/thermion_dart/lib/src/viewer/src/thermion_viewer_stub.dart
@@ -9,6 +9,12 @@ class ThermionViewerStub extends ThermionViewer {
    throw UnimplementedError();
  }

+  @override
+  Future addToScene(covariant ThermionAsset asset) {
+    // TODO: implement addToScene
+    throw UnimplementedError();
+  }
+
  @override
  Future clearBackgroundImage() {
    // TODO: implement clearBackgroundImage
@@ -21,12 +27,6 @@ class ThermionViewerStub extends ThermionViewer {
    throw UnimplementedError();
  }

-  @override
-  Future<ThermionAsset> createGeometry(Geometry geometry, {List<MaterialInstance>? materialInstances, bool keepData = false}) {
-    // TODO: implement createGeometry
-    throw UnimplementedError();
-  }
-
  @override
  Future<GizmoAsset> createGizmo(covariant View view, GizmoType type) {
    // TODO: implement createGizmo
@@ -92,23 +92,17 @@ class ThermionViewerStub extends ThermionViewer {
  Future<bool> get initialized => throw UnimplementedError();

  @override
-  Future<ThermionAsset> loadGlb(String path, {int numInstances = 1, bool keepData = false}) {
-    // TODO: implement loadGlb
-    throw UnimplementedError();
-  }
-
-  @override
-  Future<ThermionAsset> loadGlbFromBuffer(Uint8List data, {int numInstances = 1, bool keepData = false, int priority = 4, int layer = 0, bool loadResourcesAsync = false}) {
-    // TODO: implement loadGlbFromBuffer
-    throw UnimplementedError();
-  }
-
-  @override
-  Future<ThermionAsset> loadGltf(String path, String relativeResourcePath, {bool keepData = false}) {
+  Future<ThermionAsset> loadGltf(String path, {int numInstances = 1, bool keepData = false, String? relativeResourcePath}) {
    // TODO: implement loadGltf
    throw UnimplementedError();
  }

+  @override
+  Future<ThermionAsset> loadGltfFromBuffer(Uint8List data, {int numInstances = 1, bool keepData = false, int priority = 4, int layer = 0, bool loadResourcesAsync = false, String? relativeResourcePath}) {
+    // TODO: implement loadGltfFromBuffer
+    throw UnimplementedError();
+  }
+
  @override
  Future loadIbl(String lightingPath, {double intensity = 30000}) {
    // TODO: implement loadIbl
@@ -136,6 +130,12 @@ class ThermionViewerStub extends ThermionViewer {
    throw UnimplementedError();
  }

+  @override
+  Future removeFromScene(covariant ThermionAsset asset) {
+    // TODO: implement removeFromScene
+    throw UnimplementedError();
+  }
+
  @override
  Future removeGridOverlay() {
    // TODO: implement removeGridOverlay
@@ -287,5 +287,5 @@ class ThermionViewerStub extends ThermionViewer {
  @override
  // TODO: implement view
  View get view => throw UnimplementedError();
-  
+    
 }
--- a/thermion_dart/lib/thermion_dart.dart
+++ b/thermion_dart/lib/thermion_dart.dart
@@ -4,3 +4,4 @@ export 'package:vector_math/vector_math_64.dart' hide Colors;
 export 'src/viewer/viewer.dart';
 export 'src/input/input.dart';
 export 'src/utils/utils.dart';
+export 'src/filament/filament.dart';
--- a/thermion_dart/native/include/c_api/TAnimationManager.h
+++ b/thermion_dart/native/include/c_api/TAnimationManager.h
@@ -9,6 +9,8 @@ extern "C"
 #endif

 	EMSCRIPTEN_KEEPALIVE TAnimationManager *AnimationManager_create(TEngine *tEngine, TScene *tScene);
+	
+	EMSCRIPTEN_KEEPALIVE void AnimationManager_update(TAnimationManager *tAnimationManager, uint64_t frameTimeInNanos);

 	EMSCRIPTEN_KEEPALIVE void AnimationManager_addAnimationComponent(TAnimationManager *tAnimationManager, EntityId entityId);

--- a/thermion_dart/native/include/c_api/TView.h
+++ b/thermion_dart/native/include/c_api/TView.h
@@ -32,8 +32,14 @@ enum TQualityLevel {
    ULTRA
 };

+enum TBlendMode {
+    OPAQUE,
+    TRANSLUCENT
+};
+
 // View
 EMSCRIPTEN_KEEPALIVE TViewport View_getViewport(TView *view);
+EMSCRIPTEN_KEEPALIVE void View_setBlendMode(TView *view, TBlendMode blendMode);
 EMSCRIPTEN_KEEPALIVE void View_setViewport(TView *view, uint32_t width, uint32_t height);
 EMSCRIPTEN_KEEPALIVE void View_setRenderTarget(TView *view, TRenderTarget *renderTarget);
 EMSCRIPTEN_KEEPALIVE void View_setFrustumCullingEnabled(TView *view, bool enabled);
--- a/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
+++ b/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
@@ -14,12 +14,13 @@ namespace thermion
        typedef int32_t EntityId;
        typedef void (*FilamentRenderCallback)(void *const owner);

-        EMSCRIPTEN_KEEPALIVE void RenderLoop_create();
-        EMSCRIPTEN_KEEPALIVE void RenderLoop_destroy();
-        EMSCRIPTEN_KEEPALIVE void RenderLoop_requestAnimationFrame(void (*onComplete)());
+        EMSCRIPTEN_KEEPALIVE void RenderThread_create();
+        EMSCRIPTEN_KEEPALIVE void RenderThread_destroy();
+        EMSCRIPTEN_KEEPALIVE void RenderThread_requestAnimationFrame(void (*onComplete)());
+        EMSCRIPTEN_KEEPALIVE void RenderThread_setRenderTicker(TRenderTicker *tRenderTicker);
+        EMSCRIPTEN_KEEPALIVE void RenderThread_addTask(void (*task)());
+        
        EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, void (*onComplete)());
-        EMSCRIPTEN_KEEPALIVE void RenderLoop_addTask(void (*task)());
-
        EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *));

        EMSCRIPTEN_KEEPALIVE void Engine_createRenderThread(
--- a/thermion_dart/native/include/rendering/RenderThread.hpp
+++ b/thermion_dart/native/include/rendering/RenderThread.hpp
@@ -17,17 +17,17 @@ namespace thermion {
 * This class handles frame rendering requests, viewer creation, and maintains
 * a task queue for rendering operations.
 */
-class RenderLoop {
+class RenderThread {
 public:
    /**
-     * @brief Constructs a new RenderLoop and starts the render thread.
+     * @brief Constructs a new RenderThread and starts the render thread.
     */
-    explicit RenderLoop();
+    explicit RenderThread();

    /**
-     * @brief Destroys the RenderLoop and stops the render thread.
+     * @brief Destroys the RenderThread and stops the render thread.
     */
-    ~RenderLoop();
+    ~RenderThread();

    /**
     * @brief Requests a frame to be rendered.
@@ -74,7 +74,7 @@ private:

 // Template implementation
 template <class Rt>
-auto RenderLoop::add_task(std::packaged_task<Rt()>& pt) -> std::future<Rt> {
+auto RenderThread::add_task(std::packaged_task<Rt()>& pt) -> std::future<Rt> {
    std::unique_lock<std::mutex> lock(_taskMutex);
    auto ret = pt.get_future();
    _tasks.push_back([pt = std::make_shared<std::packaged_task<Rt()>>(
--- a/thermion_dart/native/src/RenderTicker.cpp
+++ b/thermion_dart/native/src/RenderTicker.cpp
@@ -69,12 +69,21 @@ namespace thermion

    for (auto animationManager : mAnimationManagers) {
      animationManager->update(frameTimeInNanos);
-    }
+      TRACE("Updated AnimationManager");

+    }
+    
+    #ifdef ENABLE_TRACING
+    int numRendered = 0;
+    TRACE("%d swapchains", mRenderable.size());
+    #endif
+    
    for (const auto& [swapChain, views] : mRenderable)
    {
      if (!views.empty())
      {
+        TRACE("Rendering %d views", views.size());
+
        bool beginFrame = mRenderer->beginFrame(swapChain, frameTimeInNanos);
        if (beginFrame)
        {
@@ -84,7 +93,15 @@ namespace thermion
          }
        }
        mRenderer->endFrame();
+    #ifdef ENABLE_TRACING
+        numRendered++;
+      } else {
+        TRACE("No views for swapchain");
      }
+      TRACE("%d swapchains rendered", numRendered);
+    #else
+    }
+      #endif
    }
 #ifdef __EMSCRIPTEN__
    _engine->execute();
--- a/thermion_dart/native/src/c_api/TAnimationManager.cpp
+++ b/thermion_dart/native/src/c_api/TAnimationManager.cpp
@@ -17,6 +17,11 @@ extern "C"
        return reinterpret_cast<TAnimationManager *>(animationManager);
    }

+    EMSCRIPTEN_KEEPALIVE void AnimationManager_update(TAnimationManager *tAnimationManager, uint64_t frameTimeInNanos) {
+        auto animationManager = reinterpret_cast<AnimationManager *>(tAnimationManager);
+        animationManager->update(frameTimeInNanos);
+    }
+
    EMSCRIPTEN_KEEPALIVE void AnimationManager_addAnimationComponent(TAnimationManager *tAnimationManager, EntityId entityId)
    {
        auto animationManager = reinterpret_cast<AnimationManager *>(tAnimationManager);
--- a/thermion_dart/native/src/c_api/TEngine.cpp
+++ b/thermion_dart/native/src/c_api/TEngine.cpp
@@ -80,14 +80,38 @@ namespace thermion
        EMSCRIPTEN_KEEPALIVE TSwapChain *Engine_createSwapChain(TEngine *tEngine, void *window, uint64_t flags)
        {
            auto *engine = reinterpret_cast<Engine *>(tEngine);
+            #ifdef ENABLE_TRACING
+            if((flags & filament::backend::SWAP_CHAIN_CONFIG_TRANSPARENT) == filament::backend::SWAP_CHAIN_CONFIG_TRANSPARENT) {
+                TRACE("SWAP_CHAIN_CONFIG_TRANSPARENT");
+                
+            }
+            if((flags & filament::backend::SWAP_CHAIN_CONFIG_READABLE) == filament::backend::SWAP_CHAIN_CONFIG_READABLE) {
+                TRACE("SWAP_CHAIN_CONFIG_READABLE");
+            }
+            if((flags & filament::backend::SWAP_CHAIN_CONFIG_HAS_STENCIL_BUFFER) == filament::backend::SWAP_CHAIN_CONFIG_HAS_STENCIL_BUFFER) {
+                TRACE("SWAP_CHAIN_CONFIG_READABLE");
+            }
+            #endif
            auto *swapChain = engine->createSwapChain(window, flags);
            return reinterpret_cast<TSwapChain *>(swapChain);
        }

        EMSCRIPTEN_KEEPALIVE TSwapChain *Engine_createHeadlessSwapChain(TEngine *tEngine, uint32_t width, uint32_t height, uint64_t flags)
        {
+            TRACE("Creating headless swapchain %dx%d, flags %flags", width, height, flags);
            auto *engine = reinterpret_cast<Engine *>(tEngine);
            auto *swapChain = engine->createSwapChain(width, height, flags);
+            #ifdef ENABLE_TRACING
+            if((flags & filament::backend::SWAP_CHAIN_CONFIG_TRANSPARENT) == filament::backend::SWAP_CHAIN_CONFIG_TRANSPARENT) {
+                TRACE("SWAP_CHAIN_CONFIG_TRANSPARENT");
+            }
+            if((flags & filament::backend::SWAP_CHAIN_CONFIG_READABLE) == filament::backend::SWAP_CHAIN_CONFIG_READABLE) {
+                TRACE("SWAP_CHAIN_CONFIG_READABLE");
+            }
+            if((flags & filament::backend::SWAP_CHAIN_CONFIG_HAS_STENCIL_BUFFER) == filament::backend::SWAP_CHAIN_CONFIG_HAS_STENCIL_BUFFER) {
+                TRACE("SWAP_CHAIN_CONFIG_READABLE");
+            }
+            #endif
            return reinterpret_cast<TSwapChain *>(swapChain);
        }

@@ -101,6 +125,9 @@ namespace thermion
        {
            auto *engine = reinterpret_cast<Engine *>(tEngine);
            auto *view = engine->createView();
+            view->setShadowingEnabled(false);
+            view->setAmbientOcclusionOptions({.enabled = false});
+            view->setDynamicResolutionOptions({.enabled = false});
            return reinterpret_cast<TView *>(view);
        }

--- a/thermion_dart/native/src/c_api/TNameComponentManager.cpp
+++ b/thermion_dart/native/src/c_api/TNameComponentManager.cpp
@@ -14,10 +14,14 @@ extern "C"
 		return reinterpret_cast<TNameComponentManager *>(ncm);
 	}

-	EMSCRIPTEN_KEEPALIVE const char *NameComponentManager_getName(TNameComponentManager *tNameComponentManager, EntityId entity)
+	EMSCRIPTEN_KEEPALIVE const char *NameComponentManager_getName(TNameComponentManager *tNameComponentManager, EntityId entityId)
 	{
 		auto ncm = reinterpret_cast<utils::NameComponentManager *>(tNameComponentManager);
-		auto instance = ncm->getInstance(utils::Entity::import(entity));
+		auto entity = utils::Entity::import(entityId);
+		if(!ncm->hasComponent(entity)) {
+			return nullptr;
+		}
+		auto instance = ncm->getInstance(entity);
 		return ncm->getName(instance);
 	}

--- a/thermion_dart/native/src/c_api/TView.cpp
+++ b/thermion_dart/native/src/c_api/TView.cpp
@@ -16,6 +16,11 @@ using namespace filament;

 #endif

+    EMSCRIPTEN_KEEPALIVE void View_setBlendMode(TView *tView, TBlendMode tBlendMode) {
+        auto view = reinterpret_cast<View *>(tView);
+        view->setBlendMode(static_cast<filament::View::BlendMode>(tBlendMode));
+    }
+
    EMSCRIPTEN_KEEPALIVE TViewport View_getViewport(TView *tView)
    {
        auto view = reinterpret_cast<View *>(tView);
@@ -58,6 +63,8 @@ using namespace filament;
    {
        auto view = reinterpret_cast<View *>(tView);
        view->setPostProcessingEnabled(enabled);
+        TRACE("Set postprocessing enabled : %d", enabled);
+
    }

    EMSCRIPTEN_KEEPALIVE void View_setShadowsEnabled(TView *tView, bool enabled)
@@ -88,6 +95,7 @@ using namespace filament;
        decltype(view->getBloomOptions()) opts;
        opts.enabled = enabled;
        opts.strength = strength;
+        TRACE("Setting bloom options {.enabled = %d, strength = %f}", enabled, strength);
        view->setBloomOptions(opts);
 #endif
    }
@@ -101,19 +109,19 @@ using namespace filament;
        switch (tToneMapping)
        {
        case TToneMapping::ACES:
-            Log("Setting tone mapping to ACES");
+            TRACE("Setting tone mapping to ACES");
            tm = new ACESToneMapper();
            break;
        case TToneMapping::LINEAR:
-            Log("Setting tone mapping to Linear");
+            TRACE("Setting tone mapping to Linear");
            tm = new LinearToneMapper();
            break;
        case TToneMapping::FILMIC:
-            Log("Setting tone mapping to Filmic");
+            TRACE("Setting tone mapping to Filmic");
            tm = new FilmicToneMapper();
            break;
        default:
-            Log("ERROR: Unsupported tone mapping");
+            TRACE("ERROR: Unsupported tone mapping");
            return;
        }
        auto newColorGrading = ColorGrading::Builder().toneMapper(tm).build(*engine);
@@ -200,6 +208,21 @@ using namespace filament;
        auto view = reinterpret_cast<View *>(tView);
        RenderQuality rq;
        rq.hdrColorBuffer = (filament::QualityLevel)qualityLevel;
+        switch(rq.hdrColorBuffer) { 
+            case filament::QualityLevel::LOW:
+                TRACE("Render Quality: LOW");
+                break;
+            case filament::QualityLevel::MEDIUM:
+                TRACE("Render Quality: MEDIUM");
+                break;
+            case filament::QualityLevel::HIGH:
+                TRACE("Render Quality: HIGH");
+                break;
+            case filament::QualityLevel::ULTRA:
+                TRACE("Render Quality: ULTRA");
+                break;
+        }
+        
        view->setRenderQuality(rq);
    }

--- a/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
+++ b/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
@@ -19,7 +19,7 @@
 #include "c_api/TView.h"
 #include "c_api/ThermionDartRenderThreadApi.h"

-#include "rendering/RenderLoop.hpp"
+#include "rendering/RenderThread.hpp"
 #include "Log.hpp"

 using namespace thermion;
@@ -29,36 +29,41 @@ using namespace std::chrono_literals;
 extern "C"
 {

-  static std::unique_ptr<RenderLoop> _rl;
+  static std::unique_ptr<RenderThread> _renderThread;

-  EMSCRIPTEN_KEEPALIVE void RenderLoop_create() {
-    TRACE("RenderLoop_create");
-    if (_rl)
+  EMSCRIPTEN_KEEPALIVE void RenderThread_create() {
+    TRACE("RenderThread_create");
+    if (_renderThread)
    {
-      Log("WARNING - you are attempting to create a RenderLoop when the previous one has not been disposed.");
+      Log("WARNING - you are attempting to create a RenderThread when the previous one has not been disposed.");
    }
-    _rl = std::make_unique<RenderLoop>();
+    _renderThread = std::make_unique<RenderThread>();
  }

-  EMSCRIPTEN_KEEPALIVE void RenderLoop_destroy() {
-    TRACE("RenderLoop_destroy");
-    if (_rl)
+  EMSCRIPTEN_KEEPALIVE void RenderThread_destroy() {
+    TRACE("RenderThread_destroy");
+    if (_renderThread)
    {
-      _rl = nullptr;
+      _renderThread = nullptr;
    }
  }

-  EMSCRIPTEN_KEEPALIVE void RenderLoop_addTask(void (*task)()) {
+  EMSCRIPTEN_KEEPALIVE void RenderThread_addTask(void (*task)()) {
    std::packaged_task<void()> lambda(
      [=]() mutable
      {
        task();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

-  EMSCRIPTEN_KEEPALIVE void RenderLoop_requestAnimationFrame(void (*onComplete)()) {
-    _rl->requestFrame(onComplete);
+  EMSCRIPTEN_KEEPALIVE void RenderThread_setRenderTicker(TRenderTicker *tRenderTicker) {
+    auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
+    _renderThread->setRenderTicker(renderTicker);
+  }
+
+  EMSCRIPTEN_KEEPALIVE void RenderThread_requestAnimationFrame(void (*onComplete)()) {
+    _renderThread->requestFrame(onComplete);
  }

  
@@ -69,7 +74,7 @@ extern "C"
        RenderTicker_render(tRenderTicker, frameTimeInNanos);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_createRenderThread(
@@ -85,7 +90,7 @@ extern "C"
        auto engine = Engine_create(backend, platform, sharedContext, stereoscopicEyeCount, disableHandleUseAfterFreeCheck);
        onComplete(engine);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_createRendererRenderThread(TEngine *tEngine, void (*onComplete)(TRenderer *)) {
@@ -95,7 +100,7 @@ extern "C"
        auto renderer = Engine_createRenderer(tEngine);
        onComplete(renderer);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_createSwapChainRenderThread(TEngine *tEngine, void *window, uint64_t flags, void (*onComplete)(TSwapChain *)) {
@@ -105,7 +110,7 @@ extern "C"
        auto swapChain = Engine_createSwapChain(tEngine, window, flags);
        onComplete(swapChain);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }
  
  EMSCRIPTEN_KEEPALIVE void Engine_createHeadlessSwapChainRenderThread(TEngine *tEngine, uint32_t width, uint32_t height, uint64_t flags, void (*onComplete)(TSwapChain *)) {
@@ -115,7 +120,7 @@ extern "C"
        auto swapChain = Engine_createHeadlessSwapChain(tEngine, width, height, flags);
        onComplete(swapChain);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }
  
  EMSCRIPTEN_KEEPALIVE void Engine_destroySwapChainRenderThread(TEngine *tEngine, TSwapChain *tSwapChain, void (*onComplete)()) {
@@ -125,7 +130,7 @@ extern "C"
        Engine_destroySwapChain(tEngine, tSwapChain);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_createCameraRenderThread(TEngine* tEngine, void (*onComplete)(TCamera *)) {
@@ -135,7 +140,7 @@ extern "C"
        auto camera = Engine_createCamera(tEngine);
        onComplete(camera);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_createViewRenderThread(TEngine *tEngine, void (*onComplete)(TView *)) {
@@ -145,7 +150,7 @@ extern "C"
        auto * view = Engine_createView(tEngine);
        onComplete(view);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_destroyTextureRenderThread(TEngine *engine, TTexture *tTexture, void (*onComplete)())
@@ -156,7 +161,7 @@ extern "C"
          Engine_destroyTexture(engine, tTexture);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_destroySkyboxRenderThread(TEngine *tEngine, TSkybox *tSkybox, void (*onComplete)()) {
@@ -166,7 +171,7 @@ extern "C"
          Engine_destroySkybox(tEngine, tSkybox);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }
    
  EMSCRIPTEN_KEEPALIVE void Engine_destroyIndirectLightRenderThread(TEngine *tEngine, TIndirectLight *tIndirectLight, void (*onComplete)()) { 
@@ -176,7 +181,7 @@ extern "C"
        Engine_destroyIndirectLight(tEngine, tIndirectLight);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_buildMaterialRenderThread(TEngine *tEngine, const uint8_t *materialData, size_t length, void (*onComplete)(TMaterial *))
@@ -187,7 +192,7 @@ extern "C"
          auto material = Engine_buildMaterial(tEngine, materialData, length);
          onComplete(material);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }


@@ -199,7 +204,17 @@ extern "C"
          Engine_destroyMaterial(tEngine, tMaterial);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
+  }
+
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialInstanceRenderThread(TEngine *tEngine, TMaterialInstance *tMaterialInstance, void (*onComplete)()) {
+    std::packaged_task<void()> lambda(
+      [=]() mutable
+      {
+        Engine_destroyMaterialInstance(tEngine, tMaterialInstance);
+        onComplete();
+      });
+      auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_createFenceRenderThread(TEngine *tEngine, void (*onComplete)(TFence*)) { 
@@ -209,7 +224,7 @@ extern "C"
        auto *fence = Engine_createFence(tEngine);
        onComplete(fence);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_destroyFenceRenderThread(TEngine *tEngine, TFence *tFence, void (*onComplete)()) {
@@ -219,7 +234,7 @@ extern "C"
        Engine_destroyFence(tEngine, tFence);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_flushAndWaitRenderThead(TEngine *tEngine, void (*onComplete)()) {
@@ -229,7 +244,7 @@ extern "C"
        Engine_flushAndWait(tEngine);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_buildSkyboxRenderThread(TEngine *tEngine, uint8_t *skyboxData, size_t length,  void (*onComplete)(TSkybox *),  void (*onTextureUploadComplete)()) {
@@ -239,7 +254,7 @@ extern "C"
        auto *skybox = Engine_buildSkybox(tEngine, skyboxData, length, onTextureUploadComplete);
        onComplete(skybox);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Engine_buildIndirectLightRenderThread(TEngine *tEngine, uint8_t *iblData, size_t length, float intensity, void (*onComplete)(TIndirectLight *), void (*onTextureUploadComplete)()) {
@@ -249,7 +264,7 @@ extern "C"
        auto *indirectLight = Engine_buildIndirectLight(tEngine, iblData, length, intensity, onTextureUploadComplete);
        onComplete(indirectLight);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Renderer_beginFrameRenderThread(TRenderer *tRenderer, TSwapChain *tSwapChain, uint64_t frameTimeInNanos, void (*onComplete)(bool)) { 
@@ -259,7 +274,7 @@ extern "C"
        auto result = Renderer_beginFrame(tRenderer, tSwapChain, frameTimeInNanos);
        onComplete(result);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }
  EMSCRIPTEN_KEEPALIVE void Renderer_endFrameRenderThread(TRenderer *tRenderer, void (*onComplete)()) {
    std::packaged_task<void()> lambda(
@@ -268,7 +283,7 @@ extern "C"
        Renderer_endFrame(tRenderer);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Renderer_renderRenderThread(TRenderer *tRenderer, TView *tView, void (*onComplete)()) {
@@ -278,7 +293,7 @@ extern "C"
        Renderer_render(tRenderer, tView);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Renderer_renderStandaloneViewRenderThread(TRenderer *tRenderer, TView *tView, void (*onComplete)()) {
@@ -288,7 +303,7 @@ extern "C"
        Renderer_renderStandaloneView(tRenderer, tView);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Renderer_setClearOptionsRenderThread(
@@ -306,7 +321,7 @@ extern "C"
          Renderer_setClearOptions(tRenderer, clearR, clearG, clearB, clearA, clearStencil, clear, discard);
          onComplete();
        });
-      auto fut = _rl->add_task(lambda);
+      auto fut = _renderThread->add_task(lambda);
  }
  
  EMSCRIPTEN_KEEPALIVE void Renderer_readPixelsRenderThread(
@@ -323,7 +338,7 @@ extern "C"
        Renderer_readPixels(tRenderer, tView, tRenderTarget, tPixelBufferFormat, tPixelDataType, out);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Material_createImageMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *)) {
@@ -333,7 +348,7 @@ extern "C"
        auto *instance = Material_createImageMaterial(tEngine);
        onComplete(instance);
      });
-      auto fut = _rl->add_task(lambda);
+      auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Material_createInstanceRenderThread(TMaterial *tMaterial, void (*onComplete)(TMaterialInstance *))
@@ -344,7 +359,7 @@ extern "C"
          auto *instance = Material_createInstance(tMaterial);
          onComplete(instance);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void SceneAsset_destroyRenderThread(TSceneAsset *tSceneAsset, void (*onComplete)()) {
@@ -354,7 +369,7 @@ extern "C"
        SceneAsset_destroy(tSceneAsset);
        onComplete();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void SceneAsset_loadGlbRenderThread(
@@ -372,7 +387,7 @@ extern "C"
        auto sceneAsset = SceneAsset_loadGlb(tEngine, tAssetLoader, tNameComponentManager, data, length, numInstances);
        callback(sceneAsset);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void SceneAsset_createGeometryRenderThread(
@@ -396,7 +411,7 @@ extern "C"
      auto sceneAsset = SceneAsset_createGeometry(tEngine, vertices, numVertices, normals, numNormals, uvs, numUvs, indices, numIndices, tPrimitiveType, materialInstances, materialInstanceCount);
      callback(sceneAsset);
    });
-  auto fut = _rl->add_task(lambda);
+  auto fut = _renderThread->add_task(lambda);
 }

  EMSCRIPTEN_KEEPALIVE void SceneAsset_createInstanceRenderThread(
@@ -410,7 +425,7 @@ extern "C"
          auto instanceAsset = SceneAsset_createInstance(asset, tMaterialInstances, materialInstanceCount);
          callback(instanceAsset);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void MaterialProvider_createMaterialInstanceRenderThread(TMaterialProvider *tMaterialProvider, TMaterialKey *tKey, void (*callback)(TMaterialInstance *))
@@ -421,7 +436,7 @@ extern "C"
          auto materialInstance = MaterialProvider_createMaterialInstance(tMaterialProvider, tKey);
          callback(materialInstance);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void View_setToneMappingRenderThread(TView *tView, TEngine *tEngine, TToneMapping toneMapping, void (*callback)())
@@ -432,7 +447,7 @@ extern "C"
          View_setToneMapping(tView, tEngine, toneMapping);
          callback();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void View_setBloomRenderThread(TView *tView, bool enabled, double strength, void (*callback)())
@@ -443,7 +458,7 @@ extern "C"
          View_setBloom(tView, enabled, strength);
          callback();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void View_setCameraRenderThread(TView *tView, TCamera *tCamera, void (*callback)())
@@ -454,7 +469,7 @@ extern "C"
          View_setCamera(tView, tCamera);
          callback();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *)) {
@@ -464,7 +479,7 @@ extern "C"
        auto *animationManager = AnimationManager_create(tEngine, tScene);
        onComplete(animationManager);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void AnimationManager_updateBoneMatricesRenderThread(
@@ -478,7 +493,7 @@ extern "C"
          bool result = AnimationManager_updateBoneMatrices(tAnimationManager, sceneAsset);
          callback(result);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void AnimationManager_setMorphTargetWeightsRenderThread(
@@ -494,7 +509,7 @@ extern "C"
          bool result = AnimationManager_setMorphTargetWeights(tAnimationManager, entityId, morphData, numWeights);
          callback(result);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  // Add these implementations to your ThermionDartRenderThreadApi.cpp file
@@ -508,7 +523,7 @@ extern "C"
          auto image = Image_createEmpty(width, height, channel);
          onComplete(image);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Image_decodeRenderThread(uint8_t *data, size_t length, const char *name, void (*onComplete)(TLinearImage *))
@@ -519,7 +534,7 @@ extern "C"
          auto image = Image_decode(data, length, name);
          onComplete(image);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Image_getBytesRenderThread(TLinearImage *tLinearImage, void (*onComplete)(float *))
@@ -530,7 +545,7 @@ extern "C"
          auto bytes = Image_getBytes(tLinearImage);
          onComplete(bytes);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Image_destroyRenderThread(TLinearImage *tLinearImage, void (*onComplete)())
@@ -541,7 +556,7 @@ extern "C"
          Image_destroy(tLinearImage);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Image_getWidthRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t))
@@ -552,7 +567,7 @@ extern "C"
          auto width = Image_getWidth(tLinearImage);
          onComplete(width);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Image_getHeightRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t))
@@ -563,7 +578,7 @@ extern "C"
          auto height = Image_getHeight(tLinearImage);
          onComplete(height);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Image_getChannelsRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t))
@@ -574,7 +589,7 @@ extern "C"
          auto channels = Image_getChannels(tLinearImage);
          onComplete(channels);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Texture_buildRenderThread(
@@ -593,7 +608,7 @@ extern "C"
          auto *texture = Texture_build(tEngine, width, height, depth, levels, tUsage, import, sampler, format);
          onComplete(texture);
        });
-    auto fut = _rl->add_task(lambda);  
+    auto fut = _renderThread->add_task(lambda);  
    }

  // Texture methods
@@ -607,7 +622,7 @@ extern "C"
          bool result = Texture_loadImage(tEngine, tTexture, tImage, bufferFormat, pixelDataType);
          onComplete(result);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Texture_setImageRenderThread(
@@ -630,7 +645,7 @@ extern "C"
                                         bufferFormat, pixelDataType);
          onComplete(result);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Texture_setImageWithDepthRenderThread(
@@ -671,7 +686,7 @@ extern "C"
        );
        onComplete(result);
      });
-  auto fut = _rl->add_task(lambda);
+  auto fut = _renderThread->add_task(lambda);
 }

  EMSCRIPTEN_KEEPALIVE void RenderTarget_getColorTextureRenderThread(TRenderTarget *tRenderTarget, void (*onComplete)(TTexture *))
@@ -682,7 +697,7 @@ extern "C"
          auto texture = RenderTarget_getColorTexture(tRenderTarget);
          onComplete(texture);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void RenderTarget_createRenderThread(
@@ -702,7 +717,7 @@ extern "C"
          auto texture = RenderTarget_create(tEngine, width, height, tColor, tDepth);
          onComplete(texture);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  
@@ -716,7 +731,7 @@ extern "C"
          auto sampler = TextureSampler_create();
          onComplete(sampler);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_createWithFilteringRenderThread(
@@ -733,7 +748,7 @@ extern "C"
          auto sampler = TextureSampler_createWithFiltering(minFilter, magFilter, wrapS, wrapT, wrapR);
          onComplete(sampler);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_createWithComparisonRenderThread(
@@ -747,7 +762,7 @@ extern "C"
          auto sampler = TextureSampler_createWithComparison(compareMode, compareFunc);
          onComplete(sampler);
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_setMinFilterRenderThread(
@@ -761,7 +776,7 @@ extern "C"
          TextureSampler_setMinFilter(sampler, filter);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_setMagFilterRenderThread(
@@ -775,7 +790,7 @@ extern "C"
          TextureSampler_setMagFilter(sampler, filter);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_setWrapModeSRenderThread(
@@ -789,7 +804,7 @@ extern "C"
          TextureSampler_setWrapModeS(sampler, mode);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_setWrapModeTRenderThread(
@@ -803,7 +818,7 @@ extern "C"
          TextureSampler_setWrapModeT(sampler, mode);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_setWrapModeRRenderThread(
@@ -817,7 +832,7 @@ extern "C"
          TextureSampler_setWrapModeR(sampler, mode);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_setAnisotropyRenderThread(
@@ -831,7 +846,7 @@ extern "C"
          TextureSampler_setAnisotropy(sampler, anisotropy);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_setCompareModeRenderThread(
@@ -846,7 +861,7 @@ extern "C"
          TextureSampler_setCompareMode(sampler, mode, func);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void TextureSampler_destroyRenderThread(
@@ -859,7 +874,7 @@ extern "C"
          TextureSampler_destroy(sampler);
          onComplete();
        });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void GltfAssetLoader_createRenderThread(TEngine *tEngine, TMaterialProvider *tMaterialProvider, void (*callback)(TGltfAssetLoader *)) {
@@ -869,7 +884,7 @@ extern "C"
        auto loader = GltfAssetLoader_create(tEngine, tMaterialProvider);
        callback(loader);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }
  
  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_createRenderThread(TEngine *tEngine, const char* relativeResourcePath, void (*callback)(TGltfResourceLoader *)) {
@@ -879,7 +894,7 @@ extern "C"
        auto loader = GltfResourceLoader_create(tEngine, relativeResourcePath);
        callback(loader);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_destroyRenderThread(TEngine *tEngine, TGltfResourceLoader *tResourceLoader, void (*callback)()) {
@@ -889,7 +904,7 @@ extern "C"
        GltfResourceLoader_destroy(tEngine, tResourceLoader);
        callback();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_loadResourcesRenderThread(TGltfResourceLoader *tGltfResourceLoader, TFilamentAsset *tFilamentAsset, void (*callback)(bool)) {
@@ -899,7 +914,7 @@ extern "C"
        auto result = GltfResourceLoader_loadResources(tGltfResourceLoader, tFilamentAsset);
        callback(result);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_addResourceDataRenderThread(
@@ -914,7 +929,7 @@ extern "C"
        GltfResourceLoader_addResourceData(tGltfResourceLoader, uri, data, length);
        callback();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }
  
  EMSCRIPTEN_KEEPALIVE void GltfAssetLoader_loadRenderThread(
@@ -931,7 +946,7 @@ extern "C"
        auto loader = GltfAssetLoader_load(tEngine, tAssetLoader, data, length, numInstances);
        callback(loader);
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }

  EMSCRIPTEN_KEEPALIVE void Scene_addFilamentAssetRenderThread(TScene* tScene, TFilamentAsset *tAsset, void (*callback)()) {
@@ -941,6 +956,6 @@ extern "C"
        Scene_addFilamentAsset(tScene, tAsset);
        callback();
      });
-    auto fut = _rl->add_task(lambda);
+    auto fut = _renderThread->add_task(lambda);
  }
 }
--- a/thermion_dart/native/src/rendering/RenderThread.cpp
+++ b/thermion_dart/native/src/rendering/RenderThread.cpp
@@ -1,4 +1,4 @@
-#include "rendering/RenderLoop.hpp"
+#include "rendering/RenderThread.hpp"

 #include <functional>
 #include <stdlib.h>
@@ -8,7 +8,7 @@

 namespace thermion {

-RenderLoop::RenderLoop()
+RenderThread::RenderThread()
 {
    srand(time(NULL));
    t = new std::thread([this]() { 
@@ -18,26 +18,27 @@ RenderLoop::RenderLoop()
    });
 }

-RenderLoop::~RenderLoop()
+RenderThread::~RenderThread()
 {
-    TRACE("Destroying RenderLoop");
+    TRACE("Destroying RenderThread");
    _stop = true;
    _cv.notify_one();
-    TRACE("Joining RenderLoop thread..");    
+    TRACE("Joining RenderThread thread..");    
    t->join();
    delete t;

-    TRACE("RenderLoop destructor complete");    
+    TRACE("RenderThread destructor complete");    
 }

-void RenderLoop::requestFrame(void (*callback)())
+void RenderThread::requestFrame(void (*callback)())
 {
+    TRACE("Request frame");
    std::unique_lock<std::mutex> lock(_mutex);
    this->_requestFrameRenderCallback = callback;
    _cv.notify_one();
 }

-void RenderLoop::iter()
+void RenderThread::iter()
 {
    {
        std::unique_lock<std::mutex> lock(_mutex);
--- a/thermion_dart/test/geometry_tests.dart
+++ b/thermion_dart/test/geometry_tests.dart
@@ -10,283 +10,288 @@ void main() async {
  final testHelper = TestHelper("geometry");
  await testHelper.setup();
  group("custom geometry", () {
-    test('create cube (uvs only)', () async {
-      var viewer = await testHelper.createViewer();
-      await viewer
-          .createGeometry(GeometryHelper.cube(normals: false, uvs: true));
-      await testHelper.capture(viewer, "geometry_cube_with_uvs");
-    });
-    test('create cube with normals & uvs', () async {
-      var viewer = await testHelper.createViewer();
-      await viewer
-          .createGeometry(GeometryHelper.cube(normals: true, uvs: true));
-      await testHelper.capture(viewer, "geometry_cube_with_normals_uvs");
-    });
-
-    test('create cube (no normals/uvs)', () async {
+    test('add geometry', () async {
      await testHelper.withViewer((viewer) async {
-        var viewMatrix =
-            makeViewMatrix(Vector3(0, 2, 5), Vector3.zero(), Vector3(0, 1, 0));
-        viewMatrix.invert();
-        await viewer.setCameraModelMatrix4(viewMatrix);
-        final cube = await viewer
-            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
-        await testHelper.capture(viewer, "geometry_cube_no_normals_uvs");
-        await viewer.destroyAsset(cube);
-        await testHelper.capture(viewer, "geometry_remove_cube");
-      });
-    });
-
-    test('create cube with unlit ubershader material (no normals/uvs)',
-        () async {
-      await testHelper.withViewer((viewer) async {
-        final materialInstance =
-            await viewer.createUbershaderMaterialInstance(unlit: true);
-        await materialInstance.setParameterFloat4(
-            "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
-        final cube = await viewer.createGeometry(
-            GeometryHelper.cube(normals: false, uvs: false),
-            materialInstances: [materialInstance]);
-        await testHelper.capture(viewer, "geometry_cube_ubershader");
-      });
-    });
-
-    test('create cube with lit ubershader material (normals/ no uvs)',
-        () async {
-      await testHelper.withViewer((viewer) async {
-        final materialInstance = await viewer.createUbershaderMaterialInstance(
-            unlit: false, alphaMode: AlphaMode.BLEND, hasVertexColors: false);
-        await materialInstance.setParameterFloat4(
-            "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
-        final cube = await viewer.createGeometry(
-            GeometryHelper.cube(normals: true, uvs: false),
-            materialInstances: [materialInstance]);
-
-        await viewer.addDirectLight(DirectLight.sun(
-            intensity: 100000,
-            castShadows: false,
-            direction: Vector3(0, -0.5, -1)));
-        // await viewer.addDirectLight(DirectLight.spot(
-        //   intensity: 1000000,
-        //   position: Vector3(0,3,3),
-        //   direction: Vector3(0,-1.5,-1),
-        //   falloffRadius: 10));
-        await materialInstance.setParameterFloat4(
-            "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
-        await testHelper.capture(viewer, "geometry_cube_lit_ubershader");
-      });
-    });
-
-    test('create instance', () async {
-      await testHelper.withViewer((viewer) async {
-        final cube = await viewer
-            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
-        await viewer.setTransform(
-            cube.entity, Matrix4.translation(Vector3.all(-1)));
-        final instance = await cube.createInstance();
-        await instance.addToScene();
-        await viewer.setTransform(
-            instance.entity, Matrix4.translation(Vector3.all(1)));
-
-        await testHelper.capture(viewer, "geometry_instanced");
-        await viewer.destroyAsset(instance);
-        await testHelper.capture(viewer, "geometry_instance_removed");
-      });
-    });
-
-    test('create instance (shared material)', () async {
-      await testHelper.withViewer((viewer) async {
-        final materialInstance = await viewer.createUnlitMaterialInstance();
-        await materialInstance.setParameterFloat4(
-            "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
-        final cube = await viewer.createGeometry(
-            GeometryHelper.cube(normals: true, uvs: false),
-            materialInstances: [materialInstance]);
-
-        final instance = await cube.createInstance();
-        await instance.addToScene();
-        await viewer.setTransform(
-            instance.entity, Matrix4.translation(Vector3.all(1)));
-
-        await testHelper.capture(
-            viewer, "geometry_instanced_with_shared_material");
-      });
-    });
-
-    // test('create instance (no material on second instance)', () async {
-    //   await testHelper.withViewer((viewer) async {
-    //     final materialInstance = await viewer.createUnlitMaterialInstance();
-    //     await materialInstance.setParameterFloat4(
-    //         "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
-    //     final cube = await viewer.createGeometry(
-    //         GeometryHelper.cube(normals: true, uvs: false),
-    //         materialInstances: [materialInstance]);
-
-    //     final instance = await viewer
-    //         .createInstance(cube);
-    //     await viewer.setTransform(
-    //         instance.entity, Matrix4.translation(Vector3.all(1)));
-
-    //     await testHelper.capture(
-    //         viewer, "geometry_instanced_with_no_material_instance");
-    //   });
-    // });
-
-    // test('create instance (separate materials)', () async {
-    //   await testHelper.withViewer((viewer) async {
-    //     final materialInstance = await viewer.createUnlitMaterialInstance();
-    //     await materialInstance.setParameterFloat4(
-    //         "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
-    //     final cube = await viewer.createGeometry(
-    //         GeometryHelper.cube(normals: true, uvs: false),
-    //         materialInstances: [materialInstance]);
-
-    //     final materialInstance2 = await viewer.createUnlitMaterialInstance();
-    //     await materialInstance2.setParameterFloat4(
-    //         "baseColorFactor", 0.0, 1.0, 0.0, 1.0);
-    //     final instance = await viewer
-    //         .createInstance(cube, materialInstances: [materialInstance2]);
-    //     await viewer.setTransform(
-    //         instance.entity, Matrix4.translation(Vector3.all(1)));
-
-    //     await testHelper.capture(
-    //         viewer, "geometry_instanced_with_separate_material_instances");
-    //   });
-    // });
-
-    test('create cube with custom ubershader material (color)', () async {
-      await testHelper.withViewer((viewer) async {
-        await viewer.addLight(LightType.SUN, 6500, 1000000, 0, 0, 0, 0, 0, -1);
-        await viewer.setCameraPosition(0, 2, 6);
-        await viewer
-            .setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
-        await viewer.setBackgroundColor(1.0, 0.0, 1.0, 1.0);
-
-        var materialInstance =
-            await viewer.createUbershaderMaterialInstance(unlit: true);
-        final cube = await viewer.createGeometry(
-            GeometryHelper.cube(uvs: false, normals: true),
-            materialInstances: [materialInstance]);
-        await materialInstance.setParameterFloat4(
-            "baseColorFactor", 0.0, 1.0, 0.0, 0.0);
-        await testHelper.capture(
-            viewer, "geometry_cube_with_custom_material_ubershader");
-        await viewer.destroyAsset(cube);
-      });
-    });
-
-    test('create cube with custom ubershader material instance (texture)',
-        () async {
-      var viewer = await testHelper.createViewer();
-      await viewer.addLight(LightType.SUN, 6500, 1000000, 0, 0, 0, 0, 0, -1);
-      await viewer.setCameraPosition(0, 2, 6);
-      await viewer
-          .setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
-      await viewer.setBackgroundColor(1.0, 0.0, 0.0, 1.0);
-
-      var materialInstance = await viewer.createUbershaderMaterialInstance();
-      final cube = await viewer.createGeometry(
-          GeometryHelper.cube(uvs: true, normals: true),
-          materialInstances: [materialInstance]);
-      final image = await viewer.decodeImage(
-          File("${testHelper.testDir}/assets/cube_texture_512x512.png")
-              .readAsBytesSync());
-      var texture = await viewer.createTexture(
-          await image.getWidth(), await image.getHeight());
-      await texture.setLinearImage(
-          image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
-      await testHelper.capture(
-          viewer, "geometry_cube_with_custom_material_ubershader_texture");
-      await viewer.destroyAsset(cube);
-      await texture.dispose();
-      await image.destroy();
-    });
-
-    test('unlit material with color only', () async {
-      await testHelper.withViewer((viewer) async {
-        var materialInstance = await viewer.createUnlitMaterialInstance();
-        var cube = await viewer.createGeometry(GeometryHelper.cube(),
-            materialInstances: [materialInstance]);
-
-        await materialInstance.setParameterFloat4(
-            "baseColorFactor", 0.0, 1.0, 0.0, 1.0);
-
-        await testHelper.capture(viewer, "unlit_material_base_color");
-      });
-    });
-
-    test('unlit material with texture', () async {
-      await testHelper.withViewer((viewer) async {
-        var materialInstance = await viewer.createUnlitMaterialInstance();
-        var cube = await viewer.createGeometry(GeometryHelper.cube(),
-            materialInstances: [materialInstance]);
-
-        await materialInstance.setParameterInt("baseColorIndex", 0);
-
-        final image = await viewer.decodeImage(
-            File("${testHelper.testDir}/assets/cube_texture_512x512.png")
-                .readAsBytesSync());
-        var texture = await viewer.createTexture(
-            await image.getWidth(), await image.getHeight());
-        await texture.setLinearImage(
-            image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
-        await testHelper.capture(viewer, "unlit_material_texture_only");
-        await viewer.destroyAsset(cube);
-      });
-    });
-
-    test('shared material instance with texture and base color', () async {
-      await testHelper.withViewer((viewer) async {
-        var materialInstance = await viewer.createUnlitMaterialInstance();
-        var cube1 = await viewer.createGeometry(GeometryHelper.cube(),
-            materialInstances: [materialInstance]);
-        var cube2 = await viewer.createGeometry(GeometryHelper.cube(),
-            materialInstances: [materialInstance]);
-        await viewer.setTransform(
-            cube2.entity, Matrix4.translation(Vector3(1, 1, 1)));
-
-        await materialInstance.setParameterInt("baseColorIndex", 0);
-        final image = await viewer.decodeImage(
-            File("${testHelper.testDir}/assets/cube_texture_512x512.png")
-                .readAsBytesSync());
-        var texture = await viewer.createTexture(
-            await image.getWidth(), await image.getHeight());
-        await texture.setLinearImage(
-            image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
-
-        await testHelper.capture(viewer, "unlit_material_shared");
-        await texture.dispose();
-        await image.destroy();
-      });
-    });
-
-    test('create sphere (no normals)', () async {
-      await testHelper.withViewer((viewer) async {
-        await viewer
-            .createGeometry(GeometryHelper.sphere(normals: false, uvs: false));
-        await testHelper.capture(viewer, "geometry_sphere_no_normals");
-      }, bg: kBlue, cameraPosition: Vector3(0, 0, 6));
-    });
-
-    test('create multiple (non-instanced) geometry', () async {
-      await testHelper.withViewer((viewer) async {
-        final cube1 = await viewer
-            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
-        final cube2 = await viewer
-            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
-        await viewer.setTransform(
-            cube2.entity, Matrix4.translation(Vector3(0, 1.5, 0)));
-        await testHelper.capture(viewer, "multiple_geometry");
+        final asset = await viewer.createGeometry(GeometryHelper.cube());
+        await viewer.addToScene(asset);
+        await testHelper.capture(viewer.view, "add_geometry");
+        await viewer.removeFromScene(asset);
+        await testHelper.capture(viewer.view, "remove_geometry");
+        await viewer.destroyAsset(asset);
      }, bg: kRed);
    });
-
-    test('create camera geometry', () async {
-      await testHelper.withViewer((viewer) async {
-        final camera = await viewer.createGeometry(
-            GeometryHelper.wireframeCamera(normals: false, uvs: false));
-        await viewer.setTransform(camera.entity, Matrix4.rotationY(pi / 4));
-        await testHelper.capture(viewer, "camera_geometry");
-      });
-    });
  });
+  //   test('create cube with normals & uvs', () async {
+  //     var viewer = await testHelper.createViewer();
+  //     await viewer
+  //         .createGeometry(GeometryHelper.cube(normals: true, uvs: true));
+  //     await testHelper.capture(viewer, "geometry_cube_with_normals_uvs");
+  //   });
+
+  //   test('create cube (no normals/uvs)', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       var viewMatrix =
+  //           makeViewMatrix(Vector3(0, 2, 5), Vector3.zero(), Vector3(0, 1, 0));
+  //       viewMatrix.invert();
+  //       await viewer.setCameraModelMatrix4(viewMatrix);
+  //       final cube = await viewer
+  //           .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
+  //       await testHelper.capture(viewer, "geometry_cube_no_normals_uvs");
+  //       await viewer.destroyAsset(cube);
+  //       await testHelper.capture(viewer, "geometry_remove_cube");
+  //     });
+  //   });
+
+  //   test('create cube with unlit ubershader material (no normals/uvs)',
+  //       () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       final materialInstance =
+  //           await viewer.createUbershaderMaterialInstance(unlit: true);
+  //       await materialInstance.setParameterFloat4(
+  //           "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
+  //       final cube = await viewer.createGeometry(
+  //           GeometryHelper.cube(normals: false, uvs: false),
+  //           materialInstances: [materialInstance]);
+  //       await testHelper.capture(viewer, "geometry_cube_ubershader");
+  //     });
+  //   });
+
+  //   test('create cube with lit ubershader material (normals/ no uvs)',
+  //       () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       final materialInstance = await viewer.createUbershaderMaterialInstance(
+  //           unlit: false, alphaMode: AlphaMode.BLEND, hasVertexColors: false);
+  //       await materialInstance.setParameterFloat4(
+  //           "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
+  //       final cube = await viewer.createGeometry(
+  //           GeometryHelper.cube(normals: true, uvs: false),
+  //           materialInstances: [materialInstance]);
+
+  //       await viewer.addDirectLight(DirectLight.sun(
+  //           intensity: 100000,
+  //           castShadows: false,
+  //           direction: Vector3(0, -0.5, -1)));
+  //       // await viewer.addDirectLight(DirectLight.spot(
+  //       //   intensity: 1000000,
+  //       //   position: Vector3(0,3,3),
+  //       //   direction: Vector3(0,-1.5,-1),
+  //       //   falloffRadius: 10));
+  //       await materialInstance.setParameterFloat4(
+  //           "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
+  //       await testHelper.capture(viewer, "geometry_cube_lit_ubershader");
+  //     });
+  //   });
+
+  //   test('create instance', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       final cube = await viewer
+  //           .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
+  //       await viewer.setTransform(
+  //           cube.entity, Matrix4.translation(Vector3.all(-1)));
+  //       final instance = await cube.createInstance();
+  //       await instance.addToScene();
+  //       await viewer.setTransform(
+  //           instance.entity, Matrix4.translation(Vector3.all(1)));
+
+  //       await testHelper.capture(viewer, "geometry_instanced");
+  //       await viewer.destroyAsset(instance);
+  //       await testHelper.capture(viewer, "geometry_instance_removed");
+  //     });
+  //   });
+
+  //   test('create instance (shared material)', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       final materialInstance = await viewer.createUnlitMaterialInstance();
+  //       await materialInstance.setParameterFloat4(
+  //           "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
+  //       final cube = await viewer.createGeometry(
+  //           GeometryHelper.cube(normals: true, uvs: false),
+  //           materialInstances: [materialInstance]);
+
+  //       final instance = await cube.createInstance();
+  //       await instance.addToScene();
+  //       await viewer.setTransform(
+  //           instance.entity, Matrix4.translation(Vector3.all(1)));
+
+  //       await testHelper.capture(
+  //           viewer, "geometry_instanced_with_shared_material");
+  //     });
+  //   });
+
+  //   // test('create instance (no material on second instance)', () async {
+  //   //   await testHelper.withViewer((viewer) async {
+  //   //     final materialInstance = await viewer.createUnlitMaterialInstance();
+  //   //     await materialInstance.setParameterFloat4(
+  //   //         "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
+  //   //     final cube = await viewer.createGeometry(
+  //   //         GeometryHelper.cube(normals: true, uvs: false),
+  //   //         materialInstances: [materialInstance]);
+
+  //   //     final instance = await viewer
+  //   //         .createInstance(cube);
+  //   //     await viewer.setTransform(
+  //   //         instance.entity, Matrix4.translation(Vector3.all(1)));
+
+  //   //     await testHelper.capture(
+  //   //         viewer, "geometry_instanced_with_no_material_instance");
+  //   //   });
+  //   // });
+
+  //   // test('create instance (separate materials)', () async {
+  //   //   await testHelper.withViewer((viewer) async {
+  //   //     final materialInstance = await viewer.createUnlitMaterialInstance();
+  //   //     await materialInstance.setParameterFloat4(
+  //   //         "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
+  //   //     final cube = await viewer.createGeometry(
+  //   //         GeometryHelper.cube(normals: true, uvs: false),
+  //   //         materialInstances: [materialInstance]);
+
+  //   //     final materialInstance2 = await viewer.createUnlitMaterialInstance();
+  //   //     await materialInstance2.setParameterFloat4(
+  //   //         "baseColorFactor", 0.0, 1.0, 0.0, 1.0);
+  //   //     final instance = await viewer
+  //   //         .createInstance(cube, materialInstances: [materialInstance2]);
+  //   //     await viewer.setTransform(
+  //   //         instance.entity, Matrix4.translation(Vector3.all(1)));
+
+  //   //     await testHelper.capture(
+  //   //         viewer, "geometry_instanced_with_separate_material_instances");
+  //   //   });
+  //   // });
+
+  //   test('create cube with custom ubershader material (color)', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       await viewer.addLight(LightType.SUN, 6500, 1000000, 0, 0, 0, 0, 0, -1);
+  //       await viewer.setCameraPosition(0, 2, 6);
+  //       await viewer
+  //           .setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
+  //       await viewer.setBackgroundColor(1.0, 0.0, 1.0, 1.0);
+
+  //       var materialInstance =
+  //           await viewer.createUbershaderMaterialInstance(unlit: true);
+  //       final cube = await viewer.createGeometry(
+  //           GeometryHelper.cube(uvs: false, normals: true),
+  //           materialInstances: [materialInstance]);
+  //       await materialInstance.setParameterFloat4(
+  //           "baseColorFactor", 0.0, 1.0, 0.0, 0.0);
+  //       await testHelper.capture(
+  //           viewer, "geometry_cube_with_custom_material_ubershader");
+  //       await viewer.destroyAsset(cube);
+  //     });
+  //   });
+
+  //   test('create cube with custom ubershader material instance (texture)',
+  //       () async {
+  //     var viewer = await testHelper.createViewer();
+  //     await viewer.addLight(LightType.SUN, 6500, 1000000, 0, 0, 0, 0, 0, -1);
+  //     await viewer.setCameraPosition(0, 2, 6);
+  //     await viewer
+  //         .setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
+  //     await viewer.setBackgroundColor(1.0, 0.0, 0.0, 1.0);
+
+  //     var materialInstance = await viewer.createUbershaderMaterialInstance();
+  //     final cube = await viewer.createGeometry(
+  //         GeometryHelper.cube(uvs: true, normals: true),
+  //         materialInstances: [materialInstance]);
+  //     final image = await viewer.decodeImage(
+  //         File("${testHelper.testDir}/assets/cube_texture_512x512.png")
+  //             .readAsBytesSync());
+  //     var texture = await viewer.createTexture(
+  //         await image.getWidth(), await image.getHeight());
+  //     await texture.setLinearImage(
+  //         image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
+  //     await testHelper.capture(
+  //         viewer, "geometry_cube_with_custom_material_ubershader_texture");
+  //     await viewer.destroyAsset(cube);
+  //     await texture.dispose();
+  //     await image.destroy();
+  //   });
+
+  //   test('unlit material with color only', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       var materialInstance = await viewer.createUnlitMaterialInstance();
+  //       var cube = await viewer.createGeometry(GeometryHelper.cube(),
+  //           materialInstances: [materialInstance]);
+
+  //       await materialInstance.setParameterFloat4(
+  //           "baseColorFactor", 0.0, 1.0, 0.0, 1.0);
+
+  //       await testHelper.capture(viewer, "unlit_material_base_color");
+  //     });
+  //   });
+
+  //   test('unlit material with texture', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       var materialInstance = await viewer.createUnlitMaterialInstance();
+  //       var cube = await viewer.createGeometry(GeometryHelper.cube(),
+  //           materialInstances: [materialInstance]);
+
+  //       await materialInstance.setParameterInt("baseColorIndex", 0);
+
+  //       final image = await viewer.decodeImage(
+  //           File("${testHelper.testDir}/assets/cube_texture_512x512.png")
+  //               .readAsBytesSync());
+  //       var texture = await viewer.createTexture(
+  //           await image.getWidth(), await image.getHeight());
+  //       await texture.setLinearImage(
+  //           image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
+  //       await testHelper.capture(viewer, "unlit_material_texture_only");
+  //       await viewer.destroyAsset(cube);
+  //     });
+  //   });
+
+  //   test('shared material instance with texture and base color', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       var materialInstance = await viewer.createUnlitMaterialInstance();
+  //       var cube1 = await viewer.createGeometry(GeometryHelper.cube(),
+  //           materialInstances: [materialInstance]);
+  //       var cube2 = await viewer.createGeometry(GeometryHelper.cube(),
+  //           materialInstances: [materialInstance]);
+  //       await viewer.setTransform(
+  //           cube2.entity, Matrix4.translation(Vector3(1, 1, 1)));
+
+  //       await materialInstance.setParameterInt("baseColorIndex", 0);
+  //       final image = await viewer.decodeImage(
+  //           File("${testHelper.testDir}/assets/cube_texture_512x512.png")
+  //               .readAsBytesSync());
+  //       var texture = await viewer.createTexture(
+  //           await image.getWidth(), await image.getHeight());
+  //       await texture.setLinearImage(
+  //           image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
+
+  //       await testHelper.capture(viewer, "unlit_material_shared");
+  //       await texture.dispose();
+  //       await image.destroy();
+  //     });
+  //   });
+
+  //   test('create sphere (no normals)', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       await viewer
+  //           .createGeometry(GeometryHelper.sphere(normals: false, uvs: false));
+  //       await testHelper.capture(viewer, "geometry_sphere_no_normals");
+  //     }, bg: kBlue, cameraPosition: Vector3(0, 0, 6));
+  //   });
+
+  //   test('create multiple (non-instanced) geometry', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       final cube1 = await viewer
+  //           .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
+  //       final cube2 = await viewer
+  //           .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
+  //       await viewer.setTransform(
+  //           cube2.entity, Matrix4.translation(Vector3(0, 1.5, 0)));
+  //       await testHelper.capture(viewer, "multiple_geometry");
+  //     }, bg: kRed);
+  //   });
+
+  //   test('create camera geometry', () async {
+  //     await testHelper.withViewer((viewer) async {
+  //       final camera = await viewer.createGeometry(
+  //           GeometryHelper.wireframeCamera(normals: false, uvs: false));
+  //       await viewer.setTransform(camera.entity, Matrix4.rotationY(pi / 4));
+  //       await testHelper.capture(viewer, "camera_geometry");
+  //     });
+  //   });
+  // });
 }
--- a/thermion_dart/test/helpers.dart
+++ b/thermion_dart/test/helpers.dart
@@ -165,22 +165,25 @@ class TestHelper {
    resourceLoader.ref.freeResource = freeResource.nativeFunction;
    await FFIFilamentApp.create();

-    await FilamentApp.instance!.setClearColor(0, 0, 0, 1);
+    await FilamentApp.instance!.setClearColor(0, 1, 0, 1);
  }

  ///
  ///
  ///
-  Future withViewer(Future Function(ThermionViewer viewer) fn,
-      {img.Color? bg,
-      Vector3? cameraPosition,
-      ({int width, int height}) viewportDimensions = (width: 500, height: 500),
-      bool postProcessing = false,
-      bool createRenderTarget = false}) async {
+  Future withViewer(
+    Future Function(ThermionViewer viewer) fn, {
+    img.Color? bg,
+    Vector3? cameraPosition,
+    ({int width, int height}) viewportDimensions = (width: 512, height: 512),
+    bool postProcessing = false,
+    bool addSkybox = false,
+    bool createRenderTarget = false,
+  }) async {
    cameraPosition ??= Vector3(0, 2, 6);

-    var swapChain = await FilamentApp.instance!.createHeadlessSwapChain(
-        viewportDimensions.width, viewportDimensions.height) as FFISwapChain;
+    var swapChain = await FilamentApp.instance!
+        .createHeadlessSwapChain(viewportDimensions.width, viewportDimensions.height) as FFISwapChain;

    FFIRenderTarget? renderTarget;
    if (createRenderTarget) {
@@ -198,7 +201,8 @@ class TestHelper {
              },
              textureFormat: TextureFormat.RGB32F,
              importedTextureHandle: metalColorTexture.metalTextureAddress);
-
+      var width = await color.getWidth();
+      var height = await color.getHeight();
      var depth = await FilamentApp.instance!
          .createTexture(viewportDimensions.width, viewportDimensions.height,
              flags: {
@@ -216,16 +220,23 @@ class TestHelper {

    var viewer = ThermionViewerFFI(
        loadAssetFromUri: (path) async =>
-            File(path.replaceAll("file://", "")).readAsBytesSync(),
-        renderTarget: renderTarget);
+            File(path.replaceAll("file://", "")).readAsBytesSync());

    await viewer.initialized;
    await FilamentApp.instance!.register(swapChain, viewer.view);
-
+    if (renderTarget != null) {
+      await viewer.view.setRenderTarget(renderTarget);
+    }
    await viewer.view
-        .setViewport(viewportDimensions.width, viewportDimensions.height);
+        .setViewport(
+          viewportDimensions.width,
+          viewportDimensions.height
+      );

-    await viewer.view.setBloom(false, 0);
+    if (addSkybox) {
+      await viewer
+          .loadSkybox("file://${testDir}/assets/default_env_skybox.ktx");
+    }

    if (bg != null) {
      await viewer.setBackgroundColor(