refactor

android/CMakeLists.txt

@@ -13,7 +13,7 @@ add_library(
             ../ios/src/ktxreader/Ktx1Reader.cpp
             src/main/cpp/StbProvider.cpp
             src/main/cpp/JobSystem.cpp
-            ../ios/src/SceneAssetLoader.cpp
+            ../ios/src/AssetManager.cpp
             ../ios/src/FilamentViewer.cpp
             ../ios/src/PolyvoxFilamentApi.cpp
             ../ios/src/StreamBufferAdapter.cpp

example/lib/main.dart

@@ -19,12 +19,12 @@ class MyApp extends StatefulWidget {
   State<MyApp> createState() => _MyAppState();
 }
 
-class _MyAppState extends State<MyApp> {
+class _MyAppState extends State<MyApp> with SingleTickerProviderStateMixin {
-  final FilamentController _filamentController = PolyvoxFilamentController();
+  late FilamentController _filamentController;
 
-  FilamentAsset? _cube;
+  FilamentEntity? _cube;
-  FilamentAsset? _flightHelmet;
+  FilamentEntity? _flightHelmet;
-  FilamentLight? _light;
+  FilamentEntity? _light;
 
   final weights = List.filled(255, 0.0);
   List<String> _targetNames = [];
@@ -37,6 +37,7 @@ class _MyAppState extends State<MyApp> {
   @override
   void initState() {
     super.initState();
+    _filamentController = FilamentController(this);
   }
 
   void onClick(int index) async {
@@ -45,7 +46,7 @@ class _MyAppState extends State<MyApp> {
         await _filamentController.initialize();
         break;
       case -2:
-        await _filamentController.render();
+        _filamentController.render();
         break;
       case -4:
         setState(() {
@@ -61,55 +62,48 @@ class _MyAppState extends State<MyApp> {
         break;
 
       case 0:
-        await _filamentController.setBackgroundImage('assets/background.ktx');
+        _filamentController.setBackgroundImage('assets/background.ktx');
         break;
       case 1:
-        await _filamentController
+        _filamentController
             .loadSkybox('assets/default_env/default_env_skybox.ktx');
         break;
       case -3:
-        await _filamentController
+        _filamentController.loadIbl('assets/default_env/default_env_ibl.ktx');
-            .loadIbl('assets/default_env/default_env_ibl.ktx');
         break;
       case 2:
-        await _filamentController.removeSkybox();
+        _filamentController.removeSkybox();
         break;
       case 3:
-        _cube = await _filamentController.loadGlb('assets/cube.glb');
+        _cube = _filamentController.loadGlb('assets/cube.glb');
-
+        _animationNames = _filamentController.getAnimationNames(_cube!);
-        _animationNames = await _filamentController.getAnimationNames(_cube!);
         break;
 
       case 4:
         if (_cube != null) {
-          await _filamentController.removeAsset(_cube!);
+          _filamentController.removeAsset(_cube!);
         }
-        _cube =
+        _cube = _filamentController.loadGltf('assets/cube.gltf', 'assets');
-            await _filamentController.loadGltf('assets/cube.gltf', 'assets');
-        print(await _filamentController.getAnimationNames(_cube!));
         break;
       case 5:
-        if (_flightHelmet == null) {
+        _flightHelmet ??= _filamentController.loadGltf(
-          _flightHelmet = await _filamentController.loadGltf(
+            'assets/FlightHelmet/FlightHelmet.gltf', 'assets/FlightHelmet');
-              'assets/FlightHelmet/FlightHelmet.gltf', 'assets/FlightHelmet');
-        }
         break;
       case 6:
-        await _filamentController.removeAsset(_cube!);
+        _filamentController.removeAsset(_cube!);
         break;
 
       case 7:
-        await _filamentController.setMorphTargetWeights(
+        _filamentController.setMorphTargetWeights(_cube!, List.filled(8, 1.0));
-            _cube!, List.filled(8, 1.0));
         break;
       case 8:
-        await _filamentController.setMorphTargetWeights(
+        _filamentController.setMorphTargetWeights(_cube!, List.filled(8, 0));
-            _cube!, List.filled(8, 0));
         break;
       case 9:
-        _filamentController.playAnimations(
+        for (int i = 0; i < _animationNames.length; i++) {
-            _cube!, List.generate(_animationNames.length, (i) => i),
+          _filamentController.playAnimation(_cube!, i, loop: _loop);
-            loop: _loop);
+        }
+
         break;
       case 10:
         _filamentController.stopAnimation(_cube!, 0);
@@ -145,39 +139,38 @@ class _MyAppState extends State<MyApp> {
         // _filamentController.setAnimation(_cube!, animation);
         break;
       case 16:
-        _targetNames =
+        _targetNames = _filamentController.getMorphTargetNames(_cube!, "Cube");
-            await _filamentController.getMorphTargetNames(_cube!, "Cube");
         setState(() {});
         break;
       case 17:
-        _animationNames = await _filamentController.getAnimationNames(_cube!);
+        _animationNames = _filamentController.getAnimationNames(_cube!);
         setState(() {});
 
         break;
       case 18:
-        await _filamentController.panStart(1, 1);
+        _filamentController.panStart(1, 1);
-        await _filamentController.panUpdate(1, 2);
+        _filamentController.panUpdate(1, 2);
-        await _filamentController.panEnd();
+        _filamentController.panEnd();
         break;
       case 19:
-        await _filamentController.panStart(1, 1);
+        _filamentController.panStart(1, 1);
-        await _filamentController.panUpdate(0, 0);
+        _filamentController.panUpdate(0, 0);
-        await _filamentController.panEnd();
+        _filamentController.panEnd();
         break;
       case 20:
-        await _filamentController.clearAssets();
+        _filamentController.clearAssets();
         break;
       case 21:
-        await _filamentController.setTexture(_cube!, "assets/background.png");
+        _filamentController.setTexture(_cube!, "assets/background.png");
         break;
       case 22:
-        await _filamentController.transformToUnitCube(_cube!);
+        _filamentController.transformToUnitCube(_cube!);
         break;
       case 23:
-        await _filamentController.setPosition(_cube!, 1.0, 1.0, -1.0);
+        _filamentController.setPosition(_cube!, 1.0, 1.0, -1.0);
         break;
       case 24:
-        await _filamentController.setRotation(_cube!, pi / 2, 0.0, 1.0, 0.0);
+        _filamentController.setRotation(_cube!, pi / 2, 0.0, 1.0, 0.0);
         break;
       case 25:
         setState(() {
@@ -185,35 +178,34 @@ class _MyAppState extends State<MyApp> {
         });
         break;
       case 26:
-        await _filamentController.setCameraPosition(0, 0, 3);
+        _filamentController.setCameraPosition(0, 0, 3);
-        await _filamentController.setCameraRotation(0, 0, 1, 0);
+        _filamentController.setCameraRotation(0, 0, 1, 0);
         break;
       case 27:
         _framerate = _framerate == 60 ? 30 : 60;
-        await _filamentController.setFrameRate(_framerate);
+        _filamentController.setFrameRate(_framerate);
         break;
       case 28:
-        await _filamentController.setBackgroundImagePosition(25, 25);
+        _filamentController.setBackgroundImagePosition(25, 25);
         break;
       case 29:
-        _light = await _filamentController.addLight(
+        _light = _filamentController.addLight(
             1, 6500, 15000000, 0, 1, 0, 0, -1, 0, true);
-        _light = await _filamentController.addLight(
+        _light = _filamentController.addLight(
             2, 6500, 15000000, 0, 0, 1, 0, 0, -1, true);
         break;
       case 30:
         if (_light != null) {
-          await _filamentController.removeLight(_light!);
+          _filamentController.removeLight(_light!);
         }
         break;
       case 31:
-        await _filamentController.clearLights();
+        _filamentController.clearLights();
         break;
       case 32:
-        await _filamentController
+        _filamentController.setCameraModelMatrix(List<double>.filled(16, 1.0));
-            .setCameraModelMatrix(List<double>.filled(16, 1.0));
 
-        // await _filamentController.setBoneTransform(
+        //  _filamentController.setBoneTransform(
         //     _cube!,
         //     "Bone.001",
         //     "Cube.001",

example/linux/CMakeLists.txt

@@ -41,7 +41,7 @@ endif()
 # of modifying this function.
 function(APPLY_STANDARD_SETTINGS TARGET)
   target_compile_features(${TARGET} PUBLIC cxx_std_14)
-  target_compile_options(${TARGET} PRIVATE -Wall -Werror -Wno-unused-function)
+  target_compile_options(${TARGET} PRIVATE -Wall -Werror -Wno-unused-function -Wno-unused-variable)
   target_compile_options(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:-O3>")
   target_compile_definitions(${TARGET} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:NDEBUG>")
 endfunction()

ios/include/AssetManager.hpp

@@ -0,0 +1,95 @@
+#pragma once
+
+#include <filament/Scene.h>
+
+#include <gltfio/AssetLoader.h>
+#include <gltfio/FilamentAsset.h>
+#include <gltfio/ResourceLoader.h>
+
+#include "ResourceManagement.hpp"
+#include "SceneAsset.hpp"
+#include "ResourceBuffer.hpp"
+
+typedef int32_t EntityId;
+
+namespace polyvox {
+    using namespace filament;
+    using namespace filament::gltfio;
+
+    class AssetManager {
+        public:
+            AssetManager(LoadResource loadResource,
+                        FreeResource freeResource,
+                        NameComponentManager *ncm, 
+                        Engine *engine,
+                        Scene *scene);
+            ~AssetManager();
+            EntityId loadGltf(const char* uri, const char* relativeResourcePath);
+            EntityId loadGlb(const char* uri, bool unlit);
+            FilamentAsset* getAssetByEntityId(EntityId entityId);
+            void remove(EntityId entity);
+            void destroyAll();
+            unique_ptr<vector<string>> getAnimationNames(EntityId entity);
+            unique_ptr<vector<string>> getMorphTargetNames(EntityId entity, const char *meshName);
+            void transformToUnitCube(EntityId e);
+            inline void updateTransform(EntityId e);
+            void setScale(EntityId e, float scale);
+            void setPosition(EntityId e, float x, float y, float z);
+            void setRotation(EntityId e, float rads, float x, float y, float z);
+            const utils::Entity *getCameraEntities(EntityId e);
+            size_t getCameraEntityCount(EntityId e);
+            const utils::Entity* getLightEntities(EntityId e) const noexcept;
+            size_t getLightEntityCount(EntityId e) const noexcept;
+            void updateAnimations();
+
+            bool setBoneAnimationBuffer(
+                EntityId entity,
+                int length,
+                const char** const boneNames,
+                const char** const meshNames,
+                const float* const frameData,
+                int numFrames, 
+                float frameLengthInMs);
+            bool setMorphAnimationBuffer(
+                EntityId entity, 
+                const char* entityName, 
+                const float* const morphData,     
+                int numMorphWeights, 
+                int numFrames, 
+                float frameLengthInMs);
+            void playAnimation(EntityId e, int index, bool loop, bool reverse);
+            void stopAnimation(EntityId e, int index);
+            void setMorphTargetWeights(const char* const entityName, float *weights, int count);
+            void loadTexture(EntityId entity, const char* resourcePath, int renderableIndex);
+            void setAnimationFrame(EntityId entity, int animationIndex, int animationFrame);
+            
+        private:
+            LoadResource _loadResource;
+            FreeResource _freeResource;
+            AssetLoader* _assetLoader = nullptr;
+            ResourceLoader* _resourceLoader = nullptr;
+            NameComponentManager* _ncm = nullptr;
+            Engine* _engine;
+            Scene* _scene;
+            MaterialProvider* _unlitProvider = nullptr;
+            MaterialProvider* _ubershaderProvider = nullptr;
+            gltfio::ResourceLoader* _gltfResourceLoader = nullptr;
+            gltfio::TextureProvider* _stbDecoder = nullptr;
+            tsl::robin_map<EntityId, SceneAsset> _assets;
+  
+            void setBoneTransform(
+              FilamentInstance* instance,
+                vector<BoneAnimationData> animations,
+                int frameNumber
+            );
+
+            utils::Entity findEntityByName(
+                SceneAsset asset, 
+                const char* entityName
+            );
+            
+            inline void updateTransform(SceneAsset asset);
+
+
+    };
+}

ios/include/FilamentViewer.hpp

@@ -31,17 +31,16 @@
 #include <string>
 #include <chrono>
 
-#include "SceneAssetLoader.hpp"
+#include "AssetManager.hpp"
-#include "SceneAsset.hpp"
 #include "ResourceManagement.hpp"
 
 using namespace std;
 using namespace filament;
 using namespace filament::math;
 using namespace gltfio;
-using namespace utils;
 using namespace camutils;
 
+typedef int32_t EntityId;
 
 namespace polyvox {
     class FilamentViewer {
@@ -56,9 +55,7 @@ namespace polyvox {
             void loadIbl(const char* const iblUri, float intensity);
             void removeIbl();
             
-            SceneAsset* loadGlb(const char* const uri, bool unlit);
+            void removeAsset(EntityId asset);
-            SceneAsset* loadGltf(const char* const uri, const char* relativeResourcePath);
-            void removeAsset(SceneAsset* asset);
             // removes all add assets from the current scene
             void clearAssets();
 
@@ -66,8 +63,7 @@ namespace polyvox {
             void render(uint64_t frameTimeInNanos);
             void setFrameInterval(float interval);
             
-            bool setFirstCamera(SceneAsset* asset);
+            bool setCamera(EntityId asset, const char* nodeName);
-            bool setCamera(SceneAsset* asset, const char* nodeName);
             
             void createSwapChain(void* surface, uint32_t width, uint32_t height);
             void destroySwapChain();
@@ -95,9 +91,13 @@ namespace polyvox {
             void scrollEnd();
 
             int32_t addLight(LightManager::Type t, float colour, float intensity, float posX, float posY, float posZ, float dirX, float dirY, float dirZ, bool shadows);
-            void removeLight(int32_t entityId);
+            void removeLight(EntityId entityId);
             void clearLights();
 
+            AssetManager* const getAssetManager() {
+                return (AssetManager* const) _assetManager;
+            }
+
         private:
             void createImageRenderable();
             void loadResources(std::string relativeResourcePath);
@@ -124,24 +124,18 @@ namespace polyvox {
     
             SwapChain* _swapChain = nullptr;
 
-            vector<SceneAsset*> _assets;
+            AssetManager* _assetManager = nullptr;
-
+            
-            SceneAssetLoader* _ubershaderAssetLoader;
+            NameComponentManager* _ncm = nullptr;
-            SceneAssetLoader* _unlitAssetLoader;
+            
-            NameComponentManager* _ncm;
             std::mutex mtx; // mutex to ensure thread safety when removing assets
 
-            vector<Entity> _lights;
+            vector<utils::Entity> _lights;
             Texture* _skyboxTexture = nullptr;
             Skybox* _skybox = nullptr;
             Texture* _iblTexture = nullptr;
             IndirectLight* _indirectLight = nullptr;
 
-            MaterialProvider* _ubershaderProvider = nullptr;
-            MaterialProvider* _unlitProvider = nullptr;
-
-            gltfio::ResourceLoader* _resourceLoader = nullptr;
-            gltfio::TextureProvider* _stbDecoder = nullptr;
             bool _recomputeAabb = false;
 
             bool _actualSize = false;     
@@ -156,7 +150,7 @@ namespace polyvox {
             uint32_t _imageWidth = 0;
             mat4f _imageScale;
             Texture* _imageTexture = nullptr;
-            Entity* _imageEntity = nullptr;
+            utils::Entity* _imageEntity = nullptr;
             VertexBuffer* _imageVb = nullptr;
             IndexBuffer* _imageIb = nullptr;
             Material* _imageMaterial = nullptr;

ios/include/PolyvoxFilamentApi.h

@@ -7,111 +7,104 @@
 
 typedef struct ResourceBuffer ResourceBuffer;
 
-/// 
+typedef int32_t EntityId;
-/// Frame data for animating multiples bones for multiple meshes.
+
-/// [data]
+///
+/// struct to facilitate passing bone animation frame data between Dart/native.
 ///
 
-struct BoneAnimation {
+void* create_filament_viewer(void *context, ResourceBuffer (*loadResource)(const char *), void (*freeResource)(uint32_t));
-    const char* const* const boneNames;
+void delete_filament_viewer(void *viewer);
-    const char* const* const meshNames;
+void* get_asset_manager(void* viewer);
-    const float* const data;
+void create_render_target(void *viewer, uint32_t textureId, uint32_t width, uint32_t height);
-    size_t numBones;
+void clear_background_image(void *viewer);
-    size_t numMeshTargets;
+void set_background_image(void *viewer, const char *path);
-};
+void set_background_image_position(void *viewer, float x, float y, bool clamp);
+void set_background_color(void *viewer, const float r, const float g, const float b, const float a);
+void load_skybox(void *viewer, const char *skyboxPath);
+void load_ibl(void *viewer, const char *iblPath, float intensity);
+void remove_skybox(void *viewer);
+void remove_ibl(void *viewer);
+EntityId add_light(void *viewer, uint8_t type, float colour, float intensity, float posX, float posY, float posZ, float dirX, float dirY, float dirZ, bool shadows);
+void remove_light(void *viewer, EntityId entityId);
+void clear_lights(void *viewer);
+EntityId load_glb(void *assetManager, const char *assetPath, bool unlit);
+EntityId load_gltf(void *assetManager, const char *assetPath, const char *relativePath);
+bool set_camera(void *viewer, EntityId asset, const char *nodeName);
+void render(void *viewer, uint64_t frameTimeInNanos);
+void create_swap_chain(void *viewer, void *surface, uint32_t width, uint32_t height);
+void destroy_swap_chain(void *viewer);
+void set_frame_interval(void *viewer, float interval);
+void* get_renderer(void *viewer);
+void update_viewport_and_camera_projection(void *viewer, int width, int height, float scaleFactor);
+void scroll_begin(void *viewer);
+void scroll_update(void *viewer, float x, float y, float z);
+void scroll_end(void *viewer);
 
-typedef struct BoneAnimation BoneAnimation;
+void grab_begin(void *viewer, float x, float y, bool pan);
+void grab_update(void *viewer, float x, float y);
+void grab_end(void *viewer);
 
-
+void apply_weights(
-void* filament_viewer_new(void* context, ResourceBuffer (*loadResource)(const char*), void (*freeResource)(uint32_t));
+    void* assetManager,
-void filament_viewer_delete(void* viewer);
+    EntityId asset, 
-void create_render_target(void* viewer, uint32_t textureId, uint32_t width, uint32_t height);
+    const char *const entityName, 
-void clear_background_image(void* viewer);
+    float *const weights, 
-void set_background_image(void* viewer, const char* path);
+    int count
-void set_background_image_position(void* viewer, float x, float y, bool clamp);
-void set_background_color(void* viewer, const float r, const float g, const float b, const float a);
-
-void load_skybox(void* viewer, const char* skyboxPath);
-void load_ibl(void* viewer, const char* iblPath, float intensity);
-void remove_skybox(void* viewer);
-void remove_ibl(void* viewer);
-int32_t add_light(void* viewer, uint8_t type, float colour, float intensity, float posX, float posY, float posZ, float dirX, float dirY, float dirZ, bool shadows);
-void remove_light(void* viewer, int32_t entityId);
-void clear_lights(void* viewer);
-void* load_glb(void* viewer, const char* assetPath, bool unlit);
-void* load_gltf(void* viewer, const char* assetPath, const char* relativePath);
-bool set_camera(void* viewer, void* asset, const char* nodeName);
-void render(void* viewer, uint64_t frameTimeInNanos);
-void create_swap_chain(void* viewer, void* surface, uint32_t width, uint32_t height);
-void destroy_swap_chain(void* viewer);
-void set_frame_interval(void* viewer, float interval);
-void* get_renderer(void* viewer);
-void update_viewport_and_camera_projection(void* viewer, int width, int height, float scaleFactor);
-
-void scroll_begin(void* viewer);
-void scroll_update(void* viewer, float x, float y , float z);
-void scroll_end(void* viewer);
-    
-void grab_begin(void* viewer, float x, float y, bool pan);
-void grab_update(void* viewer, float x, float y);
-void grab_end(void* viewer);
-
-void apply_weights(void* asset, const char* const entityName, float* const weights, int count);
-    
-void set_animation(
-    void* asset, 
-    const char* const entityName,
-    const float* const morphData, 
-    int numMorphWeights, 
-    const BoneAnimation* const boneAnimations,
-    int numBoneAnimations,
-    int numFrames, 
-    float frameLengthInMs
 );
 
+void set_morph_animation(
+    void* assetManager,
+    EntityId asset,
+    const char *const entityName,
+    const float *const morphData,
+    int numMorphWeights,
+    int numFrames,
+    float frameLengthInMs);
+
+ void set_bone_animation(
+    void* assetManager,
+    EntityId asset, 
+    int length,
+    const char** const boneNames,
+    const char** const meshNames,
+    const float* const frameData,
+    int numFrames, 
+    float frameLengthInMs);
+
 // void set_bone_transform(
-//     void* asset, 
+//     EntityId asset,
-//     const char* boneName, 
+//     const char* boneName,
 //     const char* entityName,
-//     float transX, 
+//     float transX,
-//     float transY, 
+//     float transY,
-//     float transZ, 
+//     float transZ,
 //     float quatX,
 //     float quatY,
 //     float quatZ,
 //     float quatW
 // );
-    
-void play_animation(void* asset, int index, bool loop, bool reverse);
-void set_animation_frame(void* asset, int animationIndex, int animationFrame);
-void stop_animation(void* asset, int index);
 
-int get_animation_count(void* asset);
+void play_animation(void* assetManager, EntityId asset, int index, bool loop, bool reverse);
-    
+void set_animation_frame(void* assetManager, EntityId asset, int animationIndex, int animationFrame);
-void get_animation_name(void* asset, char* const outPtr, int index);
+void stop_animation(void* assetManager, EntityId asset, int index);
+int get_animation_count(void* assetManager, EntityId asset);
+void get_animation_name(void* assetManager, EntityId asset, char *const outPtr, int index);
+void get_morph_target_name(void* assetManager, EntityId asset, const char *meshName, char *const outPtr, int index);
+int get_morph_target_name_count(void* assetManager, EntityId asset, const char *meshName);
+void remove_asset(void *viewer, EntityId asset);
+void clear_assets(void *viewer);
+void load_texture(void* assetManager, EntityId asset, const char *assetPath, int renderableIndex);
+void set_texture(void* assetManager, EntityId asset);
+void transform_to_unit_cube(void* assetManager, EntityId asset);
+void set_position(void* assetManager, EntityId asset, float x, float y, float z);
+void set_rotation(void* assetManager, EntityId asset, float rads, float x, float y, float z);
+void set_scale(void* assetManager, EntityId asset, float scale);
+void set_camera_exposure(void *viewer, float aperture, float shutterSpeed, float sensitivity);
+void set_camera_position(void *viewer, float x, float y, float z);
+void set_camera_rotation(void *viewer, float rads, float x, float y, float z);
+void set_camera_model_matrix(void *viewer, const float *const matrix);
+void set_camera_focal_length(void *viewer, float focalLength);
+void set_camera_focus_distance(void *viewer, float focusDistance);
 
-void get_morph_target_name(void* asset, const char* meshName, char* const outPtr, int index );
-
-int get_morph_target_name_count(void* asset, const char* meshName);
-    
-void remove_asset(void* viewer, void* asset);
-    
-void clear_assets(void* viewer);
-    
-void load_texture(void* asset, const char* assetPath, int renderableIndex);
-void set_texture(void* asset);
-    
-void transform_to_unit_cube(void* asset);
-    
-void set_position(void* asset, float x, float y, float z);
-void set_rotation(void* asset, float rads, float x, float y, float z);
-void set_scale(void* asset, float scale);
-
-void set_camera_exposure(void* viewer, float aperture, float shutterSpeed, float sensitivity);
-void set_camera_position(void* viewer, float x, float y, float z);
-void set_camera_rotation(void* viewer, float rads, float x, float y, float z);
-void set_camera_model_matrix(void* viewer, const float* const matrix);
-void set_camera_focal_length(void* viewer, float focalLength);
-void set_camera_focus_distance(void* viewer, float focusDistance);
-      
 #endif

ios/include/PolyvoxFilamentIOSApi.h

@@ -1,2 +1,2 @@
-void* filament_viewer_new_ios(void* texture, void* loadResource, void* freeResource, void* resources);
+void* create_filament_viewer_ios(void* texture, void* loadResource, void* freeResource, void* resources);
 

ios/include/ResourceManagement.hpp

@@ -15,7 +15,7 @@ namespace polyvox {
     // 
     // Typedef for a function that loads a resource into a ResourceBuffer from an asset URI.
     //
-    using LoadResource = function<ResourceBuffer(const char* uri)>;
+    using LoadResource = function<ResourceBuffer(const char* uri)>; 
 
     // 
     // Typedef for a function that frees an ID associated with a ResourceBuffer.

ios/include/SceneAsset.hpp

@@ -11,14 +11,12 @@
 #include <math/mat3.h>
 #include <math/norm.h>
 
+#include <gltfio/Animator.h>
 #include <gltfio/AssetLoader.h>
-#include <gltfio/FilamentAsset.h>
 #include <gltfio/ResourceLoader.h>
-
 #include <utils/NameComponentManager.h>
 
 #include "ResourceManagement.hpp"
-#include "SceneAssetAnimation.hpp"
 
 extern "C" {
     #include "PolyvoxFilamentApi.h"
@@ -30,121 +28,88 @@ namespace polyvox {
     using namespace utils;
     using namespace std;
 
-    class SceneAsset {
+    typedef std::chrono::time_point<std::chrono::high_resolution_clock> time_point_t;   
-        friend class SceneAssetLoader;
-        public:
-            SceneAsset(FilamentAsset* asset, Engine* engine, NameComponentManager* ncm, LoadResource loadResource, FreeResource freeResource);
-            ~SceneAsset();
-
-            unique_ptr<vector<string>> getMorphTargetNames(const char* meshName);
-            unique_ptr<vector<string>> getAnimationNames();
-
-            ///
-            ///
-            ///
-            void loadTexture(const char* resourcePath, int renderableIndex);
-            void setTexture();
-
-            ///
-            /// Update the bone/morph target animations to reflect the current frame (if applicable).
-            ///
-            void updateAnimations();
-
-            ///
-            /// Immediately stop the animation at the specified index. Noop if no animation is playing.
-            ///
-            void stopAnimation(int index);
-
-            ///  
-            /// Play the embedded animation (i.e. animation node embedded in the GLTF asset) under the specified index. If [loop] is true, the animation will repeat indefinitely.
-            ///
-            void playAnimation(int index, bool loop, bool reverse);
-
-            void setAnimationFrame(int animationIndex, int animationFrame);
-
-            ///
-            /// Set the weights for all [count] morph targets in this asset's entity named [inst] to [weights].
-            /// See [setAnimation] if you want to do the same across a number of frames (and extended to bone transforms).
-            ///
-            void setMorphTargetWeights(const char* const entityName, float* weights, int count);
-
-            ///
-            /// Animates the asset's morph targets/bone transforms according to the frame weights/transforms specified in [morphData]/[boneData].
-            ///  The duration of each "frame" is specified by [frameLengthInMs] (i.e. this is not the framerate of the renderer).
-            /// [morphData] is a contiguous chunk of floats whose length will be (numMorphWeights * numFrames).
-            /// [boneData] is a contiguous chunk of floats whose length will be (numBones * 7 * numFrames) (where 7 is 3 floats for translation, 4 for quat rotation).
-            /// [morphData] and [boneData] will both be copied, so remember to free these after calling this function.
-            ///
-            void setAnimation(
-                const char* entityName,
-                const float* const morphData,
-                int numMorphWeights, 
-                const BoneAnimation* const targets,
-                int numBoneAnimations,
-                int numFrames, 
-                float frameLengthInMs
-            );
-
-            size_t getBoneIndex(const char* name);
-            
-            Entity getNode(const char* name);
-
-            void transformToUnitCube();
-
-            void setScale(float scale);
-
-            void setPosition(float x, float y, float z);
-            
-            void setRotation(float rads, float x, float y, float z);         
-
-            const utils::Entity* getCameraEntities();
-
-            size_t getCameraEntityCount();
-
-            const Entity* getLightEntities() const noexcept;
-
-            size_t getLightEntityCount() const noexcept;
-
-
-        private:
-
-            FilamentAsset* _asset = nullptr;
-            Engine* _engine = nullptr;
-            NameComponentManager* _ncm;
-
-            void setBoneTransform(
-                uint8_t skinIndex,
-                const vector<uint8_t>& boneIndices,
-                const vector<Entity>& targets, 
-                const vector<float> data,
-                int frameNumber
-            );
-
-            void updateRuntimeAnimation();
-
-            void updateEmbeddedAnimations();
-
-            Animator* _animator;
-            
-            // animation flags;
-            unique_ptr<RuntimeAnimation> _runtimeAnimationBuffer;
-            vector<GLTFAnimation> _embeddedAnimationStatus;
-
-            LoadResource _loadResource;
-            FreeResource _freeResource;
-
-            // a slot to preload textures
-            filament::Texture* _texture = nullptr;
-
-            // initialized to identity
-            math::mat4f _position;
-            
-            // initialized to identity
-            math::mat4f _rotation;
-            
-            float _scale = 1;
-
-            void updateTransform();
 
+    struct AnimationStatus {
+        time_point_t mStart = time_point_t::max();
+        bool mLoop = false;
+        bool mReverse = false;
+        float mDuration = 0;
+        int mFrameNumber = -1;
     };
+
+        // 
+    // Use this to manually construct a buffer of frame data for morph animations.
+    //
+    struct MorphAnimationBuffer {
+        utils::EntityInstance<RenderableManager>* mInstance = nullptr;
+        int mNumFrames = -1;
+        float mFrameLengthInMs = 0;
+        vector<float> mFrameData;
+        int mNumMorphWeights = 0;
+    };
+
+    ///
+    /// Frame data for the bones/meshes specified by [mBoneIndices] and [mMeshTargets].
+    /// This is mainly used as a wrapper for animation data being transferred from the Dart to the native side.
+    ///
+    struct BoneAnimationData {
+        size_t skinIndex = 0;
+        uint8_t mBoneIndex;
+        utils::Entity mMeshTarget;
+        vector<float> mFrameData;
+    };
+
+    // 
+    // Use this to manually construct a buffer of frame data for bone animations.
+    //
+    struct BoneAnimationBuffer {
+        int mNumFrames = -1;
+        float mFrameLengthInMs = 0;
+        vector<BoneAnimationData> mAnimations;
+    };
+
+    struct SceneAsset {
+        
+        FilamentAsset* mAsset = nullptr;
+        Animator* mAnimator = nullptr;
+
+        // animation flags;
+        bool mAnimating = false;
+
+        // fixed-sized vector containing the status of the morph, bone and GLTF animations.
+        // entries 0 and 1 are the morph/bone animations.
+        // subsequent entries are the GLTF animations.
+        vector<AnimationStatus> mAnimations;
+
+        MorphAnimationBuffer mMorphAnimationBuffer;
+        BoneAnimationBuffer mBoneAnimationBuffer;
+
+        // a slot to preload textures
+        filament::Texture* mTexture = nullptr;
+
+        // initialized to identity
+        math::mat4f mPosition;
+        
+        // initialized to identity
+        math::mat4f mRotation;
+            
+        float mScale = 1;
+
+        SceneAsset(
+            FilamentAsset* asset
+        ) : mAsset(asset) {
+
+            mAnimator = mAsset->getInstance()->getAnimator();
+
+            mAnimations.resize(2 + mAnimator->getAnimationCount());
+            
+            for(int i=2; i < mAnimations.size(); i++) {
+                mAnimations[i].mDuration = mAnimator->getAnimationDuration(i-2);
+            }
+        }
+    };
+
 }
+
+    

ios/include/SceneAssetAnimation.hpp

@@ -1,118 +0,0 @@
-#ifndef SCENE_ASSET_ANIMATION_H_
-#define SCENE_ASSET_ANIMATION_H_
-
-#include "utils/Entity.h"
-#include <filament/RenderableManager.h>
-
-namespace polyvox {
-    
-    using namespace std;
-    
-    using Instance = utils::EntityInstance<filament::RenderableManager>;
-
-    typedef std::chrono::time_point<std::chrono::high_resolution_clock> time_point_t;   
-
-    // 
-    // Holds the current state of a GLTF animation. 
-    // Whenever a SceneAsset is created, an instance of GLTFAnimation will be created for every embedded animation.
-    // On each frame loop, we check if [play] is true, and if so, advance the animation to the correct frame based on [startedAt].
-    // The [GLTFAnimation] will persist for the lifetime of the SceneAsset.
-    //
-    struct GLTFAnimation  {        
-      GLTFAnimation(bool loop, bool reverse) : loop(loop), reverse(reverse) {}
-
-      // 
-      // A flag that is checked each frame to determine whether or not the animation should play.
-      //
-      bool play = false;
-
-      //
-      // If [play] is true, this flag will be checked when the animation is complete. If true, the animation will restart.
-      //
-      bool loop = false;
-
-      //
-      // If true, the animation will be played in reverse.
-      //
-      bool reverse = false;
-      
-      // 
-      // If [play] is true, this flag will be set to true when the animation is started.
-      // 
-      bool started = false;
-      
-      //
-      // The index of the animation in the GLTF asset.
-      //
-      int animationIndex = -1;
-      
-      //
-      // The time point at which this animation was last started.
-      // This is used to calculate the "animation time offset" that is passed to the Animator.
-      //
-      time_point_t startedAt;
-
-    };
-
-    ///
-    /// Holds a single set of frame data that may be used to animate multiple bones/meshes.
-    ///
-    struct BoneTransformTarget {
-
-        size_t skinIndex = 0;
-        unique_ptr<vector<uint8_t>> mBoneIndices;
-        unique_ptr<vector<utils::Entity>> mMeshTargets;
-        unique_ptr<vector<float>> mBoneData;
-
-        BoneTransformTarget(
-          unique_ptr<vector<uint8_t>>& boneIndices,
-          unique_ptr<vector<utils::Entity>>& meshTargets,
-          unique_ptr<vector<float>>& boneData) : mBoneIndices(move(boneIndices)), mMeshTargets(move(meshTargets)), mBoneData(move(boneData)) {}
-
-    };
-
-    // 
-    // An animation created by manually passing frame data for morph weights/bone transforms.
-    //
-    struct RuntimeAnimation {
-
-      Instance mInstance;
-
-      int frameNumber = -1;
-      int mNumFrames = -1;
-      float mFrameLengthInMs = 0;
-      time_point_t startTime;
-
-      
-      float* mMorphFrameData = nullptr;
-      int mNumMorphWeights = 0;
-
-      unique_ptr<vector<BoneTransformTarget>> mTargets;
-      
-      RuntimeAnimation(Instance instance,
-                       const float* const morphData,
-                       int numMorphWeights,
-                       unique_ptr<vector<BoneTransformTarget>>& targets,
-                       int numFrames,
-                       float frameLengthInMs) : 
-                       mInstance(instance),
-                       mNumFrames(numFrames), 
-                       mFrameLengthInMs(frameLengthInMs), 
-                       mNumMorphWeights(numMorphWeights),
-                      mTargets(move(targets)) {
-
-        if(numMorphWeights > 0) {
-          size_t morphSize = numMorphWeights * mNumFrames * sizeof(float);
-          mMorphFrameData = (float*)malloc(morphSize);
-          memcpy(mMorphFrameData, morphData, morphSize);
-        }
-      }
-
-      ~RuntimeAnimation() {
-        delete(mMorphFrameData);
-      }
-    };
-    
-}
-
-#endif

ios/include/SceneAssetLoader.hpp

@@ -1,47 +0,0 @@
-#pragma once
-
-#include <filament/Scene.h>
-
-#include <gltfio/AssetLoader.h>
-#include <gltfio/FilamentAsset.h>
-#include <gltfio/ResourceLoader.h>
-
-#include "ResourceManagement.hpp"
-#include "SceneAsset.hpp"
-#include "ResourceBuffer.hpp"
-
-namespace polyvox {
-    using namespace filament;
-    using namespace filament::gltfio;
-    using namespace utils;
-
-    class SceneAssetLoader {
-        public:
-            SceneAssetLoader(
-                LoadResource loadResource, 
-                FreeResource freeResource, 
-                MaterialProvider* materialProvider,
-                EntityManager* entityManager,
-                ResourceLoader* resourceLoader,
-                NameComponentManager* ncm,
-                Engine* engine,
-                Scene* scene);
-            ~SceneAssetLoader();
-            SceneAsset* fromGltf(const char* uri, const char* relativeResourcePath);
-            SceneAsset* fromGlb(const char* uri);
-            void remove(SceneAsset* asset);
-            void destroyAll();
-
-        private:
-            LoadResource _loadResource;
-            FreeResource _freeResource;
-            AssetLoader* _assetLoader;
-            ResourceLoader* _resourceLoader;
-            NameComponentManager* _ncm;
-            Engine* _engine;
-            Scene* _scene;
-
-            vector<SceneAsset*> _assets;
-
-    };
-}

ios/include/TimeIt.hpp

@@ -0,0 +1,32 @@
+#ifndef TIMEIT_H_
+#define TIMEIT_H_
+
+#pragma once
+
+#if __cplusplus <= 199711L
+ #include <ctime>
+#else
+ #include <chrono>
+#endif
+
+class Timer
+{
+ public:
+
+  Timer() { reset(); }
+  void reset();
+  double elapsed();
+
+ private:
+
+#if __cplusplus <= 199711L
+  timespec beg_, end_;
+#else
+  typedef std::chrono::high_resolution_clock clock_;
+  typedef std::chrono::duration<double, std::ratio<1> > second_;
+  std::chrono::time_point<clock_> beg_;
+#endif
+
+};
+
+#endif  // TIMEIT_H_

ios/include/material/FileMaterialProvider.hpp

@@ -4,6 +4,10 @@
 #include <filament/Texture.h>
 #include <filament/TextureSampler.h>
 #include <math/mat4.h>
+#include <math/vec3.h>
+#include <math/vec4.h>
+#include <math/mat3.h>
+#include <math/norm.h>
 
 namespace polyvox {
   class FileMaterialProvider : public MaterialProvider {
@@ -36,9 +40,8 @@ namespace polyvox {
               return hasTexture ? int(uvmap->at(srcIndex)) - 1 : -1;
             };
 
-            Log("CREATING MATERIAL INSTANCE");
             auto instance = _m->createInstance();
-            mat3f identity;
+            math::mat3f identity;
             instance->setParameter("baseColorUvMatrix", identity);
             instance->setParameter("normalUvMatrix", identity);
 

ios/include/material/UnlitMaterialProvider.hpp

@@ -1,5 +1,8 @@
 #ifndef UNLIT_MATERIAL_PROVIDER
 #define UNLIT_MATERIAL_PROVIDER
+
+#include "material/unlit_opaque.h"
+
 namespace polyvox {
   class UnlitMaterialProvider : public MaterialProvider {
 

ios/src/AssetManager.cpp

@@ -0,0 +1,777 @@
+#include "AssetManager.hpp"
+#include "Log.hpp"
+
+#include <filament/Engine.h>
+#include <filament/TransformManager.h>
+#include <filament/Texture.h>
+#include <filament/RenderableManager.h>
+
+#include <gltfio/Animator.h>
+#include <gltfio/AssetLoader.h>
+#include <gltfio/FilamentAsset.h>
+#include <gltfio/ResourceLoader.h>
+#include <gltfio/TextureProvider.h>
+
+#include <imageio/ImageDecoder.h>
+
+#include "StreamBufferAdapter.hpp"
+#include "SceneAsset.hpp"
+#include "Log.hpp"
+#include "ResourceManagement.hpp"
+#include "material/UnlitMaterialProvider.hpp"
+#include "material/FileMaterialProvider.hpp"
+#include "gltfio/materials/uberarchive.h"
+
+extern "C" {
+  #include "material/image.h"
+  #include "material/unlit_opaque.h"
+}
+
+namespace polyvox {
+
+using namespace std;
+using namespace std::chrono;
+using namespace image;
+using namespace utils;
+using namespace filament;
+using namespace filament::gltfio;
+
+AssetManager::AssetManager(LoadResource loadResource,
+                            FreeResource freeResource,
+                            NameComponentManager *ncm, 
+                            Engine *engine,
+                            Scene *scene)
+    : _loadResource(loadResource), 
+      _freeResource(freeResource), 
+      _ncm(ncm),
+      _engine(engine), 
+      _scene(scene) {
+
+        _stbDecoder = createStbProvider(_engine);
+
+        _gltfResourceLoader = new ResourceLoader({.engine = _engine,
+                                        .normalizeSkinningWeights = true });
+        _ubershaderProvider = gltfio::createUbershaderProvider(
+           _engine, UBERARCHIVE_DEFAULT_DATA, UBERARCHIVE_DEFAULT_SIZE);
+        EntityManager &em = EntityManager::get();
+        _assetLoader = AssetLoader::create({_engine, _ubershaderProvider, _ncm, &em });
+        _unlitProvider = new UnlitMaterialProvider(_engine);
+        
+        _gltfResourceLoader->addTextureProvider("image/png", _stbDecoder);
+        _gltfResourceLoader->addTextureProvider("image/jpeg", _stbDecoder);
+      }
+
+AssetManager::~AssetManager() { 
+  _gltfResourceLoader->asyncCancelLoad();
+  _ubershaderProvider->destroyMaterials();
+  _unlitProvider->destroyMaterials();
+  destroyAll();
+  AssetLoader::destroy(&_assetLoader);
+  
+}
+
+EntityId AssetManager::loadGltf(const char *uri,
+                                       const char *relativeResourcePath) {
+  ResourceBuffer rbuf = _loadResource(uri);
+
+  // Parse the glTF file and create Filament entities.
+  FilamentAsset *asset =
+      _assetLoader->createAsset((uint8_t *)rbuf.data, rbuf.size);
+
+  if (!asset) {
+    Log("Unable to parse asset");
+    return 0;
+  }
+
+  const char *const *const resourceUris = asset->getResourceUris();
+  const size_t resourceUriCount = asset->getResourceUriCount();
+
+  for (size_t i = 0; i < resourceUriCount; i++) {
+    string uri =
+        string(relativeResourcePath) + string("/") + string(resourceUris[i]);
+    ResourceBuffer buf = _loadResource(uri.c_str());
+
+    // using FunctionCallback = std::function<void(void*, unsigned int, void
+    // *)>; auto cb = [&] (void * ptr, unsigned int len, void * misc)  {
+    // };
+    // FunctionCallback fcb = cb;
+
+    ResourceLoader::BufferDescriptor b(buf.data, buf.size);
+    _gltfResourceLoader->addResourceData(resourceUris[i], std::move(b));
+    _freeResource(buf.id);
+  }
+
+  _gltfResourceLoader->loadResources(asset);
+  const utils::Entity *entities = asset->getEntities();
+  RenderableManager &rm = _engine->getRenderableManager();
+  for (int i = 0; i < asset->getEntityCount(); i++) {
+    auto inst = rm.getInstance(entities[i]);
+    rm.setCulling(inst, false);
+  }
+
+  FilamentInstance* inst = asset->getInstance();
+  inst->getAnimator()->updateBoneMatrices();
+  inst->recomputeBoundingBoxes();
+
+  _scene->addEntities(asset->getEntities(), asset->getEntityCount());
+
+  asset->releaseSourceData();
+
+  Log("Load complete for GLTF at URI %s", uri);
+  SceneAsset sceneAsset(asset);
+  utils::Entity e = EntityManager::get().create();
+
+  EntityId eid = Entity::smuggle(e);
+
+  _assets.emplace(eid, sceneAsset);
+
+  return eid;
+}
+
+EntityId AssetManager::loadGlb(const char *uri, bool unlit) {
+  
+  Log("Loading GLB at URI %s", uri);
+  _loadResource("BLORTY");
+  Log("blorty");
+
+  ResourceBuffer rbuf = _loadResource(uri);
+
+  FilamentAsset *asset = _assetLoader->createAsset(
+      (const uint8_t *)rbuf.data, rbuf.size);
+
+  if (!asset) {
+    Log("Unknown error loading GLB asset.");
+    return 0;
+  }
+
+  int entityCount = asset->getEntityCount();
+
+  _scene->addEntities(asset->getEntities(), entityCount);
+
+  _gltfResourceLoader->loadResources(asset);
+
+  // const Entity *entities = asset->getEntities();
+
+  // RenderableManager &rm = _engine->getRenderableManager();
+
+  // MaterialKey config;
+  // auto mi_new = _materialProvider->createMaterialInstance(&config, nullptr);
+  
+  // for (int i = 0; i < asset->getEntityCount(); i++) {
+  //   auto entityInstance = rm.getInstance(entities[i]);   
+  //   auto mi = rm.getMaterialInstanceAt(entityInstance, 0);
+  //   // auto m = mi->getMaterial();
+  //   // auto shading = m->getShading();
+  //   // Log("Shading %d", shading);
+  // }
+
+  auto lights = asset->getLightEntities();
+  _scene->addEntities(lights, asset->getLightEntityCount());
+  
+  FilamentInstance* inst = asset->getInstance();
+
+  inst->getAnimator()->updateBoneMatrices();
+
+  inst->recomputeBoundingBoxes();
+
+  asset->releaseSourceData();
+
+  _freeResource(rbuf.id);
+
+  SceneAsset sceneAsset(asset);
+
+  utils::Entity e = EntityManager::get().create();
+  EntityId eid = Entity::smuggle(e);
+
+  _assets.emplace(eid, sceneAsset);
+
+  return eid;
+}
+
+void AssetManager::destroyAll() {
+  for (auto kp : _assets) {
+    auto asset = kp.second;
+    _scene->removeEntities(asset.mAsset->getEntities(),
+                         asset.mAsset->getEntityCount());
+
+    _scene->removeEntities(asset.mAsset->getLightEntities(),
+                          asset.mAsset->getLightEntityCount());
+
+    _gltfResourceLoader->evictResourceData();
+    _assetLoader->destroyAsset(asset.mAsset);
+  }
+  _assets.clear();
+}
+
+FilamentAsset* AssetManager::getAssetByEntityId(EntityId entityId) {
+  const auto& pos = _assets.find(entityId);
+  if(pos == _assets.end()) {
+    return nullptr;
+  }
+  return pos->second.mAsset;
+}
+
+
+void AssetManager::updateAnimations() { 
+  auto now = high_resolution_clock::now();
+
+  RenderableManager &rm = _engine->getRenderableManager();
+  
+  for (auto kp : _assets) {
+    auto asset = kp.second;
+    if(asset.mAnimating) {
+
+      asset.mAnimating = false;
+      
+      // morph animation
+      AnimationStatus morphAnimation = asset.mAnimations[0];
+      auto elapsed = (now - morphAnimation.mStart).count();
+
+      int lengthInFrames = static_cast<int>(morphAnimation.mDuration / asset.mMorphAnimationBuffer.mFrameLengthInMs);
+
+      if(elapsed >= morphAnimation.mDuration) {
+        if(morphAnimation.mLoop) {
+          morphAnimation.mStart = now;
+          if(morphAnimation.mReverse) {
+            morphAnimation.mFrameNumber = lengthInFrames;
+          }
+          asset.mAnimating = true;
+        } else {
+          morphAnimation.mStart = time_point_t::max();
+        }
+      } else {
+        asset.mAnimating = true;
+      }
+      
+      int frameNumber = static_cast<int>(elapsed / asset.mMorphAnimationBuffer.mFrameLengthInMs);
+      if(frameNumber < lengthInFrames) {
+        if(morphAnimation.mReverse) {
+          frameNumber = lengthInFrames - frameNumber;
+        } 
+        rm.setMorphWeights(
+          *(asset.mMorphAnimationBuffer.mInstance),
+          asset.mMorphAnimationBuffer.mFrameData.data() + (morphAnimation.mFrameNumber * asset.mMorphAnimationBuffer.mNumMorphWeights),
+          asset.mMorphAnimationBuffer.mNumMorphWeights);
+      }
+
+      // bone animation
+      AnimationStatus boneAnimation = asset.mAnimations[1];
+      elapsed = (now - boneAnimation.mStart).count();
+
+      lengthInFrames = static_cast<int>(boneAnimation.mDuration / asset.mBoneAnimationBuffer.mFrameLengthInMs);
+
+      if(elapsed >= boneAnimation.mDuration) {
+        if(boneAnimation.mLoop) {
+          boneAnimation.mStart = now;
+          if(boneAnimation.mReverse) {
+            boneAnimation.mFrameNumber = lengthInFrames;
+          }
+          asset.mAnimating = true;
+        } else {
+          boneAnimation.mStart = time_point_t::max();
+        }
+      } else {
+        asset.mAnimating = true;
+      }
+
+      frameNumber = static_cast<int>(elapsed / asset.mBoneAnimationBuffer.mFrameLengthInMs);
+      if(frameNumber < lengthInFrames) {
+        if(boneAnimation.mReverse) {
+          frameNumber = lengthInFrames - frameNumber;
+        } 
+        boneAnimation.mFrameNumber = frameNumber;
+        setBoneTransform(
+          asset.mAsset->getInstance(),
+          asset.mBoneAnimationBuffer.mAnimations,
+          frameNumber
+        );
+      }
+
+      // GLTF animations
+      
+      Animator* animator = asset.mAnimator;
+      
+      for(int j = 2; j < asset.mAnimations.size(); j++) {
+        
+        AnimationStatus anim = asset.mAnimations[j];
+        
+        elapsed = (now - anim.mStart).count();
+
+        if(elapsed < anim.mDuration) {
+          if(anim.mLoop) {
+            animator->applyAnimation(j-2, anim.mDuration - elapsed);
+          } else {
+            animator->applyAnimation(j-2, elapsed);
+          }
+          asset.mAnimating = true;
+        } else if(anim.mLoop) {
+          animator->applyAnimation(j-2, float(elapsed) ); //% anim.mDuration
+          asset.mAnimating = true;
+        } else if(elapsed - anim.mDuration < 0.3) { 
+          // cross-fade
+          animator->applyCrossFade(j-2, anim.mDuration - 0.05, elapsed / 0.3);
+          asset.mAnimating = true;
+        } else { 
+          // stop
+          anim.mStart = time_point_t::max();
+        }
+      }
+      asset.mAnimator->updateBoneMatrices();
+    }
+  }
+}
+
+void AssetManager::remove(EntityId entityId) {
+  const auto& pos = _assets.find(entityId);
+  if(pos == _assets.end()) {
+    Log("Couldn't find asset under specified entity id.");
+    return;
+  }
+  auto sceneAsset = pos->second;
+
+  _scene->removeEntities(sceneAsset.mAsset->getEntities(),
+                        sceneAsset.mAsset->getEntityCount());
+
+  _scene->removeEntities(sceneAsset.mAsset->getLightEntities(),
+                        sceneAsset.mAsset->getLightEntityCount());
+
+  _assetLoader->destroyAsset(sceneAsset.mAsset);
+  
+  if(sceneAsset.mTexture) {
+    _engine->destroy(sceneAsset.mTexture);
+  }
+  EntityManager& em = EntityManager::get();
+  em.destroy(Entity::import(entityId));
+  _assets.erase(entityId);
+}
+
+void AssetManager::setMorphTargetWeights(const char* const entityName, float *weights, int count) {
+  // TODO 
+}
+
+utils::Entity AssetManager::findEntityByName(SceneAsset asset, const char* entityName) {
+  utils::Entity entity;
+  for (size_t i = 0, c = asset.mAsset->getEntityCount(); i != c; ++i) {
+    auto entity = asset.mAsset->getEntities()[i];    
+    auto name = _ncm->getName(_ncm->getInstance(entity));
+
+    if(strcmp(entityName,name)==0) {
+      return entity;
+    }
+  }
+  return entity;
+}
+
+
+bool AssetManager::setMorphAnimationBuffer(
+    EntityId entityId,
+    const char* entityName,
+    const float* const morphData,
+    int numMorphWeights, 
+    int numFrames, 
+    float frameLengthInMs) {
+
+  const auto& pos = _assets.find(entityId);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return false;
+  }
+  auto asset = pos->second;
+
+  auto entity = findEntityByName(asset, entityName);
+  if(!entity) {
+    Log("Warning: failed to find entity %s", entityName);
+    return false;
+  } 
+  RenderableManager &rm = _engine->getRenderableManager();
+  auto inst = rm.getInstance(entity);
+  
+  asset.mMorphAnimationBuffer.mInstance = &inst;
+  asset.mMorphAnimationBuffer.mNumFrames = numFrames;
+  asset.mMorphAnimationBuffer.mFrameLengthInMs = frameLengthInMs;
+  asset.mMorphAnimationBuffer.mFrameData.clear();
+  asset.mMorphAnimationBuffer.mFrameData.insert(
+    asset.mMorphAnimationBuffer.mFrameData.begin(), 
+    morphData,
+    morphData + (numFrames * numMorphWeights)
+  );
+
+  asset.mMorphAnimationBuffer.mNumMorphWeights = numMorphWeights;
+  return true;
+}
+
+bool AssetManager::setBoneAnimationBuffer(
+    EntityId entity,
+    int length,
+    const char** const boneNames,
+    const char** const meshNames,
+    const float* const frameData,
+    int numFrames, 
+    float frameLengthInMs) {
+
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return false;
+  }
+  auto asset = pos->second;
+
+  auto filamentInstance = asset.mAsset->getInstance();
+
+  size_t skinCount = filamentInstance->getSkinCount();
+
+  if(skinCount > 1) { 
+    Log("WARNING - skin count > 1 not currently implemented. This will probably not work");
+  }
+
+  int skinIndex = 0;
+  const utils::Entity* joints = filamentInstance->getJointsAt(skinIndex);
+  size_t numJoints = filamentInstance->getJointCountAt(skinIndex);
+  vector<int> boneIndices;
+  for(int i = 0; i < length; i++) {
+    for(int j = 0; j < numJoints; j++) {
+        const char* jointName = _ncm->getName(_ncm->getInstance(joints[j]));
+          if(strcmp(jointName, boneNames[i]) == 0) { 
+          boneIndices.push_back(j);
+          break;
+        }
+      }
+  }
+
+  if(boneIndices.size() != length) {
+    Log("Failed to find one or more bone indices");
+    return false;
+  }
+  
+  asset.mBoneAnimationBuffer.mAnimations.clear();
+
+  for(int i = 0; i < length; i++) {
+    BoneAnimationData boneAnimationData;
+    boneAnimationData.mBoneIndex = boneIndices[i];
+
+    auto entity = findEntityByName(asset, meshNames[i]);
+
+    if(!entity) {
+      Log("Mesh target %s for bone animation could not be found", meshNames[i]);
+      return false;
+    }
+    
+    boneAnimationData.mMeshTarget = entity;
+
+    boneAnimationData.mFrameData.insert(
+      boneAnimationData.mFrameData.begin(), 
+      frameData[i * numFrames * 7 * sizeof(float)],  // 7 == x, y, z, w + three euler angles
+      frameData[(i+1) * numFrames * 7 * sizeof(float)]
+    );
+
+    asset.mBoneAnimationBuffer.mAnimations.push_back(boneAnimationData);
+  }
+  return true;
+}
+
+void AssetManager::setBoneTransform(
+  FilamentInstance* filamentInstance,
+  vector<BoneAnimationData> animations,
+  int frameNumber) {  
+
+  RenderableManager &rm = _engine->getRenderableManager();
+  
+  TransformManager &transformManager = _engine->getTransformManager();
+
+  auto frameDataOffset = frameNumber * 7;
+
+  int skinIndex = 0;
+
+  for(auto& animation : animations) {
+  
+    math::mat4f inverseGlobalTransform = inverse(
+      transformManager.getWorldTransform(
+        transformManager.getInstance(animation.mMeshTarget)
+      )
+    );
+
+    utils::Entity joint = filamentInstance->getJointsAt(skinIndex)[animation.mBoneIndex];
+
+    math::mat4f localTransform(math::quatf{
+      animation.mFrameData[frameDataOffset+6],
+      animation.mFrameData[frameDataOffset+3],
+      animation.mFrameData[frameDataOffset+4],
+      animation.mFrameData[frameDataOffset+5]
+    });
+
+    const math::mat4f& inverseBindMatrix = filamentInstance->getInverseBindMatricesAt(animation.skinIndex)[animation.mBoneIndex];
+    auto jointInstance = transformManager.getInstance(joint);
+    math::mat4f globalJointTransform = transformManager.getWorldTransform(jointInstance);
+      
+    math::mat4f boneTransform = inverseGlobalTransform * globalJointTransform * localTransform * inverseBindMatrix;
+    auto renderable = rm.getInstance(animation.mMeshTarget);
+    rm.setBones(
+      renderable, 
+      &boneTransform,
+      1, 
+      animation.mBoneIndex
+    );
+  }
+}
+
+void AssetManager::playAnimation(EntityId e, int index, bool loop, bool reverse) {
+  const auto& pos = _assets.find(e);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return;
+  }
+  auto asset = pos->second;
+
+  asset.mAnimations[index+2].mStart = high_resolution_clock::now();
+  asset.mAnimations[index+2].mLoop = loop;
+  asset.mAnimations[index+2].mReverse = reverse;
+}
+
+void AssetManager::stopAnimation(EntityId entityId, int index) {
+  const auto& pos = _assets.find(entityId);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return;
+  }
+  auto asset = pos->second;
+  asset.mAnimations[index+2].mStart = time_point_t::max();
+}
+
+void AssetManager::loadTexture(EntityId entity, const char* resourcePath, int renderableIndex) {
+
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return;
+  }
+  auto asset = pos->second;
+
+  Log("Loading texture at %s for renderableIndex %d", resourcePath, renderableIndex);
+
+  string rp(resourcePath);
+
+  if(asset.mTexture) {
+    _engine->destroy(asset.mTexture);
+    asset.mTexture = nullptr;
+  }
+  
+  ResourceBuffer imageResource = _loadResource(rp.c_str());
+  
+  StreamBufferAdapter sb((char *)imageResource.data, (char *)imageResource.data + imageResource.size);
+
+  istream *inputStream = new std::istream(&sb);
+
+  LinearImage *image = new LinearImage(ImageDecoder::decode(
+      *inputStream, rp.c_str(), ImageDecoder::ColorSpace::SRGB));
+
+  if (!image->isValid()) {
+    Log("Invalid image : %s", rp.c_str());
+    delete inputStream;
+    _freeResource(imageResource.id);
+    return;
+  }
+
+  uint32_t channels = image->getChannels();
+  uint32_t w = image->getWidth();
+  uint32_t h = image->getHeight();
+  asset.mTexture = Texture::Builder()
+                      .width(w)
+                      .height(h)
+                      .levels(0xff)
+                      .format(channels == 3 ? Texture::InternalFormat::RGB16F
+                                            : Texture::InternalFormat::RGBA16F)
+                      .sampler(Texture::Sampler::SAMPLER_2D)
+                      .build(*_engine);
+
+  Texture::PixelBufferDescriptor::Callback freeCallback = [](void *buf, size_t,
+                                                            void *data) {
+    delete reinterpret_cast<LinearImage *>(data);
+  };
+
+  Texture::PixelBufferDescriptor buffer(
+      image->getPixelRef(), size_t(w * h * channels * sizeof(float)),
+      channels == 3 ? Texture::Format::RGB : Texture::Format::RGBA,
+      Texture::Type::FLOAT, freeCallback);
+
+  asset.mTexture->setImage(*_engine, 0, std::move(buffer));
+  MaterialInstance* const* inst = asset.mAsset->getInstance()->getMaterialInstances();
+  size_t mic =  asset.mAsset->getInstance()->getMaterialInstanceCount();
+  Log("Material instance count : %d", mic);
+    
+  auto sampler = TextureSampler();
+  inst[0]->setParameter("baseColorIndex",0);
+  inst[0]->setParameter("baseColorMap",asset.mTexture,sampler);
+  delete inputStream;
+
+  _freeResource(imageResource.id);
+  
+}
+
+
+void AssetManager::setAnimationFrame(EntityId entity, int animationIndex, int animationFrame) {
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return;
+  }
+  auto asset = pos->second;
+  auto offset = 60 * animationFrame * 1000; // TODO - don't hardcore 60fps framerate
+  asset.mAnimator->applyAnimation(animationIndex, offset);
+  asset.mAnimator->updateBoneMatrices();
+}
+
+unique_ptr<vector<string>> AssetManager::getAnimationNames(EntityId entity) {
+
+  const auto& pos = _assets.find(entity);
+
+  unique_ptr<vector<string>> names = make_unique<vector<string>>();
+
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity id.");
+    return names;
+  }
+  auto asset = pos->second;
+
+  size_t count = asset.mAnimator->getAnimationCount();
+
+
+  for (size_t i = 0; i < count; i++) {
+    names->push_back(asset.mAnimator->getAnimationName(i));
+  }
+
+  return names;
+}
+
+unique_ptr<vector<string>> AssetManager::getMorphTargetNames(EntityId entity, const char *meshName) {
+
+  unique_ptr<vector<string>> names = make_unique<vector<string>>();
+
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return names;
+  }
+  auto asset = pos->second;
+
+  const utils::Entity *entities = asset.mAsset->getEntities();
+  
+  for (int i = 0; i < asset.mAsset->getEntityCount(); i++) {
+    utils::Entity e = entities[i];
+    auto inst = _ncm->getInstance(e);
+    const char *name = _ncm->getName(inst);
+
+    if (strcmp(name, meshName) == 0) {
+      size_t count = asset.mAsset->getMorphTargetCountAt(e);
+      for (int j = 0; j < count; j++) {
+        const char *morphName = asset.mAsset->getMorphTargetNameAt(e, j);
+        names->push_back(morphName);
+      }
+      break;
+    }
+  }
+  return names;
+}
+
+void AssetManager::transformToUnitCube(EntityId entity) {
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return;
+  }
+  auto asset = pos->second;
+
+  Log("Transforming asset to unit cube.");
+  auto &tm = _engine->getTransformManager();
+  FilamentInstance* inst = asset.mAsset->getInstance();
+  auto aabb = inst->getBoundingBox();
+  auto center = aabb.center();
+  auto halfExtent = aabb.extent();
+  auto maxExtent = max(halfExtent) * 2;
+  auto scaleFactor = 2.0f / maxExtent;
+  auto transform =
+      math::mat4f::scaling(scaleFactor) * math::mat4f::translation(-center);
+  tm.setTransform(tm.getInstance(inst->getRoot()), transform);
+}
+
+void AssetManager::updateTransform(SceneAsset asset) {
+  auto &tm = _engine->getTransformManager();
+  auto transform = 
+      asset.mPosition * asset.mRotation * math::mat4f::scaling(asset.mScale);
+  tm.setTransform(tm.getInstance(asset.mAsset->getRoot()), transform);
+}
+
+void AssetManager::setScale(EntityId entity, float scale) {
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return;
+  }
+  auto asset = pos->second;
+  asset.mScale = scale;
+  updateTransform(asset);
+}
+
+void AssetManager::setPosition(EntityId entity, float x, float y, float z) {
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return;
+  }
+  auto asset = pos->second;
+  asset.mPosition = math::mat4f::translation(math::float3(x,y,z));
+  updateTransform(asset);
+}
+
+void AssetManager::setRotation(EntityId entity, float rads, float x, float y, float z) {
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return;
+  }
+  auto asset = pos->second;
+  asset.mRotation = math::mat4f::rotation(rads, math::float3(x,y,z));
+  updateTransform(asset);
+}
+
+const utils::Entity *AssetManager::getCameraEntities(EntityId entity) {
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return nullptr;
+  }
+  auto asset = pos->second;
+  return asset.mAsset->getCameraEntities();
+}
+
+size_t AssetManager::getCameraEntityCount(EntityId entity) {
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return 0;
+  }
+  auto asset = pos->second;
+  return asset.mAsset->getCameraEntityCount();
+}
+
+const utils::Entity* AssetManager::getLightEntities(EntityId entity) const noexcept { 
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return nullptr;
+  }
+  auto asset = pos->second;
+  return asset.mAsset->getLightEntities();
+}
+
+size_t AssetManager::getLightEntityCount(EntityId entity) const noexcept {
+  const auto& pos = _assets.find(entity);
+  if(pos == _assets.end()) {
+    Log("ERROR: asset not found for entity.");
+    return 0;
+  }
+  auto asset = pos->second;
+  return asset.mAsset->getLightEntityCount();
+}
+
+
+} // namespace polyvox

ios/src/FilamentViewer.cpp

@@ -70,17 +70,11 @@
 #include <mutex>
 
 #include "Log.hpp"
-#include "ResourceManagement.hpp"
-
-extern "C" {
-  #include "material/image.h"
-  #include "material/unlit_opaque.h"
-}
 
 #include "FilamentViewer.hpp"
 #include "StreamBufferAdapter.hpp"
-#include "material/UnlitMaterialProvider.hpp"
+#include "material/image.h"
-#include "material/FileMaterialProvider.hpp"
+#include "TimeIt.hpp"
 
 using namespace filament;
 using namespace filament::math;
@@ -116,15 +110,13 @@ static const uint16_t sFullScreenTriangleIndices[3] = {0, 1, 2};
 FilamentViewer::FilamentViewer(void* context, LoadResource loadResource,
                                FreeResource freeResource)
   : _loadResource(loadResource), _freeResource(freeResource) {
-  Log("Creating FilamentViewer");
+  
   #if TARGET_OS_IPHONE
     _engine = Engine::create(Engine::Backend::METAL);
   #else
     _engine = Engine::create(Engine::Backend::OPENGL, nullptr, context, nullptr);
   #endif
 
-  Log("Engine created");
-
   _renderer = _engine->createRenderer();
 
   float fr = 60.0f;
@@ -138,7 +130,7 @@ FilamentViewer::FilamentViewer(void* context, LoadResource loadResource,
 
   Log("Scene created");
   
-  Entity camera = EntityManager::get().create();
+  utils::Entity camera = EntityManager::get().create();
 
   _mainCamera = _engine->createCamera(camera);
 
@@ -191,38 +183,17 @@ FilamentViewer::FilamentViewer(void* context, LoadResource loadResource,
   // Log("Loaded resource of size %d", materialRb.size);
   // _materialProvider = new FileMaterialProvider(_engine, (void*) materialRb.data, (size_t)materialRb.size);
   
-  _unlitProvider = new UnlitMaterialProvider(_engine);
-  _ubershaderProvider = gltfio::createUbershaderProvider(
-         _engine, UBERARCHIVE_DEFAULT_DATA, UBERARCHIVE_DEFAULT_SIZE);
-
   EntityManager &em = EntityManager::get();
+
   _ncm = new NameComponentManager(em);
+
+  _assetManager = new AssetManager(
+    _loadResource, 
+    _freeResource, 
+    _ncm, 
+    _engine,
+    _scene);
   
-  _resourceLoader = new ResourceLoader({.engine = _engine,
-                                        .normalizeSkinningWeights = true });
-  _stbDecoder = createStbProvider(_engine);
-  _resourceLoader->addTextureProvider("image/png", _stbDecoder);
-  _resourceLoader->addTextureProvider("image/jpeg", _stbDecoder);
-  _ubershaderAssetLoader = new SceneAssetLoader(_loadResource,
-                                   _freeResource,
-                                   _ubershaderProvider,
-                                   &em,
-                                   _resourceLoader,
-                                   _ncm, 
-                                   _engine,
-                                   _scene);
-
-  _unlitAssetLoader = new SceneAssetLoader(_loadResource,
-                                   _freeResource,
-                                   _unlitProvider,
-                                   &em,
-                                   _resourceLoader,
-
-                                   _ncm, 
-                                   _engine,
-                                   _scene);
-      
-      
  _imageTexture = Texture::Builder()
                          .width(1)
                          .height(1)
@@ -261,7 +232,7 @@ FilamentViewer::FilamentViewer(void* context, LoadResource loadResource,
   _imageIb->setBuffer(*_engine, {sFullScreenTriangleIndices,
                                  sizeof(sFullScreenTriangleIndices)});
 
-  Entity imageEntity = em.create();
+  utils::Entity imageEntity = em.create();
   RenderableManager::Builder(1)
       .boundingBox({{}, {1.0f, 1.0f, 1.0f}})
       .material(0, _imageMaterial->getDefaultInstance())
@@ -432,7 +403,6 @@ void FilamentViewer::clearBackgroundImage() {
   }
 }
 
-
 void FilamentViewer::setBackgroundImage(const char *resourcePath) {
 
   string resourcePathString(resourcePath);
@@ -535,11 +505,7 @@ void FilamentViewer::setBackgroundImagePosition(float x, float y, bool clamp=fal
 
 FilamentViewer::~FilamentViewer() { 
   clearAssets();
-  delete _ubershaderAssetLoader;
+  delete _assetManager;
-  delete _unlitAssetLoader;
-  _resourceLoader->asyncCancelLoad();
-  _ubershaderProvider->destroyMaterials();
-  _unlitProvider->destroyMaterials();
   
   for(auto it : _lights) {
     _engine->destroy(it);
@@ -616,36 +582,6 @@ void FilamentViewer::destroySwapChain() {
   }
 }
 
-SceneAsset *FilamentViewer::loadGlb(const char *const uri, bool unlit) {
-  SceneAsset *asset;
-  if(unlit) {
-    asset = _unlitAssetLoader->fromGlb(uri);
-  } else {
-    asset = _ubershaderAssetLoader->fromGlb(uri);
-  }
-  if (!asset) {
-    Log("Unknown error loading asset.");
-  } else {
-    _assets.push_back(asset);
-    Log("GLB loaded, asset at index %d", _assets.size() - 1);
-  }
-  
-  return asset;
-}
-
-SceneAsset *FilamentViewer::loadGltf(const char *const uri,
-                                     const char *const relativeResourcePath) {
-  Log("Loading GLTF at URI %s with relativeResourcePath %s", uri,
-      relativeResourcePath);
-  SceneAsset *asset = _ubershaderAssetLoader->fromGltf(uri, relativeResourcePath);
-  if (!asset) {
-    Log("Unknown error loading asset.");
-  } else {
-    _assets.push_back(asset);
-  }
-  return asset;
-}
-
 void FilamentViewer::clearAssets() {
   Log("Clearing all assets");
   if(_mainCamera) {
@@ -657,21 +593,18 @@ void FilamentViewer::clearAssets() {
     _manipulator = nullptr;
   }
 
-  _ubershaderAssetLoader->destroyAll();
+  _assetManager->destroyAll();
-  _unlitAssetLoader->destroyAll();
+ 
-  
-  _assets.clear();
   Log("Cleared all assets");
 }
 
-void FilamentViewer::removeAsset(SceneAsset *asset) {
+void FilamentViewer::removeAsset(EntityId asset) {
   Log("Removing asset from scene");
 
   mtx.lock();
   // todo - what if we are using a camera from this asset?
   _view->setCamera(_mainCamera);
-  _ubershaderAssetLoader->remove(asset);
+  _assetManager->remove(asset);
-  _unlitAssetLoader->remove(asset);
   mtx.unlock();
 }
 
@@ -704,65 +637,58 @@ void FilamentViewer::setCameraFocusDistance(float focusDistance) {
 }
 
 ///
-/// Sets the active camera to the first GLTF camera node found in the hierarchy.
+/// Sets the active camera to the GLTF camera node specified by [name] (or if null, the first camera found under that node).
-/// Useful when your asset only has one camera.
-///
-bool FilamentViewer::setFirstCamera(SceneAsset *asset) {
-  size_t count = asset->getCameraEntityCount();
-  if (count == 0) {
-    Log("Failed, no cameras found in current asset.");
-    return false;
-  }
-  const utils::Entity *cameras = asset->getCameraEntities();
-  Log("%zu cameras found in asset", count);
-  auto inst = _ncm->getInstance(cameras[0]);
-  const char *name = _ncm->getName(inst);
-  return setCamera(asset, name);
-}
-
-///
-/// Sets the active camera to the GLTF camera node specified by [name].
 /// N.B. Blender will generally export a three-node hierarchy -
 /// Camera1->Camera_Orientation->Camera2. The correct name will be the Camera_Orientation.
 ///
-bool FilamentViewer::setCamera(SceneAsset *asset, const char *cameraName) {
+bool FilamentViewer::setCamera(EntityId entityId, const char *cameraName) {
-  Log("Attempting to set camera to %s.", cameraName);
+
+  auto asset = _assetManager->getAssetByEntityId(entityId);
+  if(!asset) {
+    Log("Failed to find asset attached to specified entity id.");
+  }
   size_t count = asset->getCameraEntityCount();
   if (count == 0) {
     Log("Failed, no cameras found in current asset.");
     return false;
   }
 
-  const utils::Entity *cameras = asset->getCameraEntities();
+  const utils::Entity* cameras = asset->getCameraEntities();
-  Log("%zu cameras found in asset", count);
-  for (int i = 0; i < count; i++) {
 
-    auto inst = _ncm->getInstance(cameras[i]);
+  const utils::Entity target;
-    const char *name = _ncm->getName(inst);
-    Log("Camera %d : %s", i, name);
-    if (strcmp(name, cameraName) == 0) {
 
-      Camera *camera = _engine->getCameraComponent(cameras[i]);
+  int i = -1;
-      _view->setCamera(camera);
 
-      const Viewport &vp = _view->getViewport();
+  if(!cameraName) {
-      const double aspect = (double)vp.width / vp.height;
+    i = 0;
-
+  } else {
-      const float aperture = camera->getAperture();
+    for (int j = 0; j < count; j++) {
-      const float shutterSpeed = camera->getShutterSpeed();
+      auto inst = _ncm->getInstance(cameras[j]);
-      const float sens = camera->getSensitivity();
+      const char *name = _ncm->getName(inst);
-
+      if (strcmp(name, cameraName) == 0) {
-      // camera->setExposure(1.0f);
+        i = j;
-
+        break;
-      Log("Camera focal length : %f aspect %f aperture %f shutter %f sensitivity %f", camera->getFocalLength(),
+      }
-          aspect, aperture, shutterSpeed, sens);
+    }
-      camera->setScaling({1.0 / aspect, 1.0});
+    if(i == -1) {
-      Log("Successfully set camera.");
+      Log("Unable to locate camera under name %s ", cameraName);
-      return true;
+      return false;
     }
   }
-  Log("Unable to locate camera under name %s ", cameraName);
+
-  return false;
+  Camera *camera = _engine->getCameraComponent(target);
+  _view->setCamera(camera);
+
+  const Viewport &vp = _view->getViewport();
+  const double aspect = (double)vp.width / vp.height;
+
+  // const float aperture = camera->getAperture();
+  // const float shutterSpeed = camera->getShutterSpeed();
+  // const float sens = camera->getSensitivity();
+  // camera->setExposure(1.0f);
+
+  camera->setScaling({1.0 / aspect, 1.0});
+  return true;
 }
 
 void FilamentViewer::loadSkybox(const char *const skyboxPath) {
@@ -792,9 +718,6 @@ void FilamentViewer::loadSkybox(const char *const skyboxPath) {
 
     _scene->setSkybox(_skybox);
     _freeResource(skyboxBuffer.id);
-
-    
-
   }
 }
 
@@ -856,6 +779,9 @@ void FilamentViewer::loadIbl(const char *const iblPath, float intensity) {
   }
 }
 
+double _elapsed = 0;
+int _frameCount = 0;
+
 void FilamentViewer::render(uint64_t frameTimeInNanos) {
 
   if (!_view || !_mainCamera || !_swapChain) {
@@ -863,10 +789,19 @@ void FilamentViewer::render(uint64_t frameTimeInNanos) {
     return;
   }
 
-  for (auto &asset : _assets) {
+  if(_frameCount == 60) {
-    asset->updateAnimations();
+    Log("1 sec average for asset animation update %f", _elapsed);
+    _elapsed = 0;
+    _frameCount = 0;
   }
 
+  Timer tmr;
+
+  _assetManager->updateAnimations();
+
+  _elapsed += tmr.elapsed();
+  _frameCount++;
+
   if(_manipulator) {
     math::float3 eye, target, upward;
     Camera& cam =_view->getCamera();

ios/src/PolyvoxFilamentApi.cpp

@@ -6,180 +6,210 @@
 
 using namespace polyvox;
 
+#define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default")))
+
 extern "C" {
 
   #include "PolyvoxFilamentApi.h"
 
-  void* filament_viewer_new(void* context, ResourceBuffer (*loadResource)(char const*), void (*freeResource)(unsigned int)) {
+  FLUTTER_PLUGIN_EXPORT void* create_filament_viewer(void* context, ResourceBuffer (*loadResource)(char const*), void (*freeResource)(unsigned int)) {
     FilamentViewer* v = new FilamentViewer(context, loadResource, freeResource);
     return (void*)v;
   }
 
-  void create_render_target(void* viewer, uint32_t textureId, uint32_t width, uint32_t height) {
+  FLUTTER_PLUGIN_EXPORT void create_render_target(void* viewer, uint32_t textureId, uint32_t width, uint32_t height) {
     ((FilamentViewer*)viewer)->createRenderTarget(textureId, width, height);
   }
   
-  void filament_viewer_delete(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void delete_filament_viewer(void* viewer) {
     delete((FilamentViewer*)viewer);
   }
 
-  void set_background_color(void* viewer, const float r, const float g, const float b, const float a) {
+  FLUTTER_PLUGIN_EXPORT void set_background_color(void* viewer, const float r, const float g, const float b, const float a) {
     ((FilamentViewer*)viewer)->setBackgroundColor(r, g, b, a);
   }
 
-  void clear_background_image(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void clear_background_image(void* viewer) {
     ((FilamentViewer*)viewer)->clearBackgroundImage();
   }
 
-  void set_background_image(void* viewer, const char* path) {
+  FLUTTER_PLUGIN_EXPORT void set_background_image(void* viewer, const char* path) {
     ((FilamentViewer*)viewer)->setBackgroundImage(path);
   }
 
-  void set_background_image_position(void* viewer, float x, float y, bool clamp) {
+  FLUTTER_PLUGIN_EXPORT void set_background_image_position(void* viewer, float x, float y, bool clamp) {
   ((FilamentViewer*)viewer)->setBackgroundImagePosition(x, y, clamp);
   }
 
-  void load_skybox(void* viewer, const char* skyboxPath) {
+  FLUTTER_PLUGIN_EXPORT void load_skybox(void* viewer, const char* skyboxPath) {
     ((FilamentViewer*)viewer)->loadSkybox(skyboxPath);
   }
 
-  void load_ibl(void* viewer, const char* iblPath, float intensity) {
+  FLUTTER_PLUGIN_EXPORT void load_ibl(void* viewer, const char* iblPath, float intensity) {
     ((FilamentViewer*)viewer)->loadIbl(iblPath, intensity);
   }
 
-  void remove_skybox(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void remove_skybox(void* viewer) {
     ((FilamentViewer*)viewer)->removeSkybox();
   }
   
-  void remove_ibl(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void remove_ibl(void* viewer) {
     ((FilamentViewer*)viewer)->removeIbl();
   }
 
-  int32_t add_light(void* viewer, uint8_t type, float colour, float intensity, float posX, float posY, float posZ, float dirX, float dirY, float dirZ, bool shadows) { 
+  FLUTTER_PLUGIN_EXPORT int32_t add_light(void* viewer, uint8_t type, float colour, float intensity, float posX, float posY, float posZ, float dirX, float dirY, float dirZ, bool shadows) { 
     return ((FilamentViewer*)viewer)->addLight((LightManager::Type)type, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, shadows);
   }
 
-  void remove_light(void* viewer, int32_t entityId) {
+  FLUTTER_PLUGIN_EXPORT void remove_light(void* viewer, int32_t entityId) {
     ((FilamentViewer*)viewer)->removeLight(entityId);
   }
 
-  void clear_lights(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void clear_lights(void* viewer) {
     ((FilamentViewer*)viewer)->clearLights();
   }
 
-  void* load_glb(void* viewer, const char* assetPath, bool unlit) {
+  FLUTTER_PLUGIN_EXPORT EntityId load_glb(void* assetManager, const char* assetPath, bool unlit) {
-    return ((FilamentViewer*)viewer)->loadGlb(assetPath, unlit);
+    return ((AssetManager*)assetManager)->loadGlb(assetPath, unlit);
   }
 
-  void* load_gltf(void* viewer, const char* assetPath, const char* relativePath) {
+  FLUTTER_PLUGIN_EXPORT EntityId load_gltf(void* assetManager, const char* assetPath, const char* relativePath) {
-    return ((FilamentViewer*)viewer)->loadGltf(assetPath, relativePath);
+    return ((AssetManager*)assetManager)->loadGltf(assetPath, relativePath);
   }
 
-  bool set_camera(void* viewer, void* asset, const char* nodeName) {
+  FLUTTER_PLUGIN_EXPORT bool set_camera(void* viewer, EntityId asset, const char* nodeName) {
-    return ((FilamentViewer*)viewer)->setCamera((SceneAsset*)asset, nodeName);
+    return ((FilamentViewer*)viewer)->setCamera(asset, nodeName);
   }
 
-  void set_camera_exposure(void* viewer, float aperture, float shutterSpeed, float sensitivity) {
+  FLUTTER_PLUGIN_EXPORT void set_camera_exposure(void* viewer, float aperture, float shutterSpeed, float sensitivity) {
     ((FilamentViewer*)viewer)->setCameraExposure(aperture, shutterSpeed, sensitivity);
   }
 
-  void set_camera_position(void* viewer, float x, float y, float z) {
+  FLUTTER_PLUGIN_EXPORT void set_camera_position(void* viewer, float x, float y, float z) {
     ((FilamentViewer*)viewer)->setCameraPosition(x, y, z);
   }
 
-  void set_camera_rotation(void* viewer, float rads, float x, float y, float z) {
+  FLUTTER_PLUGIN_EXPORT void set_camera_rotation(void* viewer, float rads, float x, float y, float z) {
     ((FilamentViewer*)viewer)->setCameraRotation(rads, x, y, z);
   }
 
-  void set_camera_model_matrix(void* viewer, const float* const matrix) {
+  FLUTTER_PLUGIN_EXPORT void set_camera_model_matrix(void* viewer, const float* const matrix) {
     ((FilamentViewer*)viewer)->setCameraModelMatrix(matrix);
   }
 
-  void set_camera_focal_length(void* viewer, float focalLength) {
+  FLUTTER_PLUGIN_EXPORT void set_camera_focal_length(void* viewer, float focalLength) {
     ((FilamentViewer*)viewer)->setCameraFocalLength(focalLength);
   }
 
-  void render(
+  FLUTTER_PLUGIN_EXPORT void render(
     void* viewer,
     uint64_t frameTimeInNanos
   ) {
     ((FilamentViewer*)viewer)->render(frameTimeInNanos);
   }
 
-  void set_frame_interval(
+  FLUTTER_PLUGIN_EXPORT void set_frame_interval(
     void* viewer,
     float frameInterval
   ) {
     ((FilamentViewer*)viewer)->setFrameInterval(frameInterval);
   }
 
-  void destroy_swap_chain(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void destroy_swap_chain(void* viewer) {
     ((FilamentViewer*)viewer)->destroySwapChain();
   }
 
-  void create_swap_chain(void* viewer, void* surface=nullptr, uint32_t width=0, uint32_t height=0) {
+  FLUTTER_PLUGIN_EXPORT void create_swap_chain(void* viewer, void* surface=nullptr, uint32_t width=0, uint32_t height=0) {
     ((FilamentViewer*)viewer)->createSwapChain(surface, width, height);
   }
 
-  void* get_renderer(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void* get_renderer(void* viewer) {
     return ((FilamentViewer*)viewer)->getRenderer();
   }
 
-  void update_viewport_and_camera_projection(void* viewer, int width, int height, float scaleFactor) {
+  FLUTTER_PLUGIN_EXPORT void update_viewport_and_camera_projection(void* viewer, int width, int height, float scaleFactor) {
     return ((FilamentViewer*)viewer)->updateViewportAndCameraProjection(width, height, scaleFactor);
   }
 
-  void scroll_update(void* viewer, float x, float y, float delta) {
+  FLUTTER_PLUGIN_EXPORT void scroll_update(void* viewer, float x, float y, float delta) {
     ((FilamentViewer*)viewer)->scrollUpdate(x, y, delta);
   }
 
-  void scroll_begin(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void scroll_begin(void* viewer) {
     ((FilamentViewer*)viewer)->scrollBegin();
   }
 
-  void scroll_end(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void scroll_end(void* viewer) {
     ((FilamentViewer*)viewer)->scrollEnd();
   }
 
-  void grab_begin(void* viewer, float x, float y, bool pan) {
+  FLUTTER_PLUGIN_EXPORT void grab_begin(void* viewer, float x, float y, bool pan) {
     ((FilamentViewer*)viewer)->grabBegin(x, y, pan);
   }
 
-  void grab_update(void* viewer, float x, float y) {
+  FLUTTER_PLUGIN_EXPORT void grab_update(void* viewer, float x, float y) {
     ((FilamentViewer*)viewer)->grabUpdate(x, y);
   }
 
-  void grab_end(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void grab_end(void* viewer) {
     ((FilamentViewer*)viewer)->grabEnd();
   }
 
-  void apply_weights(void* asset, const char* const entityName, float* const weights, int count) {
+  FLUTTER_PLUGIN_EXPORT void* get_asset_manager(void* viewer) {
-    ((SceneAsset*)asset)->setMorphTargetWeights(entityName, weights, count);
+    return (void*)((FilamentViewer*)viewer)->getAssetManager();
   }
 
-  void set_animation(
+  FLUTTER_PLUGIN_EXPORT void apply_weights(
-    void* asset, 
+    void* assetManager,
+    EntityId asset, 
+    const char* const entityName, 
+    float* const weights, 
+    int count) {
+    // ((AssetManager*)assetManager)->setMorphTargetWeights(asset, entityName, weights, count);
+  }
+
+  FLUTTER_PLUGIN_EXPORT void set_morph_animation(
+    void* assetManager,
+    EntityId asset, 
     const char* const entityName,
     const float* const morphData,
     int numMorphWeights, 
-    const BoneAnimation* const boneAnimations,
-    int numBoneAnimations,
     int numFrames, 
     float frameLengthInMs) {
-    ((SceneAsset*)asset)->setAnimation(
+    ((AssetManager*)assetManager)->setMorphAnimationBuffer(
+      asset, 
       entityName,
       morphData, 
       numMorphWeights, 
-      boneAnimations, 
+      numFrames, 
-      numBoneAnimations,
+      frameLengthInMs
+    );
+  }
+
+  FLUTTER_PLUGIN_EXPORT void set_bone_animation(
+    void* assetManager,
+    EntityId asset, 
+    int length,
+    const char** const boneNames,
+    const char** const meshNames,
+    const float* const frameData,
+    int numFrames, 
+    float frameLengthInMs) {
+    ((AssetManager*)assetManager)->setBoneAnimationBuffer(
+      asset, 
+      length,
+      boneNames, 
+      meshNames,
+      frameData,
       numFrames, 
       frameLengthInMs
     );
   }
 
 
+
 //   void set_bone_transform(
-//     void* asset, 
+//     EntityId asset, 
 //     const char* boneName, 
 //     const char* entityName,
 //     float transX, 
@@ -190,7 +220,7 @@ extern "C" {
 //     float quatZ,
 //     float quatW
 // ) {
-//     ((SceneAsset*)asset)->setBoneTransform(
+//     ((AssetManager*)assetManager)->setBoneTransform(
 //         boneName, 
 //         entityName, 
 //         transX, 
@@ -206,70 +236,86 @@ extern "C" {
 //   }
 
 
-  void play_animation(void* asset, int index, bool loop, bool reverse) {
+  FLUTTER_PLUGIN_EXPORT void play_animation(
-    ((SceneAsset*)asset)->playAnimation(index, loop, reverse);
+    void* assetManager,
+    EntityId asset, 
+    int index, 
+    bool loop, 
+    bool reverse) {
+    ((AssetManager*)assetManager)->playAnimation(asset, index, loop, reverse);
   }
 
-  void set_animation_frame(void* asset, int animationIndex, int animationFrame) {
+  FLUTTER_PLUGIN_EXPORT void set_animation_frame(
-    ((SceneAsset*)asset)->setAnimationFrame(animationIndex, animationFrame);
+    void* assetManager,
+    EntityId asset, 
+    int animationIndex, 
+    int animationFrame) {
+    // ((AssetManager*)assetManager)->setAnimationFrame(asset, animationIndex, animationFrame);
   }
 
-  int get_animation_count(void* asset) {
+  FLUTTER_PLUGIN_EXPORT int get_animation_count(
-    auto names = ((SceneAsset*)asset)->getAnimationNames();
+    void* assetManager,
+    EntityId asset) {
+    auto names = ((AssetManager*)assetManager)->getAnimationNames(asset);
     return names->size();
   }
 
-  void get_animation_name(void* asset, char* const outPtr, int index) {
+  FLUTTER_PLUGIN_EXPORT void get_animation_name(
-    auto names = ((SceneAsset*)asset)->getAnimationNames();
+    void* assetManager,
+    EntityId asset, 
+    char* const outPtr, 
+    int index
+  ) {
+    auto names = ((AssetManager*)assetManager)->getAnimationNames(asset);
     string name = names->at(index);
     strcpy(outPtr, name.c_str());
   }
   
-  int get_morph_target_name_count(void* asset, const char* meshName) {
+  FLUTTER_PLUGIN_EXPORT int get_morph_target_name_count(void* assetManager, EntityId asset, const char* meshName) {
-    unique_ptr<vector<string>> names = ((SceneAsset*)asset)->getMorphTargetNames(meshName);
+    unique_ptr<vector<string>> names = ((AssetManager*)assetManager)->getMorphTargetNames(asset, meshName);
     return names->size();
   }
 
-  void get_morph_target_name(void* asset, const char* meshName, char* const outPtr, int index ) {
+  FLUTTER_PLUGIN_EXPORT void get_morph_target_name(void* assetManager, EntityId asset, const char* meshName, char* const outPtr, int index ) {
-    unique_ptr<vector<string>> names = ((SceneAsset*)asset)->getMorphTargetNames(meshName);
+    unique_ptr<vector<string>> names = ((AssetManager*)assetManager)->getMorphTargetNames(asset, meshName);
     string name = names->at(index);
     strcpy(outPtr, name.c_str());
   }
 
-  void remove_asset(void* viewer, void* asset) {
+  FLUTTER_PLUGIN_EXPORT void remove_asset(void* viewer, EntityId asset) {
-    ((FilamentViewer*)viewer)->removeAsset((SceneAsset*)asset);
+    ((FilamentViewer*)viewer)->removeAsset(asset);
   }
 
-  void clear_assets(void* viewer) {
+  FLUTTER_PLUGIN_EXPORT void clear_assets(void* viewer) {
     ((FilamentViewer*)viewer)->clearAssets();
   }
 
-  void load_texture(void* asset, const char* assetPath, int renderableIndex) {
+  FLUTTER_PLUGIN_EXPORT void load_texture(void* assetManager, EntityId asset, const char* assetPath, int renderableIndex) {
-    ((SceneAsset*)asset)->loadTexture(assetPath, renderableIndex);
+    // ((AssetManager*)assetManager)->loadTexture(assetPath, renderableIndex);
   }
 
-  void set_texture(void* asset) {
+  FLUTTER_PLUGIN_EXPORT void set_texture(void* assetManager, EntityId asset) {
-    ((SceneAsset*)asset)->setTexture();
+    // ((AssetManager*)assetManager)->setTexture();
   }
 
-  void transform_to_unit_cube(void* asset) {
+  FLUTTER_PLUGIN_EXPORT void transform_to_unit_cube(void* assetManager, EntityId asset) {
-    ((SceneAsset*)asset)->transformToUnitCube();
+    ((AssetManager*)assetManager)->transformToUnitCube(asset);
   }
 
-  void set_position(void* asset, float x, float y, float z) {
+  FLUTTER_PLUGIN_EXPORT void set_position(void* assetManager, EntityId asset, float x, float y, float z) {
-     ((SceneAsset*)asset)->setPosition(x, y, z);
+     ((AssetManager*)assetManager)->setPosition(asset, x, y, z);
   }
 
-   void set_rotation(void* asset, float rads, float x, float y, float z) {
+  FLUTTER_PLUGIN_EXPORT void set_rotation(void* assetManager, EntityId asset, float rads, float x, float y, float z) {
-     ((SceneAsset*)asset)->setRotation(rads, x, y, z);
+     ((AssetManager*)assetManager)->setRotation(asset, rads, x, y, z);
    }
 
-  void set_scale(void* asset, float scale) {
+  FLUTTER_PLUGIN_EXPORT void set_scale(void* assetManager, EntityId asset, float scale) {
-     ((SceneAsset*)asset)->setScale(scale);
+    ((AssetManager*)assetManager)->setScale(asset, scale);
-   }
+  }
 
-  void stop_animation(void* asset, int index) {
+  FLUTTER_PLUGIN_EXPORT void stop_animation(void* assetManager, EntityId asset, int index) {
-     ((SceneAsset*)asset)->stopAnimation(index);
+     ((AssetManager*)assetManager)->stopAnimation(asset, index);
   }
   
 }

ios/src/SceneAsset.cpp

@@ -1,517 +0,0 @@
-#include <iostream>
-#include <chrono>
-
-#include <filament/Engine.h>
-#include <filament/TransformManager.h>
-#include <filament/Texture.h>
-#include <filament/RenderableManager.h>
-
-#include <gltfio/Animator.h>
-#include <gltfio/AssetLoader.h>
-#include <gltfio/FilamentAsset.h>
-#include <gltfio/ResourceLoader.h>
-#include <gltfio/TextureProvider.h>
-
-#include <imageio/ImageDecoder.h>
-
-#include "StreamBufferAdapter.hpp"
-#include "SceneAsset.hpp"
-#include "Log.hpp"
-#include "ResourceManagement.hpp"
-#include "SceneAssetAnimation.hpp"
-
-using namespace std::chrono;
-
-namespace polyvox {
-
-using namespace std;
-using namespace filament;
-using namespace filament::gltfio;
-using namespace image;
-using namespace utils;
-
-SceneAsset::SceneAsset(FilamentAsset *asset, Engine *engine,
-                       NameComponentManager *ncm, LoadResource loadResource, FreeResource freeResource)
-    : _asset(asset), _engine(engine), _ncm(ncm), _loadResource(loadResource), _freeResource(freeResource) {
-  _animator = _asset->getInstance()->getAnimator();
-  for (int i = 0; i < _animator->getAnimationCount(); i++) {
-    _embeddedAnimationStatus.push_back(
-        GLTFAnimation(false,false));
-  }
-  Log("Created animation buffers for %d", _embeddedAnimationStatus.size());
-}
-
-SceneAsset::~SceneAsset() { 
-  // most other destructor work is deferred to SceneAssetLoader so we don't need to do anything here
-  if(_texture) {
-    _engine->destroy(_texture);
-    _texture = nullptr;
-  }
-}
-
-void SceneAsset::setMorphTargetWeights(const char* const entityName, float *weights, int count) {
-  // TODO 
-}
-
-void SceneAsset::setAnimation(
-                const char* entityName,
-                const float* const morphData,
-                int numMorphWeights, 
-                const BoneAnimation* const boneAnimations,
-                int numBoneAnimations,
-                int numFrames, 
-                float frameLengthInMs) {
-
-  auto filamentInstance = _asset->getInstance();
-
-  size_t skinCount = filamentInstance->getSkinCount();
-
-  if(skinCount > 1) { 
-    Log("WARNING - skin count > 1 not currently implemented. This will probably not work");
-  }
-  
-  auto transforms = make_unique<vector<BoneTransformTarget>>();
-
-  auto numFloats = numFrames * 7;
-
-  for(int i = 0; i < numBoneAnimations; i++) {
-    
-    auto boneIndices = make_unique<vector<uint8_t>>();
-    boneIndices->resize(boneAnimations[i].numBones);
-    for(int j = 0; j < boneAnimations[i].numBones; j++) {
-      boneIndices->at(j) = getBoneIndex(boneAnimations[i].boneNames[j]);
-    }
-
-    auto meshTargets = make_unique<vector<Entity>>();
-    for(int j = 0; j < _asset->getEntityCount(); j++) {
-      for(int k = 0; k < boneAnimations[i].numMeshTargets;k++) {
-        auto meshName = boneAnimations[i].meshNames[k];
-        auto entity = _asset->getEntities()[j];    
-        auto nameInstance = _ncm->getInstance(entity);
-        if(strcmp(meshName,_ncm->getName(nameInstance))==0) {
-            meshTargets->push_back(entity);
-        }
-      }
-    }
-
-      auto frameData = make_unique<vector<float>>(
-        boneAnimations[i].data, 
-        boneAnimations[i].data + (numFloats * sizeof(float))
-      );
-
-      transforms->push_back(BoneTransformTarget(
-          boneIndices,
-          meshTargets,
-          frameData
-      ));
-  }
-
-  RenderableManager &rm = _engine->getRenderableManager();
-  Instance inst;
-  for (size_t i = 0, c = _asset->getEntityCount(); i != c; ++i) {
-    auto entity = _asset->getEntities()[i];    
-    auto name = _ncm->getName(_ncm->getInstance(entity));
-
-    if(strcmp(entityName,name)==0) {
-      inst = rm.getInstance(_asset->getEntities()[i]);
-    }
-  }
-
-  if(!inst) {
-    Log("Warning: failed to find Renderable instance for entity %s", entityName);
-  } else {
-
-    _runtimeAnimationBuffer = std::make_unique<RuntimeAnimation>(
-        inst,
-        morphData, 
-        numMorphWeights, 
-        transforms, 
-        numFrames, 
-        frameLengthInMs
-      );
-  }
-}
-
-void SceneAsset::updateAnimations() {
-  updateRuntimeAnimation();
-  updateEmbeddedAnimations();
-}
-
-void SceneAsset::updateRuntimeAnimation() {
-  
-  if (!_runtimeAnimationBuffer) {
-    return;
-  }
-
-  if (_runtimeAnimationBuffer->frameNumber == -1) {
-    _runtimeAnimationBuffer->startTime = high_resolution_clock::now();
-  }  
-
-  duration<double, std::milli> dur =
-        high_resolution_clock::now() - _runtimeAnimationBuffer->startTime;
-    int frameNumber =
-        static_cast<int>(dur.count() / _runtimeAnimationBuffer->mFrameLengthInMs);
-    
-  // if the animation has finished, return early
-  if (frameNumber >= _runtimeAnimationBuffer->mNumFrames) {
-    _runtimeAnimationBuffer = nullptr;
-    return;
-  } 
-
-  RenderableManager &rm = _engine->getRenderableManager();
-  if (frameNumber > _runtimeAnimationBuffer->frameNumber) {
-    _runtimeAnimationBuffer->frameNumber = frameNumber;
-    if(_runtimeAnimationBuffer->mMorphFrameData) {
-      auto morphFramePtrOffset = frameNumber * _runtimeAnimationBuffer->mNumMorphWeights;
-      rm.setMorphWeights(
-        _runtimeAnimationBuffer->mInstance,
-        _runtimeAnimationBuffer->mMorphFrameData + morphFramePtrOffset,
-        _runtimeAnimationBuffer->mNumMorphWeights);
-    }
-
-    if(_runtimeAnimationBuffer->mTargets->size() > 0) {
-      for(auto& target : *(_runtimeAnimationBuffer->mTargets)) {
-        
-        setBoneTransform(
-          target.skinIndex,
-          *(target.mBoneIndices), 
-          *(target.mMeshTargets),
-          *(target.mBoneData),
-          frameNumber
-        );
-      }
-    }
-  }
-}
-
-size_t SceneAsset::getBoneIndex(const char* name) { 
-  
-  auto filamentInstance = _asset->getInstance();
-
-  int skinIndex = 0;
-  const utils::Entity* joints = filamentInstance->getJointsAt(skinIndex);
-  size_t numJoints = filamentInstance->getJointCountAt(skinIndex);
-
-  int boneIndex = -1;
-  for(int i =0; i < numJoints; i++) {
-    const char* jointName = _ncm->getName(_ncm->getInstance(joints[i]));
-    if(strcmp(jointName, name) == 0) { 
-      boneIndex = i;
-      break;
-    }
-  }
-  if(boneIndex == -1) {
-    Log("Failed to find bone index %d for bone %s", name);
-  }
-  return boneIndex;
-}
-
-void SceneAsset::setBoneTransform(
-  uint8_t skinIndex,
-  const vector<uint8_t>& boneIndices,
-  const vector<Entity>& targets, 
-  const vector<float> data,
-  int frameNumber) {  
-
-  auto filamentInstance = _asset->getInstance();
-
-  RenderableManager &rm = _engine->getRenderableManager();
-  TransformManager &transformManager = _engine->getTransformManager();
-
-  auto frameDataOffset = frameNumber * 7;
-
-  for(auto& target : targets) {
-  
-    auto renderable = rm.getInstance(target);
-
-    math::mat4f inverseGlobalTransform = inverse(
-      transformManager.getWorldTransform(
-        transformManager.getInstance(target)
-      )
-    );
-
-    for(auto boneIndex : boneIndices) {
-
-        utils::Entity joint = filamentInstance->getJointsAt(skinIndex)[boneIndex];
-
-        math::mat4f localTransform(math::quatf{
-          data[frameDataOffset+6],
-          data[frameDataOffset+3],
-          data[frameDataOffset+4],
-          data[frameDataOffset+5]
-        });
-
-        const math::mat4f& inverseBindMatrix = filamentInstance->getInverseBindMatricesAt(skinIndex)[boneIndex];
-        auto jointInstance = transformManager.getInstance(joint);
-        math::mat4f globalJointTransform = transformManager.getWorldTransform(jointInstance);
-      
-        math::mat4f boneTransform = inverseGlobalTransform * globalJointTransform * localTransform * inverseBindMatrix;
-        
-        rm.setBones(
-        renderable, 
-        &boneTransform,
-        1, boneIndex);
-    }    
-  }
-}
-
-void SceneAsset::playAnimation(int index, bool loop, bool reverse) {
-  if (index > _animator->getAnimationCount() - 1) {
-    Log("Asset does not contain an animation at index %d", index);
-  } else {
-    const char* name = _animator->getAnimationName(index);
-    Log("Playing animation %d : %s", index, name);
-    if (_embeddedAnimationStatus[index].started) {
-      Log("Animation already playing, call stop first.");
-    } else {
-      Log("Starting animation at index %d with loop : %d and reverse %d ", index, loop, reverse);
-      _embeddedAnimationStatus[index].play = true;
-      _embeddedAnimationStatus[index].loop = loop;
-      _embeddedAnimationStatus[index].reverse = reverse;
-    }
-  }
-}
-
-void SceneAsset::stopAnimation(int index) {
-  Log("Stopping animation %d", index);
-  // TODO - does this need to be threadsafe?
-  _embeddedAnimationStatus[index].play = false;
-  _embeddedAnimationStatus[index].started = false;
-}
-
-void SceneAsset::loadTexture(const char* resourcePath, int renderableIndex) {
-
-  Log("Loading texture at %s for renderableIndex %d", resourcePath, renderableIndex);
-
-  string rp(resourcePath);
-
-  if(_texture) {
-    _engine->destroy(_texture);
-    _texture = nullptr;
-  }
-  
-  ResourceBuffer imageResource = _loadResource(rp.c_str());
-  
-  StreamBufferAdapter sb((char *)imageResource.data, (char *)imageResource.data + imageResource.size);
-
-  istream *inputStream = new std::istream(&sb);
-
-  LinearImage *image = new LinearImage(ImageDecoder::decode(
-      *inputStream, rp.c_str(), ImageDecoder::ColorSpace::SRGB));
-
-  if (!image->isValid()) {
-    Log("Invalid image : %s", rp.c_str());
-    return;
-  }
-
-  uint32_t channels = image->getChannels();
-  uint32_t w = image->getWidth();
-  uint32_t h = image->getHeight();
-  _texture = Texture::Builder()
-                      .width(w)
-                      .height(h)
-                      .levels(0xff)
-                      .format(channels == 3 ? Texture::InternalFormat::RGB16F
-                                            : Texture::InternalFormat::RGBA16F)
-                      .sampler(Texture::Sampler::SAMPLER_2D)
-                      .build(*_engine);
-
-  Texture::PixelBufferDescriptor::Callback freeCallback = [](void *buf, size_t,
-                                                            void *data) {
-    delete reinterpret_cast<LinearImage *>(data);
-  };
-
-  Texture::PixelBufferDescriptor buffer(
-      image->getPixelRef(), size_t(w * h * channels * sizeof(float)),
-      channels == 3 ? Texture::Format::RGB : Texture::Format::RGBA,
-      Texture::Type::FLOAT, freeCallback);
-
-  _texture->setImage(*_engine, 0, std::move(buffer));
-  setTexture();
-  delete inputStream;
-
-  _freeResource(imageResource.id);
-  
-}
-
-void SceneAsset::setTexture() {
-  
-  MaterialInstance* const* inst = _asset->getInstance()->getMaterialInstances();
-  size_t mic =  _asset->getInstance()->getMaterialInstanceCount();
-  Log("Material instance count : %d", mic);
-    
-  auto sampler = TextureSampler();
-  inst[0]->setParameter("baseColorIndex",0);
-  inst[0]->setParameter("baseColorMap",_texture,sampler);
-
-}
-
-void SceneAsset::setAnimationFrame(int animationIndex, int animationFrame) {
-  auto offset = 60 * animationFrame * 1000; // TODO - don't hardcore 60fps framerate
-  _animator->applyAnimation(animationIndex, offset);
-  _animator->updateBoneMatrices();
-}
-
-void SceneAsset::updateEmbeddedAnimations() {
-  auto now = high_resolution_clock::now();
-  
-  bool needsUpdate = false;
-  for (int animationIndex = 0; animationIndex < _embeddedAnimationStatus.size(); animationIndex++) {
-    auto &status = _embeddedAnimationStatus[animationIndex];
-    if (status.play == false) {
-      continue;
-    }
-    needsUpdate = true;
-
-    float animationLength = _animator->getAnimationDuration(animationIndex);
-    
-    duration<double> elapsed =
-        duration_cast<duration<double>>(now - status.startedAt);
-    float animationTimeOffset = 0;
-    bool finished = false;
-    bool fading = false;
-    
-    // if the animation hasn't started yet, start the animation at time zero
-    if (!status.started) {
-      status.started = true;
-      status.startedAt = now;
-    
-    // if the animation has finished
-    } else if (elapsed.count() >= animationLength) {
-      // if we aren't looping, just mark the animation as finished 
-      if(!status.loop) {
-        finished = true;
-      // otherwise, cross-fade between the end of the animation and the start frame over 1 second
-      } else {
-        // if 1 second has elapsed, 
-        if(elapsed.count() >= animationLength + 0.3) {
-          // reset the start time to zero 
-          status.startedAt = now;
-        // otherwise, apply the first frame of the animation, then cross-fade with the last frame over 1 second
-        } else { 
-          fading = true;
-        }
-      }
-    } else {
-      animationTimeOffset = elapsed.count();
-    }
-
-    if (finished) {
-      Log("Animation %d finished", animationIndex);
-      status.play = false;
-      status.started = false;
-    } else {
-      if(status.reverse) {
-        animationTimeOffset = _animator->getAnimationDuration(animationIndex) - animationTimeOffset;
-      }       
-      _animator->applyAnimation(animationIndex, animationTimeOffset);
-      if(fading) {
-        // Log("Fading at %0f offset %f", elapsed.count() - animationLength, animationTimeOffset);
-        _animator->applyCrossFade(animationIndex, animationLength - 0.05, (elapsed.count() - animationLength) / 0.3);
-      }
-    } 
-  }
-  if(needsUpdate) {
-    _animator->updateBoneMatrices();
-  }
-  needsUpdate = false;
-}
-
-unique_ptr<vector<string>> SceneAsset::getAnimationNames() {
-  size_t count = _animator->getAnimationCount();
-
-  unique_ptr<vector<string>> names = make_unique<vector<string>>();
-
-  for (size_t i = 0; i < count; i++) {
-    names->push_back(_animator->getAnimationName(i));
-  }
-
-  return names;
-}
-
-unique_ptr<vector<string>> SceneAsset::getMorphTargetNames(const char *meshName) {
-  if (!_asset) {
-    Log("No asset, ignoring call.");
-    return nullptr;
-  }
-//  Log("Retrieving morph target names for mesh  %s", meshName);
-  unique_ptr<vector<string>> names = make_unique<vector<string>>();
-  const Entity *entities = _asset->getEntities();
-  
-  for (int i = 0; i < _asset->getEntityCount(); i++) {
-    Entity e = entities[i];
-    auto inst = _ncm->getInstance(e);
-    const char *name = _ncm->getName(inst);
-
-    if (strcmp(name, meshName) == 0) {
-      size_t count = _asset->getMorphTargetCountAt(e);
-      for (int j = 0; j < count; j++) {
-        const char *morphName = _asset->getMorphTargetNameAt(e, j);
-        names->push_back(morphName);
-      }
-      break;
-    }
-  }
-  return names;
-}
-
-void SceneAsset::transformToUnitCube() {
-  if (!_asset) {
-    Log("No asset, cannot transform.");
-    return;
-  }
-  Log("Transforming asset to unit cube.");
-  auto &tm = _engine->getTransformManager();
-  FilamentInstance* inst = _asset->getInstance();
-  auto aabb = inst->getBoundingBox();
-  auto center = aabb.center();
-  auto halfExtent = aabb.extent();
-  auto maxExtent = max(halfExtent) * 2;
-  auto scaleFactor = 2.0f / maxExtent;
-  auto transform =
-      math::mat4f::scaling(scaleFactor) * math::mat4f::translation(-center);
-  tm.setTransform(tm.getInstance(inst->getRoot()), transform);
-}
-
-void SceneAsset::updateTransform() {
-  auto &tm = _engine->getTransformManager();
-  auto transform = 
-      _position * _rotation * math::mat4f::scaling(_scale);
-  tm.setTransform(tm.getInstance(_asset->getRoot()), transform);
-}
-
-void SceneAsset::setScale(float scale) {
-  _scale = scale;
-  updateTransform();
-}
-
-void SceneAsset::setPosition(float x, float y, float z) {
-  Log("Setting position to %f %f %f", x, y, z);
-  _position = math::mat4f::translation(math::float3(x,y,z));
-  updateTransform();
-}
-
-void SceneAsset::setRotation(float rads, float x, float y, float z) {
-  Log("Rotating %f radians around axis %f %f %f", rads, x, y, z);
-  _rotation = math::mat4f::rotation(rads, math::float3(x,y,z));
-  updateTransform();
-}
-
-const utils::Entity *SceneAsset::getCameraEntities() {
-  return _asset->getCameraEntities();
-}
-
-size_t SceneAsset::getCameraEntityCount() {
-  return _asset->getCameraEntityCount();
-}
-
-const Entity* SceneAsset::getLightEntities() const noexcept { 
-  return _asset->getLightEntities();
-}
-
-size_t SceneAsset::getLightEntityCount() const noexcept {
-  return _asset->getLightEntityCount();
-}
-
-
-} // namespace polyvox

ios/src/SceneAssetLoader.cpp

@@ -1,196 +0,0 @@
-#include "SceneAssetLoader.hpp"
-#include "Log.hpp"
-
-#include <gltfio/Animator.h>
-
-namespace polyvox {
-
-using namespace filament;
-using namespace filament::gltfio;
-
-SceneAssetLoader::SceneAssetLoader(LoadResource loadResource,
-                                   FreeResource freeResource,
-                                   MaterialProvider* materialProvider,
-                                   EntityManager* entityManager, 
-                                   ResourceLoader *resourceLoader,
-                                   NameComponentManager *ncm, 
-                                   Engine *engine,
-                                   Scene *scene)
-    : _loadResource(loadResource), _freeResource(freeResource), _resourceLoader(resourceLoader), _ncm(ncm),
-      _engine(engine), _scene(scene) {
-        _assetLoader =   AssetLoader::create({_engine, materialProvider, _ncm, entityManager});
-      }
-
-SceneAssetLoader::~SceneAssetLoader() { 
-  destroyAll();
-  AssetLoader::destroy(&_assetLoader);
-}
-
-SceneAsset *SceneAssetLoader::fromGltf(const char *uri,
-                                       const char *relativeResourcePath) {
-  ResourceBuffer rbuf = _loadResource(uri);
-
-  // Parse the glTF file and create Filament entities.
-  Log("Creating asset from JSON");
-  FilamentAsset *asset =
-      _assetLoader->createAsset((uint8_t *)rbuf.data, rbuf.size);
-  Log("Created asset from JSON");
-
-  if (!asset) {
-    Log("Unable to parse asset");
-    return nullptr;
-  }
-  Log("Loading relative resources");
-
-  const char *const *const resourceUris = asset->getResourceUris();
-  const size_t resourceUriCount = asset->getResourceUriCount();
-
-  Log("Loading %d resources for asset", resourceUriCount);
-
-  for (size_t i = 0; i < resourceUriCount; i++) {
-    string uri =
-        string(relativeResourcePath) + string("/") + string(resourceUris[i]);
-    Log("Creating resource buffer for resource at %s", uri.c_str());
-    ResourceBuffer buf = _loadResource(uri.c_str());
-
-    // using FunctionCallback = std::function<void(void*, unsigned int, void
-    // *)>; auto cb = [&] (void * ptr, unsigned int len, void * misc)  {
-    // };
-    // FunctionCallback fcb = cb;
-
-    ResourceLoader::BufferDescriptor b(buf.data, buf.size);
-    _resourceLoader->addResourceData(resourceUris[i], std::move(b));
-    _freeResource(buf.id);
-  }
-
-  _resourceLoader->loadResources(asset);
-  const Entity *entities = asset->getEntities();
-  RenderableManager &rm = _engine->getRenderableManager();
-  for (int i = 0; i < asset->getEntityCount(); i++) {
-    Entity e = entities[i];
-    auto inst = rm.getInstance(e);
-    rm.setCulling(inst, false);
-  }
-
-  FilamentInstance* inst = asset->getInstance();
-  inst->getAnimator()->updateBoneMatrices();
-
-  inst->recomputeBoundingBoxes();
-
-  _scene->addEntities(asset->getEntities(), asset->getEntityCount());
-
-  Log("Loaded relative resources");
-  asset->releaseSourceData();
-
-  Log("Load complete for GLTF at URI %s", uri);
-  return new SceneAsset(asset, _engine, _ncm, _loadResource,_freeResource);
-}
-
-SceneAsset *SceneAssetLoader::fromGlb(const char *uri) {
-  Log("Loading GLB at URI %s", uri);
-
-  ResourceBuffer rbuf = _loadResource(uri);
-
-  FilamentAsset *asset = _assetLoader->createAsset(
-      (const uint8_t *)rbuf.data, rbuf.size);
-
-
-  if (!asset) {
-    Log("Unknown error loading GLB asset.");
-    return nullptr;
-  }
-
-  int entityCount = asset->getEntityCount();
-
-  _scene->addEntities(asset->getEntities(), entityCount);
-
-  Log("Added %d entities to scene", entityCount);
-  
-  _resourceLoader->loadResources(asset);
-
-  Log("Resources loaded.");
-
-  // const Entity *entities = asset->getEntities();
-
-  // RenderableManager &rm = _engine->getRenderableManager();
-
-  // MaterialKey config;
-  // auto mi_new = _materialProvider->createMaterialInstance(&config, nullptr);
-  
-  // for (int i = 0; i < asset->getEntityCount(); i++) {
-  //   auto entityInstance = rm.getInstance(entities[i]);   
-  //   auto mi = rm.getMaterialInstanceAt(entityInstance, 0);
-  //   // auto m = mi->getMaterial();
-  //   // auto shading = m->getShading();
-  //   // Log("Shading %d", shading);
-  // }
-
-  auto lights = asset->getLightEntities();
-  _scene->addEntities(lights, asset->getLightEntityCount());
-  
-  Log("Added %d lights to scene from asset", asset->getLightEntityCount());
-
-  FilamentInstance* inst = asset->getInstance();
-
-
-  inst->getAnimator()->updateBoneMatrices();
-
-  inst->recomputeBoundingBoxes();
-
-  asset->releaseSourceData();
-  Log("Source data released.");
-
-  _freeResource(rbuf.id);
-
-  Log("Successfully loaded GLB.");
-  SceneAsset* sceneAsset = new SceneAsset(asset, _engine, _ncm, _loadResource, _freeResource);
-  _assets.push_back(sceneAsset);
-
-
-  
-
-  return sceneAsset;
-}
-
-void SceneAssetLoader::destroyAll() {
-  for (auto asset : _assets) {
-     _scene->removeEntities(asset->_asset->getEntities(),
-                         asset->_asset->getEntityCount());
-
-    _scene->removeEntities(asset->getLightEntities(),
-                          asset->getLightEntityCount());
-
-    _resourceLoader->evictResourceData();
-    _assetLoader->destroyAsset(asset->_asset);
-    delete asset;
-  }
-  _assets.clear();
-}
-
-void SceneAssetLoader::remove(SceneAsset *asset) {
-  bool erased = false;
-  for (auto it = _assets.begin(); it != _assets.end();++it) {
-    if (*it == asset) {
-      _assets.erase(it);
-      erased = true;
-      break;
-    }
-  }
-  if (!erased) {
-    Log("Error removing asset from scene : not found");
-    return;
-  }
-
-  Log("Removing asset and all associated entities/lights.");
-
-  _scene->removeEntities(asset->_asset->getEntities(),
-                         asset->_asset->getEntityCount());
-
-  _scene->removeEntities(asset->getLightEntities(),
-                         asset->getLightEntityCount());
-
-  _resourceLoader->evictResourceData();
-  _assetLoader->destroyAsset(asset->_asset);
-  delete asset;
-}
-} // namespace polyvox

ios/src/TimeIt.cpp

@@ -0,0 +1,30 @@
+#include "TimeIt.hpp"
+
+#if __cplusplus <= 199711L
+
+void Timer::reset()
+{
+  clock_gettime(CLOCK_REALTIME, &beg_);
+}
+
+double Timer::elapsed()
+{
+  clock_gettime(CLOCK_REALTIME, &end_);
+  return end_.tv_sec - beg_.tv_sec +
+      (end_.tv_nsec - beg_.tv_nsec) / 1000000000.;
+}
+
+#else
+
+void Timer::reset()
+{
+  beg_ = clock_::now();
+}
+
+double Timer::elapsed()
+{
+  return std::chrono::duration_cast<second_>
+      (clock_::now() - beg_).count();
+}
+
+#endif

ios/src/ios/PolyvoxFilamentIOSApi.cpp

@@ -11,7 +11,7 @@ extern "C" {
     using RawLoadType = ResourceBuffer(const char*, void* resource);
     using RawFreeType = void(uint32_t, void*);
 
-    void* filament_viewer_new_ios(void* pb, void* loadResource, void* freeResource, void* resources) {
+    void* create_filament_viewer_ios(void* pb, void* loadResource, void* freeResource, void* resources) {
             
       FreeResource _freeResource = [=](uint32_t rid) {
         reinterpret_cast<RawFreeType*>(freeResource)(rid, resources);

lib/animations/animation_builder.dart

@@ -1,9 +1,11 @@
-import 'animations.dart';
+import 'package:polyvox_filament/animations/animations.dart';
+import 'package:tuple/tuple.dart';
+
 import 'package:flutter/foundation.dart';
 import 'package:vector_math/vector_math.dart';
 
 class AnimationBuilder {
-  BoneAnimation? boneAnimation;
+  DartBoneAnimation? dartBoneAnimation;
   double _frameLengthInMs = 0;
   double _duration = 0;
   int _numMorphWeights = 0;
@@ -13,9 +15,10 @@ class AnimationBuilder {
   double? _interpMorphStartValue;
   double? _interpMorphEndValue;
 
-  List<BoneAnimation>? _boneAnimations = null;
+  List<DartBoneAnimation>? _dartBoneAnimations = null;
 
-  Animation build(String meshName, List<String> morphNames) {
+  Tuple2<MorphAnimation, List<DartBoneAnimation>> build(
+      String meshName, List<String> morphNames) {
     if (_numMorphWeights == 0 || _duration == 0 || _frameLengthInMs == 0)
       throw Exception();
 
@@ -39,8 +42,8 @@ class AnimationBuilder {
     var morphAnimation =
         MorphAnimation(meshName, morphData, morphNames, _frameLengthInMs);
 
-    return Animation(
+    return Tuple2<MorphAnimation, List<DartBoneAnimation>>(
-        morphAnimation: morphAnimation, boneAnimations: _boneAnimations);
+        morphAnimation, _dartBoneAnimations!);
   }
 
   AnimationBuilder setFramerate(int framerate) {
@@ -107,16 +110,18 @@ class AnimationBuilder {
       }
     }
 
-    var boneFrameData = BoneTransformFrameData(translations, quats);
+    throw Exception();
 
-    _boneAnimations ??= <BoneAnimation>[];
+    // var boneFrameData = BoneTransformFrameData(translations, quats);
 
-    var frameData = List<List<double>>.generate(
+    // _DartBoneAnimations ??= <DartBoneAnimation>[];
-        numFrames, (index) => boneFrameData.getFrameData(index).toList());
 
-    var animData = Float32List.fromList(frameData.expand((x) => x).toList());
+    // var frameData = List<List<double>>.generate(
+    //     numFrames, (index) => boneFrameData.getFrameData(index).toList());
 
-    _boneAnimations!.add(BoneAnimation([boneName], [meshName], animData));
+    // var animData = Float32List.fromList(frameData.expand((x) => x).toList());
+
+    // _DartBoneAnimations!.add(DartDartBoneAnimation([boneName], [meshName], animData));
 
     return this;
   }

lib/animations/animations.dart

@@ -2,16 +2,13 @@ import 'dart:typed_data';
 
 import 'package:vector_math/vector_math.dart';
 
-class BoneAnimation {
+class DartBoneAnimation {
-  final List<String> boneNames;
+  final String boneName;
-  final List<String> meshNames;
+  final String meshName;
   final Float32List frameData;
-
+  double frameLengthInMs;
-  BoneAnimation(this.boneNames, this.meshNames, this.frameData);
+  DartBoneAnimation(
-
+      this.boneName, this.meshName, this.frameData, this.frameLengthInMs);
-  List<List> toList() {
-    return [boneNames, meshNames, frameData];
-  }
 }
 
 //
@@ -24,25 +21,18 @@ class MorphAnimation {
   final String meshName;
   final List<String> morphNames;
 
-  late final Float32List morphData;
+  final Float32List data;
 
   MorphAnimation(
-      this.meshName, this.morphData, this.morphNames, this.frameLengthInMs);
+      this.meshName, this.data, this.morphNames, this.frameLengthInMs);
 
   int get numMorphWeights => morphNames.length;
 
-  int get numFrames => morphData.length ~/ numMorphWeights;
+  int get numFrames => data.length ~/ numMorphWeights;
 
   final double frameLengthInMs;
 }
 
-class Animation {
-  final MorphAnimation? morphAnimation;
-  final List<BoneAnimation>? boneAnimations;
-
-  Animation({this.morphAnimation, this.boneAnimations});
-}
-
 class BoneTransformFrameData {
   final List<Vector3> translations;
   final List<Quaternion> quaternions;
@@ -67,18 +57,3 @@ class BoneTransformFrameData {
     yield quaternions[frame].w;
   }
 }
-
-// Animation.from(
-//     {required this.meshName,
-//     required List<List<double>> morphData,
-//     required this.numMorphWeights,
-//     this.boneAnimations,
-//     required this.numFrames,
-//     required this.frameLengthInMs}) {
-//   if (morphData.length != numFrames) {
-//     throw Exception("Mismatched animation data with frame length");
-//   }
-// }
-
-//  not directly used, the list of morph targets animated by this [Animation], and may be a subset of the actual morph targets in the asset (and may also be ordered differently).
-// // When passed to a [FilamentController], these will be re-mapped appropriately (and any morph targets not provided will be set to zero at each frame).

lib/filament_controller.dart

@@ -1,115 +1,27 @@
 import 'dart:async';
-import 'dart:typed_data';
+import 'dart:ffi';
-import 'dart:ui';
+import 'dart:io';
+import 'dart:ui' as ui;
+
+import 'package:ffi/ffi.dart';
+import 'package:flutter/animation.dart';
+import 'package:flutter/scheduler.dart';
 
 import 'package:flutter/services.dart';
+import 'package:polyvox_filament/generated_bindings.dart';
 
-import 'animations/animation_builder.dart';
 import 'animations/animations.dart';
 
-// this is confusing - "FilamentAsset" actually defines a pointer to a SceneAsset, whereas FilamentLight is an Entity ID.
+typedef AssetManager = Pointer<Void>;
-// should make this consistent
+typedef FilamentViewer = Pointer<Void>;
-typedef FilamentAsset = int;
+typedef FilamentEntity = int;
-typedef FilamentLight = int;
+const FilamentEntity FILAMENT_ASSET_ERROR = 0;
-const FilamentAsset FILAMENT_ASSET_ERROR = 0;
 
-abstract class FilamentController {
+class FilamentController {
-  Size get size;
-  late Stream<int?> textureId;
-  Future get initialized;
-  Stream get onInitializationRequested;
-  Future initialize();
-  Future createTextureViewer(int width, int height);
-  Future setFrameRate(int framerate);
-  Future setRendering(bool render);
-  Future render();
-  void setPixelRatio(double ratio);
-  Future resize(int width, int height, {double contentScaleFactor = 1});
-  Future setBackgroundColor(Color color);
-  Future clearBackgroundImage();
-  Future setBackgroundImage(String path);
-  Future setBackgroundImagePosition(double x, double y, {bool clamp = false});
-  Future loadSkybox(String skyboxPath);
-  Future removeSkybox();
-  Future loadIbl(String path, {double intensity = 30000});
-  Future removeIbl();
-
-  // copied from LightManager.h
-  //  enum class Type : uint8_t {
-  //       SUN,            //!< Directional light that also draws a sun's disk in the sky.
-  //       DIRECTIONAL,    //!< Directional light, emits light in a given direction.
-  //       POINT,          //!< Point light, emits light from a position, in all directions.
-  //       FOCUSED_SPOT,   //!< Physically correct spot light.
-  //       SPOT,           //!< Spot light with coupling of outer cone and illumination disabled.
-  //   };
-  Future<FilamentLight> addLight(
-      int type,
-      double colour,
-      double intensity,
-      double posX,
-      double posY,
-      double posZ,
-      double dirX,
-      double dirY,
-      double dirZ,
-      bool castShadows);
-  Future removeLight(FilamentLight light);
-  Future clearLights();
-  Future<FilamentAsset> loadGlb(String path, {bool unlit = false});
-  Future<FilamentAsset> loadGltf(String path, String relativeResourcePath);
-  Future zoomBegin();
-  Future zoomUpdate(double z);
-  Future zoomEnd();
-  Future panStart(double x, double y);
-  Future panUpdate(double x, double y);
-  Future panEnd();
-  Future rotateStart(double x, double y);
-  Future rotateUpdate(double x, double y);
-  Future rotateEnd();
-  Future setMorphTargetWeights(FilamentAsset asset, List<double> weights);
-  Future<List<String>> getMorphTargetNames(
-      FilamentAsset asset, String meshName);
-  Future<List<String>> getAnimationNames(FilamentAsset asset);
-  Future removeAsset(FilamentAsset asset);
-  Future clearAssets();
-  Future setAnimationFrame(
-      FilamentAsset asset, int animationIndex, int animationFrame);
-  Future playAnimation(FilamentAsset asset, int index,
-      {bool loop = false, bool reverse = false});
-  Future playAnimations(FilamentAsset asset, List<int> indices,
-      {bool loop = false, bool reverse = false});
-  Future stopAnimation(FilamentAsset asset, int index);
-  Future setCamera(FilamentAsset asset, String name);
-  Future setTexture(FilamentAsset asset, String assetPath,
-      {int renderableIndex = 0});
-  Future transformToUnitCube(FilamentAsset asset);
-  Future setPosition(FilamentAsset asset, double x, double y, double z);
-  Future setRotation(
-      FilamentAsset asset, double rads, double x, double y, double z);
-  // Future setBoneTransform(FilamentAsset asset, String boneName, String meshName,
-  //     BoneTransform transform);
-  Future setScale(FilamentAsset asset, double scale);
-  Future setCameraExposure(
-      double aperture, double shutterSpeed, double sensitivity);
-  Future setCameraFocalLength(double focalLength);
-  Future setCameraFocusDistance(double focusDistance);
-  Future setCameraPosition(double x, double y, double z);
-  Future setCameraRotation(double rads, double x, double y, double z);
-  Future setCameraModelMatrix(List<double> matrix);
-
-  ///
-  /// Animates morph target weights/bone transforms (where each frame requires a duration of [frameLengthInMs].
-  /// [morphWeights] is a list of doubles in frame-major format.
-  /// Each frame is [numWeights] in length, and each entry is the weight to be applied to the morph target located at that index in the mesh primitive at that frame.
-  ///
-  Future setAnimation(FilamentAsset asset, Animation animation);
-}
-
-class PolyvoxFilamentController extends FilamentController {
   late MethodChannel _channel = MethodChannel("app.polyvox.filament/event");
 
   double _pixelRatio = 1.0;
-  Size size = Size(0, 0);
+  ui.Size size = ui.Size.zero;
 
   int? _textureId;
   final _textureIdController = StreamController<int?>.broadcast();
@@ -121,15 +33,27 @@ class PolyvoxFilamentController extends FilamentController {
   final _initialized = Completer();
   Future get initialized => _initialized.future;
 
-  PolyvoxFilamentController() {
+  late NativeLibrary _nativeLibrary;
+
+  late FilamentViewer _viewer;
+  late AssetManager _assetManager;
+
+  final TickerProvider _tickerProvider;
+  Ticker? _ticker;
+  bool _rendering = false;
+
+  FilamentController(this._tickerProvider) {
     _channel.setMethodCallHandler((call) async {
-      print("Received Filament method channel call : ${call.method}");
       throw Exception("Unknown method channel invocation ${call.method}");
     });
 
     _textureIdController.onListen = () {
       _textureIdController.add(_textureId);
     };
+
+    _nativeLibrary = NativeLibrary(Platform.isAndroid || Platform.isLinux
+        ? DynamicLibrary.open("libpolyvox_filament_plugin.so")
+        : DynamicLibrary.process());
   }
 
   Future initialize() async {
@@ -138,89 +62,126 @@ class PolyvoxFilamentController extends FilamentController {
   }
 
   Future setRendering(bool render) async {
-    await _channel.invokeMethod("setRendering", render);
+    _rendering = render;
   }
 
-  Future render() async {
+  void render() {
-    await _channel.invokeMethod("render");
+    _nativeLibrary.render(_viewer, 0);
+    _channel.invokeMethod("onFrameAvailable");
   }
 
   Future setFrameRate(int framerate) async {
-    await _channel.invokeMethod("setFrameInterval", 1 / framerate);
+    _nativeLibrary.set_frame_interval(_viewer, 1 / framerate);
   }
 
   void setPixelRatio(double ratio) {
-    print("Set pixel ratio to $ratio");
     _pixelRatio = ratio;
   }
 
   Future createTextureViewer(int width, int height) async {
-    size = Size(width * _pixelRatio, height * _pixelRatio);
+    size = ui.Size(width * _pixelRatio, height * _pixelRatio);
-    print("Creating texture of size $size");
     _textureId =
-        await _channel.invokeMethod("initialize", [size.width, size.height]);
+        await _channel.invokeMethod("createTexture", [size.width, size.height]);
     _textureIdController.add(_textureId);
+
+    var glContext =
+        Pointer<Void>.fromAddress(await _channel.invokeMethod("getContext"));
+
+    final loadResource = Pointer<
+            NativeFunction<ResourceBuffer Function(Pointer<Char>)>>.fromAddress(
+        await _channel.invokeMethod("getLoadResourceFn"));
+
+    print("got $loadResource loadResource");
+    var freeResource =
+        Pointer<NativeFunction<Void Function(Uint32)>>.fromAddress(
+            await _channel.invokeMethod("getFreeResourceFn"));
+
+    _viewer = _nativeLibrary.create_filament_viewer(
+        glContext, loadResource, freeResource);
+
+    // don't pass a surface to the SwapChain as we are effectively creating a headless SwapChain that will render into a RenderTarget associated with a texture
+    _nativeLibrary.create_swap_chain(
+        _viewer, nullptr, size.width.toInt(), size.height.toInt());
+
+    var glTextureId = await _channel.invokeMethod("getGlTextureId");
+
+    _nativeLibrary.create_render_target(
+        _viewer, glTextureId, size.width.toInt(), size.height.toInt());
+    _nativeLibrary.update_viewport_and_camera_projection(
+        _viewer, size.width.toInt(), size.height.toInt(), 1.0);
+
     _initialized.complete(true);
+    _assetManager = _nativeLibrary.get_asset_manager(_viewer);
+    print("got asset maanger $_assetManager");
+
+    _ticker = _tickerProvider.createTicker((elapsed) {
+      if (_rendering) {
+        render();
+      }
+    });
+    _ticker!.start();
   }
 
   Future resize(int width, int height,
       {double contentScaleFactor = 1.0}) async {
-    size = Size(width * _pixelRatio, height * _pixelRatio);
+    size = ui.Size(width * _pixelRatio, height * _pixelRatio);
 
     _textureId = await _channel.invokeMethod("resize",
         [width * _pixelRatio, height * _pixelRatio, contentScaleFactor]);
-    print("Resized to $size with texutre Id $textureId");
+
     _textureIdController.add(_textureId);
   }
 
-  @override
+  void clearBackgroundImage() async {
-  Future clearBackgroundImage() async {
+    _nativeLibrary.clear_background_image(_viewer);
-    await _channel.invokeMethod("clearBackgroundImage");
   }
 
-  @override
+  void setBackgroundImage(String path) async {
-  Future setBackgroundImage(String path) async {
+    _nativeLibrary.set_background_image(
-    await _channel.invokeMethod("setBackgroundImage", path);
+        _viewer, path.toNativeUtf8().cast<Char>());
   }
 
-  @override
+  void setBackgroundColor(Color color) async {
-  Future setBackgroundColor(Color color) async {
+    _nativeLibrary.set_background_color(
-    await _channel.invokeMethod("setBackgroundColor", [
+        _viewer,
-      color.red.toDouble() / 255.0,
+        color.red.toDouble() / 255.0,
-      color.green.toDouble() / 255.0,
+        color.green.toDouble() / 255.0,
-      color.blue.toDouble() / 255.0,
+        color.blue.toDouble() / 255.0,
-      color.alpha.toDouble() / 255.0
+        color.alpha.toDouble() / 255.0);
-    ]);
   }
 
-  @override
+  void setBackgroundImagePosition(double x, double y,
-  Future setBackgroundImagePosition(double x, double y,
       {bool clamp = false}) async {
-    await _channel.invokeMethod("setBackgroundImagePosition", [x, y, clamp]);
+    _nativeLibrary.set_background_image_position(_viewer, x, y, clamp ? 1 : 0);
   }
 
-  @override
+  void loadSkybox(String skyboxPath) async {
-  Future loadSkybox(String skyboxPath) async {
+    _nativeLibrary.load_skybox(_viewer, skyboxPath.toNativeUtf8().cast<Char>());
-    await _channel.invokeMethod("loadSkybox", skyboxPath);
   }
 
-  @override
+  void loadIbl(String lightingPath, {double intensity = 30000}) async {
-  Future loadIbl(String lightingPath, {double intensity = 30000}) async {
+    _nativeLibrary.load_ibl(
-    await _channel.invokeMethod("loadIbl", [lightingPath, intensity]);
+        _viewer, lightingPath.toNativeUtf8().cast<Char>(), intensity);
   }
 
-  @override
+  void removeSkybox() async {
-  Future removeSkybox() async {
+    _nativeLibrary.remove_skybox(_viewer);
-    await _channel.invokeMethod("removeSkybox");
   }
 
-  @override
+  void removeIbl() async {
-  Future removeIbl() async {
+    _nativeLibrary.remove_ibl(_viewer);
-    await _channel.invokeMethod("removeIbl");
   }
 
-  @override
+  // copied from LightManager.h
-  Future<FilamentLight> addLight(
+  //  enum class Type : uint8_t {
+  //       SUN,            //!< Directional light that also draws a sun's disk in the sky.
+  //       DIRECTIONAL,    //!< Directional light, emits light in a given direction.
+  //       POINT,          //!< Point light, emits light from a position, in all directions.
+  //       FOCUSED_SPOT,   //!< Physically correct spot light.
+  //       SPOT,           //!< Spot light with coupling of outer cone and illumination disabled.
+  //   };
+
+  FilamentEntity addLight(
       int type,
       double colour,
       double intensity,
@@ -230,221 +191,241 @@ class PolyvoxFilamentController extends FilamentController {
       double dirX,
       double dirY,
       double dirZ,
-      bool castShadows) async {
+      bool castShadows) {
-    var entityId = await _channel.invokeMethod("addLight", [
+    return _nativeLibrary.add_light(_viewer, type, colour, intensity, posX,
-      type,
+        posY, posZ, dirX, dirY, dirZ, castShadows ? 1 : 0);
-      colour,
-      intensity,
-      posX,
-      posY,
-      posZ,
-      dirX,
-      dirY,
-      dirZ,
-      castShadows
-    ]);
-    return entityId as FilamentLight;
   }
 
-  @override
+  void removeLight(FilamentEntity light) async {
-  Future removeLight(FilamentLight light) {
+    _nativeLibrary.remove_light(_viewer, light);
-    return _channel.invokeMethod("removeLight", light);
   }
 
-  @override
+  void clearLights() async {
-  Future clearLights() {
+    _nativeLibrary.clear_lights(_viewer);
-    return _channel.invokeMethod("clearLights");
   }
 
-  Future<FilamentAsset> loadGlb(String path, {bool unlit = false}) async {
+  FilamentEntity loadGlb(String path, {bool unlit = false}) {
-    print("Loading GLB at $path ");
+    var asset = _nativeLibrary.load_glb(
-    var asset = await _channel.invokeMethod("loadGlb", [path, unlit]);
+        _assetManager, path.toNativeUtf8().cast<Char>(), unlit ? 1 : 0);
     if (asset == FILAMENT_ASSET_ERROR) {
       throw Exception("An error occurred loading the asset at $path");
     }
-    return asset as FilamentAsset;
+    return asset;
   }
 
-  Future<FilamentAsset> loadGltf(
+  FilamentEntity loadGltf(String path, String relativeResourcePath) {
-      String path, String relativeResourcePath) async {
+    return _nativeLibrary.load_gltf(
-    print(
+        _assetManager,
-        "Loading GLTF at $path with relative resource path $relativeResourcePath");
+        path.toNativeUtf8().cast<Char>(),
-    var asset =
+        relativeResourcePath.toNativeUtf8().cast<Char>());
-        await _channel.invokeMethod("loadGltf", [path, relativeResourcePath]);
-    return asset as FilamentAsset;
   }
 
-  Future panStart(double x, double y) async {
+  void panStart(double x, double y) async {
-    await _channel.invokeMethod("panStart", [x * _pixelRatio, y * _pixelRatio]);
+    _nativeLibrary.grab_begin(_viewer, x * _pixelRatio, y * _pixelRatio, 1);
   }
 
-  Future panUpdate(double x, double y) async {
+  void panUpdate(double x, double y) async {
-    await _channel
+    _nativeLibrary.grab_update(_viewer, x * _pixelRatio, y * _pixelRatio);
-        .invokeMethod("panUpdate", [x * _pixelRatio, y * _pixelRatio]);
   }
 
-  Future panEnd() async {
+  void panEnd() async {
-    await _channel.invokeMethod("panEnd");
+    _nativeLibrary.grab_end(_viewer);
   }
 
-  Future rotateStart(double x, double y) async {
+  void rotateStart(double x, double y) async {
-    await _channel
+    _nativeLibrary.grab_begin(_viewer, x * _pixelRatio, y * _pixelRatio, 0);
-        .invokeMethod("rotateStart", [x * _pixelRatio, y * _pixelRatio]);
   }
 
-  Future rotateUpdate(double x, double y) async {
+  void rotateUpdate(double x, double y) async {
-    await _channel
+    _nativeLibrary.grab_update(_viewer, x * _pixelRatio, y * _pixelRatio);
-        .invokeMethod("rotateUpdate", [x * _pixelRatio, y * _pixelRatio]);
   }
 
-  Future rotateEnd() async {
+  void rotateEnd() async {
-    await _channel.invokeMethod("rotateEnd");
+    _nativeLibrary.grab_end(_viewer);
   }
 
-  Future setMorphTargetWeights(
+  void setMorphTargetWeights(FilamentEntity asset, List<double> weights) {
-      FilamentAsset asset, List<double> weights) async {
+    throw Exception("TODO");
-    await _channel.invokeMethod(
+    // _nativeLibrary.set_morph_target_weights(_assetManager, asset, Float32List.fromList(weights));
-        "setMorphTargetWeights", [asset, Float32List.fromList(weights)]);
   }
 
-  Future<List<String>> getMorphTargetNames(
+  List<String> getMorphTargetNames(FilamentEntity asset, String meshName) {
-      FilamentAsset asset, String meshName) async {
+    var meshNamePtr = meshName.toNativeUtf8().cast<Char>();
-    var result =
+    var count = _nativeLibrary.get_morph_target_name_count(
-        (await _channel.invokeMethod("getMorphTargetNames", [asset, meshName]))
+        _assetManager, asset, meshNamePtr);
-            .cast<String>();
+    var names = <String>[];
-    return result;
+    for (int i = 0; i < count; i++) {
+      var outPtr = calloc<Char>(255);
+      _nativeLibrary.get_morph_target_name(
+          _assetManager, asset, meshNamePtr, outPtr, i);
+      names.add(outPtr.cast<Utf8>().toDartString());
+    }
+    return names;
   }
 
-  Future<List<String>> getAnimationNames(FilamentAsset asset) async {
+  List<String> getAnimationNames(FilamentEntity asset) {
-    var result = (await _channel.invokeMethod("getAnimationNames", asset))
+    var count = _nativeLibrary.get_animation_count(_assetManager, asset);
-        .cast<String>();
+    var names = <String>[];
-    return result;
+    for (int i = 0; i < count; i++) {
+      var outPtr = calloc<Char>(255);
+      _nativeLibrary.get_animation_name(_assetManager, asset, outPtr, i);
+      names.add(outPtr.cast<Utf8>().toDartString());
+    }
+    return names;
   }
 
-  Future setAnimation(FilamentAsset asset, Animation animation) async {
+  ///
-    await _channel.invokeMethod("setAnimation", [
+  /// Animates morph target weights/bone transforms (where each frame requires a duration of [frameLengthInMs].
-      asset,
+  /// [morphWeights] is a list of doubles in frame-major format.
-      animation.morphAnimation!.meshName,
+  /// Each frame is [numWeights] in length, and each entry is the weight to be applied to the morph target located at that index in the mesh primitive at that frame.
-      animation.morphAnimation!.morphData,
+  ///
-      animation.morphAnimation!.numMorphWeights,
+  void setMorphAnimation(FilamentEntity asset, MorphAnimation animation) async {
-      animation.boneAnimations?.map((a) => a.toList()).toList() ?? [],
+    var data = calloc<Float>(animation.data.length);
-      animation.morphAnimation!.numFrames,
+    for (int i = 0; i < animation.data.length; i++) {
-      animation.morphAnimation!.frameLengthInMs
+      data.elementAt(i).value = animation.data[i];
-    ]);
+    }
+    _nativeLibrary.set_morph_animation(
+        _assetManager,
+        asset,
+        animation.meshName.toNativeUtf8().cast<Char>(),
+        data,
+        animation.numMorphWeights,
+        animation.numFrames,
+        animation.frameLengthInMs);
+    calloc.free(data);
   }
 
-  Future removeAsset(FilamentAsset asset) async {
+  ///
-    print("Removing asset : $asset");
+  /// Animates morph target weights/bone transforms (where each frame requires a duration of [frameLengthInMs].
-    await _channel.invokeMethod("removeAsset", asset);
+  /// [morphWeights] is a list of doubles in frame-major format.
+  /// Each frame is [numWeights] in length, and each entry is the weight to be applied to the morph target located at that index in the mesh primitive at that frame.
+  ///
+  void setBoneAnimation(
+      FilamentEntity asset, List<DartBoneAnimation> animations) async {
+    var data =
+        calloc<Float>(animations.length * animations.first.frameData.length);
+    int offset = 0;
+    var numFrames = animations.first.frameData.length;
+    var meshNames = calloc<Pointer<Char>>(animations.length);
+    var boneNames = calloc<Pointer<Char>>(animations.length);
+    int animIdx = 0;
+    for (var animation in animations) {
+      if (animation.frameData.length != numFrames) {
+        throw Exception(
+            "All bone animations must share the same animation frame data length.");
+      }
+      for (int i = 0; i < animation.frameData.length; i++) {
+        data.elementAt(offset).value = animation.frameData[i];
+        offset += 1;
+      }
+      meshNames.elementAt(animIdx).value =
+          animation.meshName.toNativeUtf8().cast<Char>();
+      boneNames.elementAt(animIdx).value =
+          animation.boneName.toNativeUtf8().cast<Char>();
+    }
+
+    _nativeLibrary.set_bone_animation(
+        _assetManager,
+        asset,
+        animations.length,
+        boneNames,
+        meshNames,
+        data,
+        numFrames,
+        animations.first.frameLengthInMs);
+    calloc.free(data);
   }
 
-  Future clearAssets() async {
+  void removeAsset(FilamentEntity asset) async {
-    await _channel.invokeMethod("clearAssets");
+    _nativeLibrary.remove_asset(_viewer, asset);
   }
 
-  Future zoomBegin() async {
+  void clearAssets() async {
-    await _channel.invokeMethod("zoomBegin");
+    _nativeLibrary.clear_assets(_viewer);
   }
 
-  Future zoomUpdate(double z) async {
+  void zoomBegin() async {
-    await _channel.invokeMethod("zoomUpdate", [0.0, 0.0, z]);
+    _nativeLibrary.scroll_begin(_viewer);
   }
 
-  Future zoomEnd() async {
+  void zoomUpdate(double z) async {
-    await _channel.invokeMethod("zoomEnd");
+    _nativeLibrary.scroll_update(_viewer, 0.0, 0.0, z);
   }
 
-  Future playAnimation(FilamentAsset asset, int index,
+  void zoomEnd() async {
+    _nativeLibrary.scroll_end(_viewer);
+  }
+
+  void playAnimation(FilamentEntity asset, int index,
       {bool loop = false, bool reverse = false}) async {
-    await _channel.invokeMethod("playAnimation", [asset, index, loop, reverse]);
+    _nativeLibrary.play_animation(
+        _assetManager, asset, index, loop ? 1 : 0, reverse ? 1 : 0);
   }
 
-  Future setAnimationFrame(
+  void setAnimationFrame(
-      FilamentAsset asset, int index, int animationFrame) async {
+      FilamentEntity asset, int index, int animationFrame) async {
-    await _channel
+    _nativeLibrary.set_animation_frame(
-        .invokeMethod("setAnimationFrame", [asset, index, animationFrame]);
+        _assetManager, asset, index, animationFrame);
   }
 
-  Future playAnimations(FilamentAsset asset, List<int> indices,
+  void stopAnimation(FilamentEntity asset, int animationIndex) async {
-      {bool loop = false, bool reverse = false}) async {
+    _nativeLibrary.stop_animation(_assetManager, asset, animationIndex);
-    return Future.wait(indices.map((index) {
-      return _channel
-          .invokeMethod("playAnimation", [asset, index, loop, reverse]);
-    }));
   }
 
-  Future stopAnimation(FilamentAsset asset, int animationIndex) async {
+  void setCamera(FilamentEntity asset, String name) async {
-    await _channel.invokeMethod("stopAnimation", [asset, animationIndex]);
+    _nativeLibrary.set_camera(_viewer, asset, name.toNativeUtf8().cast<Char>());
   }
 
-  Future setCamera(FilamentAsset asset, String name) async {
+  void setCameraFocalLength(double focalLength) async {
-    await _channel.invokeMethod("setCamera", [asset, name]);
+    _nativeLibrary.set_camera_focal_length(_viewer, focalLength);
   }
 
-  Future setCameraFocalLength(double focalLength) async {
+  void setCameraFocusDistance(double focusDistance) async {
-    await _channel.invokeMethod("setCameraFocalLength", focalLength);
+    _nativeLibrary.set_camera_focus_distance(_viewer, focusDistance);
   }
 
-  Future setCameraFocusDistance(double focusDistance) async {
+  void setCameraPosition(double x, double y, double z) async {
-    await _channel.invokeMethod("setCameraFocusDistance", focusDistance);
+    _nativeLibrary.set_camera_position(_viewer, x, y, z);
   }
 
-  Future setCameraPosition(double x, double y, double z) async {
+  void setCameraExposure(
-    await _channel.invokeMethod("setCameraPosition", [x, y, z]);
-  }
-
-  Future setCameraExposure(
       double aperture, double shutterSpeed, double sensitivity) async {
-    await _channel.invokeMethod(
+    _nativeLibrary.set_camera_exposure(
-        "setCameraExposure", [aperture, shutterSpeed, sensitivity]);
+        _viewer, aperture, shutterSpeed, sensitivity);
   }
 
-  Future setCameraRotation(double rads, double x, double y, double z) async {
+  void setCameraRotation(double rads, double x, double y, double z) async {
-    await _channel.invokeMethod("setCameraRotation", [rads, x, y, z]);
+    _nativeLibrary.set_camera_rotation(_viewer, rads, x, y, z);
   }
 
-  Future setCameraModelMatrix(List<double> matrix) async {
+  void setCameraModelMatrix(List<double> matrix) async {
     assert(matrix.length == 16);
-    await _channel.invokeMethod(
+    var ptr = calloc<Float>(16);
-        "setCameraModelMatrix", Float32List.fromList(matrix));
+    for (int i = 0; i < 16; i++) {
+      ptr.elementAt(i).value = matrix[i];
+    }
+    _nativeLibrary.set_camera_model_matrix(_viewer, ptr);
   }
 
-  Future setTexture(FilamentAsset asset, String assetPath,
+  void setTexture(FilamentEntity asset, String assetPath,
       {int renderableIndex = 0}) async {
-    await _channel
+    _nativeLibrary.set_texture(_assetManager, asset);
-        .invokeMethod("setTexture", [asset, assetPath, renderableIndex]);
   }
 
-  Future transformToUnitCube(FilamentAsset asset) async {
+  void transformToUnitCube(FilamentEntity asset) async {
-    await _channel.invokeMethod("transformToUnitCube", asset);
+    _nativeLibrary.transform_to_unit_cube(_assetManager, asset);
   }
 
-  Future setPosition(FilamentAsset asset, double x, double y, double z) async {
+  void setPosition(FilamentEntity asset, double x, double y, double z) async {
-    await _channel.invokeMethod("setPosition", [asset, x, y, z]);
+    _nativeLibrary.set_position(_assetManager, asset, x, y, z);
   }
 
-  // Future setBoneTransform(FilamentAsset asset, String boneName, String meshName,
+  void setScale(FilamentEntity asset, double scale) async {
-  //     BoneTransform transform) async {
+    _nativeLibrary.set_scale(_assetManager, asset, scale);
-  //   await _channel.invokeMethod("setBoneTransform", [
-  //     asset,
-  //     boneName,
-  //     meshName,
-  //     transform.translations[0].x,
-  //     transform.translations[0].y,
-  //     transform.translations[0].z,
-  //     transform.quaternions[0].x,
-  //     transform.quaternions[0].y,
-  //     transform.quaternions[0].z,
-  //     transform.quaternions[0].w
-  //   ]);
-  // }
-
-  Future setScale(FilamentAsset asset, double scale) async {
-    await _channel.invokeMethod("setScale", [asset, scale]);
   }
 
-  Future setRotation(
+  void setRotation(
-      FilamentAsset asset, double rads, double x, double y, double z) async {
+      FilamentEntity asset, double rads, double x, double y, double z) async {
-    await _channel.invokeMethod("setRotation", [asset, rads, x, y, z]);
+    _nativeLibrary.set_rotation(_assetManager, asset, rads, x, y, z);
   }
 }

lib/filament_gesture_detector.dart

@@ -41,9 +41,9 @@ class _FilamentGestureDetectorState extends State<FilamentGestureDetector> {
   // to avoid duplicating code for pan/rotate (panStart, panUpdate, panEnd, rotateStart, rotateUpdate etc)
   // we have only a single function for start/update/end.
   // when the gesture type is changed, these properties are updated to point to the correct function.
-  late Future Function(double x, double y) _functionStart;
+  late Function(double x, double y) _functionStart;
-  late Future Function(double x, double y) _functionUpdate;
+  late Function(double x, double y) _functionUpdate;
-  late Future Function() _functionEnd;
+  late Function() _functionEnd;
 
   double _lastScale = 0;
 
@@ -104,8 +104,8 @@ class _FilamentGestureDetectorState extends State<FilamentGestureDetector> {
                   : (d) async {
                       _scaling = true;
                       if (d.pointerCount == 2) {
-                        await widget.controller.zoomEnd();
+                        widget.controller.zoomEnd();
-                        await widget.controller.zoomBegin();
+                        widget.controller.zoomBegin();
                       }
                     },
               onScaleEnd: !widget.enableControls
@@ -114,7 +114,7 @@ class _FilamentGestureDetectorState extends State<FilamentGestureDetector> {
                       _scaling = false;
                       if (d.pointerCount == 2) {
                         _lastScale = 0;
-                        await widget.controller.zoomEnd();
+                        widget.controller.zoomEnd();
                       }
                     },
               onScaleUpdate: !widget.enableControls
@@ -122,7 +122,7 @@ class _FilamentGestureDetectorState extends State<FilamentGestureDetector> {
                   : (d) async {
                       if (d.pointerCount == 2) {
                         if (_lastScale != 0) {
-                          await widget.controller.zoomUpdate(Platform.isIOS
+                          widget.controller.zoomUpdate(Platform.isIOS
                               ? 1000 * (_lastScale - d.scale)
                               : 100 * (_lastScale - d.scale));
                         }
@@ -138,8 +138,8 @@ class _FilamentGestureDetectorState extends State<FilamentGestureDetector> {
                           // scroll-wheel zoom on desktop
                           if (pointerSignal is PointerScrollEvent) {
                             _scrollTimer?.cancel();
-                            await widget.controller.zoomBegin();
+                            widget.controller.zoomBegin();
-                            await widget.controller.zoomUpdate(
+                            widget.controller.zoomUpdate(
                                 pointerSignal.scrollDelta.dy > 0 ? 10 : -10);
                             _scrollTimer =
                                 Timer(Duration(milliseconds: 100), () {
@@ -154,10 +154,10 @@ class _FilamentGestureDetectorState extends State<FilamentGestureDetector> {
                       ? null
                       : (d) async {
                           if (d.buttons == kTertiaryButton || _rotating) {
-                            await widget.controller.rotateStart(
+                            widget.controller.rotateStart(
                                 d.localPosition.dx, d.localPosition.dy);
                           } else {
-                            await _functionStart(
+                            _functionStart(
                                 d.localPosition.dx, d.localPosition.dy);
                           }
                         },
@@ -165,10 +165,10 @@ class _FilamentGestureDetectorState extends State<FilamentGestureDetector> {
                       ? null
                       : (d) async {
                           if (d.buttons == kTertiaryButton || _rotating) {
-                            await widget.controller.rotateUpdate(
+                            widget.controller.rotateUpdate(
                                 d.localPosition.dx, d.localPosition.dy);
                           } else {
-                            await _functionUpdate(
+                            _functionUpdate(
                                 d.localPosition.dx, d.localPosition.dy);
                           }
                         },
@@ -176,9 +176,9 @@ class _FilamentGestureDetectorState extends State<FilamentGestureDetector> {
                       ? null
                       : (d) async {
                           if (d.buttons == kTertiaryButton || _rotating) {
-                            await widget.controller.rotateEnd();
+                            widget.controller.rotateEnd();
                           } else {
-                            await _functionEnd();
+                            _functionEnd();
                           }
                         },
                   child: widget.child))),

linux/CMakeLists.txt

@@ -29,11 +29,11 @@ add_library(${PLUGIN_NAME} SHARED
   "polyvox_filament_plugin.cc"
   "filament_texture.cc"
   "filament_pb_texture.cc"
-  "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/SceneAssetLoader.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/AssetManager.cpp"
-  "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/SceneAsset.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/FilamentViewer.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/PolyvoxFilamentApi.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/StreamBufferAdapter.cpp"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../ios/src/TimeIt.cpp"
 )
 
 # Apply a standard set of build settings that are configured in the

linux/include/polyvox_filament/resource_loader.hpp

@@ -19,6 +19,8 @@ static uint32_t _i = 0;
 
 ResourceBuffer loadResource(const char* name) {
 
+  std::cout << "LOADING RESOURCE" << std::endl;
+
     char cwd[PATH_MAX];
     if (getcwd(cwd, sizeof(cwd)) != NULL) {
        std::cout << "Current working dir: " << cwd  << std::endl;

pubspec.yaml

@@ -12,12 +12,20 @@ dependencies:
     sdk: flutter
   vector_math: ^2.1.2
   plugin_platform_interface: ^2.0.0
+  ffi: 
+  tuple:
 
 dev_dependencies:
   flutter_test:
     sdk: flutter
   flutter_lints: ^1.0.0
+  ffigen: 
 
+ffigen:
+  output: 'lib/generated_bindings.dart'
+  headers:
+    entry-points:
+      - 'ios/include/PolyvoxFilamentApi.h'
 
 flutter:
   plugin: