add light creation/removal to API and destroy manipulator on grab/zoomEnd

android/src/main/kotlin/app/polyvox/filament/FilamentInterop.kt

@@ -48,7 +48,9 @@ interface FilamentInterop : Library {
 
     fun update_viewport_and_camera_projection(viewer:Pointer, width:Int, height:Int, scaleFactor:Float);
 
-    fun scroll(viewer:Pointer, x:Float, y:Float, delta:Float);
+    fun scroll_begin(viewer:Pointer);
+    fun scroll_update(viewer:Pointer, x:Float, y:Float, delta:Float);
+    fun scroll_end(viewer:Pointer);
 
     fun grab_begin(viewer:Pointer, x:Float, y:Float, pan:Boolean)
 
@@ -76,9 +78,12 @@ interface FilamentInterop : Library {
     fun clear_assets(viewer:Pointer);
 
     fun remove_skybox(viewer:Pointer);
-
     fun remove_ibl(viewer:Pointer);
 
+    fun add_light(viewer:Pointer, type:Int, colour:Float, intensity:Float, posX:Float, posY:Float, posZ:Float, dirX:Float, dirY:Float, dirZ:Float, shadows:Boolean) : Int;
+    fun remove_light(viewer:Pointer, entityId:Int);
+    fun clear_lights(viewer:Pointer);
+
     fun set_background_image(viewer:Pointer, path:String);
     fun set_background_image_position(viewer:Pointer, x:Float, y:Float);
     

android/src/main/kotlin/app/polyvox/filament/PolyvoxFilamentPlugin.kt

@@ -225,288 +225,334 @@ class PolyvoxFilamentPlugin: FlutterPlugin, MethodCallHandler, ActivityAware {
           result.success(null)
         }
       }
-        "setBackgroundImage" -> {
+      "setBackgroundImage" -> {
-          executor.execute { 
+        executor.execute { 
-            _lib.set_background_image(_viewer!!, getAssetPath(call.arguments as String))                
+          _lib.set_background_image(_viewer!!, getAssetPath(call.arguments as String))                
+          result.success("OK");
+        }
+      }
+      "setBackgroundImagePosition" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<Any?>
+          _lib.set_background_image_position(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
+          result.success("OK");
+        }
+      }
+      "loadSkybox" -> {
+        executor.execute { 
+          _lib.load_skybox(_viewer!!, getAssetPath(call.arguments as String))
+          result.success("OK");
+        }
+      }
+      "loadIbl" -> {
+        executor.execute { 
+          _lib.load_ibl(_viewer!!, getAssetPath(call.arguments as String))
+          result.success("OK");
+        }
+      }
+      "removeIbl" -> {
+        executor.execute { 
+          _lib.remove_ibl(_viewer!!)                
+          result.success(true);
+        }
+      }
+      "removeSkybox" -> {
+        executor.execute { 
+          _lib.remove_skybox(_viewer!!)                
+          result.success(true);
+        }
+      }
+      "addLight" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<Any?>
+          val entity = _lib.add_light(
+            _viewer!!, 
+            args[0] as Int, 
+            (args[1] as Double).toFloat(),  
+            (args[2] as Double).toFloat(), 
+            (args[3] as Double).toFloat(), 
+            (args[4] as Double).toFloat(), 
+            (args[5] as Double).toFloat(),
+            (args[6] as Double).toFloat(), 
+            (args[7] as Double).toFloat(), 
+            (args[8] as Double).toFloat(),
+            (args[9] as Boolean))
+          result.success(entity);
+        }
+      }
+      "removeLight" -> {
+        executor.execute { 
+          _lib.remove_light(
+            _viewer!!, 
+            call.arguments as Int)
+          result.success(true);
+        }
+      }
+      "clearLights" -> {
+        executor.execute { 
+          _lib.clear_lights(
+            _viewer!!
+          )
+          result.success(true);
+        }
+      }
+      "loadGlb" -> {
+        executor.execute { 
+          val assetPtr = _lib.load_glb(
+              _viewer!!,
+              getAssetPath(call.arguments as String)
+          )
+          result.success(Pointer.nativeValue(assetPtr));
+        }
+      }
+      "loadGltf" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<Any?>
+          val assetPtr = _lib.load_gltf(
+              _viewer!!,
+              getAssetPath(args[0] as String),
+              getAssetPath(args[1] as String)
+          )
+          result.success(Pointer.nativeValue(assetPtr));
+        }
+      }
+      "transformToUnitCube" -> {
+        executor.execute { 
+          val assetPtr = Pointer(call.arguments as Long);
+          _lib.transform_to_unit_cube(assetPtr)
+          result.success("OK");
+        }
+      }
+      "setPosition" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<*>
+          val assetPtr = Pointer(args[0] as Long)
+          _lib.set_position(assetPtr, (args[1] as Double).toFloat(), (args[2] as Double).toFloat(), (args[3] as Double).toFloat())
+          result.success("OK");
+        }
+      }
+      "setScale" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<*>
+          val assetPtr = Pointer(args[0] as Long)
+          _lib.set_scale(assetPtr, (args[1] as Double).toFloat())
+          result.success("OK");
+        }
+      }
+      "setRotation" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<*>
+          val assetPtr = Pointer(args[0] as Long)
+          _lib.set_rotation(assetPtr, (args[1] as Double).toFloat(), (args[2] as Double).toFloat(), (args[3] as Double).toFloat(), (args[4] as Double).toFloat())
+          result.success("OK");
+        }
+      }
+      "setCameraPosition" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<*>
+          _lib.set_camera_position(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), (args[2] as Double).toFloat())
+          result.success("OK");
+        }
+      }
+      "setCameraRotation" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<*>
+          _lib.set_camera_rotation(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), (args[2] as Double).toFloat(), (args[3] as Double).toFloat())
+          result.success("OK");
+        }
+      }
+      "setCameraFocalLength" -> {
+        executor.execute { 
+          _lib.set_camera_focal_length(_viewer!!, (call.arguments as Double).toFloat())
+          result.success("OK");
+        }
+      }
+      "setCameraFocusDistance" -> {
+        executor.execute { 
+          _lib.set_camera_focus_distance(_viewer!!, (call.arguments as Double).toFloat())
+          result.success("OK");
+        }
+      }
+      "setTexture" -> {
+        executor.execute {
+          val args = call.arguments as ArrayList<*>
+          val assetPtr = Pointer(args[0] as Long);
+          _lib.load_texture(assetPtr, getAssetPath(args[1] as String), args[2] as Int)
+          print("Texture loaded")
+          result.success("OK");
+        }
+        
+      }
+      "setCamera" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<*>
+          val success = _lib.set_camera(
+              _viewer!!,
+              Pointer(args[0] as Long),
+              args[1] as String,
+          )
+          if(success) {
             result.success("OK");
+          } else {
+            result.error("failed","failed", "Failed to set camera")
           }
         }
-        "setBackgroundImagePosition" -> {
+      }
-          executor.execute { 
+      "zoomBegin" -> {
-            val args = call.arguments as ArrayList<Any?>
+        executor.execute { 
-            _lib.set_background_image_position(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
+          _lib.scroll_begin(_viewer!!)
-            result.success("OK");
+          result.success("OK");
-          }
         }
-        "loadSkybox" -> {
+      }
-          executor.execute { 
+      "zoomUpdate" -> {
-            _lib.load_skybox(_viewer!!, getAssetPath(call.arguments as String))
+        executor.execute { 
-            result.success("OK");
+          val args = call.arguments as ArrayList<*>
-          }
+          _lib.scroll_update(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), (args[2] as Double).toFloat())
+          result.success("OK");
         }
-        "loadIbl" -> {
+      }
-          executor.execute { 
+      "zoomEnd" -> {
-            _lib.load_ibl(_viewer!!, getAssetPath(call.arguments as String))
+        executor.execute { 
-            result.success("OK");
+          _lib.scroll_end(_viewer!!)
-          }
+          result.success("OK");
         }
-        "removeIbl" -> {
+      }
-          executor.execute { 
+      "getTargetNames" -> {
-            _lib.remove_ibl(_viewer!!)                
+        executor.execute { 
-            result.success(true);
+          val args = call.arguments as ArrayList<*>
+          val assetPtr = Pointer(args[0] as Long)
+          val meshName = args[1] as String
+          val names = mutableListOf<String>()
+          val outPtr = Memory(256)
+          for(i in 0.._lib.get_target_name_count(assetPtr, meshName) - 1) {
+            _lib.get_target_name(assetPtr, meshName, outPtr, i)
+            val name = outPtr.getString(0)
+            names.add(name)
           }
+          result.success(names)
         }
-        "removeSkybox" -> {
+      } 
-          executor.execute { 
+      "getAnimationNames" -> {
-            _lib.remove_skybox(_viewer!!)                
+        executor.execute { 
-            result.success(true);
+          val assetPtr = Pointer(call.arguments as Long)
+          val names = mutableListOf<String>()
+          val outPtr = Memory(256)
+          for(i in 0.._lib.get_animation_count(assetPtr) - 1) {
+            _lib.get_animation_name(assetPtr, outPtr, i)
+            val name = outPtr.getString(0)
+            names.add(name)
           }
+          result.success(names)
         }
-        "loadGlb" -> {
+      } 
-          executor.execute { 
+      "applyWeights" -> {
-            val assetPtr = _lib.load_glb(
+        executor.execute { 
-                _viewer!!,
+          val args = call.arguments as ArrayList<*>
-                getAssetPath(call.arguments as String)
+          val assetPtr = Pointer(args[0] as Long)
-            )
+          val weights = args[1] as ArrayList<Float>;
-            result.success(Pointer.nativeValue(assetPtr));
-          }
-        }
-        "loadGltf" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<Any?>
-            val assetPtr = _lib.load_gltf(
-                _viewer!!,
-                getAssetPath(args[0] as String),
-                getAssetPath(args[1] as String)
-            )
-            result.success(Pointer.nativeValue(assetPtr));
-          }
-        }
-        "transformToUnitCube" -> {
-          executor.execute { 
-            val assetPtr = Pointer(call.arguments as Long);
-            _lib.transform_to_unit_cube(assetPtr)
-            result.success("OK");
-          }
-        }
-        "setPosition" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<*>
-            val assetPtr = Pointer(args[0] as Long)
-            _lib.set_position(assetPtr, (args[1] as Double).toFloat(), (args[2] as Double).toFloat(), (args[3] as Double).toFloat())
-            result.success("OK");
-          }
-        }
-        "setScale" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<*>
-            val assetPtr = Pointer(args[0] as Long)
-            _lib.set_scale(assetPtr, (args[1] as Double).toFloat())
-            result.success("OK");
-          }
-        }
-        "setRotation" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<*>
-            val assetPtr = Pointer(args[0] as Long)
-            _lib.set_rotation(assetPtr, (args[1] as Double).toFloat(), (args[2] as Double).toFloat(), (args[3] as Double).toFloat(), (args[4] as Double).toFloat())
-            result.success("OK");
-          }
-        }
-        "setCameraPosition" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<*>
-            _lib.set_camera_position(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), (args[2] as Double).toFloat())
-            result.success("OK");
-          }
-        }
-        "setCameraRotation" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<*>
-            _lib.set_camera_rotation(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), (args[2] as Double).toFloat(), (args[3] as Double).toFloat())
-            result.success("OK");
-          }
-        }
-        "setCameraFocalLength" -> {
-          executor.execute { 
-            _lib.set_camera_focal_length(_viewer!!, (call.arguments as Double).toFloat())
-            result.success("OK");
-          }
-        }
-        "setCameraFocusDistance" -> {
-          executor.execute { 
-            _lib.set_camera_focus_distance(_viewer!!, (call.arguments as Double).toFloat())
-            result.success("OK");
-          }
-        }
-        "setTexture" -> {
-          executor.execute {
-            val args = call.arguments as ArrayList<*>
-            val assetPtr = Pointer(args[0] as Long);
-            _lib.load_texture(assetPtr, getAssetPath(args[1] as String), args[2] as Int)
-            print("Texture loaded")
-            result.success("OK");
-          }
-          
-        }
-        "setCamera" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<*>
-            val success = _lib.set_camera(
-                _viewer!!,
-                Pointer(args[0] as Long),
-                args[1] as String,
-            )
-            if(success) {
-              result.success("OK");
-            } else {
-              result.error("failed","failed", "Failed to set camera")
-            }
-          }
-        }
-        "zoom" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<*>
-            _lib.scroll(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), (args[2] as Double).toFloat())
-            result.success("OK");
-          }
-        }
-        "getTargetNames" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<*>
-            val assetPtr = Pointer(args[0] as Long)
-            val meshName = args[1] as String
-            val names = mutableListOf<String>()
-            val outPtr = Memory(256)
-            for(i in 0.._lib.get_target_name_count(assetPtr, meshName) - 1) {
-              _lib.get_target_name(assetPtr, meshName, outPtr, i)
-              val name = outPtr.getString(0)
-              names.add(name)
-            }
-            result.success(names)
-          }
-        } 
-        "getAnimationNames" -> {
-          executor.execute { 
-            val assetPtr = Pointer(call.arguments as Long)
-            val names = mutableListOf<String>()
-            val outPtr = Memory(256)
-            for(i in 0.._lib.get_animation_count(assetPtr) - 1) {
-              _lib.get_animation_name(assetPtr, outPtr, i)
-              val name = outPtr.getString(0)
-              names.add(name)
-            }
-            result.success(names)
-          }
-        } 
-        "applyWeights" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<*>
-            val assetPtr = Pointer(args[0] as Long)
-            val weights = args[1] as ArrayList<Float>;
 
-            _lib.apply_weights(assetPtr, weights.toFloatArray(), weights.size)
+          _lib.apply_weights(assetPtr, weights.toFloatArray(), weights.size)
-            result.success("OK");
+          result.success("OK");
-          }
         }
-        "animateWeights" -> {
+      }
-          executor.execute { 
+      "animateWeights" -> {
-            val args = call.arguments as ArrayList<Any?>
+        executor.execute { 
-            val assetPtr = Pointer(args[0] as Long)
+          val args = call.arguments as ArrayList<Any?>
-            val frames = args[1] as ArrayList<Float>;
+          val assetPtr = Pointer(args[0] as Long)
-            val numWeights = args[2] as Int
+          val frames = args[1] as ArrayList<Float>;
-            val numFrames = args[3] as Int
+          val numWeights = args[2] as Int
-            val frameLenInMs = args[4] as Double
+          val numFrames = args[3] as Int
+          val frameLenInMs = args[4] as Double
 
-            _lib.animate_weights(assetPtr, frames.toFloatArray(), numWeights, numFrames, frameLenInMs.toFloat())
+          _lib.animate_weights(assetPtr, frames.toFloatArray(), numWeights, numFrames, frameLenInMs.toFloat())
-            result.success("OK");
+          result.success("OK");
-          }
         }
-        "panStart" -> {
+      }
-          executor.execute { 
+      "panStart" -> {
-            val args = call.arguments as ArrayList<Any?>
+        executor.execute { 
-            _lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), true)
+          val args = call.arguments as ArrayList<Any?>
-            result.success("OK");
+          _lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), true)
-          }
+          result.success("OK");
         }
-        "panUpdate" -> {
+      }
-          executor.execute { 
+      "panUpdate" -> {
-            val args = call.arguments as ArrayList<Any?>
+        executor.execute { 
-            val x = (args[0] as Double).toFloat()
+          val args = call.arguments as ArrayList<Any?>
-            val y = (args[1] as Double).toFloat()
+          val x = (args[0] as Double).toFloat()
-            Log.v(TAG, "panUpdate ${x} ${y}")
+          val y = (args[1] as Double).toFloat()
-            _lib.grab_update(_viewer!!, x, y)
+          Log.v(TAG, "panUpdate ${x} ${y}")
-            result.success("OK");
+          _lib.grab_update(_viewer!!, x, y)
-          }
+          result.success("OK");
         }
-        "panEnd" -> {
+      }
-          executor.execute { 
+      "panEnd" -> {
-            _lib.grab_end(_viewer!!)
+        executor.execute { 
-            result.success("OK");
+          _lib.grab_end(_viewer!!)
-          }
+          result.success("OK");
         }
-        "rotateStart" -> {
+      }
-          executor.execute { 
+      "rotateStart" -> {
-            val args = call.arguments as ArrayList<Any?>
+        executor.execute { 
-            _lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), false)
+          val args = call.arguments as ArrayList<Any?>
-            result.success("OK");
+          _lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), false)
-          }
+          result.success("OK");
         }
-        "rotateUpdate" -> {
+      }
-          executor.execute { 
+      "rotateUpdate" -> {
-            val args = call.arguments as ArrayList<Any?>
+        executor.execute { 
-            _lib.grab_update(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
+          val args = call.arguments as ArrayList<Any?>
-            result.success("OK");
+          _lib.grab_update(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
-          }
+          result.success("OK");
         }
-        "rotateEnd" -> {
+      }
-          executor.execute { 
+      "rotateEnd" -> {
-            _lib.grab_end(_viewer!!)
+        executor.execute { 
-            result.success("OK");
+          _lib.grab_end(_viewer!!)
-          }
+          result.success("OK");
         }
-        "grabStart" -> {
+      }
-          executor.execute { 
+      "grabStart" -> {
-            val args = call.arguments as ArrayList<Any?>
+        executor.execute { 
-            _lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), true)
+          val args = call.arguments as ArrayList<Any?>
-            result.success("OK");
+          _lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), true)
-          }
+          result.success("OK");
         }
-        "grabUpdate" -> {
+      }
-          executor.execute { 
+      "grabUpdate" -> {
-            val args = call.arguments as ArrayList<Any?>
+        executor.execute { 
-            _lib.grab_update(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
+          val args = call.arguments as ArrayList<Any?>
-            result.success("OK");
+          _lib.grab_update(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
-          }
+          result.success("OK");
         }
-        "grabEnd" -> {
+      }
-          executor.execute { 
+      "grabEnd" -> {
-            _lib.grab_end(_viewer!!)
+        executor.execute { 
-            result.success("OK");
+          _lib.grab_end(_viewer!!)
-          }
+          result.success("OK");
         }
-        "removeAsset" -> {
+      }
-          executor.execute { 
+      "removeAsset" -> {
-            _lib.remove_asset(_viewer!!, Pointer(call.arguments as Long))
+        executor.execute { 
-            result.success("OK");
+          _lib.remove_asset(_viewer!!, Pointer(call.arguments as Long))
-          }
+          result.success("OK");
-        } 
-        "clearAssets" -> {
-          executor.execute { 
-            _lib.clear_assets(_viewer!!)
-            result.success("OK");
-          }
-        } 
-        "playAnimation" -> {
-          executor.execute { 
-            val args = call.arguments as ArrayList<Any?>
-            _lib.play_animation(Pointer(args[0] as Long), args[1] as Int, args[2] as Boolean)
-            result.success("OK")
-          }
         }
-        else -> {
+      } 
-          result.notImplemented()
+      "clearAssets" -> {
+        executor.execute { 
+          _lib.clear_assets(_viewer!!)
+          result.success("OK");
         }
+      } 
+      "playAnimation" -> {
+        executor.execute { 
+          val args = call.arguments as ArrayList<Any?>
+          _lib.play_animation(Pointer(args[0] as Long), args[1] as Int, args[2] as Boolean)
+          result.success("OK")
+        }
+      }
+      else -> {
+        result.notImplemented()
+      }
     }
 }
 

ios/src/FilamentViewer.cpp

@@ -145,7 +145,7 @@ FilamentViewer::FilamentViewer(void *layer, LoadResource loadResource,
     _engine = Engine::create(Engine::Backend::METAL);
   #else
     _engine = Engine::create(Engine::Backend::OPENGL);
-  #endif;
+  #endif
 
   Log("Engine created");
 
@@ -220,20 +220,6 @@ FilamentViewer::FilamentViewer(void *layer, LoadResource loadResource,
   _stbDecoder = createStbProvider(_engine);
   _resourceLoader->addTextureProvider("image/png", _stbDecoder);
   _resourceLoader->addTextureProvider("image/jpeg", _stbDecoder);
-
-  // Always add a direct light source since it is required for shadowing.
-  _sun = EntityManager::get().create();
-  LightManager::Builder(LightManager::Type::SUN)
-      .color(Color::cct(6500.0f))
-      .intensity(150000.0f)
-      .direction(math::float3(0.0f, 0.0f, -1.0f))
-      .castShadows(false)
-      // .castShadows(true)
-      .build(*_engine, _sun);
-  _scene->addEntity(_sun);
-
-  Log("Added sun");
-
   _sceneAssetLoader = new SceneAssetLoader(_loadResource,
                                    _freeResource,
                                    _assetLoader,
@@ -257,6 +243,35 @@ void FilamentViewer::setFrameInterval(float frameInterval) {
   Log("Set framerate interval to %f", frameInterval);
 }
 
+int32_t FilamentViewer::addLight(LightManager::Type t, float colour, float intensity, float posX, float posY, float posZ, float dirX, float dirY, float dirZ, bool shadows) {
+  Log("Adding light of type %d with colour %f intensity %f at (%f, %f, %f) with direction (%f, %f, %f) with shadows %d", t, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, shadows);
+  auto light = EntityManager::get().create();
+  LightManager::Builder(LightManager::Type::SUN)
+      .color(Color::cct(colour))
+      .intensity(intensity)
+      .position(math::float3(posX, posY, posZ))
+      .direction(math::float3(dirX, dirY, dirZ))
+      .castShadows(shadows)
+      .build(*_engine, light);
+  _scene->addEntity(light);
+  _lights.push_back(light);
+  return Entity::smuggle(light);
+}
+
+void FilamentViewer::removeLight(int32_t id) {
+  Log("Removing light with entity ID %d", id);
+  auto e = utils::Entity::import(id);
+  _scene->removeEntities(&e, 1);
+  EntityManager::get().destroy(1, &e);
+}
+
+void FilamentViewer::clearLights() {
+  Log("Removing all lights");
+  _scene->removeEntities(_lights.data(), _lights.size());
+  EntityManager::get().destroy(_lights.size(), _lights.data());
+  _lights.clear();
+}
+
 void FilamentViewer::createImageRenderable() {
 
   if (_imageEntity)
@@ -452,7 +467,10 @@ FilamentViewer::~FilamentViewer() {
   _resourceLoader->asyncCancelLoad();
   _materialProvider->destroyMaterials();
   AssetLoader::destroy(&_assetLoader);
-  _engine->destroy(_sun);
+  for(auto it : _lights) {
+    _engine->destroy(it);
+  }
+  
   _engine->destroyCameraComponent(_mainCamera->getEntity());
   _mainCamera = nullptr;
   _engine->destroy(_view);
@@ -747,24 +765,31 @@ void FilamentViewer::setCameraRotation(float rads, float x, float y, float z) {
   cam.setModelMatrix(_cameraPosition * _cameraRotation);
 }
 
+void FilamentViewer::_createManipulator() {
+  if(_manipulator) {
+    delete _manipulator;
+  }
+  Camera& cam =_view->getCamera();
+  math::float3 home = cam.getPosition();
+  math::float3 fv = cam.getForwardVector();
+  Viewport const& vp = _view->getViewport();
+  _manipulator = Manipulator<float>::Builder()
+                  .viewport(vp.width, vp.height)
+                  .orbitHomePosition(home[0], home[1], home[2])
+                  .targetPosition(fv[0], fv[1], fv[2])
+                  .build(Mode::ORBIT);
+  Log("Created manipulator for vp width %d height %d ", vp.width, vp.height);
+}
+
 void FilamentViewer::grabBegin(float x, float y, bool pan) {
   if (!_view || !_mainCamera || !_swapChain) {
     Log("View not ready, ignoring grab");
     return;
   }
   if(!_manipulator) {
-    Camera& cam =_view->getCamera();
+    _createManipulator();
-    math::float3 home = cam.getPosition();
-    math::float3 fv = cam.getForwardVector();
-    Viewport const& vp = _view->getViewport();
-    _manipulator = Manipulator<float>::Builder()
-                    .viewport(vp.width, vp.height)
-                    .orbitHomePosition(home[0], home[1], home[2])
-                    .targetPosition(fv[0], fv[1], fv[2])
-                    .build(Mode::ORBIT);
-    Log("Created manipualtor for vp width %d height %d ", vp.width, vp.height);
   } else {
-    // Log("Error - calling grabBegin while another grab session is active. This will probably cause weirdness");
+    Log("Error - calling grabBegin while another grab session is active. This will probably cause weirdness");
   }
   _manipulator->grabBegin(x, y, pan);
 }
@@ -775,7 +800,6 @@ void FilamentViewer::grabUpdate(float x, float y) {
     return;
   }
   if(_manipulator) {
-    Log("grab update %f %f", x, y);
     _manipulator->grabUpdate(x, y);
   } else {
     Log("Error - trying to use a manipulator when one is not available. Ensure you call grabBegin before grabUpdate/grabEnd");
@@ -789,16 +813,34 @@ void FilamentViewer::grabEnd() {
   }
   if(_manipulator) {
     _manipulator->grabEnd();
-    // delete _manipulator;
+    delete _manipulator;
+    _manipulator = nullptr;
   } else {
     Log("Error - trying to use a manipulator when one is not available. Ensure you call grabBegin before grabUpdate/grabEnd");
   }
 }
 
-void FilamentViewer::scroll(float x, float y, float delta) {
+void FilamentViewer::scrollBegin() {
-  if(_manipulator) {
+  if(!_manipulator) {
-    _manipulator->scroll(x, y, delta);
+    _createManipulator();
   }
 }
 
+void FilamentViewer::scrollUpdate(float x, float y, float delta) {
+  if(!_manipulator) {
+    Log("No manipulator has been created - ensure you call scrollStart before scroll");
+    return;
+  }
+  _manipulator->scroll(x, y, delta);
+}
+
+void FilamentViewer::scrollEnd() {
+  if(!_manipulator) {
+    Log("No manipulator has been created - ensure you call scrollStart before scroll/scrollEnd");
+    return;
+  }
+  delete _manipulator;
+  _manipulator = nullptr;
+}
+
 } // namespace polyvox

ios/src/FilamentViewer.hpp

@@ -11,6 +11,7 @@
 #include <filament/TransformManager.h>
 #include <filament/VertexBuffer.h>
 #include <filament/View.h>
+#include <filament/LightManager.h>
 
 #include <gltfio/AssetLoader.h>
 #include <gltfio/FilamentAsset.h>
@@ -82,7 +83,13 @@ namespace polyvox {
             void grabBegin(float x, float y, bool pan);
             void grabUpdate(float x, float y);
             void grabEnd();
-            void scroll(float x, float y, float delta);
+            void scrollBegin();
+            void scrollUpdate(float x, float y, float delta);
+            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 clearLights();
 
         private:
             void createImageRenderable();
@@ -117,7 +124,7 @@ namespace polyvox {
             NameComponentManager* _ncm;
             std::mutex mtx; // mutex to ensure thread safety when removing assets
 
-            Entity _sun;
+            vector<Entity> _lights;
             Texture* _skyboxTexture;
             Skybox* _skybox;
             Texture* _iblTexture;
@@ -145,6 +152,8 @@ namespace polyvox {
             Material* _imageMaterial = nullptr;
             TextureSampler _imageSampler;
             ColorGrading *colorGrading = nullptr;
+
+            void _createManipulator();
     };
 
 

ios/src/PolyvoxFilamentApi.hpp

@@ -2,6 +2,7 @@
 #define _POLYVOX_FILAMENT_API_H
 
 #include "ResourceBuffer.hpp"
+#include "LightManager.hpp"
 
 typedef struct ResourceBuffer ResourceBuffer;
 
@@ -14,6 +15,9 @@ void load_skybox(void* viewer, const char* skyboxPath);
 void load_ibl(void* viewer, const char* iblPath);
 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);
 void* load_gltf(void* viewer, const char* assetPath, const char* relativePath);
 bool set_camera(void* viewer, void* asset, const char* nodeName);
@@ -23,12 +27,14 @@ 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(void* viewer, float x, float y , float z);
+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, int x, int y, bool pan);
 void grab_update(void* viewer, int x, int y);
-    
 void grab_end(void* viewer);
+
     
 void apply_weights(void* asset, float* const weights, int count);
     

lib/filament_controller.dart

@@ -2,7 +2,10 @@ import 'dart:async';
 
 import 'package:flutter/services.dart';
 
+// this is confusing - "FilamentAsset" actually defines a pointer to a SceneAsset, whereas FilamentLight is an Entity ID.
+// should make this consistent
 typedef FilamentAsset = int;
+typedef FilamentLight = int;
 
 abstract class FilamentController {
   late int textureId;
@@ -20,8 +23,23 @@ abstract class FilamentController {
   Future removeSkybox();
   Future loadIbl(String path);
   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);
   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();
@@ -62,7 +80,7 @@ abstract class FilamentController {
   ///
   Future animate(FilamentAsset asset, List<double> data, int numWeights,
       int numFrames, double frameLengthInMs);
-  Future zoom(double z);
+
 }
 
 class PolyvoxFilamentController extends FilamentController {
@@ -138,6 +156,22 @@ class PolyvoxFilamentController extends FilamentController {
     await _channel.invokeMethod("removeIbl");
   }
 
+  @override
+  Future<FilamentLight> addLight(int type, double colour, double intensity, double posX, double posY, double posZ,double dirX, double dirY, double dirZ, bool castShadows) async {
+    var entityId = await _channel.invokeMethod("addLight", [type, colour, intensity, posX, posY, posZ, dirX, dirY, dirZ, castShadows]);
+    return entityId as FilamentLight;
+  }
+
+  @override
+  Future removeLight(FilamentLight light) {
+    return _channel.invokeMethod("removeLight", light);
+  }
+
+  @override
+  Future clearLights() {
+    return _channel.invokeMethod("clearLights");
+  }
+
   Future<FilamentAsset> loadGlb(String path) async {
     print("Loading GLB at $path ");
     var asset = await _channel.invokeMethod("loadGlb", path);
@@ -214,8 +248,16 @@ class PolyvoxFilamentController extends FilamentController {
     await _channel.invokeMethod("clearAssets");
   }
 
-  Future zoom(double z) async {
+  Future zoomBegin() async {
-    await _channel.invokeMethod("zoom", [0.0,0.0,z]);
+    await _channel.invokeMethod("zoomBegin");
+  }
+
+  Future zoomUpdate(double z) async {
+    await _channel.invokeMethod("zoomUpdate", [0.0,0.0,z]);
+  }
+
+  Future zoomEnd() async {
+    await _channel.invokeMethod("zoomEnd");
   }
 
   Future playAnimation(FilamentAsset asset, int index,

lib/gesture_detecting_filament_view.dart

@@ -87,7 +87,7 @@ class _GestureDetectingFilamentViewState
               behavior: HitTestBehavior.opaque,
               onScaleStart: (d) {
                 if (d.pointerCount == 2) {
-                  // _lastScale = d.
+                  widget.controller.zoomBegin();
                 } else {
                   _functionStart(d.focalPoint.dx, d.focalPoint.dy);
                 }
@@ -95,6 +95,7 @@ class _GestureDetectingFilamentViewState
               onScaleEnd: (d) {
                 if (d.pointerCount == 2) {
                   _lastScale = 0;
+                  widget.controller.zoomEnd();
                 } else {
                   _functionEnd();
                 }
@@ -104,7 +105,7 @@ class _GestureDetectingFilamentViewState
                   if (_lastScale == 0) {
                     _lastScale = d.scale;
                   } else {
-                    widget.controller.zoom(d.scale > 1 ? 5 : -5);
+                    widget.controller.zoomUpdate(d.scale > 1 ? 2 : -2);
                   }
                 } else {
                   // print("update ${d.focalPoint}");