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

add getters from animation names and play animation method

Browse Source
This commit is contained in:
Nick Fisher
2022-03-22 22:33:50 +08:00
parent 8e3b530b46
commit 1410fb9ea7
6 changed files with 525 additions and 381 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
android/src/main/cpp/filament_api.cpp
View File

@@ -6,10 +6,11 @@
#include <android/native_activity.h> #include <android/native_activity.h>
using namespace polyvox; using namespace polyvox;
using namespace std;
static AAssetManager* am; static AAssetManager* am;
std::vector<AAsset*> _assets; vector<AAsset*> _assets;
uint64_t id = -1; uint64_t id = -1;
static polyvox::ResourceBuffer loadResource(const char* name) { static polyvox::ResourceBuffer loadResource(const char* name) {
@@ -122,30 +123,44 @@ extern "C" {
((FilamentViewer*)viewer)->animateWeights((float*)data, numWeights, numFrames, frameRate); ((FilamentViewer*)viewer)->animateWeights((float*)data, numWeights, numFrames, frameRate);
} }
void get_target_names(void* viewer, char* meshName, char*** outPtr, int* countPtr ) { void play_animation(void* viewer, int index) {
StringList names = ((FilamentViewer*)viewer)->getTargetNames(meshName); __android_log_print(ANDROID_LOG_VERBOSE, "filament_api", "Playing embedded animation %d", index);
((FilamentViewer*)viewer)->playAnimation(index);
*countPtr = names.count;
*outPtr = (char**)malloc(sizeof(char*) * names.count);
__android_log_print(ANDROID_LOG_VERBOSE, "filament_api", "Got %d names", names.count);
for(int i = 0; i < names.count; i++) {
std::string as_str(names.strings[i]);
(*outPtr)[i] = (char*)malloc(sizeof(char) * as_str.length());
strcpy((*outPtr)[i], as_str.c_str());
}
} }
void free_pointer(char*** ptr, int size) { char** get_animation_names(void* viewer, int* countPtr) {
__android_log_print(ANDROID_LOG_VERBOSE, "filament_api", "Freeing %d char pointers", size); auto names = ((FilamentViewer*)viewer)->getAnimationNames();
for(int i = 0; i < size; i++) { __android_log_print(ANDROID_LOG_VERBOSE, "filament_api", "Got %d animation names", names->size());
__android_log_print(ANDROID_LOG_VERBOSE, "filament_api", "%d", i); char** names_c;
// free((*ptr)[i]); names_c = new char*[names->size()];
for(int i = 0; i < names->size(); i++) {
names_c[i] = (char*) names->at(i).c_str();
__android_log_print(ANDROID_LOG_VERBOSE, "filament_api", "Alloced animation name %s ", (char*) names->at(i).c_str());
} }
__android_log_print(ANDROID_LOG_VERBOSE, "filament_api", "Free complete"); (*countPtr) = names->size();
// free(*ptr); return names_c;
}
char** get_target_names(void* viewer, char* meshName, int* countPtr ) {
StringList names = ((FilamentViewer*)viewer)->getTargetNames(meshName);
__android_log_print(ANDROID_LOG_VERBOSE, "filament_api", "Got %d names", names.count);
*countPtr = names.count;
char** retval;
retval = new char*[names.count];
__android_log_print(ANDROID_LOG_VERBOSE, "filament_api", "Allocated char* array of size %d", names.count);
for(int i =0; i < names.count; i++) {
retval[i] = (char*)names.strings[i];
}
return retval;
}
void free_pointer(char** ptr, int num) {
free(ptr);
} }
void release_source_assets(void* viewer) { void release_source_assets(void* viewer) {

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

@@ -54,10 +54,14 @@ interface FilamentInterop : Library {
fun animate_weights(viewer:Pointer, frames:FloatArray, numWeights:Int, numFrames:Int, frameRate:Float); fun animate_weights(viewer:Pointer, frames:FloatArray, numWeights:Int, numFrames:Int, frameRate:Float);
fun get_target_names(viewer:Pointer, meshName:String, outPtr:PointerByReference, outLen:IntByReference); fun get_target_names(viewer:Pointer, meshName:String, outLen:IntByReference) : Pointer;
fun free_pointer(ptr:PointerByReference, size:Int) fun get_animation_names(viewer:Pointer, outLen:IntByReference) : Pointer;
fun release_source_assets(viewer:Pointer) fun play_animation(viewer:Pointer, index:Int);
fun free_pointer(ptr:Pointer, size:Int);
fun release_source_assets(viewer:Pointer);
} }

38
android/src/main/kotlin/app/polyvox/filament/FilamentView.kt
View File

@@ -201,19 +201,38 @@ PlatformView {
"getTargetNames" -> { "getTargetNames" -> {
if(_viewer == null) if(_viewer == null)
return; return;
val arrPtr = PointerByReference();
val countPtr = IntByReference(); val countPtr = IntByReference();
_lib.get_target_names(_viewer!!, call.arguments as String, arrPtr, countPtr) val arrPtr = _lib.get_target_names(_viewer!!, call.arguments as String, countPtr)
val names = arrPtr.value.getStringArray(0, countPtr.value); val names = arrPtr.getStringArray(0, countPtr.value);
Log.v(TAG, "Got target names $names")
for(i in 0..countPtr.value-1) {
Log.v(TAG, "Got target names ${names[i]} ${names[i].length}")
}
val namesAsList = names.toCollection(ArrayList()) val namesAsList = names.toCollection(ArrayList())
_lib.free_pointer(arrPtr, countPtr.getValue()) _lib.free_pointer(arrPtr, countPtr.getValue())
Log.v(TAG, "Free complete") result.success(namesAsList)
}
"getAnimationNames" -> {
if(_viewer == null)
return;
val countPtr = IntByReference();
val arrPtr = _lib.get_animation_names(_viewer!!, countPtr)
val names = arrPtr.getStringArray(0, countPtr.value);
for(i in 0..countPtr.value-1) {
Log.v(TAG, "Got animation names ${names[i]} ${names[i].length}")
}
val namesAsList = names.toCollection(ArrayList())
_lib.free_pointer(arrPtr, 1)
result.success(namesAsList) result.success(namesAsList)
} }
@@ -281,6 +300,13 @@ PlatformView {
"releaseSourceAssets" -> { "releaseSourceAssets" -> {
_lib.release_source_assets(_viewer!!) _lib.release_source_assets(_viewer!!)
result.success("OK"); result.success("OK");
}
"playAnimation" -> {
_lib.play_animation(_viewer!!, call.arguments as Int)
result.success("OK")
}
else -> {
result.notImplemented()
} }
} }
} }

762
ios/src/FilamentViewer.cpp
View File

@@ -73,37 +73,42 @@ using namespace gltfio;
using namespace utils; using namespace utils;
using namespace std::chrono; using namespace std::chrono;
namespace gltfio { namespace gltfio
MaterialProvider* createUbershaderLoader(filament::Engine* engine); {
MaterialProvider *createUbershaderLoader(filament::Engine *engine);
} }
namespace filament { namespace filament
class IndirectLight; {
class LightManager; class IndirectLight;
class LightManager;
} }
namespace gltfio { namespace gltfio
MaterialProvider* createGPUMorphShaderLoader( {
const void* opaqueData, MaterialProvider *createGPUMorphShaderLoader(
uint64_t opaqueDataSize, const void *opaqueData,
const void* fadeData, uint64_t opaqueDataSize,
uint64_t fadeDataSize, const void *fadeData,
Engine* engine); uint64_t fadeDataSize,
void decomposeMatrix(const filament::math::mat4f& mat, filament::math::float3* translation, Engine *engine);
filament::math::quatf* rotation, filament::math::float3* scale); void decomposeMatrix(const filament::math::mat4f &mat, filament::math::float3 *translation,
filament::math::quatf *rotation, filament::math::float3 *scale);
} }
namespace polyvox { namespace polyvox
{
const double kNearPlane = 0.05; // 5 cm
const double kFarPlane = 1000.0; // 1 km
const float kScaleMultiplier = 100.0f;
const float kAperture = 16.0f;
const float kShutterSpeed = 1.0f / 125.0f;
const float kSensitivity = 100.0f;
filament::math::mat4f composeMatrix(const filament::math::float3& translation, const double kNearPlane = 0.05; // 5 cm
const filament::math::quatf& rotation, const filament::math::float3& scale) { const double kFarPlane = 1000.0; // 1 km
const float kScaleMultiplier = 100.0f;
const float kAperture = 16.0f;
const float kShutterSpeed = 1.0f / 125.0f;
const float kSensitivity = 100.0f;
filament::math::mat4f composeMatrix(const filament::math::float3 &translation,
const filament::math::quatf &rotation, const filament::math::float3 &scale)
{
float tx = translation[0]; float tx = translation[0];
float ty = translation[1]; float ty = translation[1];
float tz = translation[2]; float tz = translation[2];
@@ -115,38 +120,39 @@ filament::math::mat4f composeMatrix(const filament::math::float3& translation,
float sy = scale[1]; float sy = scale[1];
float sz = scale[2]; float sz = scale[2];
return filament::math::mat4f( return filament::math::mat4f(
(1 - 2 * qy*qy - 2 * qz*qz) * sx, (1 - 2 * qy * qy - 2 * qz * qz) * sx,
(2 * qx*qy + 2 * qz*qw) * sx, (2 * qx * qy + 2 * qz * qw) * sx,
(2 * qx*qz - 2 * qy*qw) * sx, (2 * qx * qz - 2 * qy * qw) * sx,
0.f, 0.f,
(2 * qx*qy - 2 * qz*qw) * sy, (2 * qx * qy - 2 * qz * qw) * sy,
(1 - 2 * qx*qx - 2 * qz*qz) * sy, (1 - 2 * qx * qx - 2 * qz * qz) * sy,
(2 * qy*qz + 2 * qx*qw) * sy, (2 * qy * qz + 2 * qx * qw) * sy,
0.f, 0.f,
(2 * qx*qz + 2 * qy*qw) * sz, (2 * qx * qz + 2 * qy * qw) * sz,
(2 * qy*qz - 2 * qx*qw) * sz, (2 * qy * qz - 2 * qx * qw) * sz,
(1 - 2 * qx*qx - 2 * qy*qy) * sz, (1 - 2 * qx * qx - 2 * qy * qy) * sz,
0.f, tx, ty, tz, 1.f); 0.f, tx, ty, tz, 1.f);
} }
FilamentViewer::FilamentViewer( FilamentViewer::FilamentViewer(
void* layer, void *layer,
const char* opaqueShaderPath, const char *opaqueShaderPath,
const char* fadeShaderPath, const char *fadeShaderPath,
LoadResource loadResource, LoadResource loadResource,
FreeResource freeResource) : _layer(layer), FreeResource freeResource) : _layer(layer),
_loadResource(loadResource), _loadResource(loadResource),
_freeResource(freeResource), _freeResource(freeResource),
opaqueShaderResources(nullptr, 0, 0), opaqueShaderResources(nullptr, 0, 0),
fadeShaderResources(nullptr, 0, 0), fadeShaderResources(nullptr, 0, 0),
_assetBuffer(nullptr, 0, 0) { _assetBuffer(nullptr, 0, 0)
{
_engine = Engine::create(Engine::Backend::OPENGL); _engine = Engine::create(Engine::Backend::OPENGL);
_renderer = _engine->createRenderer(); _renderer = _engine->createRenderer();
_renderer->setDisplayInfo({ .refreshRate = 60.0f, _renderer->setDisplayInfo({.refreshRate = 60.0f,
.presentationDeadlineNanos = (uint64_t)0, .presentationDeadlineNanos = (uint64_t)0,
.vsyncOffsetNanos = (uint64_t)0 }); .vsyncOffsetNanos = (uint64_t)0});
_scene = _engine->createScene(); _scene = _engine->createScene();
Entity camera = EntityManager::get().create(); Entity camera = EntityManager::get().create();
_mainCamera = _engine->createCamera(camera); _mainCamera = _engine->createCamera(camera);
@@ -164,8 +170,9 @@ FilamentViewer::FilamentViewer(
// options.homogeneousScaling = homogeneousScaling; // options.homogeneousScaling = homogeneousScaling;
// options.minScale = filament::math::float2{ minScale }; // options.minScale = filament::math::float2{ minScale };
// options.maxScale = filament::math::float2{ maxScale }; // options.maxScale = filament::math::float2{ maxScale };
//options.sharpness = sharpness; // options.sharpness = sharpness;
options.quality = View::QualityLevel::MEDIUM;; options.quality = View::QualityLevel::MEDIUM;
;
_view->setDynamicResolutionOptions(options); _view->setDynamicResolutionOptions(options);
View::MultiSampleAntiAliasingOptions multiSampleAntiAliasingOptions; View::MultiSampleAntiAliasingOptions multiSampleAntiAliasingOptions;
@@ -175,368 +182,449 @@ FilamentViewer::FilamentViewer(
_materialProvider = gltfio::createUbershaderLoader(_engine); _materialProvider = gltfio::createUbershaderLoader(_engine);
EntityManager& em = EntityManager::get(); EntityManager &em = EntityManager::get();
_ncm = new NameComponentManager(em); _ncm = new NameComponentManager(em);
_assetLoader = AssetLoader::create({_engine, _materialProvider, _ncm, &em}); _assetLoader = AssetLoader::create({_engine, _materialProvider, _ncm, &em});
_resourceLoader = new ResourceLoader( _resourceLoader = new ResourceLoader(
{.engine = _engine, .normalizeSkinningWeights = true, .recomputeBoundingBoxes = false}); {.engine = _engine, .normalizeSkinningWeights = true, .recomputeBoundingBoxes = true});
manipulator = manipulator =
Manipulator<float>::Builder().orbitHomePosition(0.0f, 0.0f, 0.0f).targetPosition(0.0f, 0.0f, -4.0f).build(Mode::ORBIT); Manipulator<float>::Builder().orbitHomePosition(0.0f, 0.0f, 0.05f).targetPosition(0.0f, 0.0f, 0.0f).build(Mode::ORBIT);
_asset = nullptr; _asset = nullptr;
}
FilamentViewer::~FilamentViewer() {
}
Renderer* FilamentViewer::getRenderer() {
return _renderer;
}
void FilamentViewer::createSwapChain(void* surface) {
_swapChain = _engine->createSwapChain(surface);
// Log("swapchain created.");
}
void FilamentViewer::destroySwapChain() {
if(_swapChain) {
_engine->destroy(_swapChain);
_swapChain = nullptr;
} }
// Log("swapchain destroyed.");
}
void FilamentViewer::applyWeights(float* weights, int count) { FilamentViewer::~FilamentViewer()
{
for (size_t i = 0, c = _asset->getEntityCount(); i != c; ++i) {
_asset->setMorphWeights(
_asset->getEntities()[i],
weights,
count
);
} }
}
void FilamentViewer::loadResources(string relativeResourcePath) { Renderer *FilamentViewer::getRenderer()
const char* const* const resourceUris = _asset->getResourceUris(); {
return _renderer;
}
void FilamentViewer::createSwapChain(void *surface)
{
_swapChain = _engine->createSwapChain(surface);
// Log("swapchain created.");
}
void FilamentViewer::destroySwapChain()
{
if (_swapChain)
{
_engine->destroy(_swapChain);
_swapChain = nullptr;
}
// Log("swapchain destroyed.");
}
void FilamentViewer::applyWeights(float *weights, int count)
{
for (size_t i = 0, c = _asset->getEntityCount(); i != c; ++i)
{
_asset->setMorphWeights(
_asset->getEntities()[i],
weights,
count);
}
}
void FilamentViewer::loadResources(string relativeResourcePath)
{
const char *const *const resourceUris = _asset->getResourceUris();
const size_t resourceUriCount = _asset->getResourceUriCount(); const size_t resourceUriCount = _asset->getResourceUriCount();
Log("Loading %d resources for asset", resourceUriCount); Log("Loading %d resources for asset", resourceUriCount);
for (size_t i = 0; i < resourceUriCount; i++) { for (size_t i = 0; i < resourceUriCount; i++)
string uri = relativeResourcePath + string(resourceUris[i]); {
ResourceBuffer buf = _loadResource(uri.c_str()); string uri = relativeResourcePath + 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) { // 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); // FunctionCallback fcb = cb;
_resourceLoader->addResourceData(resourceUris[i], std::move(b)); ResourceLoader::BufferDescriptor b(
_freeResource(buf); buf.data, buf.size);
_resourceLoader->addResourceData(resourceUris[i], std::move(b));
_freeResource(buf);
} }
_resourceLoader->loadResources(_asset); _resourceLoader->loadResources(_asset);
const Entity* entities = _asset->getEntities(); const Entity *entities = _asset->getEntities();
RenderableManager& rm = _engine->getRenderableManager(); RenderableManager &rm = _engine->getRenderableManager();
for(int i =0; i< _asset->getEntityCount(); i++) { for (int i = 0; i < _asset->getEntityCount(); i++)
Entity e = entities[i]; {
auto inst = rm.getInstance(e); Entity e = entities[i];
rm.setCulling(inst, false); auto inst = rm.getInstance(e);
rm.setCulling(inst, false);
} }
_animator = _asset->getAnimator(); _animator = _asset->getAnimator();
_scene->addEntities(_asset->getEntities(), _asset->getEntityCount()); _scene->addEntities(_asset->getEntities(), _asset->getEntityCount());
}; };
void FilamentViewer::releaseSourceAssets() { void FilamentViewer::releaseSourceAssets()
Log("Releasing source data"); {
_asset->releaseSourceData(); Log("Releasing source data");
// _freeResource(opaqueShaderResources); _asset->releaseSourceData();
// _freeResource(fadeShaderResources); // _freeResource(opaqueShaderResources);
} // _freeResource(fadeShaderResources);
}
void FilamentViewer::loadGlb(const char *const uri)
{
void FilamentViewer::loadGlb(const char* const uri) { Log("Loading GLB at URI %s", uri);
Log("Loading GLB at URI %s", uri);
if(_asset) { if (_asset)
_asset->releaseSourceData(); {
_resourceLoader->evictResourceData(); _asset->releaseSourceData();
_scene->removeEntities(_asset->getEntities(), _asset->getEntityCount()); _resourceLoader->evictResourceData();
_assetLoader->destroyAsset(_asset); _scene->removeEntities(_asset->getEntities(), _asset->getEntityCount());
} _assetLoader->destroyAsset(_asset);
_asset = nullptr; }
_animator = nullptr; _asset = nullptr;
_animator = nullptr;
ResourceBuffer rbuf = _loadResource(uri); ResourceBuffer rbuf = _loadResource(uri);
_asset = _assetLoader->createAssetFromBinary( _asset = _assetLoader->createAssetFromBinary(
(const uint8_t*)rbuf.data, rbuf.size); (const uint8_t *)rbuf.data, rbuf.size);
if (!_asset) { if (!_asset)
{
Log("Unknown error loading GLB asset."); Log("Unknown error loading GLB asset.");
exit(1); exit(1);
} }
int entityCount = _asset->getEntityCount();
_scene->addEntities(_asset->getEntities(), entityCount);
Log("Added %d entities to scene", entityCount); int entityCount = _asset->getEntityCount();
_resourceLoader->loadResources(_asset);
_animator = _asset->getAnimator();
const Entity* entities = _asset->getEntities(); _scene->addEntities(_asset->getEntities(), entityCount);
RenderableManager& rm = _engine->getRenderableManager();
for(int i =0; i< _asset->getEntityCount(); i++) { Log("Added %d entities to scene", entityCount);
Entity e = entities[i]; _resourceLoader->loadResources(_asset);
auto inst = rm.getInstance(e); _animator = _asset->getAnimator();
rm.setCulling(inst, false);
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);
} }
_freeResource(rbuf); _freeResource(rbuf);
Log("Successfully loaded GLB.");
}
void FilamentViewer::loadGltf(const char* const uri, const char* const relativeResourcePath) { _animator->updateBoneMatrices();
Log("Successfully loaded GLB.");
}
void FilamentViewer::loadGltf(const char *const uri, const char *const relativeResourcePath)
{
Log("Loading GLTF at URI %s", uri); Log("Loading GLTF at URI %s", uri);
if(_asset) { if (_asset)
Log("Asset already exists"); {
_resourceLoader->evictResourceData(); Log("Asset already exists");
_scene->removeEntities(_asset->getEntities(), _asset->getEntityCount()); _resourceLoader->evictResourceData();
_assetLoader->destroyAsset(_asset); _scene->removeEntities(_asset->getEntities(), _asset->getEntityCount());
_freeResource(_assetBuffer); _assetLoader->destroyAsset(_asset);
_freeResource(_assetBuffer);
} }
_asset = nullptr; _asset = nullptr;
_animator = nullptr; _animator = nullptr;
_assetBuffer = _loadResource(uri); _assetBuffer = _loadResource(uri);
// Parse the glTF file and create Filament entities. // Parse the glTF file and create Filament entities.
Log("Creating asset from JSON"); Log("Creating asset from JSON");
_asset = _assetLoader->createAssetFromJson((uint8_t*)_assetBuffer.data, _assetBuffer.size); _asset = _assetLoader->createAssetFromJson((uint8_t *)_assetBuffer.data, _assetBuffer.size);
Log("Created asset from JSON"); Log("Created asset from JSON");
if (!_asset) { if (!_asset)
Log("Unable to parse asset"); {
exit(1); Log("Unable to parse asset");
exit(1);
} }
Log("Loading relative resources"); Log("Loading relative resources");
loadResources(string(relativeResourcePath) + string("/")); loadResources(string(relativeResourcePath) + string("/"));
Log("Loaded relative resources"); Log("Loaded relative resources");
// _asset->releaseSourceData(); // _asset->releaseSourceData();
Log("Load complete for GLTF at URI %s", uri); Log("Load complete for GLTF at URI %s", uri);
// transformToUnitCube(); // transformToUnitCube();
}
}
bool FilamentViewer::setCamera(const char* cameraName) { ///
FFilamentAsset* asset = (FFilamentAsset*)_asset; /// Sets the active camera to the GLTF camera specified by [name].
/// Blender export arranges cameras as follows
/// - parent node with global (?) matrix
/// --- child node with "camera" property set to camera node name
/// - camera node
/// We therefore find the first node where the "camera" property is equal to the requested name,
/// then use the parent transform matrix.
///
bool FilamentViewer::setCamera(const char *cameraName)
{
FFilamentAsset *asset = (FFilamentAsset *)_asset;
gltfio::NodeMap &sourceNodes = asset->isInstanced() ? asset->mInstances[0]->nodeMap gltfio::NodeMap &sourceNodes = asset->isInstanced() ? asset->mInstances[0]->nodeMap
: asset->mNodeMap; : asset->mNodeMap;
Log("Setting camera to %s", cameraName); Log("Setting camera to node %s", cameraName);
for (auto pair : sourceNodes) { for (auto pair : sourceNodes)
{
cgltf_node const *node = pair.first; cgltf_node const *node = pair.first;
if(!node->camera) { if (strcmp(cameraName, node->name) != 0)
if(node->name) { {
Log("No camera found under node %s", node->name);
} else {
Log("No camera found under unnamed node.");
}
continue; continue;
} }
Log("Found camera under node %s", node->name); Log("Node %s : Matrix : %03f %03f %03f %03f %03f %03f %03f %03f %03f %03f %03f %03f %03f %03f %03f %03f Translation : %03f %03f %03f Rotation %03f %03f %03f %03f Scale %03f %03f %03f",
node->name,
node->matrix[0],
node->matrix[1],
node->matrix[2],
node->matrix[3],
node->matrix[4],
node->matrix[5],
node->matrix[6],
node->matrix[7],
node->matrix[8],
node->matrix[9],
node->matrix[10],
node->matrix[11],
node->matrix[12],
node->matrix[13],
node->matrix[14],
node->matrix[15],
node->translation[0],
node->translation[1],
node->translation[2],
node->rotation[0],
node->rotation[1],
node->rotation[2],
node->rotation[3],
node->scale[0],
node->scale[1],
node->scale[2]
);
mat4f t = mat4f::translation(float3 { node->translation[0],node->translation[1],node->translation[2] });
mat4f r { quatf { node->rotation[3], node->rotation[0], node->rotation[1], node->rotation[2] } };
mat4f transform = t * r;
if(node->camera->name) { if (!node->camera)
Log("Checking camera : %s", node->camera->name); {
cgltf_node* leaf = node->children[0];
Log("Child 1 trans : %03f %03f %03f rot : %03f %03f %03f %03f ", leaf->translation[0], leaf->translation[1],leaf->translation[2], leaf->rotation[0],leaf->rotation[1],leaf->rotation[2],leaf->rotation[3]);
if (!leaf->camera) {
leaf = leaf->children[0];
Log("Child 2 %03f %03f %03f %03f %03f %03f %03f ", leaf->translation[0], leaf->translation[1],leaf->translation[2], leaf->rotation[0],leaf->rotation[1],leaf->rotation[2],leaf->rotation[3]);
if (!leaf->camera) {
Log("Could not find GLTF camera under node or its ssecond or third child nodes.");
exit(-1);
}
}
Log("Using rotation from leaf node.");
mat4f child_rot { quatf { leaf->rotation[3], leaf->rotation[0], leaf->rotation[1], leaf->rotation[2] } };
transform *= child_rot;
} }
Entity cameraEntity = EntityManager::get().create();
Camera *cam = _engine->createCamera(cameraEntity);
if(strcmp(cameraName, node->camera->name) == 0) { const Viewport &vp = _view->getViewport();
Log("Found camera.");
filament::math::mat4 mat( const double aspect = (double)vp.width / vp.height;
node->matrix[0],
node->matrix[1], // todo - pull focal length from gltf node
node->matrix[2],
node->matrix[3], cam->setLensProjection(_cameraFocalLength, aspect, kNearPlane, kFarPlane);
node->matrix[4],
node->matrix[5], if (!cam)
node->matrix[6], {
node->matrix[7], Log("Couldn't create camera");
node->matrix[8], }
node->matrix[9], else
node->matrix[10], {
node->matrix[11], _engine->getTransformManager().setTransform(
node->parent->translation[0], _engine->getTransformManager().getInstance(cameraEntity), transform
node->parent->translation[1],
node->parent->translation[2],
1
); );
quatf rot1(node->parent->rotation[0],node->parent->rotation[1], node->parent->rotation[2], node->parent->rotation[3]); _view->setCamera(cam);
quatf rot2(node->rotation[0],node->rotation[1], node->rotation[2], node->rotation[3]); return true;
quatf rot3 = rot1 * rot2;
filament::math::mat4 rotm(rot3);
filament::math::mat4 result = mat * rotm;
Entity cameraEntity = EntityManager::get().create();
Camera* cam = _engine->createCamera(cameraEntity);
const Viewport& vp = _view->getViewport();
const double aspect = (double)vp.width / vp.height;
cam->setLensProjection(_cameraFocalLength, aspect, kNearPlane, kFarPlane);
if(!cam) {
Log("Couldn't create camera");
} else {
_engine->getTransformManager().setTransform(
_engine->getTransformManager().getInstance(cameraEntity), result);
_view->setCamera(cam);
return true;
}
} }
}
return false;
} }
return false;
}
StringList FilamentViewer::getTargetNames(const char* meshName) { unique_ptr<vector<string>> FilamentViewer::getAnimationNames()
FFilamentAsset* asset = (FFilamentAsset*)_asset; {
NodeMap &sourceNodes = asset->isInstanced() ? asset->mInstances[0]->nodeMap : asset->mNodeMap;
if(sourceNodes.empty()) { size_t count = _animator->getAnimationCount();
Log("Found %d animations in asset.", count);
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;
}
StringList FilamentViewer::getTargetNames(const char *meshName)
{
FFilamentAsset *asset = (FFilamentAsset *)_asset;
NodeMap &sourceNodes = asset->isInstanced() ? asset->mInstances[0]->nodeMap : asset->mNodeMap;
if (sourceNodes.empty())
{
Log("Asset source nodes empty?"); Log("Asset source nodes empty?");
return StringList(nullptr, 0); return StringList(nullptr, 0);
} }
Log("Fetching morph target names for mesh %s", meshName); Log("Fetching morph target names for mesh %s", meshName);
for (auto pair : sourceNodes) { for (auto pair : sourceNodes)
{
cgltf_node const *node = pair.first; cgltf_node const *node = pair.first;
cgltf_mesh const *mesh = node->mesh; cgltf_mesh const *mesh = node->mesh;
if (mesh) { if (mesh)
Log("Mesh : %s ",mesh->name); {
if(strcmp(meshName, mesh->name) == 0) { Log("Mesh : %s ", mesh->name);
return StringList((const char**)mesh->target_names, (int) mesh->target_names_count); if (strcmp(meshName, mesh->name) == 0)
} {
} return StringList((const char **)mesh->target_names, (int)mesh->target_names_count);
}
}
}
return StringList(nullptr, 0);
} }
return StringList(nullptr, 0);
}
void FilamentViewer::loadSkybox(const char *const skyboxPath, const char *const iblPath, AAssetManager *am)
{
void FilamentViewer::loadSkybox(const char* const skyboxPath, const char* const iblPath, AAssetManager* am) {
ResourceBuffer skyboxBuffer = _loadResource(skyboxPath); ResourceBuffer skyboxBuffer = _loadResource(skyboxPath);
image::KtxBundle* skyboxBundle = image::KtxBundle *skyboxBundle =
new image::KtxBundle(static_cast<const uint8_t*>(skyboxBuffer.data), static_cast<uint32_t>(skyboxBuffer.size)); new image::KtxBundle(static_cast<const uint8_t *>(skyboxBuffer.data), static_cast<uint32_t>(skyboxBuffer.size));
_skyboxTexture = image::ktx::createTexture(_engine, skyboxBundle, false); _skyboxTexture = image::ktx::createTexture(_engine, skyboxBundle, false);
_skybox = filament::Skybox::Builder().environment(_skyboxTexture).build(*_engine); _skybox = filament::Skybox::Builder().environment(_skyboxTexture).build(*_engine);
_scene->setSkybox(_skybox); _scene->setSkybox(_skybox);
_freeResource(skyboxBuffer); _freeResource(skyboxBuffer);
Log("Loading IBL from %s", iblPath); Log("Loading IBL from %s", iblPath);
// Load IBL. // Load IBL.
ResourceBuffer iblBuffer = _loadResource(iblPath); ResourceBuffer iblBuffer = _loadResource(iblPath);
image::KtxBundle* iblBundle = new image::KtxBundle( image::KtxBundle *iblBundle = new image::KtxBundle(
static_cast<const uint8_t*>(iblBuffer.data), static_cast<uint32_t>(iblBuffer.size)); static_cast<const uint8_t *>(iblBuffer.data), static_cast<uint32_t>(iblBuffer.size));
math::float3 harmonics[9]; math::float3 harmonics[9];
iblBundle->getSphericalHarmonics(harmonics); iblBundle->getSphericalHarmonics(harmonics);
_iblTexture = image::ktx::createTexture(_engine, iblBundle, false); _iblTexture = image::ktx::createTexture(_engine, iblBundle, false);
_indirectLight = IndirectLight::Builder() _indirectLight = IndirectLight::Builder()
.reflections(_iblTexture) .reflections(_iblTexture)
.irradiance(3, harmonics) .irradiance(3, harmonics)
.intensity(30000.0f) .intensity(30000.0f)
.build(*_engine); .build(*_engine);
_scene->setIndirectLight(_indirectLight); _scene->setIndirectLight(_indirectLight);
_freeResource(iblBuffer); _freeResource(iblBuffer);
// Always add a direct light source since it is required for shadowing. // Always add a direct light source since it is required for shadowing.
_sun = EntityManager::get().create(); _sun = EntityManager::get().create();
LightManager::Builder(LightManager::Type::DIRECTIONAL) LightManager::Builder(LightManager::Type::DIRECTIONAL)
.color(Color::cct(6500.0f)) .color(Color::cct(6500.0f))
.intensity(100000.0f) .intensity(100000.0f)
.direction(math::float3(0.0f, 1.0f, 0.0f)) .direction(math::float3(0.0f, 1.0f, 0.0f))
.castShadows(true) .castShadows(true)
.build(*_engine, _sun); .build(*_engine, _sun);
_scene->addEntity(_sun); _scene->addEntity(_sun);
Log("Skybox/IBL load complete."); Log("Skybox/IBL load complete.");
}
} void FilamentViewer::transformToUnitCube()
{
if (!_asset)
{
Log("No asset, cannot transform.");
return;
}
auto &tm = _engine->getTransformManager();
auto aabb = _asset->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(_asset->getRoot()), transform);
}
void FilamentViewer::transformToUnitCube() { void FilamentViewer::cleanup()
if (!_asset) { {
Log("No asset, cannot transform.");
return;
}
auto& tm = _engine->getTransformManager();
auto aabb = _asset->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(_asset->getRoot()), transform);
}
void FilamentViewer::cleanup() {
_resourceLoader->asyncCancelLoad(); _resourceLoader->asyncCancelLoad();
_assetLoader->destroyAsset(_asset); _assetLoader->destroyAsset(_asset);
_materialProvider->destroyMaterials(); _materialProvider->destroyMaterials();
AssetLoader::destroy(&_assetLoader); AssetLoader::destroy(&_assetLoader);
_freeResource(_assetBuffer); _freeResource(_assetBuffer);
}; };
void FilamentViewer::render() { void FilamentViewer::render()
if (!_view || !_mainCamera || !_swapChain) { {
Log("Not ready for rendering"); if (!_view || !_mainCamera || !_swapChain)
return; {
Log("Not ready for rendering");
return;
} }
if(morphAnimationBuffer) { if (morphAnimationBuffer)
{
updateMorphAnimation(); updateMorphAnimation();
} }
if(embeddedAnimationBuffer) {
updateEmbeddedAnimation();
}
math::float3 eye, target, upward; math::float3 eye, target, upward;
manipulator->getLookAt(&eye, &target, &upward); manipulator->getLookAt(&eye, &target, &upward);
_mainCamera->lookAt(eye, target, upward); _mainCamera->lookAt(eye, target, upward);
// Render the scene, unless the renderer wants to skip the frame. // Render the scene, unless the renderer wants to skip the frame.
if (_renderer->beginFrame(_swapChain)) { if (_renderer->beginFrame(_swapChain))
_renderer->render(_view); {
_renderer->endFrame(); _renderer->render(_view);
} _renderer->endFrame();
} }
}
void FilamentViewer::updateViewportAndCameraProjection(int width, int height, float contentScaleFactor)
void FilamentViewer::updateViewportAndCameraProjection(int width, int height, float contentScaleFactor) { {
if (!_view || !_mainCamera) { if (!_view || !_mainCamera)
Log("Skipping camera update, no view or camrea"); {
return; Log("Skipping camera update, no view or camrea");
return;
} }
const uint32_t _width = width * contentScaleFactor; const uint32_t _width = width * contentScaleFactor;
@@ -546,58 +634,65 @@ void FilamentViewer::updateViewportAndCameraProjection(int width, int height, fl
const double aspect = (double)width / height; const double aspect = (double)width / height;
_mainCamera->setLensProjection(_cameraFocalLength, aspect, kNearPlane, kFarPlane); _mainCamera->setLensProjection(_cameraFocalLength, aspect, kNearPlane, kFarPlane);
Log("Set viewport to %d %d", _width, _height); Log("Set viewport to %d %d", _width, _height);
}
void FilamentViewer::animateWeights(float* data, int numWeights, int numFrames, float frameRate) {
morphAnimationBuffer = std::make_unique<MorphAnimationBuffer>(data, numWeights, numFrames, 1000 / frameRate );
}
void FilamentViewer::updateMorphAnimation() {
if(morphAnimationBuffer->frameIndex >= morphAnimationBuffer->numFrames) {
morphAnimationBuffer = nullptr;
return;
} }
if(morphAnimationBuffer->frameIndex == -1) { void FilamentViewer::animateWeights(float *data, int numWeights, int numFrames, float frameRate)
morphAnimationBuffer->frameIndex++; {
morphAnimationBuffer->startTime = std::chrono::high_resolution_clock::now(); morphAnimationBuffer = std::make_unique<MorphAnimationBuffer>(data, numWeights, numFrames, 1000 / frameRate);
applyWeights(morphAnimationBuffer->frameData, morphAnimationBuffer->numWeights); }
} else {
std::chrono::duration<double, std::milli> dur = std::chrono::high_resolution_clock::now() - morphAnimationBuffer->startTime; void FilamentViewer::updateMorphAnimation()
int frameIndex = dur.count() / morphAnimationBuffer->frameLength; {
if(frameIndex != morphAnimationBuffer->frameIndex) {
if (morphAnimationBuffer->frameIndex >= morphAnimationBuffer->numFrames)
{
morphAnimationBuffer = nullptr;
return;
}
if (morphAnimationBuffer->frameIndex == -1)
{
morphAnimationBuffer->frameIndex++;
morphAnimationBuffer->startTime = std::chrono::high_resolution_clock::now();
applyWeights(morphAnimationBuffer->frameData, morphAnimationBuffer->numWeights);
}
else
{
std::chrono::duration<double, std::milli> dur = std::chrono::high_resolution_clock::now() - morphAnimationBuffer->startTime;
int frameIndex = dur.count() / morphAnimationBuffer->frameLength;
if (frameIndex != morphAnimationBuffer->frameIndex)
{
morphAnimationBuffer->frameIndex = frameIndex; morphAnimationBuffer->frameIndex = frameIndex;
applyWeights(morphAnimationBuffer->frameData + (morphAnimationBuffer->frameIndex * morphAnimationBuffer->numWeights), morphAnimationBuffer->numWeights); applyWeights(morphAnimationBuffer->frameData + (morphAnimationBuffer->frameIndex * morphAnimationBuffer->numWeights), morphAnimationBuffer->numWeights);
}
} }
} }
}
void FilamentViewer::playAnimation(int index) {
embeddedAnimationBuffer = make_unique<EmbeddedAnimationBuffer>(index, _animator->getAnimationDuration(index));
}
void FilamentViewer::updateEmbeddedAnimation() {
duration<double> dur = duration_cast<duration<double>>(std::chrono::high_resolution_clock::now() - embeddedAnimationBuffer->lastTime);
float startTime = 0;
if(!embeddedAnimationBuffer->hasStarted) {
embeddedAnimationBuffer->hasStarted = true;
embeddedAnimationBuffer->lastTime = std::chrono::high_resolution_clock::now();
} else if(dur.count() >= embeddedAnimationBuffer->duration) {
embeddedAnimationBuffer = nullptr;
return;
} else {
startTime = dur.count();
}
_animator->applyAnimation(embeddedAnimationBuffer->animationIndex, startTime);
_animator->updateBoneMatrices();
}
} }
// void FilamentViewer::updateEmbeddedAnimation() {
// duration<double> dur = duration_cast<duration<double>>(std::chrono::high_resolution_clock::now() - embeddedAnimationBuffer->lastTime);
// float startTime = 0;
// if(!embeddedAnimationBuffer->hasStarted) {
// embeddedAnimationBuffer->hasStarted = true;
// embeddedAnimationBuffer->lastTime = std::chrono::high_resolution_clock::now();
// } else if(dur.count() >= embeddedAnimationBuffer->duration) {
// embeddedAnimationBuffer = nullptr;
// return;
// } else {
// startTime = dur.count();
// }
// _animator->applyAnimation(embeddedAnimationBuffer->animationIndex, startTime);
// _animator->updateBoneMatrices();
// }
// // // //
// //if(morphAnimationBuffer.frameIndex >= morphAnimationBuffer.numFrames) { // //if(morphAnimationBuffer.frameIndex >= morphAnimationBuffer.numFrames) {
// // this.morphAnimationBuffer = null; // // this.morphAnimationBuffer = null;
@@ -617,9 +712,6 @@ void FilamentViewer::updateMorphAnimation() {
// // morphAnimationBuffer->lastTime = std::chrono::high_resolution_clock::now(); // // morphAnimationBuffer->lastTime = std::chrono::high_resolution_clock::now();
// // } // // }
// //} // //}
// void FilamentViewer::playAnimation(int index) {
// embeddedAnimationBuffer = make_unique<EmbeddedAnimationBuffer>(index, _animator->getAnimationDuration(index));
// }
// void FilamentViewer::createMorpher(const char* meshName, int* primitives, int numPrimitives) { // void FilamentViewer::createMorpher(const char* meshName, int* primitives, int numPrimitives) {
@@ -656,7 +748,7 @@ void FilamentViewer::updateMorphAnimation() {
// this.animation = null; // this.animation = null;
// return; // return;
// } // }
// if(animation.frameIndex == -1) { // if(animation.frameIndex == -1) {
// animation->frameIndex++; // animation->frameIndex++;
// animation->lastTime = std::chrono::high_resolution_clock::now(); // animation->lastTime = std::chrono::high_resolution_clock::now();
@@ -670,4 +762,4 @@ void FilamentViewer::updateMorphAnimation() {
// callback(); // applyWeights(frameData + (frameIndex * numWeights), numWeights); // callback(); // applyWeights(frameData + (frameIndex * numWeights), numWeights);
// } // }
// } // }
// } // }

30
ios/src/FilamentViewer.hpp
View File

@@ -54,6 +54,16 @@ namespace polyvox {
const int count; const int count;
}; };
struct EmbeddedAnimationBuffer {
EmbeddedAnimationBuffer(int animationIndex, float duration) : animationIndex(animationIndex), duration(duration) {}
bool hasStarted = false;
int animationIndex;
float duration = 0;
time_point_t lastTime;
};
struct ResourceBuffer { struct ResourceBuffer {
ResourceBuffer(const void* data, const uint32_t size, const uint32_t id) : data(data), size(size), id(id) {}; ResourceBuffer(const void* data, const uint32_t size, const uint32_t id) : data(data), size(size), id(id) {};
@@ -102,6 +112,7 @@ namespace polyvox {
// void createMorpher(const char* meshName, int* primitives, int numPrimitives); // void createMorpher(const char* meshName, int* primitives, int numPrimitives);
void releaseSourceAssets(); void releaseSourceAssets();
StringList getTargetNames(const char* meshName); StringList getTargetNames(const char* meshName);
unique_ptr<vector<string>> getAnimationNames();
Manipulator<float>* manipulator; Manipulator<float>* manipulator;
void applyWeights(float* weights, int count); void applyWeights(float* weights, int count);
void animateWeights(float* data, int numWeights, int length, float frameRate); void animateWeights(float* data, int numWeights, int length, float frameRate);
@@ -158,27 +169,16 @@ namespace polyvox {
float _cameraFocalLength = 0.0f; float _cameraFocalLength = 0.0f;
void updateMorphAnimation(); void updateMorphAnimation();
// void updateEmbeddedAnimation(); void updateEmbeddedAnimation();
// animation flags; // animation flags;
bool isAnimating; bool isAnimating;
unique_ptr<MorphAnimationBuffer> morphAnimationBuffer; unique_ptr<MorphAnimationBuffer> morphAnimationBuffer;
// unique_ptr<EmbeddedAnimationBuffer> embeddedAnimationBuffer; unique_ptr<EmbeddedAnimationBuffer> embeddedAnimationBuffer;
}; };
} }
// struct EmbeddedAnimationBuffer {
// EmbeddedAnimationBuffer(int animationIndex, float duration) : animationIndex(animationIndex), duration(duration) {}
// bool hasStarted = false;
// int animationIndex;
// float duration = 0;
// time_point_t lastTime;
// };

7
lib/filament_controller.dart
View File

@@ -15,6 +15,7 @@ abstract class FilamentController {
Future rotateEnd(); Future rotateEnd();
Future applyWeights(List<double> weights); Future applyWeights(List<double> weights);
Future<List<String>> getTargetNames(String meshName); Future<List<String>> getTargetNames(String meshName);
Future<List<String>> getAnimationNames();
Future releaseSourceAssets(); Future releaseSourceAssets();
Future playAnimation(int index); Future playAnimation(int index);
Future setCamera(String name); Future setCamera(String name);
@@ -102,6 +103,12 @@ class PolyvoxFilamentController extends FilamentController {
return result; return result;
} }
Future<List<String>> getAnimationNames() async {
var result = (await _channel.invokeMethod("getAnimationNames"))
.cast<String>();
return result;
}
Future animate(List<double> weights, int numWeights, double frameRate) async { Future animate(List<double> weights, int numWeights, double frameRate) async {
await _channel await _channel
.invokeMethod("animateWeights", [weights, numWeights, frameRate]); .invokeMethod("animateWeights", [weights, numWeights, frameRate]);