chore(release): publish packages

- thermion_dart@0.3.3-pre
 - thermion_flutter@0.3.3-pre
 - thermion_flutter_method_channel@0.3.3-pre
 - thermion_flutter_platform_interface@0.3.3-pre
 - thermion_flutter_web@0.3.3-pre

.github/workflows/dart.yml

@@ -117,8 +117,28 @@ jobs:
             # D:\a\thermion\thermion\thermion_dart\.dart_tool\thermion_dart\log\build.log
             /Users/runner/work/thermion/thermion/thermion_dart/.dart_tool/thermion_dart/log/build.log
           retention-days: 5
-
-
+  flutter_examples_windows:
+    name: flutter_examples_windows
+    runs-on: windows-latest
+    defaults:
+      run:
+        working-directory: examples/flutter 
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Flutter
+        uses: subosito/flutter-action@v2
+        with:
+          channel: master
+      - run: cd quickstart && flutter pub get && flutter build windows 
+      - run: cd picking && flutter pub get && flutter build windows
+      - name: Upload logs
+        if: failure() || steps.build.outcome == 'failure'
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-logs
+          path: |
+            D:\a\thermion\thermion\thermion_dart\.dart_tool\thermion_dart\log\build.log
+          retention-days: 5
             # thermion_dart:
   #   name: thermion_dart
   #   runs-on: macos-latest

CHANGELOG.md

@@ -3,6 +3,48 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 2025-07-17
+
+### Changes
+
+---
+
+Packages with breaking changes:
+
+ - There are no breaking changes in this release.
+
+Packages with other changes:
+
+ - [`thermion_dart` - `v0.3.3-pre`](#thermion_dart---v033-pre)
+ - [`thermion_flutter` - `v0.3.3-pre`](#thermion_flutter---v033-pre)
+ - [`thermion_flutter_method_channel` - `v0.3.3-pre`](#thermion_flutter_method_channel---v033-pre)
+ - [`thermion_flutter_platform_interface` - `v0.3.3-pre`](#thermion_flutter_platform_interface---v033-pre)
+ - [`thermion_flutter_web` - `v0.3.3-pre`](#thermion_flutter_web---v033-pre)
+
+---
+
+#### `thermion_dart` - `v0.3.3-pre`
+
+ - **FIX**: fix Windows build.dart.
+ - **FIX**: add nan/negative checks inside setLensProjection.
+
+#### `thermion_flutter` - `v0.3.3-pre`
+
+ - **DOCS**: replace thermion_flutter README with symlink to thermion_dart README.
+
+#### `thermion_flutter_method_channel` - `v0.3.3-pre`
+
+ - **FEAT**: allow passing renderTargetColorTextureFormat via ThermionFlutterOptions.
+
+#### `thermion_flutter_platform_interface` - `v0.3.3-pre`
+
+ - **FEAT**: allow passing renderTargetColorTextureFormat via ThermionFlutterOptions.
+
+#### `thermion_flutter_web` - `v0.3.3-pre`
+
+ - Bump "thermion_flutter_web" to `0.3.3-pre`.
+
+
 ## 2025-07-08
 
 ### Changes

README.md

@@ -79,4 +79,4 @@ Thank you to the following people:
 - @LukasPoque for CI/refactoring work
 - @alexmercerind for his work on integrating ANGLE textures on Flutter Windows
 - @BrutalCoding for documentation fixes
-
+- @chenriji for testing and bug fixes

docs/quickstart.mdx

@@ -14,6 +14,8 @@ This is a simplified, Flutter-only wrapper around the underlying 3D rendering AP
 
 Follow the steps listed in [Getting Started](./getting_started) to configure your Flutter installation and project.
 
+If you're running Windows, delete the `examples/flutter/quickstart/assets` symlink and copy the `assets` folder from `examples/assets` to `examples/flutter/quickstart/assets`.
+
 ## Basic Usage
 
 ```dart

examples/flutter/camera_manipulation/lib/main.dart

@@ -0,0 +1,103 @@
+import 'dart:async';
+import 'package:flutter/services.dart';
+import 'package:logging/logging.dart';
+import 'package:flutter/material.dart';
+import 'package:thermion_flutter/thermion_flutter.dart';
+
+void main() {
+  runApp(const MyApp());
+  Logger.root.onRecord.listen((record) {
+    print(record);
+  });
+}
+
+class MyApp extends StatelessWidget {
+  const MyApp({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return MaterialApp(
+      title: 'Thermion Demo',
+      theme: ThemeData(
+        colorScheme: ColorScheme.fromSeed(seedColor: Colors.deepPurple),
+        useMaterial3: true,
+      ),
+      home: const MyHomePage(title: 'Thermion Demo Home Page'),
+    );
+  }
+}
+
+class MyHomePage extends StatefulWidget {
+  const MyHomePage({super.key, required this.title});
+  final String title;
+
+  @override
+  State<MyHomePage> createState() => _MyHomePageState();
+}
+
+class _MyHomePageState extends State<MyHomePage> {
+  
+  late DelegateInputHandler _fixedOrbitInputHandler;
+  late DelegateInputHandler _freeFlightInputHandler;
+  
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addPostFrameCallback((_) async {
+      _thermionViewer = await ThermionFlutterPlugin.createViewer();
+      var assetData = await rootBundle.load("assets/cube.glb");
+      var asset =
+          await _thermionViewer!.loadGltfFromBuffer(assetData.buffer.asUint8List(assetData.offsetInBytes), keepData: true, loadResourcesAsync: true);
+      await _thermionViewer!.loadSkybox("assets/default_env_skybox.ktx");
+      await _thermionViewer!.loadIbl("assets/default_env_ibl.ktx");
+      await _thermionViewer!.setPostProcessing(true);
+      await _thermionViewer!.setRendering(true);
+
+      _fixedOrbitInputHandler =
+          DelegateInputHandler.fixedOrbit(_thermionViewer!)
+            ..setActionForType(InputType.MMB_HOLD_AND_MOVE, InputAction.ROTATE)
+            ..setActionForType(InputType.SCALE1, InputAction.ROTATE)
+            ..setActionForType(InputType.SCALE2, InputAction.ZOOM)
+            ..setActionForType(InputType.SCROLLWHEEL, InputAction.ZOOM);
+
+      _freeFlightInputHandler =
+          DelegateInputHandler.flight(_thermionViewer!)
+            ..setActionForType(InputType.MMB_HOLD_AND_MOVE, InputAction.ROTATE)
+            ..setActionForType(InputType.SCALE1, InputAction.ROTATE)
+            ..setActionForType(InputType.SCALE2, InputAction.ZOOM)
+            ..setActionForType(InputType.SCROLLWHEEL, InputAction.ZOOM);
+
+      setState(() {});
+    });
+  }
+
+  ThermionViewer? _thermionViewer;
+
+  bool isOrbit = true;
+
+  @override
+  Widget build(BuildContext context) {
+    return Stack(children: [
+      if (_thermionViewer != null) ...[
+        Positioned.fill(
+            child: ThermionListenerWidget(
+                inputHandler: isOrbit
+                    ? _fixedOrbitInputHandler : _freeFlightInputHandler,
+                    child:ThermionWidget(
+                        viewer: _thermionViewer!,
+                      ))),
+        Column(
+          mainAxisAlignment: MainAxisAlignment.end,
+          children: [
+            ElevatedButton(
+                onPressed: () {
+                  isOrbit = !isOrbit;
+                  setState(() {});
+                },
+                child: Text("Switch to ${isOrbit ? "Free Flight" : "Orbit"}"))
+          ],
+        )
+      ],
+    ]);
+  }
+}

materials/grid.mat

@@ -108,10 +108,13 @@ fragment {
             1.0
         );  
 
-        color.rgb = (axes.x < 1e-8) ? color.rgb : AXIS_COLOR_X;
-        color.rgb = (axes.z < 1e-8) ? color.rgb : AXIS_COLOR_Z;
-        
-        material.baseColor = color * gridAlpha; 
-        
+        if(axes.x > 1e-8) {
+            material.baseColor = vec4(AXIS_COLOR_X, 1.0);
+        } else if(axes.z > 1e-8) {
+            material.baseColor = vec4(AXIS_COLOR_Z, 1.0);
+        } else {
+            material.baseColor = color * gridAlpha; 
+        }
+
     }
 }

melos.yaml

@@ -1,4 +1,8 @@
 name: thermion_workspace
 packages:
   - thermion_dart
-  - thermion_flutter/**
+  - thermion_flutter/thermion_flutter_platform_interface
+  - thermion_flutter/thermion_flutter_method_channel
+  - thermion_flutter/thermion_flutter_web
+  - thermion_flutter/thermion_flutter
+  

thermion_dart/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.3.3-pre
+
+ - **FIX**: fix Windows build.dart.
+ - **FIX**: add nan/negative checks inside setLensProjection.
+
 ## 0.3.2
 
  - Bump "thermion_dart" to `0.3.2`.

thermion_dart/hook/build.dart

@@ -1,10 +1,11 @@
 import 'dart:io';
+
 import 'package:archive/archive.dart';
 import 'package:code_assets/code_assets.dart';
 import 'package:hooks/hooks.dart';
+import 'package:native_toolchain_c/native_toolchain_c.dart';
 import 'package:logging/logging.dart';
 
-import 'package:native_toolchain_c/native_toolchain_c.dart';
 import 'package:path/path.dart' as path;
 
 void main(List<String> args) async {
@@ -130,7 +131,7 @@ void main(List<String> args) async {
 
     var frameworks = [];
 
-    if (platform != "windows") {
+    if (targetOS != OS.windows) {
       flags.addAll(['-std=c++17']);
     } else {
       defines["WIN32"] = "1";
@@ -193,7 +194,7 @@ void main(List<String> args) async {
       name: packageName,
       language: Language.cpp,
       assetName: 'thermion_dart.dart',
-      sources: platform == "windows" ? [] : sources,
+      sources: targetOS == OS.windows ? [] : sources,
       includes: platform == "windows"
           ? []
           : ['native/include', 'native/include/filament'],
@@ -219,12 +220,12 @@ void main(List<String> args) async {
           "/I${path.join(pkgRootFilePath, "native", "include", "windows", "vulkan")}",
           "@${srcs.uri.toFilePath(windows: true)}",
           // ...sources,
-          '/link',
-          "/LIBPATH:$libDir",
-          '/DLL',
+          // '/link',
+          // "/LIBPATH:$libDir",
+          // '/DLL',
         ]
       ],
-      dartBuildFiles: ['hook/build.dart'],
+      libraryDirectories: [libDir],
     );
 
     await cbuilder.run(

thermion_dart/lib/src/filament/src/implementation/ffi_camera.dart

@@ -5,11 +5,10 @@ import '../../../utils/src/matrix.dart';
 
 class FFICamera extends Camera<Pointer<TCamera>> {
   final Pointer<TCamera> camera;
-  
+
   @override
   Pointer<TCamera> getNativeHandle() {
     return camera;
-
   }
 
   final FFIFilamentApp app;
@@ -92,6 +91,16 @@ class FFICamera extends Camera<Pointer<TCamera>> {
       double far = kFar,
       double aspect = 1.0,
       double focalLength = kFocalLength}) async {
+    if (near.isNaN ||
+        far.isNaN ||
+        aspect.isNaN ||
+        focalLength.isNaN ||
+        near.isNegative ||
+        far.isNegative ||
+        aspect.isNegative ||
+        focalLength.isNegative) {
+      throw FormatException();
+    }
     Camera_setLensProjection(camera, near, far, aspect, focalLength);
   }
 

thermion_dart/lib/src/viewer/src/thermion_viewer_base.dart

@@ -344,13 +344,14 @@ abstract class ThermionViewer {
   int getCameraCount();
 
   ///
-  /// Adds the asset to the scene, meaning the asset will be rendered/visible.
+  /// Adds the asset to the scene. All renderable entities attached to  
+  /// the asset will be visible.
   ///
   Future addToScene(covariant ThermionAsset asset);
 
   ///
-  /// Removes the asset from the scene, meaning the asset will not be rendered/visible.
-  /// The asset itself will remain valid.
+  /// Removes the asset from the scene. None of the renderable entities 
+  /// attached to the asset will be visible, but the asset itself remains valid.
   ///
   Future removeFromScene(covariant ThermionAsset asset);
 }

thermion_dart/native/include/ThermionWin32.h

@@ -25,7 +25,6 @@
 #pragma comment(lib, "dracodec.lib")
 #pragma comment(lib, "ibl.lib")
 #pragma comment(lib, "ktxreader.lib")
-#pragma comment(lib, "png.lib")
 #pragma comment(lib, "z.lib")
 #pragma comment(lib, "stb.lib")
 #pragma comment(lib, "uberzlib.lib")

thermion_dart/native/include/c_api/TCamera.h

@@ -1,5 +1,9 @@
 #pragma once
 
+#ifdef _WIN32
+#include "ThermionWin32.h"
+#endif
+
 #ifdef __cplusplus
 namespace thermion {
 extern "C"
@@ -16,35 +20,35 @@ enum TProjection {
 typedef enum TProjection TProjection;
 
 // Camera methods
-void Camera_setExposure(TCamera *camera, float aperture, float shutterSpeed, float sensitivity);
-double4x4 Camera_getModelMatrix(TCamera *const camera);
-double4x4 Camera_getViewMatrix(TCamera *const camera);
-double4x4 Camera_getProjectionMatrix(TCamera *const camera);
-double4x4 Camera_getCullingProjectionMatrix(TCamera *const camera);
-void Camera_getFrustum(TCamera *camera, double* out);
-void Camera_setProjectionMatrix(TCamera *camera, double *matrix, double near, double far);
-void Camera_setProjectionFromFov(TCamera *camera, double fovInDegrees, double aspect, double near, double far, bool horizontal);
-double Camera_getFocalLength(TCamera *const camera);
-double4x4 Camera_getViewMatrix(TCamera *const camera);
-double4x4 Camera_getModelMatrix(TCamera* camera);
-void Camera_lookAt(TCamera* camera, double3 eye, double3 focus, double3 up);
+EMSCRIPTEN_KEEPALIVE void Camera_setExposure(TCamera *camera, float aperture, float shutterSpeed, float sensitivity);
+EMSCRIPTEN_KEEPALIVE double4x4 Camera_getModelMatrix(TCamera *const camera);
+EMSCRIPTEN_KEEPALIVE double4x4 Camera_getViewMatrix(TCamera *const camera);
+EMSCRIPTEN_KEEPALIVE double4x4 Camera_getProjectionMatrix(TCamera *const camera);
+EMSCRIPTEN_KEEPALIVE double4x4 Camera_getCullingProjectionMatrix(TCamera *const camera);
+EMSCRIPTEN_KEEPALIVE void Camera_getFrustum(TCamera *camera, double* out);
+EMSCRIPTEN_KEEPALIVE void Camera_setProjectionMatrix(TCamera *camera, double *matrix, double near, double far);
+EMSCRIPTEN_KEEPALIVE void Camera_setProjectionFromFov(TCamera *camera, double fovInDegrees, double aspect, double near, double far, bool horizontal);
+EMSCRIPTEN_KEEPALIVE double Camera_getFocalLength(TCamera *const camera);
+EMSCRIPTEN_KEEPALIVE double4x4 Camera_getViewMatrix(TCamera *const camera);
+EMSCRIPTEN_KEEPALIVE double4x4 Camera_getModelMatrix(TCamera* camera);
+EMSCRIPTEN_KEEPALIVE void Camera_lookAt(TCamera* camera, double3 eye, double3 focus, double3 up);
 
-double Camera_getNear(TCamera *camera);
-double Camera_getCullingFar(TCamera *camera);
-float Camera_getFov(TCamera *camera, bool horizontal);
-double Camera_getFocusDistance(TCamera *camera);
-void Camera_setFocusDistance(TCamera *camera, float focusDistance);
+EMSCRIPTEN_KEEPALIVE double Camera_getNear(TCamera *camera);
+EMSCRIPTEN_KEEPALIVE double Camera_getCullingFar(TCamera *camera);
+EMSCRIPTEN_KEEPALIVE float Camera_getFov(TCamera *camera, bool horizontal);
+EMSCRIPTEN_KEEPALIVE double Camera_getFocusDistance(TCamera *camera);
+EMSCRIPTEN_KEEPALIVE void Camera_setFocusDistance(TCamera *camera, float focusDistance);
 
-void Camera_setCustomProjectionWithCulling(
+EMSCRIPTEN_KEEPALIVE void Camera_setCustomProjectionWithCulling(
     TCamera* camera,
     double4x4 projectionMatrix,
     double near,
     double far
 );
-void Camera_setModelMatrix(TCamera* camera, double *tModelMatrix);
-void Camera_setLensProjection(TCamera *camera, double near, double far, double aspect, double focalLength);
-EntityId Camera_getEntity(TCamera* camera);
-void Camera_setProjection(TCamera *const tCamera, TProjection projection, double left, double right,
+EMSCRIPTEN_KEEPALIVE void Camera_setModelMatrix(TCamera* camera, double *tModelMatrix);
+EMSCRIPTEN_KEEPALIVE void Camera_setLensProjection(TCamera *camera, double near, double far, double aspect, double focalLength);
+EMSCRIPTEN_KEEPALIVE EntityId Camera_getEntity(TCamera* camera);
+EMSCRIPTEN_KEEPALIVE void Camera_setProjection(TCamera *const tCamera, TProjection projection, double left, double right,
             double bottom, double top,
             double near, double far);
 

thermion_dart/native/include/c_api/ThermionDartRenderThreadApi.h

@@ -16,16 +16,16 @@ namespace thermion
         typedef int32_t EntityId;
         typedef void (*FilamentRenderCallback)(void *const owner);
 
-        void RenderThread_create();
-        void RenderThread_destroy();
-        void RenderThread_requestFrameAsync();
-        void RenderThread_setRenderTicker(TRenderTicker *tRenderTicker);
-        void RenderThread_addTask(void (*task)());
+        EMSCRIPTEN_KEEPALIVE void RenderThread_create();
+        EMSCRIPTEN_KEEPALIVE void RenderThread_destroy();
+        EMSCRIPTEN_KEEPALIVE void RenderThread_requestFrameAsync();
+        EMSCRIPTEN_KEEPALIVE void RenderThread_setRenderTicker(TRenderTicker *tRenderTicker);
+        EMSCRIPTEN_KEEPALIVE void RenderThread_addTask(void (*task)());
         
-        void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, uint32_t requestId, VoidCallback onComplete);
-        void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *));
+        EMSCRIPTEN_KEEPALIVE void RenderTicker_renderRenderThread(TRenderTicker *tRenderTicker, uint64_t frameTimeInNanos, uint32_t requestId, VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void AnimationManager_createRenderThread(TEngine *tEngine, TScene *tScene, void (*onComplete)(TAnimationManager *));
 
-        void Engine_createRenderThread(
+        EMSCRIPTEN_KEEPALIVE void Engine_createRenderThread(
             TBackend backend,
             void* platform,
             void* sharedContext,
@@ -33,22 +33,22 @@ namespace thermion
             bool disableHandleUseAfterFreeCheck,
             void (*onComplete)(TEngine *)
         );
-        void Engine_createRendererRenderThread(TEngine *tEngine, void (*onComplete)(TRenderer *));
-        void Engine_createSwapChainRenderThread(TEngine *tEngine, void *window, uint64_t flags, void (*onComplete)(TSwapChain *));
-        void Engine_createHeadlessSwapChainRenderThread(TEngine *tEngine, uint32_t width, uint32_t height, uint64_t flags, void (*onComplete)(TSwapChain *));
-        void Engine_createCameraRenderThread(TEngine* tEngine, void (*onComplete)(TCamera *));
-        void Engine_createViewRenderThread(TEngine *tEngine, void (*onComplete)(TView *));
-        void Engine_buildMaterialRenderThread(TEngine *tEngine, const uint8_t *materialData, size_t length, void (*onComplete)(TMaterial *));
-        void Engine_destroyRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete);
-        void Engine_destroySwapChainRenderThread(TEngine *tEngine, TSwapChain *tSwapChain, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_destroyViewRenderThread(TEngine *tEngine, TView *tView, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_destroySceneRenderThread(TEngine *tEngine, TScene *tScene, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_destroyColorGradingRenderThread(TEngine *tEngine, TColorGrading *tColorGrading, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_destroyMaterialRenderThread(TEngine *tEngine, TMaterial *tMaterial, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_destroyMaterialInstanceRenderThread(TEngine *tEngine, TMaterialInstance *tMaterialInstance, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_destroySkyboxRenderThread(TEngine *tEngine, TSkybox *tSkybox, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_destroyIndirectLightRenderThread(TEngine *tEngine, TIndirectLight *tIndirectLight, uint32_t requestId,  VoidCallback onComplete);
-        void Texture_buildRenderThread(TEngine *engine, 
+        EMSCRIPTEN_KEEPALIVE void Engine_createRendererRenderThread(TEngine *tEngine, void (*onComplete)(TRenderer *));
+        EMSCRIPTEN_KEEPALIVE void Engine_createSwapChainRenderThread(TEngine *tEngine, void *window, uint64_t flags, void (*onComplete)(TSwapChain *));
+        EMSCRIPTEN_KEEPALIVE void Engine_createHeadlessSwapChainRenderThread(TEngine *tEngine, uint32_t width, uint32_t height, uint64_t flags, void (*onComplete)(TSwapChain *));
+        EMSCRIPTEN_KEEPALIVE void Engine_createCameraRenderThread(TEngine* tEngine, void (*onComplete)(TCamera *));
+        EMSCRIPTEN_KEEPALIVE void Engine_createViewRenderThread(TEngine *tEngine, void (*onComplete)(TView *));
+        EMSCRIPTEN_KEEPALIVE void Engine_buildMaterialRenderThread(TEngine *tEngine, const uint8_t *materialData, size_t length, void (*onComplete)(TMaterial *));
+        EMSCRIPTEN_KEEPALIVE void Engine_destroyRenderThread(TEngine *tEngine, uint32_t requestId, VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_destroySwapChainRenderThread(TEngine *tEngine, TSwapChain *tSwapChain, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_destroyViewRenderThread(TEngine *tEngine, TView *tView, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_destroySceneRenderThread(TEngine *tEngine, TScene *tScene, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_destroyColorGradingRenderThread(TEngine *tEngine, TColorGrading *tColorGrading, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialRenderThread(TEngine *tEngine, TMaterial *tMaterial, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_destroyMaterialInstanceRenderThread(TEngine *tEngine, TMaterialInstance *tMaterialInstance, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_destroySkyboxRenderThread(TEngine *tEngine, TSkybox *tSkybox, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_destroyIndirectLightRenderThread(TEngine *tEngine, TIndirectLight *tIndirectLight, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Texture_buildRenderThread(TEngine *engine, 
             uint32_t width, 
             uint32_t height, 
             uint32_t depth, 
@@ -59,25 +59,25 @@ namespace thermion
             TTextureFormat format,
             void (*onComplete)(TTexture*)
         );
-        void Texture_generateMipMapsRenderThread(TTexture *tTexture, TEngine *tEngine, uint32_t requestId, VoidCallback onComplete);
-        void Ktx1Reader_createTextureRenderThread(TEngine *tEngine, TKtx1Bundle *tBundle, uint32_t requestId, VoidCallback onTextureUploadComplete, void (*onComplete)(TTexture *));
+        EMSCRIPTEN_KEEPALIVE void Texture_generateMipMapsRenderThread(TTexture *tTexture, TEngine *tEngine, uint32_t requestId, VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Ktx1Reader_createTextureRenderThread(TEngine *tEngine, TKtx1Bundle *tBundle, uint32_t requestId, VoidCallback onTextureUploadComplete, void (*onComplete)(TTexture *));
 
-        void Engine_destroyTextureRenderThread(TEngine *engine, TTexture* tTexture, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_createFenceRenderThread(TEngine *tEngine, void (*onComplete)(TFence*));
-        void Fence_waitAndDestroyRenderThread(TFence *tFence, uint32_t requestId, VoidCallback onComplete);
-        void Engine_destroyFenceRenderThread(TEngine *tEngine, TFence *tFence, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_flushAndWaitRenderThread(TEngine *tEngine, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_executeRenderThread(TEngine *tEngine, uint32_t requestId,  VoidCallback onComplete);
-        void Engine_buildSkyboxRenderThread(TEngine *tEngine, TTexture *tTexture, void (*onComplete)(TSkybox *));
-        void Engine_buildIndirectLightFromIrradianceTextureRenderThread(TEngine *tEngine, TTexture *tReflectionsTexture, TTexture* tIrradianceTexture, float intensity, void (*onComplete)(TIndirectLight *));
-        void Engine_buildIndirectLightFromIrradianceHarmonicsRenderThread(TEngine *tEngine, TTexture *tReflectionsTexture, float *harmonics, float intensity, void (*onComplete)(TIndirectLight *));
+        EMSCRIPTEN_KEEPALIVE void Engine_destroyTextureRenderThread(TEngine *engine, TTexture* tTexture, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_createFenceRenderThread(TEngine *tEngine, void (*onComplete)(TFence*));
+        EMSCRIPTEN_KEEPALIVE void Fence_waitAndDestroyRenderThread(TFence *tFence, uint32_t requestId, VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_destroyFenceRenderThread(TEngine *tEngine, TFence *tFence, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_flushAndWaitRenderThread(TEngine *tEngine, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_executeRenderThread(TEngine *tEngine, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Engine_buildSkyboxRenderThread(TEngine *tEngine, TTexture *tTexture, void (*onComplete)(TSkybox *));
+        EMSCRIPTEN_KEEPALIVE void Engine_buildIndirectLightFromIrradianceTextureRenderThread(TEngine *tEngine, TTexture *tReflectionsTexture, TTexture* tIrradianceTexture, float intensity, void (*onComplete)(TIndirectLight *));
+        EMSCRIPTEN_KEEPALIVE void Engine_buildIndirectLightFromIrradianceHarmonicsRenderThread(TEngine *tEngine, TTexture *tReflectionsTexture, float *harmonics, float intensity, void (*onComplete)(TIndirectLight *));
 
-        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);
-        void Renderer_beginFrameRenderThread(TRenderer *tRenderer, TSwapChain *tSwapChain, uint64_t frameTimeInNanos, void (*onComplete)(bool));
-        void Renderer_endFrameRenderThread(TRenderer *tRenderer, uint32_t requestId,  VoidCallback onComplete);
-        void Renderer_renderRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId,  VoidCallback onComplete);
-        void Renderer_renderStandaloneViewRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId,  VoidCallback onComplete);
-        void Renderer_readPixelsRenderThread(
+        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);
+        EMSCRIPTEN_KEEPALIVE void Renderer_beginFrameRenderThread(TRenderer *tRenderer, TSwapChain *tSwapChain, uint64_t frameTimeInNanos, void (*onComplete)(bool));
+        EMSCRIPTEN_KEEPALIVE void Renderer_endFrameRenderThread(TRenderer *tRenderer, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Renderer_renderRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Renderer_renderStandaloneViewRenderThread(TRenderer *tRenderer, TView *tView, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Renderer_readPixelsRenderThread(
             TRenderer *tRenderer,
             uint32_t width, uint32_t height, uint32_t xOffset, uint32_t yOffset,
             TRenderTarget *tRenderTarget,
@@ -87,29 +87,29 @@ namespace thermion
             size_t outLength,
             uint32_t requestId,  VoidCallback onComplete);
 
-        void Material_createInstanceRenderThread(TMaterial *tMaterial, void (*onComplete)(TMaterialInstance *));
-        void Material_createImageMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *));
-        void Material_createGizmoMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *));
-        void Material_createOutlineMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *));
+        EMSCRIPTEN_KEEPALIVE void Material_createInstanceRenderThread(TMaterial *tMaterial, void (*onComplete)(TMaterialInstance *));
+        EMSCRIPTEN_KEEPALIVE void Material_createImageMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *));
+        EMSCRIPTEN_KEEPALIVE void Material_createGizmoMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *));
+        EMSCRIPTEN_KEEPALIVE void Material_createOutlineMaterialRenderThread(TEngine *tEngine, void (*onComplete)(TMaterial *));
 
-        void ColorGrading_createRenderThread(TEngine *tEngine, TToneMapping toneMapping, void (*callback)(TColorGrading *));  
-        void View_pickRenderThread(TView *tView, uint32_t requestId, uint32_t x, uint32_t y, PickCallback callback);
-        void View_setColorGradingRenderThread(TView *tView, TColorGrading *tColorGrading, uint32_t requestId,  VoidCallback onComplete);
-        void View_setBloomRenderThread(TView *tView, bool enabled, double strength, uint32_t requestId,  VoidCallback onComplete);
-        void View_setCameraRenderThread(TView *tView, TCamera *tCamera, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void ColorGrading_createRenderThread(TEngine *tEngine, TToneMapping toneMapping, void (*callback)(TColorGrading *));  
+        EMSCRIPTEN_KEEPALIVE void View_pickRenderThread(TView *tView, uint32_t requestId, uint32_t x, uint32_t y, PickCallback callback);
+        EMSCRIPTEN_KEEPALIVE void View_setColorGradingRenderThread(TView *tView, TColorGrading *tColorGrading, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void View_setBloomRenderThread(TView *tView, bool enabled, double strength, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void View_setCameraRenderThread(TView *tView, TCamera *tCamera, uint32_t requestId,  VoidCallback onComplete);
 
-        void SceneAsset_createGridRenderThread(TEngine *tEngine, TMaterial * tMaterial, void (*callback)(TSceneAsset *));
+        EMSCRIPTEN_KEEPALIVE void SceneAsset_createGridRenderThread(TEngine *tEngine, TMaterial * tMaterial, void (*callback)(TSceneAsset *));
 
-        void SceneAsset_destroyRenderThread(TSceneAsset *tSceneAsset, uint32_t requestId,  VoidCallback onComplete);
-        void SceneAsset_createFromFilamentAssetRenderThread(
+        EMSCRIPTEN_KEEPALIVE void SceneAsset_destroyRenderThread(TSceneAsset *tSceneAsset, uint32_t requestId,  VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void SceneAsset_createFromFilamentAssetRenderThread(
             TEngine *tEngine,
             TGltfAssetLoader *tAssetLoader,
             TNameComponentManager *tNameComponentManager,
             TFilamentAsset *tFilamentAsset,
             void (*onComplete)(TSceneAsset *)
         );
-        void SceneAsset_createInstanceRenderThread(TSceneAsset *asset, TMaterialInstance **tMaterialInstances, int materialInstanceCount, void (*callback)(TSceneAsset *));
-        void SceneAsset_createGeometryRenderThread(
+        EMSCRIPTEN_KEEPALIVE void SceneAsset_createInstanceRenderThread(TSceneAsset *asset, TMaterialInstance **tMaterialInstances, int materialInstanceCount, void (*callback)(TSceneAsset *));
+        EMSCRIPTEN_KEEPALIVE void SceneAsset_createGeometryRenderThread(
             TEngine *tEngine, 
             float *vertices,
             uint32_t numVertices,
@@ -124,7 +124,7 @@ namespace thermion
             int materialInstanceCount,
             void (*callback)(TSceneAsset *)
         );
-        void MaterialProvider_createMaterialInstanceRenderThread(
+        EMSCRIPTEN_KEEPALIVE void MaterialProvider_createMaterialInstanceRenderThread(
             TMaterialProvider *tMaterialProvider, 
             bool doubleSided,
             bool unlit,
@@ -166,12 +166,12 @@ namespace thermion
             bool hasVolume,
             void (*callback)(TMaterialInstance *));
 
-        void AnimationManager_updateBoneMatricesRenderThread(
+        EMSCRIPTEN_KEEPALIVE void AnimationManager_updateBoneMatricesRenderThread(
             TAnimationManager *tAnimationManager,
             TSceneAsset *sceneAsset,
             void (*callback)(bool));
 
-        void AnimationManager_setMorphTargetWeightsRenderThread(
+        EMSCRIPTEN_KEEPALIVE void AnimationManager_setMorphTargetWeightsRenderThread(
             TAnimationManager *tAnimationManager,
             EntityId entityId,
             const float *const morphData,
@@ -179,16 +179,16 @@ namespace thermion
             void (*callback)(bool));
 
         // Image methods
-        void Image_createEmptyRenderThread(uint32_t width, uint32_t height, uint32_t channel, void (*onComplete)(TLinearImage *));
-        void Image_decodeRenderThread(uint8_t* data, size_t length, const char* name, bool alpha, void (*onComplete)(TLinearImage *));
-        void Image_getBytesRenderThread(TLinearImage *tLinearImage, void (*onComplete)(float *));
-        void Image_destroyRenderThread(TLinearImage *tLinearImage, uint32_t requestId, VoidCallback onComplete);
-        void Image_getWidthRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t));
-        void Image_getHeightRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t));
-        void Image_getChannelsRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t));
+        EMSCRIPTEN_KEEPALIVE void Image_createEmptyRenderThread(uint32_t width, uint32_t height, uint32_t channel, void (*onComplete)(TLinearImage *));
+        EMSCRIPTEN_KEEPALIVE void Image_decodeRenderThread(uint8_t* data, size_t length, const char* name, bool alpha, void (*onComplete)(TLinearImage *));
+        EMSCRIPTEN_KEEPALIVE void Image_getBytesRenderThread(TLinearImage *tLinearImage, void (*onComplete)(float *));
+        EMSCRIPTEN_KEEPALIVE void Image_destroyRenderThread(TLinearImage *tLinearImage, uint32_t requestId, VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Image_getWidthRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t));
+        EMSCRIPTEN_KEEPALIVE void Image_getHeightRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t));
+        EMSCRIPTEN_KEEPALIVE void Image_getChannelsRenderThread(TLinearImage *tLinearImage, void (*onComplete)(uint32_t));
 
 
-        void Texture_loadImageRenderThread(
+        EMSCRIPTEN_KEEPALIVE void Texture_loadImageRenderThread(
             TEngine *tEngine,
             TTexture *tTexture,
             TLinearImage *tImage,
@@ -197,7 +197,7 @@ namespace thermion
             int level,
             void (*onComplete)(bool)
         );
-        void Texture_setImageRenderThread(
+        EMSCRIPTEN_KEEPALIVE void Texture_setImageRenderThread(
             TEngine *tEngine,
             TTexture *tTexture,
             uint32_t level,
@@ -213,8 +213,8 @@ namespace thermion
             uint32_t pixelDataType,
             void (*onComplete)(bool)
         );
-        void RenderTarget_getColorTextureRenderThread(TRenderTarget *tRenderTarget, void (*onComplete)(TTexture *));
-        void RenderTarget_createRenderThread(
+        EMSCRIPTEN_KEEPALIVE void RenderTarget_getColorTextureRenderThread(TRenderTarget *tRenderTarget, void (*onComplete)(TTexture *));
+        EMSCRIPTEN_KEEPALIVE void RenderTarget_createRenderThread(
             TEngine *tEngine,
             uint32_t width,
             uint32_t height,
@@ -222,7 +222,7 @@ namespace thermion
             TTexture *depth,
             void (*onComplete)(TRenderTarget *)
         );
-        void RenderTarget_destroyRenderThread(
+        EMSCRIPTEN_KEEPALIVE void RenderTarget_destroyRenderThread(
             TEngine *tEngine,
             TRenderTarget *tRenderTarget,
             uint32_t requestId, VoidCallback onComplete
@@ -230,8 +230,8 @@ namespace thermion
 
 
         // TextureSampler methods
-        void TextureSampler_createRenderThread(void (*onComplete)(TTextureSampler*));
-        void TextureSampler_createWithFilteringRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_createRenderThread(void (*onComplete)(TTextureSampler*));
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_createWithFilteringRenderThread(
             TSamplerMinFilter minFilter, 
             TSamplerMagFilter magFilter, 
             TSamplerWrapMode wrapS, 
@@ -239,53 +239,53 @@ namespace thermion
             TSamplerWrapMode wrapR,
             void (*onComplete)(TTextureSampler*)
         );
-        void TextureSampler_createWithComparisonRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_createWithComparisonRenderThread(
             TSamplerCompareMode compareMode, 
             TSamplerCompareFunc compareFunc,
             void (*onComplete)(TTextureSampler*)
         );
-        void TextureSampler_setMinFilterRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_setMinFilterRenderThread(
             TTextureSampler* sampler, 
             TSamplerMinFilter filter,
             uint32_t requestId, VoidCallback onComplete
         );
-        void TextureSampler_setMagFilterRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_setMagFilterRenderThread(
             TTextureSampler* sampler, 
             TSamplerMagFilter filter,
             uint32_t requestId, VoidCallback onComplete
         );
-        void TextureSampler_setWrapModeSRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_setWrapModeSRenderThread(
             TTextureSampler* sampler, 
             TSamplerWrapMode mode,
             uint32_t requestId, VoidCallback onComplete
         );
-        void TextureSampler_setWrapModeTRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_setWrapModeTRenderThread(
             TTextureSampler* sampler, 
             TSamplerWrapMode mode,
             uint32_t requestId, VoidCallback onComplete
         );
-        void TextureSampler_setWrapModeRRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_setWrapModeRRenderThread(
             TTextureSampler* sampler, 
             TSamplerWrapMode mode,
             uint32_t requestId, VoidCallback onComplete
         );
-        void TextureSampler_setAnisotropyRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_setAnisotropyRenderThread(
             TTextureSampler* sampler, 
             double anisotropy,
             uint32_t requestId, VoidCallback onComplete
         );
-        void TextureSampler_setCompareModeRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_setCompareModeRenderThread(
             TTextureSampler* sampler, 
             TSamplerCompareMode mode, 
             TTextureSamplerCompareFunc func,
             uint32_t requestId, VoidCallback onComplete
         );
-        void TextureSampler_destroyRenderThread(
+        EMSCRIPTEN_KEEPALIVE void TextureSampler_destroyRenderThread(
             TTextureSampler* sampler,
             uint32_t requestId, VoidCallback onComplete
         );
 
-        void AnimationManager_setBoneTransformRenderThread(
+        EMSCRIPTEN_KEEPALIVE void AnimationManager_setBoneTransformRenderThread(
             TAnimationManager *tAnimationManager,
             EntityId asset,
             int skinIndex,
@@ -293,18 +293,18 @@ namespace thermion
             const float *const transform,
             void (*callback)(bool));
 
-        void AnimationManager_resetToRestPoseRenderThread(TAnimationManager *tAnimationManager, TSceneAsset *tSceneAsset, uint32_t requestId, VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void AnimationManager_resetToRestPoseRenderThread(TAnimationManager *tAnimationManager, TSceneAsset *tSceneAsset, uint32_t requestId, VoidCallback onComplete);
 
-        void GltfAssetLoader_createRenderThread(TEngine *tEngine, TMaterialProvider *tMaterialProvider, TNameComponentManager *tNameComponentManager, void (*callback)(TGltfAssetLoader *));
-        void GltfResourceLoader_createRenderThread(TEngine *tEngine, void (*callback)(TGltfResourceLoader *));
-        void GltfResourceLoader_destroyRenderThread(TEngine *tEngine, TGltfResourceLoader *tResourceLoader, uint32_t requestId, VoidCallback onComplete);
-        void GltfResourceLoader_loadResourcesRenderThread(TGltfResourceLoader *tGltfResourceLoader, TFilamentAsset *tFilamentAsset, void (*callback)(bool));
-        void GltfResourceLoader_addResourceDataRenderThread(TGltfResourceLoader *tGltfResourceLoader, const char *uri, uint8_t *data, size_t length, uint32_t requestId, VoidCallback onComplete);
-        void GltfResourceLoader_asyncBeginLoadRenderThread(TGltfResourceLoader *tGltfResourceLoader, TFilamentAsset *tFilamentAsset, void (*callback)(bool));
-        void GltfResourceLoader_asyncUpdateLoadRenderThread(TGltfResourceLoader *tGltfResourceLoader);
-        void GltfResourceLoader_asyncGetLoadProgressRenderThread(TGltfResourceLoader *tGltfResourceLoader, void (*callback)(float));
+        EMSCRIPTEN_KEEPALIVE void GltfAssetLoader_createRenderThread(TEngine *tEngine, TMaterialProvider *tMaterialProvider, TNameComponentManager *tNameComponentManager, void (*callback)(TGltfAssetLoader *));
+        EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_createRenderThread(TEngine *tEngine, void (*callback)(TGltfResourceLoader *));
+        EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_destroyRenderThread(TEngine *tEngine, TGltfResourceLoader *tResourceLoader, uint32_t requestId, VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_loadResourcesRenderThread(TGltfResourceLoader *tGltfResourceLoader, TFilamentAsset *tFilamentAsset, void (*callback)(bool));
+        EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_addResourceDataRenderThread(TGltfResourceLoader *tGltfResourceLoader, const char *uri, uint8_t *data, size_t length, uint32_t requestId, VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_asyncBeginLoadRenderThread(TGltfResourceLoader *tGltfResourceLoader, TFilamentAsset *tFilamentAsset, void (*callback)(bool));
+        EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_asyncUpdateLoadRenderThread(TGltfResourceLoader *tGltfResourceLoader);
+        EMSCRIPTEN_KEEPALIVE void GltfResourceLoader_asyncGetLoadProgressRenderThread(TGltfResourceLoader *tGltfResourceLoader, void (*callback)(float));
 
-        void GltfAssetLoader_loadRenderThread(
+        EMSCRIPTEN_KEEPALIVE void GltfAssetLoader_loadRenderThread(
             TEngine *tEngine,
             TGltfAssetLoader *tAssetLoader,
             uint8_t *data,
@@ -312,8 +312,8 @@ namespace thermion
             uint8_t numInstances,
             void (*callback)(TFilamentAsset *)
         );
-        void Scene_addFilamentAssetRenderThread(TScene* tScene, TFilamentAsset *tAsset, uint32_t requestId, VoidCallback onComplete);
-        void Gizmo_createRenderThread(
+        EMSCRIPTEN_KEEPALIVE void Scene_addFilamentAssetRenderThread(TScene* tScene, TFilamentAsset *tAsset, uint32_t requestId, VoidCallback onComplete);
+        EMSCRIPTEN_KEEPALIVE void Gizmo_createRenderThread(
             TEngine *tEngine,
             TGltfAssetLoader *tAssetLoader,
             TGltfResourceLoader *tGltfResourceLoader,
@@ -330,4 +330,3 @@ namespace thermion
     }
 }
 #endif
-

thermion_dart/native/include/material/grid.S

@@ -8,5 +8,5 @@ GRID_PACKAGE:
 GRID_GRID_OFFSET:
     .int 0
 GRID_GRID_SIZE:
-    .int 50913
+    .int 49793
 

thermion_dart/native/include/material/grid.apple.S

@@ -8,5 +8,5 @@ _GRID_PACKAGE:
 _GRID_GRID_OFFSET:
     .int 0
 _GRID_GRID_SIZE:
-    .int 50913
+    .int 49793
 

thermion_dart/native/src/c_api/TGltfAssetLoader.cpp

@@ -85,10 +85,10 @@ EMSCRIPTEN_KEEPALIVE TFilamentAsset *GltfAssetLoader_load(
     const char *const *const resourceUris = asset->getResourceUris();
     const size_t resourceUriCount = asset->getResourceUriCount();
 
-    Log("glTF asset : %d resource URIs, %d instances", resourceUriCount, numInstances);
+    TRACE("Loading glTF asset with %d resource URIs (allocating %d reserved instances", resourceUriCount, numInstances);
 
     for(int i = 0; i < resourceUriCount; i++) {
-        Log("%s", resourceUris[i]);
+        TRACE("%s", resourceUris[i]);
     }
 
     return reinterpret_cast<TFilamentAsset *>(asset);

thermion_dart/pubspec.yaml

@@ -1,6 +1,6 @@
 name: thermion_dart
 description: 3D rendering toolkit for Dart.
-version: 0.3.2
+version: 0.3.3-pre
 homepage: https://thermion.dev
 repository: https://github.com/nmfisher/thermion
 

thermion_dart/test/helpers.dart

@@ -82,10 +82,6 @@ class TestHelper {
     testDir = Directory("${packageUri}test").path;
     outDir = Directory("$testDir/output/${dir}");
     outDir.createSync(recursive: true);
-    if (Platform.isMacOS) {
-      DynamicLibrary.open('${testDir}/generated/objective_c.dylib');
-      DynamicLibrary.open('${testDir}/generated/libThermionTextureSwift.dylib');
-    }
   }
 
   ///
@@ -226,6 +222,10 @@ class TestHelper {
 
     FFIRenderTarget? renderTarget;
     if (createRenderTarget) {
+    //   if (Platform.isMacOS) {
+    //   DynamicLibrary.open('${testDir}/generated/objective_c.dylib');
+    //   DynamicLibrary.open('${testDir}/generated/libThermionTextureSwift.dylib');
+    // }
       // var metalColorTexture = await createTexture(
       //     viewportDimensions.width, viewportDimensions.height);
       // var metalDepthTexture = await createTexture(

thermion_flutter/thermion_flutter/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.3-pre
+
+ - **DOCS**: replace thermion_flutter README with symlink to thermion_dart README.
+
 ## 0.3.2
 
  - Bump "thermion_flutter" to `0.3.2`.

thermion_flutter/thermion_flutter/README.md

@@ -1,63 +0,0 @@
-![Thermion Logo](https://raw.githubusercontent.com/nmfisher/flutter_filament/f19ea9b/docs/logo.png)
-
-<p align="center">
-  <a href="https://thermion.dev/quickstart">Quickstart (Flutter)</a> •
-  <a href="https://thermion.dev/quickstart">Documentation</a> •
-  <a href="https://thermion.dev/showcase">Showcase</a> •
-  <a href="https://dartpad.thermion.dev/">Playground</a> •
-  <a href="https://discord.gg/h2VdDK3EAQ">Discord</a>
-</p>
-
-## Cross-platform 3D engine for Dart and Flutter.
-
-<a href="https://pub.dev/packages/thermion_dart"><img src="https://img.shields.io/pub/v/thermion_dart?label=pub.dev&labelColor=333940&logo=dart&color=00589B" alt="pub"></a>
-<a href="https://github.com/nmfisher/thermion"><img src="https://img.shields.io/github/stars/nmfisher/flutter_filament?style=flat&label=stars&labelColor=333940&color=8957e5&logo=github" alt="github"></a>
-<a href="https://discord.gg/h2VdDK3EAQ"><img src="https://img.shields.io/discord/993167615587520602?logo=discord&logoColor=fff&labelColor=333940" alt="discord"></a>
-<a href="https://github.com/nmfisher/thermion"><img src="https://img.shields.io/github/contributors/nmfisher/flutter_filament?logo=github&labelColor=333940" alt="contributors"></a>
-
-### Quickstart (Flutter)
-
-```
-_thermionViewer = await ThermionFlutterPlugin.createViewer();
-
-// Geometry and models are represented as "entities". Here, we load a glTF
-// file containing a plain cube.
-// By default, all paths are treated as asset paths. To load from a file 
-// instead, use file:// URIs.
-var entity =
-    await _thermionViewer!.loadGlb("assets/cube.glb", keepData: true);
-
-// Thermion uses a right-handed coordinate system where +Y is up and -Z is
-// "into" the screen.
-// By default, the camera is located at (0,0,0) looking at (0,0,-1); this
-// would place it directly inside the cube we just loaded.
-//
-// Let's move the camera to (0,0,10) to ensure the cube is visible in the
-// viewport.
-await _thermionViewer!.setCameraPosition(0, 0, 10);
-
-// Without a light source, your scene will be totally black. Let's load a skybox
-// (a cubemap image that is rendered behind everything else in the scene)
-// and an image-based indirect light that has been precomputed from the same
-// skybox.
-await _thermionViewer!.loadSkybox("assets/default_env_skybox.ktx");
-await _thermionViewer!.loadIbl("assets/default_env_ibl.ktx");
-
-// Finally, you need to explicitly enable rendering. Setting rendering to
-// false is designed to allow you to pause rendering to conserve battery life
-await _thermionViewer!.setRendering(true);
-```
-
-and then in your Flutter application:
-```
- @override
-  Widget build(BuildContext context) {
-    return Stack(children: [
-      if (_thermionViewer != null)
-        Positioned.fill(
-            child: ThermionWidget(
-          viewer: _thermionViewer!,
-        )),
-    ]);
-  }
-```

thermion_flutter/thermion_flutter/README.md

@@ -0,0 +1 @@
+../../thermion_dart/README.md

thermion_flutter/thermion_flutter/pubspec.yaml

@@ -1,6 +1,6 @@
 name: thermion_flutter
 description: Flutter plugin for 3D rendering with the Thermion toolkit.
-version: 0.3.2
+version: 0.3.3-pre
 homepage: https://thermion.dev
 repository: https://github.com/nmfisher/thermion
 
@@ -17,10 +17,10 @@ dependencies:
   plugin_platform_interface: ^2.0.0
   ffi: ^2.1.2
   animation_tools_dart: ^0.1.0
-  thermion_dart: ^0.3.2
-  thermion_flutter_platform_interface: ^0.3.2
-  thermion_flutter_method_channel: ^0.3.2
-  thermion_flutter_web: ^0.3.2
+  thermion_dart: ^0.3.3-pre
+  thermion_flutter_platform_interface: ^0.3.3-pre
+  thermion_flutter_method_channel: ^0.3.3-pre
+  thermion_flutter_web: ^0.3.3-pre
   logging: ^1.2.0
   web: ^1.0.0
 

thermion_flutter/thermion_flutter_method_channel/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.3-pre
+
+ - **FEAT**: allow passing renderTargetColorTextureFormat via ThermionFlutterOptions.
+
 ## 0.3.2
 
  - Bump "thermion_flutter_method_channel" to `0.3.2`.

thermion_flutter/thermion_flutter_method_channel/lib/src/thermion_flutter_method_channel_platform.dart

@@ -212,7 +212,7 @@ class ThermionFlutterMethodChannelPlatform extends ThermionFlutterPlatform {
           TextureUsage.TEXTURE_USAGE_COLOR_ATTACHMENT,
           TextureUsage.TEXTURE_USAGE_SAMPLEABLE,
         },
-        textureFormat: TextureFormat.RGBA32F,
+        textureFormat: options.renderTargetColorTextureFormat,
         textureSamplerType: TextureSamplerType.SAMPLER_2D,
       );
       final depth = await FilamentApp.instance!.createTexture(
@@ -225,7 +225,7 @@ class ThermionFlutterMethodChannelPlatform extends ThermionFlutterPlatform {
           TextureUsage.TEXTURE_USAGE_STENCIL_ATTACHMENT
         },
         textureFormat:
-            TextureFormat.DEPTH24_STENCIL8, // TextureFormat.DEPTH32F,
+            options.renderTargetDepthTextureFormat,
         textureSamplerType: TextureSamplerType.SAMPLER_2D,
       );
 

thermion_flutter/thermion_flutter_method_channel/pubspec.yaml

@@ -1,7 +1,7 @@
 name: thermion_flutter_method_channel
 description: Desktop + mobile implementation for texture creation + registration with Flutter.
 repository: https://github.com/nmfisher/thermion_flutter/thermion_flutter
-version: 0.3.2
+version: 0.3.3-pre
 
 environment:
   sdk: ">=3.3.0 <4.0.0"
@@ -23,8 +23,8 @@ dependencies:
   flutter:
     sdk: flutter
   plugin_platform_interface: ^2.1.0
-  thermion_flutter_platform_interface: ^0.3.2
-  thermion_dart: ^0.3.2
+  thermion_flutter_platform_interface: ^0.3.3-pre
+  thermion_dart: ^0.3.3-pre
   logging: ^1.2.0
 dependency_overrides:
   thermion_dart:

thermion_flutter/thermion_flutter_platform_interface/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.3-pre
+
+ - **FEAT**: allow passing renderTargetColorTextureFormat via ThermionFlutterOptions.
+
 ## 0.3.2
 
  - Bump "thermion_flutter_platform_interface" to `0.3.2`.

thermion_flutter/thermion_flutter_platform_interface/lib/thermion_flutter_platform_interface.dart

@@ -7,13 +7,25 @@ import 'thermion_flutter_texture.dart';
 class ThermionFlutterOptions {
   final String? uberarchivePath;
   final Backend? backend;
+  
+  /// The format to use for the default render target color attachment.
+  /// Currently only applicable on iOS/macOS.
+  ///
+  final TextureFormat renderTargetColorTextureFormat;
+
+  /// The format to use for the default render target depth attachment.
+  /// Currently only applicable on iOS/macOS.
+  ///
+  final TextureFormat renderTargetDepthTextureFormat;
 
   const ThermionFlutterOptions(
-      {this.uberarchivePath = null, this.backend = null});
+      {this.uberarchivePath = null,
+      this.backend = null,
+      this.renderTargetColorTextureFormat = TextureFormat.RGBA32F,
+      this.renderTargetDepthTextureFormat = TextureFormat.DEPTH24_STENCIL8});
 }
 
 class ThermionFlutterWebOptions extends ThermionFlutterOptions {
-  
   final bool createCanvas;
   final bool importCanvasAsWidget;
 
@@ -22,8 +34,6 @@ class ThermionFlutterWebOptions extends ThermionFlutterOptions {
       this.createCanvas = true,
       String? uberarchivePath})
       : super(uberarchivePath: uberarchivePath);
-
-
 }
 
 abstract class ThermionFlutterPlatform extends PlatformInterface {
@@ -42,15 +52,11 @@ abstract class ThermionFlutterPlatform extends PlatformInterface {
     _options ??= const ThermionFlutterOptions();
     return _options!;
   }
-  
+
   ///
   ///
   ///
   void setOptions(covariant ThermionFlutterOptions options) {
-    if (_options != null) {
-      throw Exception(
-          "Options can only be set once for the entire app lifecycle.");
-    }
     _options = options;
   }
 

thermion_flutter/thermion_flutter_platform_interface/pubspec.yaml

@@ -1,7 +1,7 @@
 name: thermion_flutter_platform_interface
 description: A common platform interface for the thermion_flutter plugin.
 repository: https://github.com/nmfisher/thermion_flutter/thermion_flutter
-version: 0.3.2
+version: 0.3.3-pre
 
 environment:
   sdk: ">=3.3.0 <4.0.0"
@@ -11,7 +11,7 @@ dependencies:
   flutter:
     sdk: flutter
   plugin_platform_interface: ^2.1.0
-  thermion_dart: ^0.3.2
+  thermion_dart: ^0.3.3-pre
 
 dev_dependencies:
   flutter_test:

thermion_flutter/thermion_flutter_web/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.3.3-pre
+
+ - Bump "thermion_flutter_web" to `0.3.3-pre`.
+
 ## 0.3.2
 
  - **FIX**: add missing destroySwapchain argument for web.

thermion_flutter/thermion_flutter_web/pubspec.yaml

@@ -1,7 +1,7 @@
 name: thermion_flutter_web
 description: A web platform interface for the thermion_flutter plugin.
 repository: https://github.com/nmfisher/thermion_flutter/thermion_flutter
-version: 0.3.2
+version: 0.3.3-pre
 
 environment:
   sdk: ">=3.3.0 <4.0.0"
@@ -20,8 +20,8 @@ dependencies:
     sdk: flutter
   plugin_platform_interface: ^2.1.0
   web: ^1.0.0
-  thermion_dart: ^0.3.2
-  thermion_flutter_platform_interface: ^0.3.2
+  thermion_dart: ^0.3.3-pre
+  thermion_flutter_platform_interface: ^0.3.3-pre
   flutter_web_plugins:
     sdk: flutter
   logging: ^1.3.0