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

finalize bone transform animation

Browse Source
This commit is contained in:
Nick Fisher
2022-12-17 16:31:20 +08:00
parent de9797a20e
commit b1832c237f
17 changed files with 581 additions and 476 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ios/include/FilamentViewer.hpp
View File

@@ -33,7 +33,7 @@
#include "SceneAssetLoader.hpp"
#include "SceneAsset.hpp"
#include "SceneResources.hpp"
#include "ResourceManagement.hpp"
using namespace std;
using namespace filament;

172
ios/include/PolyvoxFilamentApi.h
View File

@@ -5,91 +5,105 @@
typedef struct ResourceBuffer ResourceBuffer;
//ResourceBuffer create_resource_buffer(const void* data, const uint32_t size, const uint32_t id);
void* filament_viewer_new(void* context, ResourceBuffer (*loadResource)(const char*), void (*freeResource)(uint32_t));
void* filament_viewer_delete(void* viewer);
void create_render_target(void* viewer, uint32_t textureId, uint32_t width, uint32_t height);
void set_background_image(void* viewer, const char* path);
void set_background_image_position(void* viewer, float x, float y, bool clamp);
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);
void render(void* viewer, uint64_t frameTimeInNanos);
void create_swap_chain(void* viewer, void* surface, uint32_t width, uint32_t height);
void destroy_swap_chain(void* viewer);
void set_frame_interval(void* viewer, float interval);
void* get_renderer(void* viewer);
void update_viewport_and_camera_projection(void* viewer, int width, int height, float scaleFactor);
void scroll_begin(void* viewer);
void scroll_update(void* viewer, float x, float y , float z);
void scroll_end(void* viewer);
void grab_begin(void* viewer, float x, float y, bool pan);
void grab_update(void* viewer, float x, float y);
void grab_end(void* viewer);
///
/// A wrapper for a single set of frame-data that may animate multiples bones/mesh nodes.
/// [data]
///
struct BoneAnimation {
const char** boneNames;
const char** meshNames;
float* data;
size_t numBones;
size_t numMeshTargets;
};
void apply_weights(void* asset, float* const weights, int count);
void set_animation(
void* asset,
float* morphData,
int numMorphWeights,
float* boneData,
const char** boneNames,
const char** meshNames,
int numBones,
int numFrames,
float frameLengthInMs
);
typedef struct BoneAnimation BoneAnimation;
void set_bone_transform(
void* asset,
const char* boneName,
const char* entityName,
float transX,
float transY,
float transZ,
float quatX,
float quatY,
float quatZ,
float quatW
);
void play_animation(void* asset, int index, bool loop, bool reverse);
void stop_animation(void* asset, int index);
int get_animation_count(void* asset);
extern "C" {
void* filament_viewer_new(void* context, ResourceBuffer (*loadResource)(const char*), void (*freeResource)(uint32_t));
void filament_viewer_delete(void* viewer);
void create_render_target(void* viewer, uint32_t textureId, uint32_t width, uint32_t height);
void set_background_image(void* viewer, const char* path);
void set_background_image_position(void* viewer, float x, float y, bool clamp);
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);
void render(void* viewer, uint64_t frameTimeInNanos);
void create_swap_chain(void* viewer, void* surface, uint32_t width, uint32_t height);
void destroy_swap_chain(void* viewer);
void set_frame_interval(void* viewer, float interval);
void* get_renderer(void* viewer);
void update_viewport_and_camera_projection(void* viewer, int width, int height, float scaleFactor);
void get_animation_name(void* asset, char* const outPtr, int index);
void scroll_begin(void* viewer);
void scroll_update(void* viewer, float x, float y , float z);
void scroll_end(void* viewer);
void grab_begin(void* viewer, float x, float y, bool pan);
void grab_update(void* viewer, float x, float y);
void grab_end(void* viewer);
void get_morph_target_name(void* asset, const char* meshName, char* const outPtr, int index );
void apply_weights(void* asset, float* const weights, int count);
void set_animation(
void* asset,
float* morphData,
int numMorphWeights,
BoneAnimation* boneAnimations,
int numBoneAnimations,
int numFrames,
float frameLengthInMs
);
int get_morph_target_name_count(void* asset, const char* meshName);
void remove_asset(void* viewer, void* asset);
void clear_assets(void* viewer);
void load_texture(void* asset, const char* assetPath, int renderableIndex);
void set_texture(void* asset);
void transform_to_unit_cube(void* asset);
void set_position(void* asset, float x, float y, float z);
void set_rotation(void* asset, float rads, float x, float y, float z);
void set_scale(void* asset, float scale);
// void set_bone_transform(
// void* asset,
// const char* boneName,
// const char* entityName,
// float transX,
// float transY,
// float transZ,
// float quatX,
// float quatY,
// float quatZ,
// float quatW
// );
void play_animation(void* asset, int index, bool loop, bool reverse);
void stop_animation(void* asset, int index);
void set_camera_position(void* viewer, float x, float y, float z);
void set_camera_rotation(void* viewer, float rads, float x, float y, float z);
void set_camera_focal_length(void* viewer, float focalLength);
void set_camera_focus_distance(void* viewer, float focusDistance);
int get_animation_count(void* asset);
void get_animation_name(void* asset, char* const outPtr, int index);
void get_morph_target_name(void* asset, const char* meshName, char* const outPtr, int index );
int get_morph_target_name_count(void* asset, const char* meshName);
void remove_asset(void* viewer, void* asset);
void clear_assets(void* viewer);
void load_texture(void* asset, const char* assetPath, int renderableIndex);
void set_texture(void* asset);
void transform_to_unit_cube(void* asset);
void set_position(void* asset, float x, float y, float z);
void set_rotation(void* asset, float rads, float x, float y, float z);
void set_scale(void* asset, float scale);
void set_camera_position(void* viewer, float x, float y, float z);
void set_camera_rotation(void* viewer, float rads, float x, float y, float z);
void set_camera_focal_length(void* viewer, float focalLength);
void set_camera_focus_distance(void* viewer, float focusDistance);
}
#endif

27
ios/include/ResourceManagement.hpp Normal file
View File

@@ -0,0 +1,27 @@
#pragma once
#include <functional>
#include <memory>
#include <chrono>
#include <iostream>
#include <vector>
#include "ResourceBuffer.hpp"
namespace polyvox {
using namespace std;
//
// Typedef for a function that loads a resource into a ResourceBuffer from an asset URI.
//
using LoadResource = function<ResourceBuffer(const char* uri)>;
//
// Typedef for a function that frees an ID associated with a ResourceBuffer.
//
using FreeResource = function<void (uint32_t)>;
}

45
ios/include/SceneAsset.hpp
View File

@@ -17,14 +17,16 @@
#include <utils/NameComponentManager.h>
#include "SceneResources.hpp"
#include "ResourceManagement.hpp"
#include "SceneAssetAnimation.hpp"
#include "PolyvoxFilamentApi.h"
namespace polyvox {
using namespace filament;
using namespace filament::gltfio;
using namespace utils;
using namespace std;
class SceneAsset {
friend class SceneAssetLoader;
public:
@@ -71,25 +73,16 @@ namespace polyvox {
void setAnimation(
float* morphData,
int numMorphWeights,
float* boneData,
const char** boneNames,
const char** meshNames,
int numBones,
BoneAnimation* targets,
int numBoneAnimations,
int numFrames,
float frameLengthInMs
);
void setBoneTransform(
const char* boneName,
const char* meshName,
float transX,
float transY,
float transZ,
float quatX,
float quatY,
float quatZ,
float quatW
);
void fillEntitiesByName(const char** name, int count, vector<Entity>& out);
size_t getBoneIndex(const char* name);
Entity getNode(const char* name);
void transformToUnitCube();
@@ -97,9 +90,7 @@ namespace polyvox {
void setPosition(float x, float y, float z);
void setRotation(float rads, float x, float y, float z);
void setRotation(float rads, float x, float y, float z);
const utils::Entity* getCameraEntities();
@@ -116,9 +107,17 @@ namespace polyvox {
Engine* _engine = nullptr;
NameComponentManager* _ncm;
void updateRuntimeAnimation();
void updateEmbeddedAnimations();
void setBoneTransform(
uint8_t skinIndex,
const vector<uint8_t>& boneIndices,
const vector<Entity>& targets,
const vector<float> data,
int frameNumber
);
void updateRuntimeAnimation();
void updateEmbeddedAnimations();
Animator* _animator;
@@ -143,4 +142,4 @@ namespace polyvox {
void updateTransform();
};
}
}

107
ios/include/SceneResources.hpp → ios/include/SceneAssetAnimation.hpp
View File

@@ -1,27 +1,12 @@
#pragma once
#ifndef SCENE_ASSET_ANIMATION_H_
#define SCENE_ASSET_ANIMATION_H_
#include <functional>
#include <memory>
#include <chrono>
#include <iostream>
#include <vector>
#include "utils/Entity.h"
#include "ResourceBuffer.hpp"
namespace polyvox {
namespace polyvox {
using namespace std;
//
// Typedef for a function that loads a resource into a ResourceBuffer from an asset URI.
//
using LoadResource = function<ResourceBuffer(const char* uri)>;
//
// Typedef for a function that frees an ID associated with a ResourceBuffer.
//
using FreeResource = function<void (uint32_t)>;
typedef std::chrono::time_point<std::chrono::high_resolution_clock> time_point_t;
//
@@ -66,48 +51,29 @@ namespace polyvox {
};
///
/// Holds a single set of frame data that may be used to animate multiple bones/meshes.
///
struct BoneTransformTarget {
size_t skinIndex = 0;
unique_ptr<vector<uint8_t>> mBoneIndices;
unique_ptr<vector<utils::Entity>> mMeshTargets;
unique_ptr<vector<float>> mBoneData;
BoneTransformTarget(
unique_ptr<vector<uint8_t>>& boneIndices,
unique_ptr<vector<utils::Entity>>& meshTargets,
unique_ptr<vector<float>>& boneData) : mBoneIndices(move(boneIndices)), mMeshTargets(move(meshTargets)), mBoneData(move(boneData)) {}
};
//
// An animation created by manually passing frame data for morph weights/bone transforms.
//
struct RuntimeAnimation {
RuntimeAnimation(float* morphData,
int numMorphWeights,
float* boneData,
const char** boneNames,
const char** meshNames,
int numBones,
int numFrames,
float frameLengthInMs) :
mNumFrames(numFrames),
mFrameLengthInMs(frameLengthInMs),
mNumMorphWeights(numMorphWeights),
mNumBones(numBones) {
if(numMorphWeights > 0) {
size_t morphSize = numMorphWeights * mNumFrames * sizeof(float);
mMorphFrameData = (float*)malloc(morphSize);
memcpy(mMorphFrameData, morphData, morphSize);
}
if(numBones > 0) {
size_t boneSize = numBones * numFrames * 7 * sizeof(float);
mBoneFrameData = (float*)malloc(boneSize);
memcpy(mBoneFrameData, boneData, boneSize);
}
for(int i =0; i < numBones; i++) {
mBoneNames.push_back(string(boneNames[i]));
mMeshNames.push_back(string(meshNames[i]));
}
}
~RuntimeAnimation() {
delete(mMorphFrameData);
delete(mBoneFrameData);
}
int frameIndex = -1;
int frameNumber = -1;
int mNumFrames = -1;
float mFrameLengthInMs = 0;
time_point_t startTime;
@@ -115,13 +81,30 @@ namespace polyvox {
float* mMorphFrameData = nullptr;
int mNumMorphWeights = 0;
float* mBoneFrameData = nullptr;
int mNumBones = 0;
vector<string> mBoneNames;
vector<string> mMeshNames;
unique_ptr<vector<BoneTransformTarget>> mTargets;
RuntimeAnimation(float* morphData,
int numMorphWeights,
unique_ptr<vector<BoneTransformTarget>>& targets,
int numFrames,
float frameLengthInMs) :
mNumFrames(numFrames),
mFrameLengthInMs(frameLengthInMs),
mNumMorphWeights(numMorphWeights),
mTargets(move(targets)) {
if(numMorphWeights > 0) {
size_t morphSize = numMorphWeights * mNumFrames * sizeof(float);
mMorphFrameData = (float*)malloc(morphSize);
memcpy(mMorphFrameData, morphData, morphSize);
}
}
~RuntimeAnimation() {
delete(mMorphFrameData);
}
};
}
#endif

4
ios/include/SceneAssetLoader.hpp
View File

@@ -6,7 +6,7 @@
#include <gltfio/FilamentAsset.h>
#include <gltfio/ResourceLoader.h>
#include "SceneResources.hpp"
#include "ResourceManagement.hpp"
#include "SceneAsset.hpp"
#include "ResourceBuffer.hpp"
@@ -39,4 +39,4 @@ namespace polyvox {
Scene* _scene;
};
}
}

2
ios/include/gltfio/FilamentInstance.h
View File

@@ -126,6 +126,8 @@ public:
*/
void detachSkin(size_t skinIndex, utils::Entity target) noexcept;
const math::mat4f* getInverseBindMatricesAt(size_t skinIndex) const noexcept;
/**
* Resets the AABB on all renderables by manually computing the bounding box.
*

2
ios/src/FilamentViewer.cpp
View File

@@ -70,7 +70,7 @@
#include <mutex>
#include "Log.hpp"
#include "SceneResources.hpp"
#include "ResourceManagement.hpp"
extern "C" {
#include "material/image_material.h"

67
ios/src/PolyvoxFilamentApi.cpp
View File

@@ -1,4 +1,5 @@
#include "ResourceBuffer.hpp"
#include "FilamentViewer.hpp"
#include "filament/LightManager.h"
#include "Log.hpp"
@@ -6,9 +7,8 @@
using namespace polyvox;
extern "C" {
// ResourceBuffer create_resource_buffer(const void* data, const uint32_t size, const uint32_t id) {
// return ResourceBuffer {data, size, id };
// }
#include "PolyvoxFilamentApi.h"
void* filament_viewer_new(void* context, ResourceBuffer (*loadResource)(char const*), void (*freeResource)(unsigned int)) {
FilamentViewer* v = new FilamentViewer(context, loadResource, freeResource);
@@ -148,50 +148,47 @@ extern "C" {
void* asset,
float* morphData,
int numMorphWeights,
float* boneData,
const char** boneNames,
const char** meshNames,
int numBones,
BoneAnimation* boneAnimations,
int numBoneAnimations,
int numFrames,
float frameLengthInMs) {
((SceneAsset*)asset)->setAnimation(
morphData,
numMorphWeights,
boneData,
boneNames,
meshNames,
numBones,
boneAnimations,
numBoneAnimations,
numFrames,
frameLengthInMs
);
}
void set_bone_transform(
void* asset,
const char* boneName,
const char* entityName,
float transX,
float transY,
float transZ,
float quatX,
float quatY,
float quatZ,
float quatW
) {
((SceneAsset*)asset)->setBoneTransform(
boneName,
entityName,
transX,
transY,
transZ,
quatX,
quatY,
quatZ,
quatW
);
// void set_bone_transform(
// void* asset,
// const char* boneName,
// const char* entityName,
// float transX,
// float transY,
// float transZ,
// float quatX,
// float quatY,
// float quatZ,
// float quatW
// ) {
// ((SceneAsset*)asset)->setBoneTransform(
// boneName,
// entityName,
// transX,
// transY,
// transZ,
// quatX,
// quatY,
// quatZ,
// quatW,
// false
// );
}
// }
void play_animation(void* asset, int index, bool loop, bool reverse) {

244
ios/src/SceneAsset.cpp
View File

@@ -16,7 +16,8 @@
#include "StreamBufferAdapter.hpp"
#include "SceneAsset.hpp"
#include "Log.hpp"
#include "SceneResources.hpp"
#include "ResourceManagement.hpp"
#include "SceneAssetAnimation.hpp"
using namespace std::chrono;
@@ -58,19 +59,58 @@ void SceneAsset::setMorphTargetWeights(float *weights, int count) {
void SceneAsset::setAnimation(
float* morphData,
int numMorphWeights,
float* boneData,
const char** boneNames,
const char** meshNames,
int numBones,
BoneAnimation* boneAnimations,
int numBoneAnimations,
int numFrames,
float frameLengthInMs) {
auto filamentInstance = _asset->getInstance();
size_t skinCount = filamentInstance->getSkinCount();
if(skinCount > 1) {
Log("WARNING - skin count > 1 not currently implemented. This will probably not work");
}
auto transforms = make_unique<vector<BoneTransformTarget>>();
auto numFloats = numFrames * 7;
for(int i = 0; i < numBoneAnimations; i++) {
auto boneIndices = make_unique<vector<uint8_t>>();
boneIndices->resize(boneAnimations[i].numBones);
for(int j = 0; j < boneAnimations[i].numBones; j++) {
boneIndices->at(j) = getBoneIndex(boneAnimations[i].boneNames[j]);
}
auto meshTargets = make_unique<vector<Entity>>();
for(int j = 0; j < _asset->getEntityCount(); j++) {
for(int k = 0; k < boneAnimations[i].numMeshTargets;k++) {
auto meshName = boneAnimations[i].meshNames[k];
auto entity = _asset->getEntities()[j];
auto nameInstance = _ncm->getInstance(entity);
if(strcmp(meshName,_ncm->getName(nameInstance))==0) {
meshTargets->push_back(entity);
}
}
}
auto frameData = make_unique<vector<float>>(
boneAnimations[i].data,
boneAnimations[i].data + (numFloats * sizeof(float))
);
transforms->push_back(BoneTransformTarget(
boneIndices,
meshTargets,
frameData
));
}
_runtimeAnimationBuffer = std::make_unique<RuntimeAnimation>(
morphData,
numMorphWeights,
boneData,
boneNames,
meshNames,
numBones,
transforms,
numFrames,
frameLengthInMs
);
@@ -87,50 +127,115 @@ void SceneAsset::updateRuntimeAnimation() {
return;
}
if (_runtimeAnimationBuffer->frameIndex == -1) {
if (_runtimeAnimationBuffer->frameNumber == -1) {
_runtimeAnimationBuffer->startTime = high_resolution_clock::now();
}
duration<double, std::milli> dur =
high_resolution_clock::now() - _runtimeAnimationBuffer->startTime;
int frameIndex =
int frameNumber =
static_cast<int>(dur.count() / _runtimeAnimationBuffer->mFrameLengthInMs);
// if the animation has finished, return early
if (frameIndex >= _runtimeAnimationBuffer->mNumFrames) {
if (frameNumber >= _runtimeAnimationBuffer->mNumFrames) {
_runtimeAnimationBuffer = nullptr;
return;
}
if (frameIndex > _runtimeAnimationBuffer->frameIndex) {
_runtimeAnimationBuffer->frameIndex = frameIndex;
if (frameNumber > _runtimeAnimationBuffer->frameNumber) {
_runtimeAnimationBuffer->frameNumber = frameNumber;
if(_runtimeAnimationBuffer->mMorphFrameData) {
auto morphFramePtrOffset = frameIndex * _runtimeAnimationBuffer->mNumMorphWeights;
auto morphFramePtrOffset = frameNumber * _runtimeAnimationBuffer->mNumMorphWeights;
setMorphTargetWeights(_runtimeAnimationBuffer->mMorphFrameData + morphFramePtrOffset,
_runtimeAnimationBuffer->mNumMorphWeights);
}
if(_runtimeAnimationBuffer->mBoneFrameData) {
for(int i = 0; i < _runtimeAnimationBuffer->mNumBones; i++) {
// auto boneFramePtrOffset = (frameIndex * _runtimeAnimationBuffer->mNumBones * 7) + (i*7);
const char* boneName = _runtimeAnimationBuffer->mBoneNames[i].c_str();
const char* meshName = _runtimeAnimationBuffer->mMeshNames[i].c_str();
// float* frame = _runtimeAnimationBuffer->mBoneFrameData + boneFramePtrOffset;
float transX = 0.0f;//frame[0];
float transY = 0.0f;//frame[1];
float transZ = 0.0f;//frame[2];
float quatX = 0.0f; //frame[3];
float quatY = 0.0f;//frame[4];
float quatZ = 0.0f; //frame[5];
float quatW = 1.0;//frame[6];
setBoneTransform(boneName, meshName, transX, transY, transZ, quatX, quatY, quatZ, quatW);
if(_runtimeAnimationBuffer->mTargets->size() > 0) {
for(auto& target : *(_runtimeAnimationBuffer->mTargets)) {
setBoneTransform(
target.skinIndex,
*(target.mBoneIndices),
*(target.mMeshTargets),
*(target.mBoneData),
frameNumber
);
}
}
}
}
size_t SceneAsset::getBoneIndex(const char* name) {
auto filamentInstance = _asset->getInstance();
int skinIndex = 0;
const utils::Entity* joints = filamentInstance->getJointsAt(skinIndex);
size_t numJoints = filamentInstance->getJointCountAt(skinIndex);
int boneIndex = -1;
for(int i =0; i < numJoints; i++) {
const char* jointName = _ncm->getName(_ncm->getInstance(joints[i]));
if(strcmp(jointName, name) == 0) {
boneIndex = i;
break;
}
}
if(boneIndex == -1) {
Log("Failed to find bone index %d for bone %s", name);
}
return boneIndex;
}
void SceneAsset::setBoneTransform(
uint8_t skinIndex,
const vector<uint8_t>& boneIndices,
const vector<Entity>& targets,
const vector<float> data,
int frameNumber) {
auto filamentInstance = _asset->getInstance();
RenderableManager &rm = _engine->getRenderableManager();
TransformManager &transformManager = _engine->getTransformManager();
auto frameDataOffset = frameNumber * 7;
for(auto& target : targets) {
auto renderable = rm.getInstance(target);
math::mat4f inverseGlobalTransform = inverse(
transformManager.getWorldTransform(
transformManager.getInstance(target)
)
);
for(auto boneIndex : boneIndices) {
utils::Entity joint = filamentInstance->getJointsAt(skinIndex)[boneIndex];
math::mat4f localTransform(math::quatf{
data[frameDataOffset+6],
data[frameDataOffset+3],
data[frameDataOffset+4],
data[frameDataOffset+5]
});
const math::mat4f& inverseBindMatrix = filamentInstance->getInverseBindMatricesAt(skinIndex)[boneIndex];
auto jointInstance = transformManager.getInstance(joint);
math::mat4f globalJointTransform = transformManager.getWorldTransform(jointInstance);
math::mat4f boneTransform = inverseGlobalTransform * globalJointTransform * localTransform * inverseBindMatrix;
rm.setBones(
renderable,
&boneTransform,
1, boneIndex);
}
}
}
void SceneAsset::playAnimation(int index, bool loop, bool reverse) {
if (index > _animator->getAnimationCount() - 1) {
Log("Asset does not contain an animation at index %d", index);
@@ -353,66 +458,6 @@ void SceneAsset::setRotation(float rads, float x, float y, float z) {
updateTransform();
}
void SceneAsset::setBoneTransform(
const char* boneName,
const char* entityName,
float transX,
float transY,
float transZ,
float quatX,
float quatY,
float quatZ,
float quatW) {
auto filamentInstance = _asset->getInstance();
if(filamentInstance->getSkinCount()) {
// Log("WARNING - skin count > 1 not currently implemented. This will probably not work");
}
// filamentInstance->getAnimator()->resetBoneMatrices();
int skinIndex = 0;
const utils::Entity* joints = filamentInstance->getJointsAt(skinIndex);
size_t numJoints = filamentInstance->getJointCountAt(skinIndex);
int boneIndex = -1;
for(int i =0; i < numJoints; i++) {
const char* jointName = _ncm->getName(_ncm->getInstance(joints[i]));
if(strcmp(jointName, boneName) == 0) {
boneIndex = i;
// Log("Found bone index %d for bone %s", boneIndex, boneName);
break;
}
}
if(boneIndex == -1) {
Log("Failed to find bone index %d for bone %s", boneName);
return;
}
RenderableManager &rm = _engine->getRenderableManager();
// RenderableManager::Bone transform = {
// .unitQuaternion={quatX,quatY,quatZ,quatW},
// .translation={transX,transY,transZ}
// };
for(int j = 0; j < _asset->getEntityCount(); j++) {
Entity e = _asset->getEntities()[j];
if(strcmp(entityName,_ncm->getName(_ncm->getInstance(e)))==0) {
// Log("Setting bone transform on entity %s", _ncm->getName(_ncm->getInstance(e)));
auto inst = rm.getInstance(e);
if(!inst) {
Log("No renderable instance");
}
// rm.setBones(inst, &transform, 1, boneIndex);
}
}
}
const utils::Entity *SceneAsset::getCameraEntities() {
return _asset->getCameraEntities();
}
@@ -431,3 +476,20 @@ size_t SceneAsset::getLightEntityCount() const noexcept {
} // namespace polyvox
// const utils::Entity* joints = filamentInstance->getJointsAt(skinIndex);
// size_t numJoints = filamentInstance->getJointCountAt(skinIndex);
// int boneIndex = -1;
// for(int i =0; i < numJoints; i++) {
// const char* jointName = _ncm->getName(_ncm->getInstance(joints[i]));
// if(strcmp(jointName, boneName) == 0) {
// boneIndex = i;
// joint = joints[i];
// break;
// }
// }
// if(boneIndex == -1) {
// Log("Failed to find bone index %d for bone %s", boneName);
// return;
// }

2
ios/src/ios/PolyvoxFilamentIOSApi.cpp
View File

@@ -1,7 +1,7 @@
#include "PolyvoxFilamentApi.h"
#include "FilamentViewer.hpp"
#include "ResourceBuffer.hpp"
#include "SceneResources.hpp"
#include "ResourceManagement.hpp"
#include <functional>
using namespace polyvox;