From 9ae36088b42336135573d12037f310acf831ace0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?P=C3=A4r=20Winzell?= Date: Sun, 5 Nov 2017 00:06:24 -0700 Subject: [PATCH] Blend Shape / Morph Target Support (#33) This adds blend shape / morph target functionality. At the FBX level, a mesh can have a number of deformers associated with it. One such deformer type is the blend shape. A blend shape is a collection of channels, which do all the work. A channel can consist of a single target shape (the simple case) or multiple (a progressive morph). In the latter case, the artist has created in-between shapes, the assumption being that linear interpolation between a beginning shape and an end shape would be too crude. Each such target shape contains a complete set of new positions for each vertex of the deformed base mesh. (It's also supposed to be optionally a complete set of normals and tangents, but I've yet to see that work right; they always come through as zeroes. This is something to investigate in the future.) So the number of glTF morph targets in a mesh is the total number of FBX target shapes associated with channels associated with blend shape deformers associated with that mesh! Yikes. The per-vertex data of each such target shape is added to a vector in RawVertex. A side effect of this is that vertices that participate in blend shapes must be made unique to the mesh in question, as opposed to general vertices which are shared across multiple surfaces. Blend Shape based animations become identical glTF morph target animations.. Fixes #17. --- README.md | 13 +- src/Fbx2Raw.cpp | 296 +++++++++++++++++++++++++++++++++++-- src/Raw2Gltf.cpp | 62 +++++++- src/RawModel.cpp | 4 +- src/RawModel.h | 48 ++++-- src/glTF/MeshData.cpp | 11 +- src/glTF/MeshData.h | 3 +- src/glTF/PrimitiveData.cpp | 23 ++- src/glTF/PrimitiveData.h | 4 + 9 files changed, 427 insertions(+), 37 deletions(-) diff --git a/README.md b/README.md index 66b9e58..0a35c71 100644 --- a/README.md +++ b/README.md @@ -143,14 +143,15 @@ process happens in reverse when we construct meshes and materials that conform to the expectations of the glTF format. ### Animations -Every skinned animation in the FBX file becomes an animation in the glTF file. -The method used is one of "baking": we step through the interval of time spanned -by the animation, keyframe by keyframe, calculate the local transform of each -node,and whenever we find any node that's rotated, translated or scaled, we +Every animation in the FBX file becomes an animation in the glTF file. The +method used is one of "baking": we step through the interval of time spanned by +the animation, keyframe by keyframe, calculate the local transform of each +node, and whenever we find any node that's rotated, translated or scaled, we record that fact in the output. -(*Blend Shapes* are not currently supported, but are -[high on the TODO list](https://github.com/facebookincubator/FBX2glTF/issues/17).) +Beyond skeleton-based animation, *Blend Shapes* are also supported; they are +read from the FBX file on a per-mesh basis, and animations can them by varying +the weights associated with each one. The baking method has the benefit of being simple and precise. It has the drawback of creating potentially very large files. The more complex the diff --git a/src/Fbx2Raw.cpp b/src/Fbx2Raw.cpp index 8153183..297cc56 100644 --- a/src/Fbx2Raw.cpp +++ b/src/Fbx2Raw.cpp @@ -449,6 +449,175 @@ private: std::vector vertexJointWeights; }; +/** + * At the FBX level, each Mesh can have a set of FbxBlendShape deformers; organisational units that contain no data + * of their own. The actual deformation is determined by one or more FbxBlendShapeChannels, whose influences are all + * additively applied to the mesh. In a simpler world, each such channel would extend each base vertex with alternate + * position, and optionally normal and tangent. + * + * It's not quite so simple, though. We also have progressive morphing, where one logical morph actually consists of + * several concrete ones, each applied in sequence. For us, this means each channel contains a sequence of FbxShapes + * (aka target shape); these are the actual data-holding entities that provide the alternate vertex attributes. As such + * a channel is given more weight, it moves from one target shape to another. + * + * The total number of alternate sets of attributes, then, is the total number of target shapes across all the channels + * of all the blend shapes of the mesh. + * + * Each animation in the scene stack can yield one or zero FbxAnimCurves per channel (not target shape). We evaluate + * these curves to get the weight of the channel: this weight is further introspected on to figure out which target + * shapes we're currently interpolation between. + */ +class FbxBlendShapesAccess +{ +public: + struct TargetShape + { + TargetShape( + double fullWeight, + const std::vector &positions, + const std::vector &normals, + const std::vector &tangents + ) : fullWeight(fullWeight), + positions(positions), + normals(normals), + tangents(tangents) {} + + const double fullWeight; + const std::vector positions; + const std::vector normals; + const std::vector tangents; + }; + + struct BlendChannel { + explicit BlendChannel(FbxDouble defaultDeform) : + defaultDeform(defaultDeform) + {} + const FbxDouble defaultDeform; + + // one for each FbxShape + std::vector targetShapes {}; + + // always the size of the scene's animation stack; can and will contain nulls + std::vector animations {}; + }; + + explicit FbxBlendShapesAccess(const FbxScene *scene, FbxMesh *mesh) : + channels(extractChannels(scene, mesh)) + { } + + size_t GetChannelCount() const { return channels.size(); } + FbxDouble GetDefaultDeform(size_t channelIx) const { + return channels.at(channelIx).defaultDeform; + } + size_t GetTargetShapeCount(size_t channelIx) const { return channels[channelIx].targetShapes.size(); } + const TargetShape &GetTargetShape(size_t channelIx, size_t targetShapeIx) const { + return channels.at(channelIx).targetShapes[targetShapeIx]; + } + size_t GetAnimCount(size_t channelIx) const { return channels.at(channelIx).animations.size(); } + FbxAnimCurve *GetAnimation(size_t channelIx, size_t animIx) const { + return channels.at(channelIx).animations[animIx]; + } + +private: + std::vector extractChannels(const FbxScene *scene, FbxMesh *mesh) const { + // acquire the regular control points from the mesh + const int controlPointsCount = mesh->GetControlPointsCount(); + const FbxVector4 *meshPoints = mesh->GetControlPoints(); + + // acquire the normals, if they're present & make sure they're well-formed + FbxLayerElementArrayTemplate* meshNormals = nullptr; + if (!mesh->GetNormals(&meshNormals) || meshNormals->GetCount() != controlPointsCount) { + meshNormals = nullptr; + } + + // same, but tangents + FbxLayerElementArrayTemplate* meshTangents = nullptr; + if (!mesh->GetTangents(&meshTangents) || meshTangents->GetCount() != controlPointsCount) { + meshTangents = nullptr; + } + + std::vector results; + for (int shapeIx = 0; shapeIx < mesh->GetDeformerCount(FbxDeformer::eBlendShape); shapeIx++) { + auto *fbxBlendShape = dynamic_cast(mesh->GetDeformer(shapeIx, FbxDeformer::eBlendShape)); + if (fbxBlendShape == nullptr) { + continue; + } + for (int channelIx = 0; channelIx < fbxBlendShape->GetBlendShapeChannelCount(); ++channelIx) { + FbxBlendShapeChannel *channel = fbxBlendShape->GetBlendShapeChannel(channelIx); + unsigned int targetShapeCount = static_cast(channel->GetTargetShapeCount()); + if (targetShapeCount < 1) { + continue; + } + BlendChannel shape(channel->DeformPercent * 0.01f); + + std::vector> targetShapes (targetShapeCount); + double *fullWeights = channel->GetTargetShapeFullWeights(); + for (int targetShapeIx = 0; targetShapeIx < targetShapes.size(); targetShapeIx++) { + FbxShape *fbxShape = channel->GetTargetShape(targetShapeIx); + assert(fbxShape->GetControlPointsCount() == controlPointsCount); + + // glTF morph target positions are *mutation vectors* to be added (by weight) to the regular mesh positions. + // FBX blend shape control points, on the other hand are final positions. + // So we must do a little subtracting. + std::vector positions, normals, tangents; + // fetch positions + const FbxVector4 *shapePoints = fbxShape->GetControlPoints(); + for (int pointIx = 0; pointIx < controlPointsCount; pointIx ++) { + positions.push_back(shapePoints[pointIx] - meshPoints[pointIx]); + } + +#if 0 // I've never seen anything but zero normals and tangents come out of this. Revisit later. + // maybe fetch normals + if (meshNormals) { + FbxLayerElementArrayTemplate* fbxNormals = nullptr; + if (fbxShape->GetNormals(&fbxNormals)) { + for (int pointIx = 0; pointIx < controlPointsCount; pointIx ++) { + normals.push_back(fbxNormals->GetAt(pointIx) - meshNormals->GetAt(pointIx)); + } + } + } + + // maybe fetch tangents + if (meshTangents) { + FbxLayerElementArrayTemplate* fbxTangents = nullptr; + if (fbxShape->GetTangents(&fbxTangents)) { + for (int pointIx = 0; pointIx < controlPointsCount; pointIx ++) { + tangents.push_back(fbxTangents->GetAt(pointIx) - meshTangents->GetAt(pointIx)); + } + } + } +#endif + // finally combine all this into a TargetShape and add it to our work-in-progress BlendChannel + shape.targetShapes.push_back( + TargetShape(fullWeights[targetShapeIx], positions, normals, tangents) + ); + } + + // go through all the animations in the scene and figure out their relevance to this mesh + size_t animationCount = static_cast(scene->GetSrcObjectCount()); + std::vectoranimations(animationCount); + for (int animIx = 0; animIx < animationCount; animIx++) { + auto *pAnimStack = scene->GetSrcObject(animIx); + auto *layer = pAnimStack->GetMember(0); + if (pAnimStack->GetMemberCount() > 1) { + fmt::print("Warning: ignoring animation layers 1+ in stack %s", pAnimStack->GetName()); + } + + // note that some of these will be null here, which is fine; the critical part is that the + // indices maintain parity with the scene-wide animation stack + shape.animations.push_back(mesh->GetShapeChannel(shapeIx, channelIx, layer, true)); + } + + results.push_back(shape); + } + } + return results; + } + + + const std::vector channels; +}; + static bool TriangleTexturePolarity(const Vec2f &uv0, const Vec2f &uv1, const Vec2f &uv2) { const Vec2f d0 = uv1 - uv0; @@ -483,7 +652,7 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std: { FbxGeometryConverter meshConverter(pScene->GetFbxManager()); meshConverter.Triangulate(pNode->GetNodeAttribute(), true); - const FbxMesh *pMesh = pNode->GetMesh(); + FbxMesh *pMesh = pNode->GetMesh(); const char *meshName = (pNode->GetName()[0] != '\0') ? pNode->GetName() : pMesh->GetName(); const int rawSurfaceIndex = raw.AddSurface(meshName, pNode->GetName()); @@ -497,6 +666,7 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std: const FbxLayerElementAccess uvLayer1(pMesh->GetElementUV(1), pMesh->GetElementUVCount()); const FbxSkinningAccess skinning(pMesh, pScene, pNode); const FbxMaterialsAccess materials(pMesh, textureLocations); + const FbxBlendShapesAccess blendShapes(pScene, pMesh); if (verboseOutput) { fmt::printf( @@ -542,6 +712,21 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std: rawSurface.jointGeometryMaxs.emplace_back(-FLT_MAX, -FLT_MAX, -FLT_MAX); } + rawSurface.blendChannels.clear(); + std::vector targetShapes; + for (size_t shapeIx = 0; shapeIx < blendShapes.GetChannelCount(); shapeIx ++) { + for (size_t targetIx = 0; targetIx < blendShapes.GetTargetShapeCount(shapeIx); targetIx ++) { + const FbxBlendShapesAccess::TargetShape &shape = blendShapes.GetTargetShape(shapeIx, targetIx); + targetShapes.push_back(&shape); + + rawSurface.blendChannels.push_back(RawBlendChannel { + static_cast(blendShapes.GetDefaultDeform(shapeIx)), + !shape.normals.empty(), + !shape.tangents.empty() + }); + } + } + int polygonVertexIndex = 0; for (int polygonIndex = 0; polygonIndex < pMesh->GetPolygonCount(); polygonIndex++) { @@ -638,6 +823,24 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std: rawSurface.bounds.AddPoint(vertex.position); + if (!targetShapes.empty()) { + vertex.blendSurfaceIx = rawSurfaceIndex; + for (const auto *targetShape : targetShapes) { + RawBlendVertex blendVertex; + // the morph target positions must be transformed just as with the vertex positions above + blendVertex.position = toVec3f(transform.MultNormalize(targetShape->positions[controlPointIndex])); + if (!targetShape->normals.empty()) { + blendVertex.normal = toVec3f(targetShape->normals[controlPointIndex]); + } + if (!targetShape->tangents.empty()) { + blendVertex.tangent = toVec4f(targetShape->tangents[controlPointIndex]); + } + vertex.blends.push_back(blendVertex); + } + } else { + vertex.blendSurfaceIx = -1; + } + if (skinning.IsSkinned()) { const int jointIndices[FbxSkinningAccess::MAX_WEIGHTS] = { vertex.jointIndices[0], @@ -847,13 +1050,15 @@ static void ReadNodeHierarchy( static void ReadAnimations(RawModel &raw, FbxScene *pScene) { FbxTime::EMode eMode = FbxTime::eFrames24; + const double epsilon = 1e-5f; + const int animationCount = pScene->GetSrcObjectCount(); - for (int i = 0; i < animationCount; i++) { - FbxAnimStack *pAnimStack = pScene->GetSrcObject(i); + for (size_t animIx = 0; animIx < animationCount; animIx++) { + FbxAnimStack *pAnimStack = pScene->GetSrcObject(animIx); FbxString animStackName = pAnimStack->GetName(); if (verboseOutput) { - fmt::printf("animation %d: %s (%d%%)", i, (const char *) animStackName, 0); + fmt::printf("animation %zu: %s (%d%%)", animIx, (const char *) animStackName, 0); } pScene->SetCurrentAnimationStack(pAnimStack); @@ -886,6 +1091,7 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene) bool hasTranslation = false; bool hasRotation = false; bool hasScale = false; + bool hasMorphs = false; RawChannel channel; channel.nodeIndex = raw.GetNodeByName(pNode->GetName()); @@ -899,7 +1105,6 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene) const FbxQuaternion localRotation = localTransform.GetQ(); const FbxVector4 localScale = computeLocalScale(pNode, pTime); - const double epsilon = 1e-5f; hasTranslation |= ( fabs(localTranslation[0] - baseTranslation[0]) > epsilon || fabs(localTranslation[1] - baseTranslation[1]) > epsilon || @@ -919,7 +1124,76 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene) channel.scales.push_back(toVec3f(localScale)); } - if (hasTranslation || hasRotation || hasScale) { + std::vector shapeAnimCurves; + FbxNodeAttribute *nodeAttr = pNode->GetNodeAttribute(); + if (nodeAttr != nullptr && nodeAttr->GetAttributeType() == FbxNodeAttribute::EType::eMesh) { + // it's inelegant to recreate this same access class multiple times, but it's also dirt cheap... + FbxBlendShapesAccess blendShapes(pScene, dynamic_cast(nodeAttr)); + + for (FbxLongLong frameIndex = firstFrameIndex; frameIndex <= lastFrameIndex; frameIndex++) { + FbxTime pTime; + pTime.SetFrame(frameIndex, eMode); + + for (size_t channelIx = 0; channelIx < blendShapes.GetChannelCount(); channelIx++) { + auto curve = blendShapes.GetAnimation(channelIx, animIx); + float influence = (curve != nullptr) ? curve->Evaluate(pTime) : 0; // 0-100 + + int targetCount = static_cast(blendShapes.GetTargetShapeCount(channelIx)); + + // the target shape 'fullWeight' values are a strictly ascending list of floats (between + // 0 and 100), forming a sequence of intervals -- this convenience function figures out if + // 'p' lays between some certain target fullWeights, and if so where (from 0 to 1). + auto findInInterval = [&](const double p, const int n) { + if (n >= targetCount) { + // p is certainly completely left of this interval + return NAN; + } + double leftWeight = 0; + if (n >= 0) { + leftWeight = blendShapes.GetTargetShape(channelIx, n).fullWeight; + if (p < leftWeight) { + return NAN; + } + // the first interval implicitly includes all lesser influence values + } + double rightWeight = blendShapes.GetTargetShape(channelIx, n+1).fullWeight; + if (p > rightWeight && n+1 < targetCount-1) { + return NAN; + // the last interval implicitly includes all greater influence values + } + // transform p linearly such that [leftWeight, rightWeight] => [0, 1] + return static_cast((p - leftWeight) / (rightWeight - leftWeight)); + }; + + for (int targetIx = 0; targetIx < targetCount; targetIx++) { + if (curve) { + float result = findInInterval(influence, targetIx-1); + if (!isnan(result)) { + // we're transitioning into targetIx + channel.weights.push_back(result); + hasMorphs = true; + continue; + } + if (targetIx != targetCount-1) { + result = findInInterval(influence, targetIx); + if (!isnan(result)) { + // we're transitioning AWAY from targetIx + channel.weights.push_back(1.0f - result); + hasMorphs = true; + continue; + } + } + } + + // this is here because we have to fill in a weight for every channelIx/targetIx permutation, + // regardless of whether or not they participate in this animation. + channel.weights.push_back(0.0f); + } + } + } + } + + if (hasTranslation || hasRotation || hasScale || hasMorphs) { if (!hasTranslation) { channel.translations.clear(); } @@ -929,16 +1203,20 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene) if (!hasScale) { channel.scales.clear(); } + if (!hasMorphs) { + channel.weights.clear(); + } animation.channels.emplace_back(channel); totalSizeInBytes += channel.translations.size() * sizeof(channel.translations[0]) + channel.rotations.size() * sizeof(channel.rotations[0]) + - channel.scales.size() * sizeof(channel.scales[0]); + channel.scales.size() * sizeof(channel.scales[0]) + + channel.weights.size() * sizeof(channel.weights[0]); } if (verboseOutput) { - fmt::printf("\ranimation %d: %s (%d%%)", i, (const char *) animStackName, nodeIndex * 100 / nodeCount); + fmt::printf("\ranimation %d: %s (%d%%)", animIx, (const char *) animStackName, nodeIndex * 100 / nodeCount); } } @@ -946,7 +1224,7 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene) if (verboseOutput) { fmt::printf( - "\ranimation %d: %s (%d channels, %3.1f MB)\n", i, (const char *) animStackName, + "\ranimation %d: %s (%d channels, %3.1f MB)\n", animIx, (const char *) animStackName, (int) animation.channels.size(), (float) totalSizeInBytes * 1e-6f); } } diff --git a/src/Raw2Gltf.cpp b/src/Raw2Gltf.cpp index 1dc3139..3aafe3c 100644 --- a/src/Raw2Gltf.cpp +++ b/src/Raw2Gltf.cpp @@ -333,15 +333,15 @@ ModelData *Raw2Gltf( fmt::printf("Animation '%s' has %lu channels:\n", animation.name.c_str(), animation.channels.size()); } - for (size_t j = 0; j < animation.channels.size(); j++) { - const RawChannel &channel = animation.channels[j]; + for (size_t channelIx = 0; channelIx < animation.channels.size(); channelIx++) { + const RawChannel &channel = animation.channels[channelIx]; const RawNode &node = raw.GetNode(channel.nodeIndex); if (verboseOutput) { fmt::printf( - " Channel %lu (%s) has translations/rotations/scales: [%lu, %lu, %lu]\n", - j, node.name.c_str(), channel.translations.size(), - channel.rotations.size(), channel.scales.size()); + " Channel %lu (%s) has translations/rotations/scales/weights: [%lu, %lu, %lu, %lu]\n", + channelIx, node.name.c_str(), channel.translations.size(), channel.rotations.size(), + channel.scales.size(), channel.weights.size()); } NodeData &nDat = require(nodesByName, node.name); @@ -354,6 +354,9 @@ ModelData *Raw2Gltf( if (!channel.scales.empty()) { aDat.AddNodeChannel(nDat, *gltf->AddAccessorAndView(buffer, GLT_VEC3F, channel.scales), "scale"); } + if (!channel.weights.empty()) { + aDat.AddNodeChannel(nDat, *gltf->AddAccessorAndView(buffer, {CT_FLOAT, 1, "SCALAR"}, channel.weights), "weights"); + } } } @@ -494,7 +497,11 @@ ModelData *Raw2Gltf( mesh = meshIter->second.get(); } else { - auto meshPtr = gltf->meshes.hold(new MeshData(rawSurface.name)); + std::vector defaultDeforms; + for (const auto &channel : rawSurface.blendChannels) { + defaultDeforms.push_back(channel.defaultDeform); + } + auto meshPtr = gltf->meshes.hold(new MeshData(rawSurface.name, defaultDeforms)); meshByNodeName[nodeName] = meshPtr; meshNode.SetMesh(meshPtr->ix); mesh = meshPtr.get(); @@ -598,6 +605,49 @@ ModelData *Raw2Gltf( GLT_VEC4F, draco::GeometryAttribute::GENERIC, draco::DT_FLOAT32); gltf->AddAttributeToPrimitive(buffer, surfaceModel, *primitive, ATTR_WEIGHTS); } + + // each channel present in the mesh always ends up a target in the primitive + for (int channelIx = 0; channelIx < rawSurface.blendChannels.size(); channelIx ++) { + const auto &channel = rawSurface.blendChannels[channelIx]; + + // track the bounds of each shape channel + Bounds shapeBounds; + + std::vector positions, normals; + std::vector tangents; + for (int jj = 0; jj < surfaceModel.GetVertexCount(); jj ++) { + auto blendVertex = surfaceModel.GetVertex(jj).blends[channelIx]; + shapeBounds.AddPoint(blendVertex.position); + positions.push_back(blendVertex.position); + if (channel.hasNormals) { + normals.push_back(blendVertex.normal); + } + if (channel.hasTangents) { + tangents.push_back(blendVertex.tangent); + } + } + std::shared_ptr pAcc = gltf->AddAccessorWithView( + *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), + GLT_VEC3F, positions); + pAcc->min = toStdVec(shapeBounds.min); + pAcc->max = toStdVec(shapeBounds.max); + + std::shared_ptr nAcc; + if (channel.hasNormals) { + nAcc = gltf->AddAccessorWithView( + *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), + GLT_VEC3F, normals); + } + + std::shared_ptr tAcc; + if (channel.hasTangents) { + nAcc = gltf->AddAccessorWithView( + *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), + GLT_VEC4F, tangents); + } + + primitive->AddTarget(pAcc.get(), nAcc.get(), tAcc.get()); + } } if (options.useDraco) { // Set up the encoder. diff --git a/src/RawModel.cpp b/src/RawModel.cpp index 8b3e134..22084c2 100644 --- a/src/RawModel.cpp +++ b/src/RawModel.cpp @@ -33,7 +33,9 @@ bool RawVertex::operator==(const RawVertex &other) const (uv1 == other.uv1) && (jointIndices == other.jointIndices) && (jointWeights == other.jointWeights) && - (polarityUv0 == other.polarityUv0); + (polarityUv0 == other.polarityUv0) && + (blendSurfaceIx == other.blendSurfaceIx) && + (blends == other.blends); } size_t RawVertex::Difference(const RawVertex &other) const diff --git a/src/RawModel.h b/src/RawModel.h index e0b01b9..1d0961f 100644 --- a/src/RawModel.h +++ b/src/RawModel.h @@ -28,6 +28,19 @@ enum RawVertexAttribute RAW_VERTEX_ATTRIBUTE_AUTO = 1 << 31 }; +struct RawBlendVertex +{ + Vec3f position {}; + Vec3f normal {}; + Vec4f tangent {}; + + bool operator==(const RawBlendVertex &other) const { + return position == other.position && + normal == other.normal && + tangent == other.tangent; + } +}; + struct RawVertex { RawVertex() : @@ -45,6 +58,12 @@ struct RawVertex Vec2f uv1 { 0.0f }; Vec4i jointIndices { 0, 0, 0, 0 }; Vec4f jointWeights { 0.0f }; + // end of members that directly correspond to vertex attributes + + // if this vertex participates in a blend shape setup, the surfaceIx of its dedicated mesh; otherwise, -1 + int blendSurfaceIx = -1; + // the size of this vector is always identical to the size of the corresponding RawSurface.blendChannels + std::vector blends { }; bool polarityUv0; bool pad1; @@ -154,25 +173,34 @@ struct RawMaterial int textures[RAW_TEXTURE_USAGE_MAX]; }; +struct RawBlendChannel +{ + float defaultDeform; + bool hasNormals; + bool hasTangents; +}; + struct RawSurface { - std::string name; // The name of this surface - std::string nodeName; // The node that links to this surface. - std::string skeletonRootName; // The name of the root of the skeleton. - Bounds bounds; - std::vector jointNames; - std::vector jointGeometryMins; - std::vector jointGeometryMaxs; - std::vector inverseBindMatrices; - bool discrete; + std::string name; // The name of this surface + std::string nodeName; // The node that links to this surface. + std::string skeletonRootName; // The name of the root of the skeleton. + Bounds bounds; + std::vector jointNames; + std::vector jointGeometryMins; + std::vector jointGeometryMaxs; + std::vector inverseBindMatrices; + std::vector blendChannels; + bool discrete; }; struct RawChannel { - int nodeIndex; + int nodeIndex; std::vector translations; std::vector rotations; std::vector scales; + std::vector weights; }; struct RawAnimation diff --git a/src/glTF/MeshData.cpp b/src/glTF/MeshData.cpp index e7dae6a..a236c53 100644 --- a/src/glTF/MeshData.cpp +++ b/src/glTF/MeshData.cpp @@ -10,9 +10,10 @@ #include "MeshData.h" #include "PrimitiveData.h" -MeshData::MeshData(std::string name) +MeshData::MeshData(const std::string &name, const std::vector &weights) : Holdable(), - name(std::move(name)) + name(name), + weights(weights) { } @@ -22,8 +23,12 @@ json MeshData::serialize() const for (const auto &primitive : primitives) { jsonPrimitivesArray.push_back(*primitive); } - return { + json result = { { "name", name }, { "primitives", jsonPrimitivesArray } }; + if (!weights.empty()) { + result["weights"] = weights; + } + return result; } diff --git a/src/glTF/MeshData.h b/src/glTF/MeshData.h index 993a9bb..a88f0c4 100644 --- a/src/glTF/MeshData.h +++ b/src/glTF/MeshData.h @@ -20,7 +20,7 @@ struct MeshData : Holdable { - explicit MeshData(std::string name); + MeshData(const std::string &name, const std::vector &weights); void AddPrimitive(std::shared_ptr primitive) { @@ -30,6 +30,7 @@ struct MeshData : Holdable json serialize() const override; const std::string name; + const std::vector weights; std::vector> primitives; }; diff --git a/src/glTF/PrimitiveData.cpp b/src/glTF/PrimitiveData.cpp index 9d6b732..ab39eab 100644 --- a/src/glTF/PrimitiveData.cpp +++ b/src/glTF/PrimitiveData.cpp @@ -39,6 +39,15 @@ void PrimitiveData::NoteDracoBuffer(const BufferViewData &data) dracoBufferView = data.ix; } +void PrimitiveData::AddTarget(const AccessorData *positions, const AccessorData *normals, const AccessorData *tangents) +{ + targetAccessors.push_back({ + positions->ix, + normals ? normals->ix : -1, + tangents ? tangents ->ix : -1 + }); +} + void to_json(json &j, const PrimitiveData &d) { j = { { "material", d.material }, @@ -48,7 +57,19 @@ void to_json(json &j, const PrimitiveData &d) { if (d.indices >= 0) { j["indices"] = d.indices; } - + if (!d.targetAccessors.empty()) { + json targets {}; + int pIx, nIx, tIx; + for (auto accessor : d.targetAccessors) { + std::tie(pIx, nIx, tIx) = accessor; + json target {}; + if (pIx >= 0) { target["POSITION"] = pIx; } + if (nIx >= 0) { target["NORMAL"] = nIx; } + if (tIx >= 0) { target["TANGENT"] = tIx; } + targets.push_back(target); + } + j["targets"] = targets; + } if (!d.dracoAttributes.empty()) { j["extensions"] = { { KHR_DRACO_MESH_COMPRESSION, { diff --git a/src/glTF/PrimitiveData.h b/src/glTF/PrimitiveData.h index 5d6ffb4..892c662 100644 --- a/src/glTF/PrimitiveData.h +++ b/src/glTF/PrimitiveData.h @@ -31,6 +31,8 @@ struct PrimitiveData void AddAttrib(std::string name, const AccessorData &accessor); + void AddTarget(const AccessorData *positions, const AccessorData *normals, const AccessorData *tangents); + template void AddDracoAttrib(const AttributeDefinition attribute, const std::vector &attribArr) { @@ -59,6 +61,8 @@ struct PrimitiveData const unsigned int material; const MeshMode mode; + std::vector> targetAccessors {}; + std::map attributes; std::map dracoAttributes;