dqn
/
FBX2glTF
mirror of https://github.com/facebookincubator/FBX2glTF.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add Sparse Accessor Support

This commit is contained in:
Mayank Nagpal 2021-07-05 13:57:56 +05:30 committed by K. S. Ernest (iFire) Lee
parent 1bfd930402
commit 2fe07994d1
7 changed files with 275 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
src/FBX2glTF.cpp
View File

@ -142,6 +142,11 @@ int main(int argc, char* argv[]) {
gltfOptions.enableUserProperties,
"Transcribe FBX User Properties into glTF node and material 'extras'.");
app.add_flag(
"--blend-shape-no-sparse",
gltfOptions.disableSparseBlendShapes,
"Don't use sparse accessors to store blend shapes");
app.add_flag(
"--blend-shape-normals",
gltfOptions.useBlendShapeNormals,
@ -250,7 +255,9 @@ int main(int argc, char* argv[]) {
->check(CLI::Range(1, 32))
->group("Draco");
app.add_option("--fbx-temp-dir", gltfOptions.fbxTempDir, "Temporary directory to be used by FBX SDK.")->check(CLI::ExistingDirectory);
app.add_option(
"--fbx-temp-dir", gltfOptions.fbxTempDir, "Temporary directory to be used by FBX SDK.")
->check(CLI::ExistingDirectory);
CLI11_PARSE(app, argc, argv);

10
src/FBX2glTF.h
View File

@ -112,14 +112,16 @@ struct GltfOptions {
/** Whether to include lights through the KHR_punctual_lights extension. */
bool useKHRLightsPunctual{true};
/** Whether to not use sparse accessors in blend shapes */
bool disableSparseBlendShapes{false};
/** Whether to include blend shape normals, if present according to the SDK. */
bool useBlendShapeNormals { false };
bool useBlendShapeNormals{false};
/** Whether to include blend shape tangents, if present according to the SDK. */
bool useBlendShapeTangents { false };
bool useBlendShapeTangents{false};
/** Whether to normalized skinning weights. */
bool normalizeSkinningWeights { true };
bool normalizeSkinningWeights{true};
/** Maximum number of bone influences per vertex. */
int maxSkinningWeights { 8 };
int maxSkinningWeights{8};
/** When to compute vertex normals from geometry. */
ComputeNormalsOption computeNormals = ComputeNormalsOption::BROKEN;
/** When to use 32-bit indices. */

47
src/gltf/GltfModel.hpp
View File

@ -69,6 +69,12 @@ class GltfModel {
BufferData& buffer,
const std::string& filename);
template <class T>
void
CopyToBufferView(BufferViewData& bufferView, const std::vector<T>& source, const GLType& type) {
bufferView.appendAsBinaryArray(source, *binary, type);
}
template <class T>
std::shared_ptr<AccessorData> AddAccessorWithView(
BufferViewData& bufferView,
@ -76,8 +82,42 @@ class GltfModel {
const std::vector<T>& source,
std::string name) {
auto accessor = accessors.hold(new AccessorData(bufferView, type, name));
accessor->appendAsBinaryArray(source, *binary);
bufferView.byteLength = accessor->byteLength();
bufferView.appendAsBinaryArray(source, *binary, type);
accessor->count = bufferView.count;
return accessor;
}
template <class T>
std::shared_ptr<AccessorData> AddSparseAccessorWithView(
AccessorData& baseAccessor,
BufferViewData& indexBufferView,
const GLType& indexBufferViewType,
BufferViewData& bufferView,
const GLType& type,
const std::vector<T>& source,
std::string name) {
auto accessor =
accessors.hold(new AccessorData(baseAccessor, indexBufferView, bufferView, type, name));
bufferView.appendAsBinaryArray(source, *binary, type);
accessor->count = baseAccessor.count;
accessor->sparseIdxBufferViewType = indexBufferViewType.componentType.glType;
return accessor;
}
// template <class T>
std::shared_ptr<AccessorData> AddSparseAccessor(
AccessorData& baseAccessor,
BufferViewData& indexBufferView,
const GLType& indexBufferViewType,
BufferViewData& bufferView,
const GLType& type,
// const std::vector<T>& source,
std::string name) {
auto accessor =
accessors.hold(new AccessorData(baseAccessor, indexBufferView, bufferView, type, name));
// bufferView.appendAsBinaryArray(source, *binary, type);
accessor->count = baseAccessor.count;
accessor->sparseIdxBufferViewType = indexBufferViewType.componentType.glType;
return accessor;
}
@ -138,8 +178,7 @@ class GltfModel {
accessor = accessors.hold(new AccessorData(attrDef.glType));
accessor->count = attribArr.size();
}
else {
} else {
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER);
accessor = AddAccessorWithView(*bufferView, attrDef.glType, attribArr, std::string(""));
}

123
src/gltf/Raw2Gltf.cpp
View File

@ -470,6 +470,9 @@ ModelData* Raw2Gltf(
surfaceModel.GetMaterial(surfaceModel.GetTriangle(0).materialIndex);
const MaterialData& mData = require(materialsById, rawMaterial.id);
if (verboseOutput)
fmt::printf("\rMaterial Name: %s\n", mData.name);
MeshData* mesh = nullptr;
auto meshIter = meshBySurfaceId.find(surfaceId);
if (meshIter != meshBySurfaceId.end()) {
@ -522,6 +525,16 @@ ModelData* Raw2Gltf(
//
// surface vertices
//
// Base Accessors needed for Sparse Accessors
std::shared_ptr<AccessorData> pAccBase;
std::shared_ptr<AccessorData> nAccBase;
std::shared_ptr<AccessorData> tAccBase;
// Sparse accessors cannot be zero length, but morph targets can easily have
// no modified vertices in multiprim meshes. In order to utilise sparse accessors
// in this case, we need a couple of single element dummy buffer views to reference.
std::shared_ptr<BufferViewData> dummyIdxView;
std::shared_ptr<BufferViewData> dummyDataView;
{
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_POSITION) != 0) {
const AttributeDefinition<Vec3f> ATTR_POSITION(
@ -535,6 +548,8 @@ ModelData* Raw2Gltf(
accessor->min = toStdVec(rawSurface.bounds.min);
accessor->max = toStdVec(rawSurface.bounds.max);
pAccBase = accessor;
}
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_NORMAL) != 0) {
const AttributeDefinition<Vec3f> ATTR_NORMAL(
@ -545,11 +560,13 @@ ModelData* Raw2Gltf(
draco::DT_FLOAT32);
const auto _ =
gltf->AddAttributeToPrimitive<Vec3f>(buffer, surfaceModel, *primitive, ATTR_NORMAL);
nAccBase = _;
}
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_TANGENT) != 0) {
const AttributeDefinition<Vec4f> ATTR_TANGENT("TANGENT", &RawVertex::tangent, GLT_VEC4F);
const auto _ =
gltf->AddAttributeToPrimitive<Vec4f>(buffer, surfaceModel, *primitive, ATTR_TANGENT);
tAccBase = _;
}
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_COLOR) != 0) {
const AttributeDefinition<Vec4f> ATTR_COLOR(
@ -617,26 +634,115 @@ ModelData* Raw2Gltf(
std::vector<Vec3f> positions, normals;
std::vector<Vec4f> tangents;
std::vector<TriangleIndex> sparseIndices;
for (int jj = 0; jj < surfaceModel.GetVertexCount(); jj++) {
auto blendVertex = surfaceModel.GetVertex(jj).blends[channelIx];
shapeBounds.AddPoint(blendVertex.position);
bool isSparseVertex = options.disableSparseBlendShapes; // If sparse is off, add all vertices
// Check to see whether position, normal or tangent deviates from base mesh and flag as
// sparse.
if (blendVertex.position.Length() > 0.00) {
isSparseVertex = true;
}
// if (options.useBlendShapeNormals && channel.hasNormals &&
// blendVertex.normal.Length() > 0.00) {
// isSparseVertex = true;
// }
// if (options.useBlendShapeTangents && channel.hasTangents &&
// blendVertex.tangent.Length() > 0.00) {
// isSparseVertex = true;
// }
if (isSparseVertex == true) {
sparseIndices.push_back(jj);
positions.push_back(blendVertex.position);
if (options.useBlendShapeTangents && channel.hasNormals) {
if (options.useBlendShapeNormals && channel.hasNormals) {
normals.push_back(blendVertex.normal);
}
if (options.useBlendShapeTangents && channel.hasTangents) {
tangents.push_back(blendVertex.tangent);
}
}
std::shared_ptr<AccessorData> pAcc = gltf->AddAccessorWithView(
}
std::shared_ptr<AccessorData> pAcc;
std::shared_ptr<AccessorData> nAcc;
std::shared_ptr<AccessorData> tAcc;
if (!options.disableSparseBlendShapes) {
if (verboseOutput)
fmt::printf(
"\rChannel Name: %-50s Sparse Count: %d\n", channel.name, sparseIndices.size());
if (sparseIndices.size() == 0) {
// Initalize dummy bufferviews if needed
if (!dummyIdxView) {
std::vector<TriangleIndex> dummyIndices;
dummyIndices.push_back(int(0));
dummyIdxView = gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
gltf->CopyToBufferView(
*dummyIdxView, dummyIndices, useLongIndices ? GLT_UINT : GLT_USHORT);
}
if (!dummyDataView) {
std::vector<Vec3f> dummyData;
dummyData.push_back(Vec3f(0.0));
dummyDataView = gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
dummyDataView->appendAsBinaryArray(dummyData, *gltf->binary, GLT_VEC3F);
}
// Set up sparse accessor with dummy buffer views
pAcc = gltf->AddSparseAccessor(
*pAccBase,
*dummyIdxView,
useLongIndices ? GLT_UINT : GLT_USHORT,
*dummyDataView,
GLT_VEC3F,
channel.name);
} else {
// Build Orphan Bufferview for Sparse Indices
std::shared_ptr<BufferViewData> indexBufferView =
gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
gltf->CopyToBufferView(
*indexBufferView, sparseIndices, useLongIndices ? GLT_UINT : GLT_USHORT);
pAcc = gltf->AddSparseAccessorWithView(
*pAccBase,
*indexBufferView,
useLongIndices ? GLT_UINT : GLT_USHORT,
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE),
GLT_VEC3F,
positions,
channel.name);
if (!normals.empty()) {
nAcc = gltf->AddSparseAccessorWithView(
*nAccBase,
*indexBufferView,
useLongIndices ? GLT_UINT : GLT_USHORT,
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE),
GLT_VEC3F,
normals,
channel.name);
}
if (!tangents.empty()) {
tAcc = gltf->AddSparseAccessorWithView(
*nAccBase,
*indexBufferView,
useLongIndices ? GLT_UINT : GLT_USHORT,
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE),
GLT_VEC4F,
tangents,
channel.name);
}
}
} else {
pAcc = gltf->AddAccessorWithView(
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER),
GLT_VEC3F,
positions,
channel.name);
pAcc->min = toStdVec(shapeBounds.min);
pAcc->max = toStdVec(shapeBounds.max);
std::shared_ptr<AccessorData> nAcc;
if (!normals.empty()) {
nAcc = gltf->AddAccessorWithView(
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER),
@ -644,8 +750,6 @@ ModelData* Raw2Gltf(
normals,
channel.name);
}
std::shared_ptr<AccessorData> tAcc;
if (!tangents.empty()) {
nAcc = gltf->AddAccessorWithView(
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER),
@ -653,7 +757,10 @@ ModelData* Raw2Gltf(
tangents,
channel.name);
}
}
pAcc->min = toStdVec(shapeBounds.min);
pAcc->max = toStdVec(shapeBounds.max);
primitive->AddTarget(pAcc.get(), nAcc.get(), tAcc.get());
}
}

31
src/gltf/properties/AccessorData.cpp
View File

@ -15,7 +15,23 @@ AccessorData::AccessorData(const BufferViewData& bufferView, GLType type, std::s
type(std::move(type)),
byteOffset(0),
count(0),
name(name) {}
name(name),
sparse(false) {}
AccessorData::AccessorData(const AccessorData& baseAccessor, const BufferViewData& sparseIdxBufferView, const BufferViewData& sparseDataBufferView, GLType type, std::string name)
: Holdable(),
bufferView(baseAccessor.bufferView),
type(std::move(type)),
byteOffset(baseAccessor.byteOffset),
count(baseAccessor.count),
name(name),
sparse(true),
sparseIdxCount(sparseIdxBufferView.count),
sparseIdxBufferView(sparseIdxBufferView.ix),
sparseIdxBufferViewOffset(0),
sparseIdxBufferViewType(0),
sparseDataBufferView(sparseDataBufferView.ix),
sparseDataBufferViewOffset(0) {}
AccessorData::AccessorData(GLType type)
: Holdable(), bufferView(-1), type(std::move(type)), byteOffset(0), count(0) {}
@ -23,7 +39,7 @@ AccessorData::AccessorData(GLType type)
json AccessorData::serialize() const {
json result{
{"componentType", type.componentType.glType}, {"type", type.dataType}, {"count", count}};
if (bufferView >= 0) {
if (bufferView >= 0 && !sparse) {
result["bufferView"] = bufferView;
result["byteOffset"] = byteOffset;
}
@ -33,6 +49,17 @@ json AccessorData::serialize() const {
if (!max.empty()) {
result["max"] = max;
}
if (sparse) {
json sparseData = {{"count", sparseIdxCount}};
sparseData["indices"] = { {"bufferView", sparseIdxBufferView},
{"byteOffset", sparseIdxBufferViewOffset},
{"componentType", sparseIdxBufferViewType}};
sparseData["values"] = { {"bufferView", sparseDataBufferView},
{"byteOffset", sparseDataBufferViewOffset}};
result["sparse"] = sparseData;
}
if (name.length() > 0) {
result["name"] = name;
}

23
src/gltf/properties/AccessorData.hpp
View File

@ -13,23 +13,10 @@
struct AccessorData : Holdable {
AccessorData(const BufferViewData& bufferView, GLType type, std::string name);
explicit AccessorData(GLType type);
AccessorData(const AccessorData& baseAccessor, const BufferViewData& sparseIdxBufferView, const BufferViewData& sparseDataBufferView, GLType type, std::string name);
json serialize() const override;
template <class T>
void appendAsBinaryArray(const std::vector<T>& in, std::vector<uint8_t>& out) {
const unsigned int stride = type.byteStride();
const size_t offset = out.size();
const size_t count = in.size();
this->count = (unsigned int)count;
out.resize(offset + count * stride);
for (int ii = 0; ii < count; ii++) {
type.write(&out[offset + ii * stride], in[ii]);
}
}
unsigned int byteLength() const {
return type.byteStride() * count;
}
@ -42,4 +29,12 @@ struct AccessorData : Holdable {
std::vector<float> min;
std::vector<float> max;
std::string name;
bool sparse;
int sparseIdxCount;
int sparseIdxBufferView;
int sparseIdxBufferViewOffset;
int sparseIdxBufferViewType;
int sparseDataBufferView;
int sparseDataBufferViewOffset;
};

16
src/gltf/properties/BufferViewData.hpp
View File

@ -21,9 +21,25 @@ struct BufferViewData : Holdable {
json serialize() const override;
template <class T>
void appendAsBinaryArray(const std::vector<T>& in, std::vector<uint8_t>& out, GLType type) {
const unsigned int stride = type.byteStride();
const size_t offset = out.size();
const size_t count = in.size();
this->byteLength = stride * count;
this->count = count;
out.resize(offset + count * stride);
for (int ii = 0; ii < count; ii++) {
type.write(&out[offset + ii * stride], in[ii]);
}
}
const unsigned int buffer;
const unsigned int byteOffset;
const GL_ArrayType target;
unsigned int count = 0;
unsigned int byteLength = 0;
};