maobo/cup_edit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Nick Fisher
2022-09-05 14:24:21 +10:00
parent 5693a0a957
commit 5ae59794df
7 changed files with 451 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
android/src/main/kotlin/app/polyvox/filament/FilamentInterop.kt
View File

@@ -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);

560
android/src/main/kotlin/app/polyvox/filament/PolyvoxFilamentPlugin.kt
View File

@@ -225,288 +225,334 @@ class PolyvoxFilamentPlugin: FlutterPlugin, MethodCallHandler, ActivityAware {
result.success(null)
}
}
"setBackgroundImage" -> {
executor.execute {
_lib.set_background_image(_viewer!!, getAssetPath(call.arguments as String))
"setBackgroundImage" -> {
executor.execute {
_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 {
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");
}
}
"zoomBegin" -> {
executor.execute {
_lib.scroll_begin(_viewer!!)
result.success("OK");
}
"loadSkybox" -> {
executor.execute {
_lib.load_skybox(_viewer!!, getAssetPath(call.arguments as String))
result.success("OK");
}
}
"zoomUpdate" -> {
executor.execute {
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 {
_lib.load_ibl(_viewer!!, getAssetPath(call.arguments as String))
result.success("OK");
}
}
"zoomEnd" -> {
executor.execute {
_lib.scroll_end(_viewer!!)
result.success("OK");
}
"removeIbl" -> {
executor.execute {
_lib.remove_ibl(_viewer!!)
result.success(true);
}
"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)
}
"removeSkybox" -> {
executor.execute {
_lib.remove_skybox(_viewer!!)
result.success(true);
}
"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)
}
"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")
}
}
}
"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>;
}
"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)
result.success("OK");
}
_lib.apply_weights(assetPtr, weights.toFloatArray(), weights.size)
result.success("OK");
}
"animateWeights" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
val assetPtr = Pointer(args[0] as Long)
val frames = args[1] as ArrayList<Float>;
val numWeights = args[2] as Int
val numFrames = args[3] as Int
val frameLenInMs = args[4] as Double
}
"animateWeights" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
val assetPtr = Pointer(args[0] as Long)
val frames = args[1] as ArrayList<Float>;
val numWeights = args[2] as Int
val numFrames = args[3] as Int
val frameLenInMs = args[4] as Double
_lib.animate_weights(assetPtr, frames.toFloatArray(), numWeights, numFrames, frameLenInMs.toFloat())
result.success("OK");
}
_lib.animate_weights(assetPtr, frames.toFloatArray(), numWeights, numFrames, frameLenInMs.toFloat())
result.success("OK");
}
"panStart" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), true)
result.success("OK");
}
}
"panStart" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), true)
result.success("OK");
}
"panUpdate" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
val x = (args[0] as Double).toFloat()
val y = (args[1] as Double).toFloat()
Log.v(TAG, "panUpdate ${x} ${y}")
_lib.grab_update(_viewer!!, x, y)
result.success("OK");
}
}
"panUpdate" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
val x = (args[0] as Double).toFloat()
val y = (args[1] as Double).toFloat()
Log.v(TAG, "panUpdate ${x} ${y}")
_lib.grab_update(_viewer!!, x, y)
result.success("OK");
}
"panEnd" -> {
executor.execute {
_lib.grab_end(_viewer!!)
result.success("OK");
}
}
"panEnd" -> {
executor.execute {
_lib.grab_end(_viewer!!)
result.success("OK");
}
"rotateStart" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), false)
result.success("OK");
}
}
"rotateStart" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), false)
result.success("OK");
}
"rotateUpdate" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_update(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
result.success("OK");
}
}
"rotateUpdate" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_update(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
result.success("OK");
}
"rotateEnd" -> {
executor.execute {
_lib.grab_end(_viewer!!)
result.success("OK");
}
}
"rotateEnd" -> {
executor.execute {
_lib.grab_end(_viewer!!)
result.success("OK");
}
"grabStart" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), true)
result.success("OK");
}
}
"grabStart" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_begin(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat(), true)
result.success("OK");
}
"grabUpdate" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_update(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
result.success("OK");
}
}
"grabUpdate" -> {
executor.execute {
val args = call.arguments as ArrayList<Any?>
_lib.grab_update(_viewer!!, (args[0] as Double).toFloat(), (args[1] as Double).toFloat())
result.success("OK");
}
"grabEnd" -> {
executor.execute {
_lib.grab_end(_viewer!!)
result.success("OK");
}
}
"grabEnd" -> {
executor.execute {
_lib.grab_end(_viewer!!)
result.success("OK");
}
"removeAsset" -> {
executor.execute {
_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")
}
}
"removeAsset" -> {
executor.execute {
_lib.remove_asset(_viewer!!, Pointer(call.arguments as Long))
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()
}
}
}

106
ios/src/FilamentViewer.cpp
View File

@@ -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();
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);
_createManipulator();
} 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) {
if(_manipulator) {
_manipulator->scroll(x, y, delta);
void FilamentViewer::scrollBegin() {
if(!_manipulator) {
_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

13
ios/src/FilamentViewer.hpp
View File

@@ -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();
};

10
ios/src/PolyvoxFilamentApi.hpp
View File

@@ -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);

48
lib/filament_controller.dart
View File

@@ -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 {
await _channel.invokeMethod("zoom", [0.0,0.0,z]);
Future zoomBegin() async {
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,

5
lib/gesture_detecting_filament_view.dart
View File

@@ -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}");