diff --git a/thermion_dart/lib/src/bindings/src/thermion_dart_ffi.g.dart b/thermion_dart/lib/src/bindings/src/thermion_dart_ffi.g.dart
index e7ad14bb..35daa86b 100644
--- a/thermion_dart/lib/src/bindings/src/thermion_dart_ffi.g.dart
+++ b/thermion_dart/lib/src/bindings/src/thermion_dart_ffi.g.dart
@@ -887,11 +887,86 @@ external void Gizmo_unhighlight(
 );
 
 @ffi.Native<
-    ffi.Pointer<TMaterialInstance> Function(ffi.Pointer<TMaterialProvider>,
-        ffi.Pointer<TMaterialKey>)>(isLeaf: true)
+    ffi.Pointer<TMaterialInstance> Function(
+        ffi.Pointer<TMaterialProvider>,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Int,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Uint8,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool)>(isLeaf: true)
 external ffi.Pointer<TMaterialInstance> MaterialProvider_createMaterialInstance(
   ffi.Pointer<TMaterialProvider> provider,
-  ffi.Pointer<TMaterialKey> key,
+  bool doubleSided,
+  bool unlit,
+  bool hasVertexColors,
+  bool hasBaseColorTexture,
+  bool hasNormalTexture,
+  bool hasOcclusionTexture,
+  bool hasEmissiveTexture,
+  bool useSpecularGlossiness,
+  int alphaMode,
+  bool enableDiagnostics,
+  bool hasMetallicRoughnessTexture,
+  int metallicRoughnessUV,
+  bool hasSpecularGlossinessTexture,
+  int specularGlossinessUV,
+  int baseColorUV,
+  bool hasClearCoatTexture,
+  int clearCoatUV,
+  bool hasClearCoatRoughnessTexture,
+  int clearCoatRoughnessUV,
+  bool hasClearCoatNormalTexture,
+  int clearCoatNormalUV,
+  bool hasClearCoat,
+  bool hasTransmission,
+  bool hasTextureTransforms,
+  int emissiveUV,
+  int aoUV,
+  int normalUV,
+  bool hasTransmissionTexture,
+  int transmissionUV,
+  bool hasSheenColorTexture,
+  int sheenColorUV,
+  bool hasSheenRoughnessTexture,
+  int sheenRoughnessUV,
+  bool hasVolumeThicknessTexture,
+  int volumeThicknessUV,
+  bool hasSheen,
+  bool hasIOR,
+  bool hasVolume,
 );
 
 @ffi.Native<
@@ -2121,14 +2196,88 @@ external void SceneAsset_createGeometryRenderThread(
 @ffi.Native<
     ffi.Void Function(
         ffi.Pointer<TMaterialProvider>,
-        ffi.Pointer<TMaterialKey>,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Int,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Uint8,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Uint8,
+        ffi.Bool,
+        ffi.Bool,
+        ffi.Bool,
         ffi.Pointer<
             ffi.NativeFunction<
                 ffi.Void Function(
                     ffi.Pointer<TMaterialInstance>)>>)>(isLeaf: true)
 external void MaterialProvider_createMaterialInstanceRenderThread(
   ffi.Pointer<TMaterialProvider> tMaterialProvider,
-  ffi.Pointer<TMaterialKey> tKey,
+  bool doubleSided,
+  bool unlit,
+  bool hasVertexColors,
+  bool hasBaseColorTexture,
+  bool hasNormalTexture,
+  bool hasOcclusionTexture,
+  bool hasEmissiveTexture,
+  bool useSpecularGlossiness,
+  int alphaMode,
+  bool enableDiagnostics,
+  bool hasMetallicRoughnessTexture,
+  int metallicRoughnessUV,
+  bool hasSpecularGlossinessTexture,
+  int specularGlossinessUV,
+  int baseColorUV,
+  bool hasClearCoatTexture,
+  int clearCoatUV,
+  bool hasClearCoatRoughnessTexture,
+  int clearCoatRoughnessUV,
+  bool hasClearCoatNormalTexture,
+  int clearCoatNormalUV,
+  bool hasClearCoat,
+  bool hasTransmission,
+  bool hasTextureTransforms,
+  int emissiveUV,
+  int aoUV,
+  int normalUV,
+  bool hasTransmissionTexture,
+  int transmissionUV,
+  bool hasSheenColorTexture,
+  int sheenColorUV,
+  bool hasSheenRoughnessTexture,
+  int sheenRoughnessUV,
+  bool hasVolumeThicknessTexture,
+  int volumeThicknessUV,
+  bool hasSheen,
+  bool hasIOR,
+  bool hasVolume,
   ffi.Pointer<
           ffi.NativeFunction<ffi.Void Function(ffi.Pointer<TMaterialInstance>)>>
       callback,
@@ -3323,134 +3472,6 @@ final class TFilamentAsset extends ffi.Opaque {}
 
 final class TColorGrading extends ffi.Opaque {}
 
-final class UnnamedStruct1 extends ffi.Struct {
-  @ffi.Bool()
-  external bool hasMetallicRoughnessTexture;
-
-  @ffi.Uint8()
-  external int metallicRoughnessUV;
-}
-
-final class UnnamedStruct2 extends ffi.Struct {
-  @ffi.Bool()
-  external bool hasSpecularGlossinessTexture;
-
-  @ffi.Uint8()
-  external int specularGlossinessUV;
-}
-
-final class UnnamedUnion1 extends ffi.Union {
-  external UnnamedStruct1 unnamed;
-
-  external UnnamedStruct2 unnamed$1;
-}
-
-final class TMaterialKey extends ffi.Struct {
-  @ffi.Bool()
-  external bool doubleSided;
-
-  @ffi.Bool()
-  external bool unlit;
-
-  @ffi.Bool()
-  external bool hasVertexColors;
-
-  @ffi.Bool()
-  external bool hasBaseColorTexture;
-
-  @ffi.Bool()
-  external bool hasNormalTexture;
-
-  @ffi.Bool()
-  external bool hasOcclusionTexture;
-
-  @ffi.Bool()
-  external bool hasEmissiveTexture;
-
-  @ffi.Bool()
-  external bool useSpecularGlossiness;
-
-  @ffi.Int()
-  external int alphaMode;
-
-  @ffi.Bool()
-  external bool enableDiagnostics;
-
-  external UnnamedUnion1 unnamed;
-
-  @ffi.Uint8()
-  external int baseColorUV;
-
-  @ffi.Bool()
-  external bool hasClearCoatTexture;
-
-  @ffi.Uint8()
-  external int clearCoatUV;
-
-  @ffi.Bool()
-  external bool hasClearCoatRoughnessTexture;
-
-  @ffi.Uint8()
-  external int clearCoatRoughnessUV;
-
-  @ffi.Bool()
-  external bool hasClearCoatNormalTexture;
-
-  @ffi.Uint8()
-  external int clearCoatNormalUV;
-
-  @ffi.Bool()
-  external bool hasClearCoat;
-
-  @ffi.Bool()
-  external bool hasTransmission;
-
-  @ffi.Bool()
-  external bool hasTextureTransforms;
-
-  @ffi.Uint8()
-  external int emissiveUV;
-
-  @ffi.Uint8()
-  external int aoUV;
-
-  @ffi.Uint8()
-  external int normalUV;
-
-  @ffi.Bool()
-  external bool hasTransmissionTexture;
-
-  @ffi.Uint8()
-  external int transmissionUV;
-
-  @ffi.Bool()
-  external bool hasSheenColorTexture;
-
-  @ffi.Uint8()
-  external int sheenColorUV;
-
-  @ffi.Bool()
-  external bool hasSheenRoughnessTexture;
-
-  @ffi.Uint8()
-  external int sheenRoughnessUV;
-
-  @ffi.Bool()
-  external bool hasVolumeThicknessTexture;
-
-  @ffi.Uint8()
-  external int volumeThicknessUV;
-
-  @ffi.Bool()
-  external bool hasSheen;
-
-  @ffi.Bool()
-  external bool hasIOR;
-
-  @ffi.Bool()
-  external bool hasVolume;
-}
-
 final class double3 extends ffi.Struct {
   @ffi.Double()
   external double x;
diff --git a/thermion_dart/lib/src/bindings/src/thermion_dart_js_interop.g.dart b/thermion_dart/lib/src/bindings/src/thermion_dart_js_interop.g.dart
index 10802a13..1002a425 100644
--- a/thermion_dart/lib/src/bindings/src/thermion_dart_js_interop.g.dart
+++ b/thermion_dart/lib/src/bindings/src/thermion_dart_js_interop.g.dart
@@ -255,7 +255,7 @@ sealed class Struct extends NativeType {
   Struct(this._address);
 
   static create<T extends Struct>() {
-    switch (T) {
+        switch (T) {
       case double4x4:
         final ptr = double4x4.stackAlloc();
         final arr1 =
@@ -901,7 +901,44 @@ extension type NativeLibrary(JSObject _) implements JSObject {
   );
   external Pointer<TMaterialInstance> _MaterialProvider_createMaterialInstance(
     Pointer<TMaterialProvider> provider,
-    Pointer<TMaterialKey> key,
+    bool doubleSided,
+    bool unlit,
+    bool hasVertexColors,
+    bool hasBaseColorTexture,
+    bool hasNormalTexture,
+    bool hasOcclusionTexture,
+    bool hasEmissiveTexture,
+    bool useSpecularGlossiness,
+    int alphaMode,
+    bool enableDiagnostics,
+    bool hasMetallicRoughnessTexture,
+    int metallicRoughnessUV,
+    bool hasSpecularGlossinessTexture,
+    int specularGlossinessUV,
+    int baseColorUV,
+    bool hasClearCoatTexture,
+    int clearCoatUV,
+    bool hasClearCoatRoughnessTexture,
+    int clearCoatRoughnessUV,
+    bool hasClearCoatNormalTexture,
+    int clearCoatNormalUV,
+    bool hasClearCoat,
+    bool hasTransmission,
+    bool hasTextureTransforms,
+    int emissiveUV,
+    int aoUV,
+    int normalUV,
+    bool hasTransmissionTexture,
+    int transmissionUV,
+    bool hasSheenColorTexture,
+    int sheenColorUV,
+    bool hasSheenRoughnessTexture,
+    int sheenRoughnessUV,
+    bool hasVolumeThicknessTexture,
+    int volumeThicknessUV,
+    bool hasSheen,
+    bool hasIOR,
+    bool hasVolume,
   );
   external Pointer<TRenderTarget> _RenderTarget_create(
     Pointer<TEngine> tEngine,
@@ -1558,7 +1595,44 @@ extension type NativeLibrary(JSObject _) implements JSObject {
   );
   external void _MaterialProvider_createMaterialInstanceRenderThread(
     Pointer<TMaterialProvider> tMaterialProvider,
-    Pointer<TMaterialKey> tKey,
+    bool doubleSided,
+    bool unlit,
+    bool hasVertexColors,
+    bool hasBaseColorTexture,
+    bool hasNormalTexture,
+    bool hasOcclusionTexture,
+    bool hasEmissiveTexture,
+    bool useSpecularGlossiness,
+    int alphaMode,
+    bool enableDiagnostics,
+    bool hasMetallicRoughnessTexture,
+    int metallicRoughnessUV,
+    bool hasSpecularGlossinessTexture,
+    int specularGlossinessUV,
+    int baseColorUV,
+    bool hasClearCoatTexture,
+    int clearCoatUV,
+    bool hasClearCoatRoughnessTexture,
+    int clearCoatRoughnessUV,
+    bool hasClearCoatNormalTexture,
+    int clearCoatNormalUV,
+    bool hasClearCoat,
+    bool hasTransmission,
+    bool hasTextureTransforms,
+    int emissiveUV,
+    int aoUV,
+    int normalUV,
+    bool hasTransmissionTexture,
+    int transmissionUV,
+    bool hasSheenColorTexture,
+    int sheenColorUV,
+    bool hasSheenRoughnessTexture,
+    int sheenRoughnessUV,
+    bool hasVolumeThicknessTexture,
+    int volumeThicknessUV,
+    bool hasSheen,
+    bool hasIOR,
+    bool hasVolume,
     Pointer<self.NativeFunction<void Function(PointerClass<TMaterialInstance>)>>
         callback,
   );
@@ -3143,10 +3217,85 @@ void Gizmo_unhighlight(
 
 self.Pointer<TMaterialInstance> MaterialProvider_createMaterialInstance(
   self.Pointer<TMaterialProvider> provider,
-  self.Pointer<TMaterialKey> key,
+  bool doubleSided,
+  bool unlit,
+  bool hasVertexColors,
+  bool hasBaseColorTexture,
+  bool hasNormalTexture,
+  bool hasOcclusionTexture,
+  bool hasEmissiveTexture,
+  bool useSpecularGlossiness,
+  int alphaMode,
+  bool enableDiagnostics,
+  bool hasMetallicRoughnessTexture,
+  int metallicRoughnessUV,
+  bool hasSpecularGlossinessTexture,
+  int specularGlossinessUV,
+  int baseColorUV,
+  bool hasClearCoatTexture,
+  int clearCoatUV,
+  bool hasClearCoatRoughnessTexture,
+  int clearCoatRoughnessUV,
+  bool hasClearCoatNormalTexture,
+  int clearCoatNormalUV,
+  bool hasClearCoat,
+  bool hasTransmission,
+  bool hasTextureTransforms,
+  int emissiveUV,
+  int aoUV,
+  int normalUV,
+  bool hasTransmissionTexture,
+  int transmissionUV,
+  bool hasSheenColorTexture,
+  int sheenColorUV,
+  bool hasSheenRoughnessTexture,
+  int sheenRoughnessUV,
+  bool hasVolumeThicknessTexture,
+  int volumeThicknessUV,
+  bool hasSheen,
+  bool hasIOR,
+  bool hasVolume,
 ) {
   final result = _lib._MaterialProvider_createMaterialInstance(
-      provider.cast(), key.cast());
+      provider.cast(),
+      doubleSided,
+      unlit,
+      hasVertexColors,
+      hasBaseColorTexture,
+      hasNormalTexture,
+      hasOcclusionTexture,
+      hasEmissiveTexture,
+      useSpecularGlossiness,
+      alphaMode,
+      enableDiagnostics,
+      hasMetallicRoughnessTexture,
+      metallicRoughnessUV,
+      hasSpecularGlossinessTexture,
+      specularGlossinessUV,
+      baseColorUV,
+      hasClearCoatTexture,
+      clearCoatUV,
+      hasClearCoatRoughnessTexture,
+      clearCoatRoughnessUV,
+      hasClearCoatNormalTexture,
+      clearCoatNormalUV,
+      hasClearCoat,
+      hasTransmission,
+      hasTextureTransforms,
+      emissiveUV,
+      aoUV,
+      normalUV,
+      hasTransmissionTexture,
+      transmissionUV,
+      hasSheenColorTexture,
+      sheenColorUV,
+      hasSheenRoughnessTexture,
+      sheenRoughnessUV,
+      hasVolumeThicknessTexture,
+      volumeThicknessUV,
+      hasSheen,
+      hasIOR,
+      hasVolume);
   return self.Pointer<TMaterialInstance>(result);
 }
 
@@ -4493,12 +4642,88 @@ void SceneAsset_createGeometryRenderThread(
 
 void MaterialProvider_createMaterialInstanceRenderThread(
   self.Pointer<TMaterialProvider> tMaterialProvider,
-  self.Pointer<TMaterialKey> tKey,
+  bool doubleSided,
+  bool unlit,
+  bool hasVertexColors,
+  bool hasBaseColorTexture,
+  bool hasNormalTexture,
+  bool hasOcclusionTexture,
+  bool hasEmissiveTexture,
+  bool useSpecularGlossiness,
+  int alphaMode,
+  bool enableDiagnostics,
+  bool hasMetallicRoughnessTexture,
+  int metallicRoughnessUV,
+  bool hasSpecularGlossinessTexture,
+  int specularGlossinessUV,
+  int baseColorUV,
+  bool hasClearCoatTexture,
+  int clearCoatUV,
+  bool hasClearCoatRoughnessTexture,
+  int clearCoatRoughnessUV,
+  bool hasClearCoatNormalTexture,
+  int clearCoatNormalUV,
+  bool hasClearCoat,
+  bool hasTransmission,
+  bool hasTextureTransforms,
+  int emissiveUV,
+  int aoUV,
+  int normalUV,
+  bool hasTransmissionTexture,
+  int transmissionUV,
+  bool hasSheenColorTexture,
+  int sheenColorUV,
+  bool hasSheenRoughnessTexture,
+  int sheenRoughnessUV,
+  bool hasVolumeThicknessTexture,
+  int volumeThicknessUV,
+  bool hasSheen,
+  bool hasIOR,
+  bool hasVolume,
   self.Pointer<self.NativeFunction<void Function(Pointer<TMaterialInstance>)>>
       callback,
 ) {
   final result = _lib._MaterialProvider_createMaterialInstanceRenderThread(
-      tMaterialProvider.cast(), tKey.cast(), callback.cast());
+      tMaterialProvider.cast(),
+      doubleSided,
+      unlit,
+      hasVertexColors,
+      hasBaseColorTexture,
+      hasNormalTexture,
+      hasOcclusionTexture,
+      hasEmissiveTexture,
+      useSpecularGlossiness,
+      alphaMode,
+      enableDiagnostics,
+      hasMetallicRoughnessTexture,
+      metallicRoughnessUV,
+      hasSpecularGlossinessTexture,
+      specularGlossinessUV,
+      baseColorUV,
+      hasClearCoatTexture,
+      clearCoatUV,
+      hasClearCoatRoughnessTexture,
+      clearCoatRoughnessUV,
+      hasClearCoatNormalTexture,
+      clearCoatNormalUV,
+      hasClearCoat,
+      hasTransmission,
+      hasTextureTransforms,
+      emissiveUV,
+      aoUV,
+      normalUV,
+      hasTransmissionTexture,
+      transmissionUV,
+      hasSheenColorTexture,
+      sheenColorUV,
+      hasSheenRoughnessTexture,
+      sheenRoughnessUV,
+      hasVolumeThicknessTexture,
+      volumeThicknessUV,
+      hasSheen,
+      hasIOR,
+      hasVolume,
+      callback.cast());
   return result;
 }
 
@@ -6415,22 +6640,6 @@ sealed class TGizmoAxis {
   static const Z = 2;
 }
 
-extension TMaterialKeyExt on Pointer<TMaterialKey> {
-  TMaterialKey toDart() {
-    return TMaterialKey(this);
-  }
-
-  void setFrom(TMaterialKey dartType) {}
-}
-
-final class TMaterialKey extends self.Struct {
-  TMaterialKey(super._address);
-
-  static Pointer<TMaterialKey> stackAlloc() {
-    return Pointer<TMaterialKey>(_lib._stackAlloc<TMaterialKey>(0));
-  }
-}
-
 extension TSkyboxExt on Pointer<TSkybox> {
   TSkybox toDart() {
     return TSkybox(this);
diff --git a/thermion_dart/lib/src/filament/src/implementation/ffi_asset.dart b/thermion_dart/lib/src/filament/src/implementation/ffi_asset.dart
index f5a98cae..20ede093 100644
--- a/thermion_dart/lib/src/filament/src/implementation/ffi_asset.dart
+++ b/thermion_dart/lib/src/filament/src/implementation/ffi_asset.dart
@@ -1,6 +1,5 @@
 import 'package:animation_tools_dart/animation_tools_dart.dart';
 import 'package:logging/logging.dart';
-import 'package:thermion_dart/src/bindings/src/js_interop.dart';
 import 'package:thermion_dart/src/utils/src/matrix.dart';
 import 'package:thermion_dart/src/filament/src/implementation/ffi_filament_app.dart';
 import 'package:thermion_dart/src/filament/src/implementation/ffi_material.dart';
@@ -224,33 +223,33 @@ class FFIAsset extends ThermionAsset {
           .setStencilOpDepthStencilPass(StencilOperation.REPLACE);
 
       await sourceMaterialInstance.setStencilReferenceValue(1);
+      throw Exception("TODO");
+      // final materialInstancePtr =
+      //     await withPointerCallback<TMaterialInstance>((cb) {
 
-      final materialInstancePtr =
-          await withPointerCallback<TMaterialInstance>((cb) {
-        final key = Struct.create<TMaterialKey>();
-        MaterialProvider_createMaterialInstanceRenderThread(
-            app.ubershaderMaterialProvider, key.address, cb);
-      });
-      final highlightMaterialInstance =
-          FFIMaterialInstance(materialInstancePtr, app);
-      await highlightMaterialInstance
-          .setStencilCompareFunction(SamplerCompareFunction.NE);
-      await highlightMaterialInstance.setStencilReferenceValue(1);
+      //   MaterialProvider_createMaterialInstanceRenderThread(
+      //       app.ubershaderMaterialProvider, , cb);
+      // });
+      // final highlightMaterialInstance =
+      //     FFIMaterialInstance(materialInstancePtr, app);
+      // await highlightMaterialInstance
+      //     .setStencilCompareFunction(SamplerCompareFunction.NE);
+      // await highlightMaterialInstance.setStencilReferenceValue(1);
 
-      await highlightMaterialInstance.setDepthCullingEnabled(false);
+      // await highlightMaterialInstance.setDepthCullingEnabled(false);
 
-      await highlightMaterialInstance.setParameterFloat4(
-          "baseColorFactor", r, g, b, 1.0);
+      // await highlightMaterialInstance.setParameterFloat4(
+      //     "baseColorFactor", r, g, b, 1.0);
 
-      var highlightInstance = await this
-          .createInstance(materialInstances: [highlightMaterialInstance]);
-      _highlight = highlightInstance;
+      // var highlightInstance = await this
+      //     .createInstance(materialInstances: [highlightMaterialInstance]);
+      // _highlight = highlightInstance;
 
-      await highlightMaterialInstance.setStencilReferenceValue(1);
-      RenderableManager_setPriority(app.renderableManager, targetEntity, 0);
+      // await highlightMaterialInstance.setStencilReferenceValue(1);
+      // RenderableManager_setPriority(app.renderableManager, targetEntity, 0);
 
-      TransformManager_setParent(
-          app.transformManager, _highlight!.entity, entity, false);
+      // TransformManager_setParent(
+      //     app.transformManager, _highlight!.entity, entity, false);
     }
 
     var targetHighlightEntity = _highlight!.entity;
@@ -365,9 +364,47 @@ class FFIAsset extends ThermionAsset {
       // Create unlit material instance for the wireframe
       final materialInstancePtr =
           await withPointerCallback<TMaterialInstance>((cb) {
-        final key = Struct.create<TMaterialKey>();
         MaterialProvider_createMaterialInstanceRenderThread(
-            app.ubershaderMaterialProvider, key.address, cb);
+            app.ubershaderMaterialProvider,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            0,
+            false,
+            false,
+            0,
+            false,
+            0,
+            0,
+            false,
+            0,
+            false,
+            0,
+            false,
+            0,
+            false,
+            false,
+            false,
+            0,
+            0,
+            0,
+            false,
+            0,
+            false,
+            0,
+            false,
+            0,
+            false,
+            0,
+            false,
+            false,
+            false,
+            cb);
       });
 
       final material = FFIMaterialInstance(materialInstancePtr, app);
diff --git a/thermion_dart/lib/src/filament/src/implementation/ffi_filament_app.dart b/thermion_dart/lib/src/filament/src/implementation/ffi_filament_app.dart
index f4fb5c8b..24d2bcfb 100644
--- a/thermion_dart/lib/src/filament/src/implementation/ffi_filament_app.dart
+++ b/thermion_dart/lib/src/filament/src/implementation/ffi_filament_app.dart
@@ -247,8 +247,8 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
   ///
   ///
   Future destroyAsset(covariant FFIAsset asset) async {
-    await withVoidCallback(
-        (requestId, cb) => SceneAsset_destroyRenderThread(asset.asset, requestId, cb));
+    await withVoidCallback((requestId, cb) =>
+        SceneAsset_destroyRenderThread(asset.asset, requestId, cb));
     await asset.dispose();
   }
 
@@ -414,6 +414,8 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
       bool enableDiagnostics = false,
       bool hasMetallicRoughnessTexture = false,
       int metallicRoughnessUV = 0,
+      bool hasSpecularGlossiness = false,
+      int specularGlossinessUV = 0,
       int baseColorUV = 0,
       bool hasClearCoatTexture = false,
       int clearCoatUV = 0,
@@ -438,54 +440,48 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
       bool hasSheen = false,
       bool hasIOR = false,
       bool hasVolume = false}) async {
-    late Pointer stackPtr;
-    if (FILAMENT_WASM) {
-      //stackPtr = stackSave();
-    }
-
-    final key = Struct.create<TMaterialKey>();
-
-    key.doubleSided = doubleSided;
-    key.unlit = unlit;
-    key.hasVertexColors = hasVertexColors;
-    key.hasBaseColorTexture = hasBaseColorTexture;
-    key.hasNormalTexture = hasNormalTexture;
-    key.hasOcclusionTexture = hasOcclusionTexture;
-    key.hasEmissiveTexture = hasEmissiveTexture;
-    key.useSpecularGlossiness = useSpecularGlossiness;
-    key.alphaMode = alphaMode.index;
-    key.enableDiagnostics = enableDiagnostics;
-    key.unnamed.unnamed.hasMetallicRoughnessTexture =
-        hasMetallicRoughnessTexture;
-    key.unnamed.unnamed.metallicRoughnessUV = 0;
-    key.baseColorUV = baseColorUV;
-    key.hasClearCoatTexture = hasClearCoatTexture;
-    key.clearCoatUV = clearCoatUV;
-    key.hasClearCoatRoughnessTexture = hasClearCoatRoughnessTexture;
-    key.clearCoatRoughnessUV = clearCoatRoughnessUV;
-    key.hasClearCoatNormalTexture = hasClearCoatNormalTexture;
-    key.clearCoatNormalUV = clearCoatNormalUV;
-    key.hasClearCoat = hasClearCoat;
-    key.hasTransmission = hasTransmission;
-    key.hasTextureTransforms = hasTextureTransforms;
-    key.emissiveUV = emissiveUV;
-    key.aoUV = aoUV;
-    key.normalUV = normalUV;
-    key.hasTransmissionTexture = hasTransmissionTexture;
-    key.transmissionUV = transmissionUV;
-    key.hasSheenColorTexture = hasSheenColorTexture;
-    key.sheenColorUV = sheenColorUV;
-    key.hasSheenRoughnessTexture = hasSheenRoughnessTexture;
-    key.sheenRoughnessUV = sheenRoughnessUV;
-    key.hasVolumeThicknessTexture = hasVolumeThicknessTexture;
-    key.volumeThicknessUV = volumeThicknessUV;
-    key.hasSheen = hasSheen;
-    key.hasIOR = hasIOR;
-    key.hasVolume = hasVolume;
-
     final materialInstance = await withPointerCallback<TMaterialInstance>((cb) {
       MaterialProvider_createMaterialInstanceRenderThread(
-          ubershaderMaterialProvider, key.address, cb);
+          ubershaderMaterialProvider,
+          doubleSided,
+          unlit,
+          hasVertexColors,
+          hasBaseColorTexture,
+          hasNormalTexture,
+          hasOcclusionTexture,
+          hasEmissiveTexture,
+          useSpecularGlossiness,
+          alphaMode.index,
+          enableDiagnostics,
+          hasMetallicRoughnessTexture,
+          metallicRoughnessUV,
+          hasSpecularGlossiness,
+          specularGlossinessUV,
+          baseColorUV,
+          hasClearCoatTexture,
+          clearCoatUV,
+          hasClearCoatRoughnessTexture,
+          clearCoatRoughnessUV,
+          hasClearCoatNormalTexture,
+          clearCoatNormalUV,
+          hasClearCoat,
+          hasTransmission,
+          hasTextureTransforms,
+          emissiveUV,
+          aoUV,
+          normalUV,
+          hasTransmissionTexture,
+          transmissionUV,
+          hasSheenColorTexture,
+          sheenColorUV,
+          hasSheenRoughnessTexture,
+          sheenRoughnessUV,
+          hasVolumeThicknessTexture,
+          volumeThicknessUV,
+          hasSheen,
+          hasIOR,
+          hasVolume,
+          cb);
     });
 
     if (FILAMENT_WASM) {
@@ -549,10 +545,11 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
     });
 
     if (FILAMENT_SINGLE_THREADED) {
-      await withVoidCallback((requestId, cb) => Engine_executeRenderThread(engine, requestId, cb));
-    } else {
       await withVoidCallback(
-          (requestId, cb) => Engine_flushAndWaitRenderThread(engine, requestId, cb));
+          (requestId, cb) => Engine_executeRenderThread(engine, requestId, cb));
+    } else {
+      await withVoidCallback((requestId, cb) =>
+          Engine_flushAndWaitRenderThread(engine, requestId, cb));
     }
   }
 
@@ -868,8 +865,9 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
           SceneAsset_createFromFilamentAssetRenderThread(engine,
               gltfAssetLoader, nameComponentManager, filamentAsset, cb));
 
-      await withVoidCallback((requestId, cb) => GltfResourceLoader_destroyRenderThread(
-          engine, gltfResourceLoader, requestId, cb));
+      await withVoidCallback((requestId, cb) =>
+          GltfResourceLoader_destroyRenderThread(
+              engine, gltfResourceLoader, requestId, cb));
 
       return FFIAsset(asset, this, animationManager.cast<TAnimationManager>());
     } finally {
@@ -886,11 +884,12 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
   Future destroyView(covariant FFIView view) async {
     View_setColorGrading(view.view, nullptr);
     for (final cg in view.colorGrading.entries) {
-      await withVoidCallback(
-          (requestId, cb) => Engine_destroyColorGradingRenderThread(engine, cg.value, requestId, cb));
+      await withVoidCallback((requestId, cb) =>
+          Engine_destroyColorGradingRenderThread(
+              engine, cg.value, requestId, cb));
     }
-    await withVoidCallback(
-        (requestId, cb) => Engine_destroyViewRenderThread(engine, view.view, requestId, cb));
+    await withVoidCallback((requestId, cb) =>
+        Engine_destroyViewRenderThread(engine, view.view, requestId, cb));
     for (final swapchain in _swapChains.keys) {
       if (_swapChains[swapchain]!.contains(view)) {
         _swapChains[swapchain]!.remove(view);
@@ -901,8 +900,8 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
   }
 
   Future destroyScene(covariant FFIScene scene) async {
-    await withVoidCallback(
-        (requestId, cb) => Engine_destroySceneRenderThread(engine, scene.scene, requestId, cb));
+    await withVoidCallback((requestId, cb) =>
+        Engine_destroySceneRenderThread(engine, scene.scene, requestId, cb));
   }
 
   Future<Pointer<TColorGrading>> createColorGrading(ToneMapper mapper) async {
@@ -1028,10 +1027,11 @@ class FFIFilamentApp extends FilamentApp<Pointer> {
   ///
   Future flush() async {
     if (FILAMENT_SINGLE_THREADED) {
-      await withVoidCallback((requestId, cb) => Engine_executeRenderThread(engine, requestId, cb));
-    } else {
       await withVoidCallback(
-          (requestId, cb) => Engine_flushAndWaitRenderThread(engine, requestId, cb));
+          (requestId, cb) => Engine_executeRenderThread(engine, requestId, cb));
+    } else {
+      await withVoidCallback((requestId, cb) =>
+          Engine_flushAndWaitRenderThread(engine, requestId, cb));
     }
   }
 
diff --git a/thermion_dart/lib/src/filament/src/implementation/ffi_view.dart b/thermion_dart/lib/src/filament/src/implementation/ffi_view.dart
index 7c4dcbb6..1798a18a 100644
--- a/thermion_dart/lib/src/filament/src/implementation/ffi_view.dart
+++ b/thermion_dart/lib/src/filament/src/implementation/ffi_view.dart
@@ -1,6 +1,5 @@
 import 'dart:async';
 import 'package:logging/logging.dart';
-import 'package:thermion_dart/src/bindings/src/js_interop.dart';
 import 'package:thermion_dart/src/filament/src/interface/scene.dart';
 import 'package:thermion_dart/src/filament/src/implementation/ffi_filament_app.dart';
 import 'package:thermion_dart/src/filament/src/implementation/ffi_render_target.dart';
diff --git a/thermion_dart/native/include/c_api/APIBoundaryTypes.h b/thermion_dart/native/include/c_api/APIBoundaryTypes.h
index af91337d..6ada7065 100644
--- a/thermion_dart/native/include/c_api/APIBoundaryTypes.h
+++ b/thermion_dart/native/include/c_api/APIBoundaryTypes.h
@@ -45,68 +45,6 @@ extern "C"
 	typedef struct TFilamentAsset TFilamentAsset;
 	typedef struct TColorGrading TColorGrading;
 
-	struct TMaterialKey {
-		bool doubleSided;
-		bool unlit;
-		bool hasVertexColors;
-		bool hasBaseColorTexture;
-		bool hasNormalTexture;
-		bool hasOcclusionTexture;
-		bool hasEmissiveTexture;
-		bool useSpecularGlossiness;
-		int alphaMode;
-		bool enableDiagnostics;
-		union {
-			#ifdef __cplusplus
-			struct {
-				bool hasMetallicRoughnessTexture;
-				uint8_t metallicRoughnessUV;
-			};
-			struct {
-				bool hasSpecularGlossinessTexture;
-				uint8_t specularGlossinessUV;
-			};
-			#else
-			struct {
-				bool hasMetallicRoughnessTexture;
-				uint8_t metallicRoughnessUV;
-			};
-			struct {
-				bool hasSpecularGlossinessTexture;
-				uint8_t specularGlossinessUV;
-			};
-			#endif
-		};
-		uint8_t baseColorUV;
-		// -- 32 bit boundary --
-		bool hasClearCoatTexture;
-		uint8_t clearCoatUV;
-		bool hasClearCoatRoughnessTexture;
-		uint8_t clearCoatRoughnessUV;
-		bool hasClearCoatNormalTexture;
-		uint8_t clearCoatNormalUV;
-		bool hasClearCoat;
-		bool hasTransmission;
-		bool hasTextureTransforms;
-		// -- 32 bit boundary --
-		uint8_t emissiveUV;
-		uint8_t aoUV;
-		uint8_t normalUV;
-		bool hasTransmissionTexture;
-		uint8_t transmissionUV;
-		// -- 32 bit boundary --
-		bool hasSheenColorTexture;
-		uint8_t sheenColorUV;
-		bool hasSheenRoughnessTexture;
-		uint8_t sheenRoughnessUV;
-		bool hasVolumeThicknessTexture;
-		uint8_t volumeThicknessUV ;
-		bool hasSheen;
-		bool hasIOR;
-		bool hasVolume;
-	} ;
-	typedef struct TMaterialKey TMaterialKey; 
-
 	typedef struct { 
 		double x;
 		double y; 
diff --git a/thermion_dart/native/include/c_api/TMaterialProvider.h b/thermion_dart/native/include/c_api/TMaterialProvider.h
index 35679a7c..06fb7e54 100644
--- a/thermion_dart/native/include/c_api/TMaterialProvider.h
+++ b/thermion_dart/native/include/c_api/TMaterialProvider.h
@@ -9,7 +9,47 @@ extern "C"
 #endif
 	
 	// EMSCRIPTEN_KEEPALIVE TMaterialProvider *MaterialProvider_create(TEngine *tEngine, uint8_t* data, size_t length);
-	EMSCRIPTEN_KEEPALIVE TMaterialInstance *MaterialProvider_createMaterialInstance(TMaterialProvider *provider, TMaterialKey *key);
+	EMSCRIPTEN_KEEPALIVE TMaterialInstance *MaterialProvider_createMaterialInstance(
+		TMaterialProvider *provider, 
+		bool doubleSided,
+		bool unlit,
+		bool hasVertexColors,
+		bool hasBaseColorTexture,
+		bool hasNormalTexture,
+		bool hasOcclusionTexture,
+		bool hasEmissiveTexture,
+		bool useSpecularGlossiness,
+		int alphaMode,
+		bool enableDiagnostics,
+		bool hasMetallicRoughnessTexture,
+		uint8_t metallicRoughnessUV,
+		bool hasSpecularGlossinessTexture,
+		uint8_t specularGlossinessUV,
+		uint8_t baseColorUV,
+		bool hasClearCoatTexture,
+		uint8_t clearCoatUV,
+		bool hasClearCoatRoughnessTexture,
+		uint8_t clearCoatRoughnessUV,
+		bool hasClearCoatNormalTexture,
+		uint8_t clearCoatNormalUV,
+		bool hasClearCoat,
+		bool hasTransmission,
+		bool hasTextureTransforms,
+		uint8_t emissiveUV,
+		uint8_t aoUV,
+		uint8_t normalUV,
+		bool hasTransmissionTexture,
+		uint8_t transmissionUV,
+		bool hasSheenColorTexture,
+		uint8_t sheenColorUV,
+		bool hasSheenRoughnessTexture,
+		uint8_t sheenRoughnessUV,
+		bool hasVolumeThicknessTexture,
+		uint8_t volumeThicknessUV ,
+		bool hasSheen,
+		bool hasIOR,
+		bool hasVolume
+	);
 	
 #ifdef __cplusplus
 }
diff --git a/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h b/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
index fb8799bc..ece7c8ba 100644
--- a/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
+++ b/thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h
@@ -116,7 +116,47 @@ namespace thermion
             int materialInstanceCount,
             void (*callback)(TSceneAsset *)
         );
-        void MaterialProvider_createMaterialInstanceRenderThread(TMaterialProvider *tMaterialProvider, TMaterialKey *tKey, void (*callback)(TMaterialInstance *));
+        void MaterialProvider_createMaterialInstanceRenderThread(
+            TMaterialProvider *tMaterialProvider, 
+            bool doubleSided,
+            bool unlit,
+            bool hasVertexColors,
+            bool hasBaseColorTexture,
+            bool hasNormalTexture,
+            bool hasOcclusionTexture,
+            bool hasEmissiveTexture,
+            bool useSpecularGlossiness,
+            int alphaMode,
+            bool enableDiagnostics,
+            bool hasMetallicRoughnessTexture,
+            uint8_t metallicRoughnessUV,
+            bool hasSpecularGlossinessTexture,
+            uint8_t specularGlossinessUV,
+            uint8_t baseColorUV,
+            bool hasClearCoatTexture,
+            uint8_t clearCoatUV,
+            bool hasClearCoatRoughnessTexture,
+            uint8_t clearCoatRoughnessUV,
+            bool hasClearCoatNormalTexture,
+            uint8_t clearCoatNormalUV,
+            bool hasClearCoat,
+            bool hasTransmission,
+            bool hasTextureTransforms,
+            uint8_t emissiveUV,
+            uint8_t aoUV,
+            uint8_t normalUV,
+            bool hasTransmissionTexture,
+            uint8_t transmissionUV,
+            bool hasSheenColorTexture,
+            uint8_t sheenColorUV,
+            bool hasSheenRoughnessTexture,
+            uint8_t sheenRoughnessUV,
+            bool hasVolumeThicknessTexture,
+            uint8_t volumeThicknessUV ,
+            bool hasSheen,
+            bool hasIOR,
+            bool hasVolume,
+            void (*callback)(TMaterialInstance *));
 
         void AnimationManager_updateBoneMatricesRenderThread(
             TAnimationManager *tAnimationManager,
diff --git a/thermion_dart/native/src/c_api/TMaterialProvider.cpp b/thermion_dart/native/src/c_api/TMaterialProvider.cpp
index e500a9ac..87a23313 100644
--- a/thermion_dart/native/src/c_api/TMaterialProvider.cpp
+++ b/thermion_dart/native/src/c_api/TMaterialProvider.cpp
@@ -20,41 +20,81 @@ namespace thermion
     {
 #endif
         
-        EMSCRIPTEN_KEEPALIVE TMaterialInstance *MaterialProvider_createMaterialInstance(TMaterialProvider *tMaterialProvider, TMaterialKey *materialConfig)
+        EMSCRIPTEN_KEEPALIVE TMaterialInstance *MaterialProvider_createMaterialInstance(
+            TMaterialProvider *tMaterialProvider, 
+            bool doubleSided,
+            bool unlit,
+            bool hasVertexColors,
+            bool hasBaseColorTexture,
+            bool hasNormalTexture,
+            bool hasOcclusionTexture,
+            bool hasEmissiveTexture,
+            bool useSpecularGlossiness,
+            int alphaMode,
+            bool enableDiagnostics,
+            bool hasMetallicRoughnessTexture,
+            uint8_t metallicRoughnessUV,
+            bool hasSpecularGlossinessTexture,
+            uint8_t specularGlossinessUV,
+            uint8_t baseColorUV,
+            bool hasClearCoatTexture,
+            uint8_t clearCoatUV,
+            bool hasClearCoatRoughnessTexture,
+            uint8_t clearCoatRoughnessUV,
+            bool hasClearCoatNormalTexture,
+            uint8_t clearCoatNormalUV,
+            bool hasClearCoat,
+            bool hasTransmission,
+            bool hasTextureTransforms,
+            uint8_t emissiveUV,
+            uint8_t aoUV,
+            uint8_t normalUV,
+            bool hasTransmissionTexture,
+            uint8_t transmissionUV,
+            bool hasSheenColorTexture,
+            uint8_t sheenColorUV,
+            bool hasSheenRoughnessTexture,
+            uint8_t sheenRoughnessUV,
+            bool hasVolumeThicknessTexture,
+            uint8_t volumeThicknessUV ,
+            bool hasSheen,
+            bool hasIOR,
+            bool hasVolume)
         {
             gltfio::MaterialKey config;
             gltfio::UvMap uvMap;
             memset(&config, 0, sizeof(gltfio::MaterialKey));
 
             // Set and log each field
-            config.unlit = materialConfig->unlit;
-            config.doubleSided = materialConfig->doubleSided;
-            config.useSpecularGlossiness = materialConfig->useSpecularGlossiness;
-            config.alphaMode = static_cast<filament::gltfio::AlphaMode>(materialConfig->alphaMode);
-            config.hasBaseColorTexture = materialConfig->hasBaseColorTexture;
-            config.hasClearCoat = materialConfig->hasClearCoat;
-            config.hasClearCoatNormalTexture = materialConfig->hasClearCoatNormalTexture;
-            config.hasClearCoatRoughnessTexture = materialConfig->hasClearCoatRoughnessTexture;
-            config.hasEmissiveTexture = materialConfig->hasEmissiveTexture;
-            config.hasIOR = materialConfig->hasIOR;
-            config.hasMetallicRoughnessTexture = materialConfig->hasMetallicRoughnessTexture;
-            config.hasNormalTexture = materialConfig->hasNormalTexture;
-            config.hasOcclusionTexture = materialConfig->hasOcclusionTexture;
-            config.hasSheen = materialConfig->hasSheen;
-            config.hasSheenColorTexture = materialConfig->hasSheenColorTexture;
-            config.hasSheenRoughnessTexture = materialConfig->hasSheenRoughnessTexture;
-            config.hasTextureTransforms = materialConfig->hasTextureTransforms;
-            config.hasTransmission = materialConfig->hasTransmission;
-            config.hasTransmissionTexture = materialConfig->hasTransmissionTexture;
-            config.hasVolume = materialConfig->hasVolume;
-            config.hasVolumeThicknessTexture = materialConfig->hasVolumeThicknessTexture;
-            config.baseColorUV = materialConfig->baseColorUV;
-            config.hasVertexColors = materialConfig->hasVertexColors;
+            config.unlit = unlit;
+            config.doubleSided = doubleSided;
+            config.useSpecularGlossiness = useSpecularGlossiness;
+            config.alphaMode = static_cast<filament::gltfio::AlphaMode>(alphaMode);
+            config.hasBaseColorTexture = hasBaseColorTexture;
+            config.hasClearCoat = hasClearCoat;
+            config.hasClearCoatNormalTexture = hasClearCoatNormalTexture;
+            config.hasClearCoatRoughnessTexture = hasClearCoatRoughnessTexture;
+            config.hasEmissiveTexture = hasEmissiveTexture;
+            config.hasIOR = hasIOR;
+            config.hasMetallicRoughnessTexture = hasMetallicRoughnessTexture;
+            config.hasNormalTexture = hasNormalTexture;
+            config.hasOcclusionTexture = hasOcclusionTexture;
+            config.hasSheen = hasSheen;
+            config.hasSheenColorTexture = hasSheenColorTexture;
+            config.hasSheenRoughnessTexture = hasSheenRoughnessTexture;
+            config.hasTextureTransforms = hasTextureTransforms;
+            config.hasTransmission = hasTransmission;
+            config.hasTransmissionTexture = hasTransmissionTexture;
+            config.hasVolume = hasVolume;
+            config.hasVolumeThicknessTexture = hasVolumeThicknessTexture;
+            config.baseColorUV = baseColorUV;
+            config.hasVertexColors = hasVertexColors;
 
             auto *materialProvider = reinterpret_cast<gltfio::MaterialProvider *>(tMaterialProvider);
             auto materialInstance = materialProvider->createMaterialInstance(&config, &uvMap);
             return reinterpret_cast<TMaterialInstance *>(materialInstance);
         }
+
 #ifdef __cplusplus
     }
 }
diff --git a/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp b/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
index fce6a651..cd5d9239 100644
--- a/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
+++ b/thermion_dart/native/src/c_api/ThermionDartRenderThreadApi.cpp
@@ -51,21 +51,20 @@ using namespace std::chrono_literals;
   //Log("inner proxy fn time: %.3f ms", innerDurationMs);\
 
 #if defined __EMSCRIPTEN__
-#define PROXY(call) \
-auto startTime = std::chrono::high_resolution_clock::now(); \
-TRACE("PROXYING"); \
-_renderThread->queue.proxySync(_renderThread->outer, [=]() { \
-  call; \
-}); 
-#else      
-  #define PROXY(call) call
+#define PROXY(call)                                           \
+  auto startTime = std::chrono::high_resolution_clock::now(); \
+  TRACE("PROXYING");                                          \
+  _renderThread->queue.proxySync(_renderThread->outer, [=]() { call; });
+#else
+#define PROXY(call) call
 #endif
 extern "C"
 {
 
   static std::unique_ptr<RenderThread> _renderThread;
 
-  EMSCRIPTEN_KEEPALIVE void RenderThread_create() {
+  EMSCRIPTEN_KEEPALIVE void RenderThread_create()
+  {
     TRACE("RenderThread_create");
     if (_renderThread)
     {
@@ -75,7 +74,8 @@ extern "C"
     TRACE("RenderThread created");
   }
 
-  EMSCRIPTEN_KEEPALIVE void RenderThread_destroy() {
+  EMSCRIPTEN_KEEPALIVE void RenderThread_destroy()
+  {
     TRACE("RenderThread_destroy");
     if (_renderThread)
     {
@@ -83,139 +83,153 @@ extern "C"
     }
   }
 
-  EMSCRIPTEN_KEEPALIVE void RenderThread_addTask(void (*task)()) {
+  EMSCRIPTEN_KEEPALIVE void RenderThread_addTask(void (*task)())
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        task();
-      });
+        [=]() mutable
+        {
+          task();
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void RenderThread_setRenderTicker(TRenderTicker *tRenderTicker) {
+  EMSCRIPTEN_KEEPALIVE void RenderThread_setRenderTicker(TRenderTicker *tRenderTicker)
+  {
     auto *renderTicker = reinterpret_cast<RenderTicker *>(tRenderTicker);
     _renderThread->setRenderTicker(renderTicker);
   }
 
-  EMSCRIPTEN_KEEPALIVE void RenderThread_requestFrameAsync() {
+  EMSCRIPTEN_KEEPALIVE void RenderThread_requestFrameAsync()
+  {
     _renderThread->requestFrame();
   }
 
-  EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        RenderTicker_render(tRenderTicker, frameTimeInNanos);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          RenderTicker_render(tRenderTicker, frameTimeInNanos);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
   EMSCRIPTEN_KEEPALIVE void Engine_createRenderThread(
-    TBackend backend,
-    void* platform,
-    void* sharedContext,
-    uint8_t stereoscopicEyeCount,
-    bool disableHandleUseAfterFreeCheck,
-    void (*onComplete)(TEngine *)) {      
+      TBackend backend,
+      void *platform,
+      void *sharedContext,
+      uint8_t stereoscopicEyeCount,
+      bool disableHandleUseAfterFreeCheck,
+      void (*onComplete)(TEngine *))
+  {
 
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto *engine = Engine_create(backend, platform, sharedContext, stereoscopicEyeCount, disableHandleUseAfterFreeCheck);        
-        PROXY(onComplete(engine));
-      });
+        [=]() mutable
+        {
+          auto *engine = Engine_create(backend, platform, sharedContext, stereoscopicEyeCount, disableHandleUseAfterFreeCheck);
+          PROXY(onComplete(engine));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_createRendererRenderThread(TEngine *tEngine, void (*onComplete)(TRenderer *)) {
+  EMSCRIPTEN_KEEPALIVE void Engine_createRendererRenderThread(TEngine *tEngine, void (*onComplete)(TRenderer *))
+  {
 
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto *renderer = Engine_createRenderer(tEngine);
-        PROXY(onComplete(renderer));
-      });
+        [=]() mutable
+        {
+          auto *renderer = Engine_createRenderer(tEngine);
+          PROXY(onComplete(renderer));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_createSwapChainRenderThread(TEngine *tEngine, void *window, uint64_t flags, void (*onComplete)(TSwapChain *)) {
+  EMSCRIPTEN_KEEPALIVE void Engine_createSwapChainRenderThread(TEngine *tEngine, void *window, uint64_t flags, void (*onComplete)(TSwapChain *))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto swapChain = Engine_createSwapChain(tEngine, window, flags);
-        PROXY(onComplete(swapChain));
-      });
-    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 *)) {
-    std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto swapChain = Engine_createHeadlessSwapChain(tEngine, width, height, flags);
-        PROXY(onComplete(swapChain));
-      });
-    auto fut = _renderThread->add_task(lambda);
-  }
-  
-  EMSCRIPTEN_KEEPALIVE void Engine_destroySwapChainRenderThread(TEngine *tEngine, TSwapChain *tSwapChain, uint32_t requestId, VoidCallback onComplete) {
-    std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Engine_destroySwapChain(tEngine, tSwapChain);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          auto swapChain = Engine_createSwapChain(tEngine, window, flags);
+          PROXY(onComplete(swapChain));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyViewRenderThread(TEngine *tEngine, TView *tView, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_createHeadlessSwapChainRenderThread(TEngine *tEngine, uint32_t width, uint32_t height, uint64_t flags, void (*onComplete)(TSwapChain *))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Engine_destroyView(tEngine, tView);
-        PROXY(onComplete(requestId));
-      });
-    auto fut = _renderThread->add_task(lambda);
-  }
-    
-  EMSCRIPTEN_KEEPALIVE void Engine_destroySceneRenderThread(TEngine *tEngine, TScene *tScene, uint32_t requestId, VoidCallback onComplete) {
-    std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Engine_destroyScene(tEngine, tScene);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          auto swapChain = Engine_createHeadlessSwapChain(tEngine, width, height, flags);
+          PROXY(onComplete(swapChain));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_createCameraRenderThread(TEngine* tEngine, void (*onComplete)(TCamera *)) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroySwapChainRenderThread(TEngine *tEngine, TSwapChain *tSwapChain, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto camera = Engine_createCamera(tEngine);
-        PROXY(onComplete(camera));
-      });
+        [=]() mutable
+        {
+          Engine_destroySwapChain(tEngine, tSwapChain);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_createViewRenderThread(TEngine *tEngine, void (*onComplete)(TView *)) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyViewRenderThread(TEngine *tEngine, TView *tView, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto * view = Engine_createView(tEngine);
-        PROXY(onComplete(view));
-      });
+        [=]() mutable
+        {
+          Engine_destroyView(tEngine, tView);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroySceneRenderThread(TEngine *tEngine, TScene *tScene, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Engine_destroy(tEngine);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          Engine_destroyScene(tEngine, tScene);
+          PROXY(onComplete(requestId));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
+
+  EMSCRIPTEN_KEEPALIVE void Engine_createCameraRenderThread(TEngine *tEngine, void (*onComplete)(TCamera *))
+  {
+    std::packaged_task<void()> lambda(
+        [=]() mutable
+        {
+          auto camera = Engine_createCamera(tEngine);
+          PROXY(onComplete(camera));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
+
+  EMSCRIPTEN_KEEPALIVE void Engine_createViewRenderThread(TEngine *tEngine, void (*onComplete)(TView *))
+  {
+    std::packaged_task<void()> lambda(
+        [=]() mutable
+        {
+          auto *view = Engine_createView(tEngine);
+          PROXY(onComplete(view));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
+
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete)
+  {
+    std::packaged_task<void()> lambda(
+        [=]() mutable
+        {
+          Engine_destroy(tEngine);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
@@ -230,8 +244,9 @@ extern "C"
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroySkyboxRenderThread(TEngine *tEngine, TSkybox *tSkybox, uint32_t requestId, VoidCallback onComplete) {
-      std::packaged_task<void()> lambda(
+  EMSCRIPTEN_KEEPALIVE void Engine_destroySkyboxRenderThread(TEngine *tEngine, TSkybox *tSkybox, uint32_t requestId, VoidCallback onComplete)
+  {
+    std::packaged_task<void()> lambda(
         [=]() mutable
         {
           Engine_destroySkybox(tEngine, tSkybox);
@@ -239,14 +254,15 @@ extern "C"
         });
     auto fut = _renderThread->add_task(lambda);
   }
-    
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyIndirectLightRenderThread(TEngine *tEngine, TIndirectLight *tIndirectLight, uint32_t requestId, VoidCallback onComplete) { 
+
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyIndirectLightRenderThread(TEngine *tEngine, TIndirectLight *tIndirectLight, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Engine_destroyIndirectLight(tEngine, tIndirectLight);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          Engine_destroyIndirectLight(tEngine, tIndirectLight);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
@@ -261,7 +277,6 @@ extern "C"
     auto fut = _renderThread->add_task(lambda);
   }
 
-
   EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialRenderThread(TEngine *tEngine, TMaterial *tMaterial, uint32_t requestId, VoidCallback onComplete)
   {
     std::packaged_task<void()> lambda(
@@ -273,177 +288,192 @@ extern "C"
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialInstanceRenderThread(TEngine *tEngine, TMaterialInstance *tMaterialInstance, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialInstanceRenderThread(TEngine *tEngine, TMaterialInstance *tMaterialInstance, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Engine_destroyMaterialInstance(tEngine, tMaterialInstance);
-        PROXY(onComplete(requestId));
-      });
-      auto fut = _renderThread->add_task(lambda);
-  }
-
-  EMSCRIPTEN_KEEPALIVE void Engine_createFenceRenderThread(TEngine *tEngine, void (*onComplete)(TFence*)) { 
-    std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto *fence = Engine_createFence(tEngine);
-        PROXY(onComplete(fence));
-      });
+        [=]() mutable
+        {
+          Engine_destroyMaterialInstance(tEngine, tMaterialInstance);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_destroyFenceRenderThread(TEngine *tEngine, TFence *tFence, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_createFenceRenderThread(TEngine *tEngine, void (*onComplete)(TFence *))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Engine_destroyFence(tEngine, tFence);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          auto *fence = Engine_createFence(tEngine);
+          PROXY(onComplete(fence));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_flushAndWaitRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_destroyFenceRenderThread(TEngine *tEngine, TFence *tFence, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Engine_flushAndWait(tEngine);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          Engine_destroyFence(tEngine, tFence);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Engine_executeRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Engine_flushAndWaitRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Engine_execute(tEngine);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          Engine_flushAndWait(tEngine);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void execute_queue() {
-    #ifdef __EMSCRIPTEN__
-      _renderThread->queue.execute();
-    #endif
-  }
-
-  EMSCRIPTEN_KEEPALIVE void Engine_buildSkyboxRenderThread(TEngine *tEngine, uint8_t *skyboxData, size_t length,  void (*onComplete)(TSkybox *),  void (*onTextureUploadComplete)()) {
+  EMSCRIPTEN_KEEPALIVE void Engine_executeRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto *skybox = Engine_buildSkybox(tEngine, skyboxData, length, onTextureUploadComplete);
-        PROXY(onComplete(skybox));
-      });
+        [=]() mutable
+        {
+          Engine_execute(tEngine);
+          PROXY(onComplete(requestId));
+        });
     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)()) {
+  EMSCRIPTEN_KEEPALIVE void execute_queue()
+  {
+#ifdef __EMSCRIPTEN__
+    _renderThread->queue.execute();
+#endif
+  }
+
+  EMSCRIPTEN_KEEPALIVE void Engine_buildSkyboxRenderThread(TEngine *tEngine, uint8_t *skyboxData, size_t length, void (*onComplete)(TSkybox *), void (*onTextureUploadComplete)())
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto *indirectLight = Engine_buildIndirectLight(tEngine, iblData, length, intensity, onTextureUploadComplete);
-        PROXY(onComplete(indirectLight));
-      });
+        [=]() mutable
+        {
+          auto *skybox = Engine_buildSkybox(tEngine, skyboxData, length, onTextureUploadComplete);
+          PROXY(onComplete(skybox));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Renderer_beginFrameRenderThread(TRenderer *tRenderer, TSwapChain *tSwapChain, uint64_t frameTimeInNanos, void (*onComplete)(bool)) { 
+  EMSCRIPTEN_KEEPALIVE void Engine_buildIndirectLightRenderThread(TEngine *tEngine, uint8_t *iblData, size_t length, float intensity, void (*onComplete)(TIndirectLight *), void (*onTextureUploadComplete)())
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto result = Renderer_beginFrame(tRenderer, tSwapChain, frameTimeInNanos);
-        PROXY(onComplete(result));
-      });
-    auto fut = _renderThread->add_task(lambda);
-  }
-  EMSCRIPTEN_KEEPALIVE void Renderer_endFrameRenderThread(TRenderer *tRenderer, uint32_t requestId, VoidCallback onComplete) {
-    std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Renderer_endFrame(tRenderer);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          auto *indirectLight = Engine_buildIndirectLight(tEngine, iblData, length, intensity, onTextureUploadComplete);
+          PROXY(onComplete(indirectLight));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Renderer_renderRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Renderer_beginFrameRenderThread(TRenderer *tRenderer, TSwapChain *tSwapChain, uint64_t frameTimeInNanos, void (*onComplete)(bool))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Renderer_render(tRenderer, tView);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          auto result = Renderer_beginFrame(tRenderer, tSwapChain, frameTimeInNanos);
+          PROXY(onComplete(result));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
+  EMSCRIPTEN_KEEPALIVE void Renderer_endFrameRenderThread(TRenderer *tRenderer, uint32_t requestId, VoidCallback onComplete)
+  {
+    std::packaged_task<void()> lambda(
+        [=]() mutable
+        {
+          Renderer_endFrame(tRenderer);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Renderer_renderStandaloneViewRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Renderer_renderRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Renderer_renderStandaloneView(tRenderer, tView);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          Renderer_render(tRenderer, tView);
+          PROXY(onComplete(requestId));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
+
+  EMSCRIPTEN_KEEPALIVE void Renderer_renderStandaloneViewRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId, VoidCallback onComplete)
+  {
+    std::packaged_task<void()> lambda(
+        [=]() mutable
+        {
+          Renderer_renderStandaloneView(tRenderer, tView);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
   EMSCRIPTEN_KEEPALIVE void Renderer_setClearOptionsRenderThread(
-    TRenderer *tRenderer,
-    double clearR,
-    double clearG,
-    double clearB,
-    double clearA,
-    uint8_t clearStencil,
-    bool clear,
-    bool discard, uint32_t requestId, VoidCallback onComplete) {
-      std::packaged_task<void()> lambda(
+      TRenderer *tRenderer,
+      double clearR,
+      double clearG,
+      double clearB,
+      double clearA,
+      uint8_t clearStencil,
+      bool clear,
+      bool discard, uint32_t requestId, VoidCallback onComplete)
+  {
+    std::packaged_task<void()> lambda(
         [=]() mutable
         {
           Renderer_setClearOptions(tRenderer, clearR, clearG, clearB, clearA, clearStencil, clear, discard);
           PROXY(onComplete(requestId));
         });
-      auto fut = _renderThread->add_task(lambda);
-  }
-  
-  EMSCRIPTEN_KEEPALIVE void Renderer_readPixelsRenderThread(
-    TRenderer *tRenderer,
-    TView *tView,
-    TRenderTarget *tRenderTarget,
-    TPixelDataFormat tPixelBufferFormat,
-    TPixelDataType tPixelDataType,
-    uint8_t *out,
-    size_t outLength,
-    uint32_t requestId, VoidCallback onComplete) {
-    std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Renderer_readPixels(tRenderer, tView, tRenderTarget, tPixelBufferFormat, tPixelDataType, out, outLength);
-        PROXY(onComplete(requestId));
-      });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Material_createImageMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *)) {
+  EMSCRIPTEN_KEEPALIVE void Renderer_readPixelsRenderThread(
+      TRenderer *tRenderer,
+      TView *tView,
+      TRenderTarget *tRenderTarget,
+      TPixelDataFormat tPixelBufferFormat,
+      TPixelDataType tPixelDataType,
+      uint8_t *out,
+      size_t outLength,
+      uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto *instance = Material_createImageMaterial(tEngine);
-        PROXY(onComplete(instance));
-      });
-      auto fut = _renderThread->add_task(lambda);
-  }
-  
-  EMSCRIPTEN_KEEPALIVE void Material_createGizmoMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *)) {
-    std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto *instance = Material_createGizmoMaterial(tEngine);
-        PROXY(onComplete(instance));
-      });
-      auto fut = _renderThread->add_task(lambda);
+        [=]() mutable
+        {
+          Renderer_readPixels(tRenderer, tView, tRenderTarget, tPixelBufferFormat, tPixelDataType, out, outLength);
+          PROXY(onComplete(requestId));
+        });
+    auto fut = _renderThread->add_task(lambda);
   }
 
+  EMSCRIPTEN_KEEPALIVE void Material_createImageMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *))
+  {
+    std::packaged_task<void()> lambda(
+        [=]() mutable
+        {
+          auto *instance = Material_createImageMaterial(tEngine);
+          PROXY(onComplete(instance));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
+
+  EMSCRIPTEN_KEEPALIVE void Material_createGizmoMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *))
+  {
+    std::packaged_task<void()> lambda(
+        [=]() mutable
+        {
+          auto *instance = Material_createGizmoMaterial(tEngine);
+          PROXY(onComplete(instance));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
 
   EMSCRIPTEN_KEEPALIVE void Material_createInstanceRenderThread(TMaterial *tMaterial, void (*onComplete)(TMaterialInstance *))
   {
@@ -456,56 +486,56 @@ extern "C"
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void SceneAsset_destroyRenderThread(TSceneAsset *tSceneAsset, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void SceneAsset_destroyRenderThread(TSceneAsset *tSceneAsset, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        SceneAsset_destroy(tSceneAsset);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          SceneAsset_destroy(tSceneAsset);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-
   EMSCRIPTEN_KEEPALIVE void SceneAsset_createGeometryRenderThread(
-    TEngine *tEngine, 
-    float *vertices,
-    uint32_t numVertices,
-    float *normals,
-    uint32_t numNormals,
-    float *uvs,
-    uint32_t numUvs,
-    uint16_t *indices,
-    uint32_t numIndices,
-    TPrimitiveType tPrimitiveType,
-    TMaterialInstance **materialInstances,
-    int materialInstanceCount,
-    void (*callback)(TSceneAsset *)
-) {
-  std::packaged_task<void()> lambda(
-    [=]
-    {
-      auto sceneAsset = SceneAsset_createGeometry(tEngine, vertices, numVertices, normals, numNormals, uvs, numUvs, indices, numIndices, tPrimitiveType, materialInstances, materialInstanceCount);
-      PROXY(callback(sceneAsset));
-    });
-  auto fut = _renderThread->add_task(lambda);
-}
+      TEngine *tEngine,
+      float *vertices,
+      uint32_t numVertices,
+      float *normals,
+      uint32_t numNormals,
+      float *uvs,
+      uint32_t numUvs,
+      uint16_t *indices,
+      uint32_t numIndices,
+      TPrimitiveType tPrimitiveType,
+      TMaterialInstance **materialInstances,
+      int materialInstanceCount,
+      void (*callback)(TSceneAsset *))
+  {
+    std::packaged_task<void()> lambda(
+        [=]
+        {
+          auto sceneAsset = SceneAsset_createGeometry(tEngine, vertices, numVertices, normals, numNormals, uvs, numUvs, indices, numIndices, tPrimitiveType, materialInstances, materialInstanceCount);
+          PROXY(callback(sceneAsset));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
 
-EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
-  TEngine *tEngine,
-  TGltfAssetLoader *tAssetLoader,
-  TNameComponentManager *tNameComponentManager,
-  TFilamentAsset *tFilamentAsset,
-  void (*onComplete)(TSceneAsset *)
-) {
-  std::packaged_task<void()> lambda(
-    [=]
-    {
-      auto sceneAsset = SceneAsset_createFromFilamentAsset(tEngine, tAssetLoader, tNameComponentManager, tFilamentAsset);
-      PROXY(onComplete(sceneAsset));
-    });
-  auto fut = _renderThread->add_task(lambda);
-}
+  EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
+      TEngine *tEngine,
+      TGltfAssetLoader *tAssetLoader,
+      TNameComponentManager *tNameComponentManager,
+      TFilamentAsset *tFilamentAsset,
+      void (*onComplete)(TSceneAsset *))
+  {
+    std::packaged_task<void()> lambda(
+        [=]
+        {
+          auto sceneAsset = SceneAsset_createFromFilamentAsset(tEngine, tAssetLoader, tNameComponentManager, tFilamentAsset);
+          PROXY(onComplete(sceneAsset));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
 
   EMSCRIPTEN_KEEPALIVE void SceneAsset_createInstanceRenderThread(
       TSceneAsset *asset, TMaterialInstance **tMaterialInstances,
@@ -521,17 +551,96 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void MaterialProvider_createMaterialInstanceRenderThread(TMaterialProvider *tMaterialProvider, TMaterialKey *tKey, void (*callback)(TMaterialInstance *))
+  EMSCRIPTEN_KEEPALIVE void MaterialProvider_createMaterialInstanceRenderThread(
+      TMaterialProvider *tMaterialProvider,
+      bool doubleSided,
+      bool unlit,
+      bool hasVertexColors,
+      bool hasBaseColorTexture,
+      bool hasNormalTexture,
+      bool hasOcclusionTexture,
+      bool hasEmissiveTexture,
+      bool useSpecularGlossiness,
+      int alphaMode,
+      bool enableDiagnostics,
+      bool hasMetallicRoughnessTexture,
+      uint8_t metallicRoughnessUV,
+      bool hasSpecularGlossinessTexture,
+      uint8_t specularGlossinessUV,
+      uint8_t baseColorUV,
+      bool hasClearCoatTexture,
+      uint8_t clearCoatUV,
+      bool hasClearCoatRoughnessTexture,
+      uint8_t clearCoatRoughnessUV,
+      bool hasClearCoatNormalTexture,
+      uint8_t clearCoatNormalUV,
+      bool hasClearCoat,
+      bool hasTransmission,
+      bool hasTextureTransforms,
+      uint8_t emissiveUV,
+      uint8_t aoUV,
+      uint8_t normalUV,
+      bool hasTransmissionTexture,
+      uint8_t transmissionUV,
+      bool hasSheenColorTexture,
+      uint8_t sheenColorUV,
+      bool hasSheenRoughnessTexture,
+      uint8_t sheenRoughnessUV,
+      bool hasVolumeThicknessTexture,
+      uint8_t volumeThicknessUV,
+      bool hasSheen,
+      bool hasIOR,
+      bool hasVolume,
+      void (*callback)(TMaterialInstance *))
   {
     std::packaged_task<void()> lambda(
         [=]
         {
-          auto materialInstance = MaterialProvider_createMaterialInstance(tMaterialProvider, tKey);
+          auto materialInstance = MaterialProvider_createMaterialInstance(
+              tMaterialProvider,
+              doubleSided,
+              unlit,
+              hasVertexColors,
+              hasBaseColorTexture,
+              hasNormalTexture,
+              hasOcclusionTexture,
+              hasEmissiveTexture,
+              useSpecularGlossiness,
+              alphaMode,
+              enableDiagnostics,
+              hasMetallicRoughnessTexture,
+              metallicRoughnessUV,
+              hasSpecularGlossinessTexture,
+              specularGlossinessUV,
+              baseColorUV,
+              hasClearCoatTexture,
+              clearCoatUV,
+              hasClearCoatRoughnessTexture,
+              clearCoatRoughnessUV,
+              hasClearCoatNormalTexture,
+              clearCoatNormalUV,
+              hasClearCoat,
+              hasTransmission,
+              hasTextureTransforms,
+              emissiveUV,
+              aoUV,
+              normalUV,
+              hasTransmissionTexture,
+              transmissionUV,
+              hasSheenColorTexture,
+              sheenColorUV,
+              hasSheenRoughnessTexture,
+              sheenRoughnessUV,
+              hasVolumeThicknessTexture,
+              volumeThicknessUV,
+              hasSheen,
+              hasIOR,
+              hasVolume);
           PROXY(callback(materialInstance));
         });
     auto fut = _renderThread->add_task(lambda);
   }
-  
+
   EMSCRIPTEN_KEEPALIVE void ColorGrading_createRenderThread(TEngine *tEngine, TToneMapping toneMapping, void (*callback)(TColorGrading *))
   {
     std::packaged_task<void()> lambda(
@@ -554,11 +663,11 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void View_pickRenderThread(TView *tView, uint32_t requestId, uint32_t x, uint32_t y, PickCallback callback) {
+  EMSCRIPTEN_KEEPALIVE void View_pickRenderThread(TView *tView, uint32_t requestId, uint32_t x, uint32_t y, PickCallback callback)
+  {
     auto *view = reinterpret_cast<View *>(tView);
-    view->pick(x, y, [=](filament::View::PickingQueryResult const &result) {       
-      PROXY(callback(requestId, utils::Entity::smuggle(result.renderable), result.depth, result.fragCoords.x, result.fragCoords.y, result.fragCoords.z));
-    });
+    view->pick(x, y, [=](filament::View::PickingQueryResult const &result)
+               { PROXY(callback(requestId, utils::Entity::smuggle(result.renderable), result.depth, result.fragCoords.x, result.fragCoords.y, result.fragCoords.z)); });
   }
 
   EMSCRIPTEN_KEEPALIVE void View_setColorGradingRenderThread(TView *tView, TColorGrading *tColorGrading, uint32_t requestId, VoidCallback onComplete)
@@ -594,13 +703,14 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *)) {
+  EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto *animationManager = AnimationManager_create(tEngine, tScene);
-        PROXY(onComplete(animationManager));
-      });
+        [=]() mutable
+        {
+          auto *animationManager = AnimationManager_create(tEngine, tScene);
+          PROXY(onComplete(animationManager));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
@@ -715,23 +825,24 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   }
 
   EMSCRIPTEN_KEEPALIVE void Texture_buildRenderThread(
-    TEngine *tEngine, 
-    uint32_t width, 
-    uint32_t height, 
-    uint32_t depth, 
-    uint8_t levels, 
-    uint16_t tUsage,
-    intptr_t import,
-    TTextureSamplerType sampler, 
-    TTextureFormat format, void (*onComplete)(TTexture *)) {
-      std::packaged_task<void()> lambda(
+      TEngine *tEngine,
+      uint32_t width,
+      uint32_t height,
+      uint32_t depth,
+      uint8_t levels,
+      uint16_t tUsage,
+      intptr_t import,
+      TTextureSamplerType sampler,
+      TTextureFormat format, void (*onComplete)(TTexture *))
+  {
+    std::packaged_task<void()> lambda(
         [=]() mutable
         {
           auto *texture = Texture_build(tEngine, width, height, depth, levels, tUsage, import, sampler, format);
           PROXY(onComplete(texture));
         });
-    auto fut = _renderThread->add_task(lambda);  
-    }
+    auto fut = _renderThread->add_task(lambda);
+  }
 
   // Texture methods
   EMSCRIPTEN_KEEPALIVE void Texture_loadImageRenderThread(TEngine *tEngine, TTexture *tTexture, TLinearImage *tImage,
@@ -771,45 +882,44 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   }
 
   EMSCRIPTEN_KEEPALIVE void Texture_setImageWithDepthRenderThread(
-    TEngine *tEngine,
-    TTexture *tTexture,
-    uint32_t level,
-    uint8_t *data,
-    size_t size,
-    uint32_t x_offset,
-    uint32_t y_offset,
-    uint32_t z_offset,
-    uint32_t width,
-    uint32_t height,
-    uint32_t channels,
-    uint32_t depth,
-    uint32_t bufferFormat,
-    uint32_t pixelDataType,
-    void (*onComplete)(bool)
-) {
-  std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        bool result = Texture_setImageWithDepth(
-          tEngine,
-          tTexture,
-          level,
-          data,
-          size,
-          x_offset,
-          y_offset,
-          z_offset,
-          width,
-          height,
-          channels,
-          depth,
-          bufferFormat,
-          pixelDataType
-        );
-        PROXY(onComplete(result));
-      });
-  auto fut = _renderThread->add_task(lambda);
-}
+      TEngine *tEngine,
+      TTexture *tTexture,
+      uint32_t level,
+      uint8_t *data,
+      size_t size,
+      uint32_t x_offset,
+      uint32_t y_offset,
+      uint32_t z_offset,
+      uint32_t width,
+      uint32_t height,
+      uint32_t channels,
+      uint32_t depth,
+      uint32_t bufferFormat,
+      uint32_t pixelDataType,
+      void (*onComplete)(bool))
+  {
+    std::packaged_task<void()> lambda(
+        [=]() mutable
+        {
+          bool result = Texture_setImageWithDepth(
+              tEngine,
+              tTexture,
+              level,
+              data,
+              size,
+              x_offset,
+              y_offset,
+              z_offset,
+              width,
+              height,
+              channels,
+              depth,
+              bufferFormat,
+              pixelDataType);
+          PROXY(onComplete(result));
+        });
+    auto fut = _renderThread->add_task(lambda);
+  }
 
   EMSCRIPTEN_KEEPALIVE void RenderTarget_getColorTextureRenderThread(TRenderTarget *tRenderTarget, void (*onComplete)(TTexture *))
   {
@@ -823,12 +933,12 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   }
 
   EMSCRIPTEN_KEEPALIVE void RenderTarget_createRenderThread(
-    TEngine *tEngine,
-    uint32_t width,
-    uint32_t height,
-    TTexture *tColor,
-    TTexture *tDepth,
-    void (*onComplete)(TRenderTarget *)) 
+      TEngine *tEngine,
+      uint32_t width,
+      uint32_t height,
+      TTexture *tColor,
+      TTexture *tDepth,
+      void (*onComplete)(TRenderTarget *))
   {
     auto color = reinterpret_cast<filament::Texture *>(tColor);
     auto depth = reinterpret_cast<filament::Texture *>(tDepth);
@@ -843,10 +953,10 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
   }
 
   EMSCRIPTEN_KEEPALIVE void RenderTarget_destroyRenderThread(
-    TEngine *tEngine,
-    TRenderTarget *tRenderTarget,
-    uint32_t requestId, VoidCallback onComplete
-  ) {
+      TEngine *tEngine,
+      TRenderTarget *tRenderTarget,
+      uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
         [=]() mutable
         {
@@ -856,7 +966,6 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  
   EMSCRIPTEN_KEEPALIVE void TextureSampler_createRenderThread(void (*onComplete)(TTextureSampler *))
   {
     std::packaged_task<void()> lambda(
@@ -1011,7 +1120,8 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void GltfAssetLoader_createRenderThread(TEngine *tEngine, TMaterialProvider *tMaterialProvider, void (*callback)(TGltfAssetLoader *)) {
+  EMSCRIPTEN_KEEPALIVE void GltfAssetLoader_createRenderThread(TEngine *tEngine, TMaterialProvider *tMaterialProvider, void (*callback)(TGltfAssetLoader *))
+  {
     std::packaged_task<void()> lambda(
       [=]() mutable
       {
@@ -1031,119 +1141,127 @@ EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_destroyRenderThread(TEngine *tEngine, TGltfResourceLoader *tResourceLoader, uint32_t requestId, VoidCallback onComplete) {
+
+  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_destroyRenderThread(TEngine *tEngine, TGltfResourceLoader *tResourceLoader, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        GltfResourceLoader_destroy(tEngine, tResourceLoader);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          GltfResourceLoader_destroy(tEngine, tResourceLoader);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_loadResourcesRenderThread(TGltfResourceLoader *tGltfResourceLoader, TFilamentAsset *tFilamentAsset, void (*callback)(bool)) {
+  EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_loadResourcesRenderThread(TGltfResourceLoader *tGltfResourceLoader, TFilamentAsset *tFilamentAsset, void (*callback)(bool))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto result = GltfResourceLoader_loadResources(tGltfResourceLoader, tFilamentAsset);
-        PROXY(callback(result));
-      });
+        [=]() mutable
+        {
+          auto result = GltfResourceLoader_loadResources(tGltfResourceLoader, tFilamentAsset);
+          PROXY(callback(result));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
   EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_addResourceDataRenderThread(
-    TGltfResourceLoader *tGltfResourceLoader,
-    const char *uri,
-    uint8_t *data,
-    size_t length,
-    uint32_t requestId, VoidCallback onComplete) {
+      TGltfResourceLoader *tGltfResourceLoader,
+      const char *uri,
+      uint8_t *data,
+      size_t length,
+      uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        GltfResourceLoader_addResourceData(tGltfResourceLoader, uri, data, length);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          GltfResourceLoader_addResourceData(tGltfResourceLoader, uri, data, length);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
   EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_asyncBeginLoadRenderThread(
-    TGltfResourceLoader *tGltfResourceLoader,
-    TFilamentAsset *tFilamentAsset,
-    void (*callback)(bool)) {
+      TGltfResourceLoader *tGltfResourceLoader,
+      TFilamentAsset *tFilamentAsset,
+      void (*callback)(bool))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto result = GltfResourceLoader_asyncBeginLoad(tGltfResourceLoader, tFilamentAsset);
-        PROXY(callback(result));
-      });
+        [=]() mutable
+        {
+          auto result = GltfResourceLoader_asyncBeginLoad(tGltfResourceLoader, tFilamentAsset);
+          PROXY(callback(result));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
   EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_asyncUpdateLoadRenderThread(
-    TGltfResourceLoader *tGltfResourceLoader) {
+      TGltfResourceLoader *tGltfResourceLoader)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        GltfResourceLoader_asyncUpdateLoad(tGltfResourceLoader);
-      });
+        [=]() mutable
+        {
+          GltfResourceLoader_asyncUpdateLoad(tGltfResourceLoader);
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
   EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_asyncGetLoadProgressRenderThread(
-    TGltfResourceLoader *tGltfResourceLoader,
-    void (*callback)(float)) {
+      TGltfResourceLoader *tGltfResourceLoader,
+      void (*callback)(float))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto result = GltfResourceLoader_asyncGetLoadProgress(tGltfResourceLoader);
-        PROXY(callback(result));
-      });
+        [=]() mutable
+        {
+          auto result = GltfResourceLoader_asyncGetLoadProgress(tGltfResourceLoader);
+          PROXY(callback(result));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
-  
+
   EMSCRIPTEN_KEEPALIVE void GltfAssetLoader_loadRenderThread(
       TEngine *tEngine,
       TGltfAssetLoader *tAssetLoader,
       uint8_t *data,
       size_t length,
       uint8_t numInstances,
-      void (*callback)(TFilamentAsset *)
-  ) {
+      void (*callback)(TFilamentAsset *))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto loader = GltfAssetLoader_load(tEngine, tAssetLoader, data, length, numInstances);
-        PROXY(callback(loader));
-      });
+        [=]() mutable
+        {
+          auto loader = GltfAssetLoader_load(tEngine, tAssetLoader, data, length, numInstances);
+          PROXY(callback(loader));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
-  EMSCRIPTEN_KEEPALIVE void Scene_addFilamentAssetRenderThread(TScene* tScene, TFilamentAsset *tAsset, uint32_t requestId, VoidCallback onComplete) {
+  EMSCRIPTEN_KEEPALIVE void Scene_addFilamentAssetRenderThread(TScene *tScene, TFilamentAsset *tAsset, uint32_t requestId, VoidCallback onComplete)
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        Scene_addFilamentAsset(tScene, tAsset);
-        PROXY(onComplete(requestId));
-      });
+        [=]() mutable
+        {
+          Scene_addFilamentAsset(tScene, tAsset);
+          PROXY(onComplete(requestId));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 
   EMSCRIPTEN_KEEPALIVE void Gizmo_createRenderThread(
-    TEngine *tEngine,
-    TGltfAssetLoader *tAssetLoader,
-    TGltfResourceLoader *tGltfResourceLoader,
-    TNameComponentManager *tNameComponentManager,
-    TView *tView,
-    TMaterial *tMaterial,
-    TGizmoType tGizmoType,
-    void (*callback)(TGizmo *)
-  ) {
+      TEngine *tEngine,
+      TGltfAssetLoader *tAssetLoader,
+      TGltfResourceLoader *tGltfResourceLoader,
+      TNameComponentManager *tNameComponentManager,
+      TView *tView,
+      TMaterial *tMaterial,
+      TGizmoType tGizmoType,
+      void (*callback)(TGizmo *))
+  {
     std::packaged_task<void()> lambda(
-      [=]() mutable
-      {
-        auto *gizmo = Gizmo_create(tEngine, tAssetLoader,tGltfResourceLoader, tNameComponentManager, tView, tMaterial, tGizmoType);
-        PROXY(callback(gizmo));
-      });
+        [=]() mutable
+        {
+          auto *gizmo = Gizmo_create(tEngine, tAssetLoader, tGltfResourceLoader, tNameComponentManager, tView, tMaterial, tGizmoType);
+          PROXY(callback(gizmo));
+        });
     auto fut = _renderThread->add_task(lambda);
   }
 }