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

Merge remote-tracking branch 'upstream/master' into feat/mocha-tests

This commit is contained in:
Par Winzell 2018-12-19 09:31:08 -08:00
parent 8874a38751 5730d1c301
commit f94b3650f2
67 changed files with 5426 additions and 5249 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.clang-format
View File

@ -35,7 +35,7 @@ BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false BreakConstructorInitializersBeforeComma: false
BreakAfterJavaFieldAnnotations: false BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: false BreakStringLiterals: false
ColumnLimit: 80 ColumnLimit: 100
CommentPragmas: '^ IWYU pragma:' CommentPragmas: '^ IWYU pragma:'
ConstructorInitializerAllOnOneLineOrOnePerLine: true ConstructorInitializerAllOnOneLineOrOnePerLine: true
ConstructorInitializerIndentWidth: 4 ConstructorInitializerIndentWidth: 4

75
src/FBX2glTF.cpp
View File

@ -35,8 +35,7 @@ int main(int argc, char* argv[]) {
CLI::App app{ CLI::App app{
fmt::sprintf( fmt::sprintf(
"FBX2glTF %s: Generate a glTF 2.0 representation of an FBX model.", "FBX2glTF %s: Generate a glTF 2.0 representation of an FBX model.", FBX2GLTF_VERSION),
FBX2GLTF_VERSION),
"FBX2glTF"}; "FBX2glTF"};
app.add_flag( app.add_flag(
@ -45,32 +44,22 @@ int main(int argc, char* argv[]) {
"Include blend shape tangents, if reported present by the FBX SDK."); "Include blend shape tangents, if reported present by the FBX SDK.");
app.add_flag_function("-V,--version", [&](size_t count) { app.add_flag_function("-V,--version", [&](size_t count) {
fmt::printf( fmt::printf("FBX2glTF version %s\nCopyright (c) 2016-2018 Oculus VR, LLC.\n", FBX2GLTF_VERSION);
"FBX2glTF version %s\nCopyright (c) 2016-2018 Oculus VR, LLC.\n",
FBX2GLTF_VERSION);
exit(0); exit(0);
}); });
std::string inputPath; std::string inputPath;
app.add_option("FBX Model", inputPath, "The FBX model to convert.") app.add_option("FBX Model", inputPath, "The FBX model to convert.")->check(CLI::ExistingFile);
->check(CLI::ExistingFile); app.add_option("-i,--input", inputPath, "The FBX model to convert.")->check(CLI::ExistingFile);
app.add_option("-i,--input", inputPath, "The FBX model to convert.")
->check(CLI::ExistingFile);
std::string outputPath; std::string outputPath;
app.add_option( app.add_option("-o,--output", outputPath, "Where to generate the output, without suffix.");
"-o,--output",
outputPath,
"Where to generate the output, without suffix.");
app.add_flag( app.add_flag(
"-e,--embed", "-e,--embed",
gltfOptions.embedResources, gltfOptions.embedResources,
"Inline buffers as data:// URIs within generated non-binary glTF."); "Inline buffers as data:// URIs within generated non-binary glTF.");
app.add_flag( app.add_flag("-b,--binary", gltfOptions.outputBinary, "Output a single binary format .glb file.");
"-b,--binary",
gltfOptions.outputBinary,
"Output a single binary format .glb file.");
app.add_option( app.add_option(
"--long-indices", "--long-indices",
@ -119,8 +108,7 @@ int main(int argc, char* argv[]) {
"--flip-u", "--flip-u",
[&](size_t count) { [&](size_t count) {
if (count > 0) { if (count > 0) {
texturesTransforms.emplace_back( texturesTransforms.emplace_back([](Vec2f uv) { return Vec2f(1.0f - uv[0], uv[1]); });
[](Vec2f uv) { return Vec2f(1.0f - uv[0], uv[1]); });
if (verboseOutput) { if (verboseOutput) {
fmt::printf("Flipping texture coordinates in the 'U' dimension.\n"); fmt::printf("Flipping texture coordinates in the 'U' dimension.\n");
} }
@ -128,23 +116,20 @@ int main(int argc, char* argv[]) {
}, },
"Flip all U texture coordinates."); "Flip all U texture coordinates.");
app.add_flag("--no-flip-u", "Don't flip U texture coordinates.") app.add_flag("--no-flip-u", "Don't flip U texture coordinates.")->excludes("--flip-u");
->excludes("--flip-u");
app.add_flag_function( app.add_flag_function(
"--no-flip-v", "--no-flip-v",
[&](size_t count) { [&](size_t count) {
if (count > 0) { if (count > 0) {
texturesTransforms.emplace_back( texturesTransforms.emplace_back([](Vec2f uv) { return Vec2f(uv[0], 1.0f - uv[1]); });
[](Vec2f uv) { return Vec2f(uv[0], 1.0f - uv[1]); });
if (verboseOutput) { if (verboseOutput) {
fmt::printf("NOT flipping texture coordinates in the 'V' dimension.\n"); fmt::printf("NOT flipping texture coordinates in the 'V' dimension.\n");
} }
} }
}, },
"Flip all V texture coordinates."); "Flip all V texture coordinates.");
app.add_flag("--flip-v", "Don't flip U texture coordinates.") app.add_flag("--flip-v", "Don't flip U texture coordinates.")->excludes("--no-flip-v");
->excludes("--no-flip-v");
app.add_flag( app.add_flag(
"--pbr-metallic-rougnness", "--pbr-metallic-rougnness",
@ -181,8 +166,8 @@ int main(int argc, char* argv[]) {
app.add_option( app.add_option(
"-k,--keep-attribute", "-k,--keep-attribute",
[&](std::vector<std::string> attributes) -> bool { [&](std::vector<std::string> attributes) -> bool {
gltfOptions.keepAttribs = RAW_VERTEX_ATTRIBUTE_JOINT_INDICES | gltfOptions.keepAttribs =
RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS; RAW_VERTEX_ATTRIBUTE_JOINT_INDICES | RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS;
for (std::string attribute : attributes) { for (std::string attribute : attributes) {
if (attribute == "position") { if (attribute == "position") {
gltfOptions.keepAttribs |= RAW_VERTEX_ATTRIBUTE_POSITION; gltfOptions.keepAttribs |= RAW_VERTEX_ATTRIBUTE_POSITION;
@ -212,9 +197,7 @@ int main(int argc, char* argv[]) {
->type_name("(position|normal|tangent|binormial|color|uv0|uv1|auto)"); ->type_name("(position|normal|tangent|binormial|color|uv0|uv1|auto)");
app.add_flag( app.add_flag(
"-d,--draco", "-d,--draco", gltfOptions.draco.enabled, "Apply Draco mesh compression to geometries.")
gltfOptions.draco.enabled,
"Apply Draco mesh compression to geometries.")
->group("Draco"); ->group("Draco");
app.add_option( app.add_option(
@ -301,16 +284,12 @@ int main(int argc, char* argv[]) {
} else { } else {
// in gltf mode, we create a folder and write into that // in gltf mode, we create a folder and write into that
outputFolder = fmt::format( outputFolder =
"{}_out{}", fmt::format("{}_out{}", outputPath.c_str(), (const char)StringUtils::GetPathSeparator());
outputPath.c_str(), modelPath = outputFolder + StringUtils::GetFileNameString(outputPath) + ".gltf";
(const char)StringUtils::GetPathSeparator());
modelPath =
outputFolder + StringUtils::GetFileNameString(outputPath) + ".gltf";
} }
if (!FileUtils::CreatePath(modelPath.c_str())) { if (!FileUtils::CreatePath(modelPath.c_str())) {
fmt::fprintf( fmt::fprintf(stderr, "ERROR: Failed to create folder: %s'\n", outputFolder.c_str());
stderr, "ERROR: Failed to create folder: %s'\n", outputFolder.c_str());
return 1; return 1;
} }
@ -334,14 +313,9 @@ int main(int argc, char* argv[]) {
std::ofstream outStream; // note: auto-flushes in destructor std::ofstream outStream; // note: auto-flushes in destructor
const auto streamStart = outStream.tellp(); const auto streamStart = outStream.tellp();
outStream.open( outStream.open(modelPath, std::ios::trunc | std::ios::ate | std::ios::out | std::ios::binary);
modelPath,
std::ios::trunc | std::ios::ate | std::ios::out | std::ios::binary);
if (outStream.fail()) { if (outStream.fail()) {
fmt::fprintf( fmt::fprintf(stderr, "ERROR:: Couldn't open file for writing: %s\n", modelPath.c_str());
stderr,
"ERROR:: Couldn't open file for writing: %s\n",
modelPath.c_str());
return 1; return 1;
} }
data_render_model = Raw2Gltf(outStream, outputFolder, raw, gltfOptions); data_render_model = Raw2Gltf(outStream, outputFolder, raw, gltfOptions);
@ -371,8 +345,7 @@ int main(int argc, char* argv[]) {
const std::string binaryPath = outputFolder + extBufferFilename; const std::string binaryPath = outputFolder + extBufferFilename;
FILE* fp = fopen(binaryPath.c_str(), "wb"); FILE* fp = fopen(binaryPath.c_str(), "wb");
if (fp == nullptr) { if (fp == nullptr) {
fmt::fprintf( fmt::fprintf(stderr, "ERROR:: Couldn't open file '%s' for writing.\n", binaryPath);
stderr, "ERROR:: Couldn't open file '%s' for writing.\n", binaryPath);
return 1; return 1;
} }
@ -381,16 +354,12 @@ int main(int argc, char* argv[]) {
unsigned long binarySize = data_render_model->binary->size(); unsigned long binarySize = data_render_model->binary->size();
if (fwrite(binaryData, binarySize, 1, fp) != 1) { if (fwrite(binaryData, binarySize, 1, fp) != 1) {
fmt::fprintf( fmt::fprintf(
stderr, stderr, "ERROR: Failed to write %lu bytes to file '%s'.\n", binarySize, binaryPath);
"ERROR: Failed to write %lu bytes to file '%s'.\n",
binarySize,
binaryPath);
fclose(fp); fclose(fp);
return 1; return 1;
} }
fclose(fp); fclose(fp);
fmt::printf( fmt::printf("Wrote %lu bytes of binary data to %s.\n", binarySize, binaryPath);
"Wrote %lu bytes of binary data to %s.\n", binarySize, binaryPath);
} }
delete data_render_model; delete data_render_model;

464
src/fbx/Fbx2Raw.cpp
View File

@ -10,22 +10,22 @@
#include "Fbx2Raw.hpp" #include "Fbx2Raw.hpp"
#include <algorithm> #include <algorithm>
#include <vector> #include <cassert>
#include <unordered_map> #include <cmath>
#include <cstdint>
#include <cstdio>
#include <fstream>
#include <map> #include <map>
#include <set> #include <set>
#include <string> #include <string>
#include <fstream> #include <unordered_map>
#include <cstdint> #include <vector>
#include <cstdio>
#include <cassert>
#include <cmath>
#include "FBX2glTF.h" #include "FBX2glTF.h"
#include "raw/RawModel.hpp"
#include "utils/File_Utils.hpp" #include "utils/File_Utils.hpp"
#include "utils/String_Utils.hpp" #include "utils/String_Utils.hpp"
#include "raw/RawModel.hpp"
#include "FbxBlendShapesAccess.hpp" #include "FbxBlendShapesAccess.hpp"
#include "FbxLayerElementAccess.hpp" #include "FbxLayerElementAccess.hpp"
@ -34,18 +34,20 @@
float scaleFactor; float scaleFactor;
static bool TriangleTexturePolarity(const Vec2f &uv0, const Vec2f &uv1, const Vec2f &uv2) static bool TriangleTexturePolarity(const Vec2f& uv0, const Vec2f& uv1, const Vec2f& uv2) {
{
const Vec2f d0 = uv1 - uv0; const Vec2f d0 = uv1 - uv0;
const Vec2f d1 = uv2 - uv0; const Vec2f d1 = uv2 - uv0;
return (d0[0] * d1[1] - d0[1] * d1[0] < 0.0f); return (d0[0] * d1[1] - d0[1] * d1[0] < 0.0f);
} }
static RawMaterialType static RawMaterialType GetMaterialType(
GetMaterialType(const RawModel &raw, const int textures[RAW_TEXTURE_USAGE_MAX], const bool vertexTransparency, const bool skinned) const RawModel& raw,
{ const int textures[RAW_TEXTURE_USAGE_MAX],
// DIFFUSE and ALBEDO are different enough to represent distinctly, but they both help determine transparency. const bool vertexTransparency,
const bool skinned) {
// DIFFUSE and ALBEDO are different enough to represent distinctly, but they both help determine
// transparency.
int diffuseTexture = textures[RAW_TEXTURE_USAGE_DIFFUSE]; int diffuseTexture = textures[RAW_TEXTURE_USAGE_DIFFUSE];
if (diffuseTexture < 0) { if (diffuseTexture < 0) {
diffuseTexture = textures[RAW_TEXTURE_USAGE_ALBEDO]; diffuseTexture = textures[RAW_TEXTURE_USAGE_ALBEDO];
@ -62,13 +64,15 @@ GetMaterialType(const RawModel &raw, const int textures[RAW_TEXTURE_USAGE_MAX],
return skinned ? RAW_MATERIAL_TYPE_SKINNED_TRANSPARENT : RAW_MATERIAL_TYPE_TRANSPARENT; return skinned ? RAW_MATERIAL_TYPE_SKINNED_TRANSPARENT : RAW_MATERIAL_TYPE_TRANSPARENT;
} }
// Default to simply opaque. // Default to simply opaque.
return skinned ? RAW_MATERIAL_TYPE_SKINNED_OPAQUE : RAW_MATERIAL_TYPE_OPAQUE; return skinned ? RAW_MATERIAL_TYPE_SKINNED_OPAQUE : RAW_MATERIAL_TYPE_OPAQUE;
} }
static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std::map<const FbxTexture *, FbxString> &textureLocations) static void ReadMesh(
{ RawModel& raw,
FbxScene* pScene,
FbxNode* pNode,
const std::map<const FbxTexture*, FbxString>& textureLocations) {
FbxGeometryConverter meshConverter(pScene->GetFbxManager()); FbxGeometryConverter meshConverter(pScene->GetFbxManager());
meshConverter.Triangulate(pNode->GetNodeAttribute(), true); meshConverter.Triangulate(pNode->GetNodeAttribute(), true);
FbxMesh* pMesh = pNode->GetMesh(); FbxMesh* pMesh = pNode->GetMesh();
@ -92,20 +96,29 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
const int rawSurfaceIndex = raw.AddSurface(meshName, surfaceId); const int rawSurfaceIndex = raw.AddSurface(meshName, surfaceId);
const FbxVector4* controlPoints = pMesh->GetControlPoints(); const FbxVector4* controlPoints = pMesh->GetControlPoints();
const FbxLayerElementAccess<FbxVector4> normalLayer(pMesh->GetElementNormal(), pMesh->GetElementNormalCount()); const FbxLayerElementAccess<FbxVector4> normalLayer(
const FbxLayerElementAccess<FbxVector4> binormalLayer(pMesh->GetElementBinormal(), pMesh->GetElementBinormalCount()); pMesh->GetElementNormal(), pMesh->GetElementNormalCount());
const FbxLayerElementAccess<FbxVector4> tangentLayer(pMesh->GetElementTangent(), pMesh->GetElementTangentCount()); const FbxLayerElementAccess<FbxVector4> binormalLayer(
const FbxLayerElementAccess<FbxColor> colorLayer(pMesh->GetElementVertexColor(), pMesh->GetElementVertexColorCount()); pMesh->GetElementBinormal(), pMesh->GetElementBinormalCount());
const FbxLayerElementAccess<FbxVector2> uvLayer0(pMesh->GetElementUV(0), pMesh->GetElementUVCount()); const FbxLayerElementAccess<FbxVector4> tangentLayer(
const FbxLayerElementAccess<FbxVector2> uvLayer1(pMesh->GetElementUV(1), pMesh->GetElementUVCount()); pMesh->GetElementTangent(), pMesh->GetElementTangentCount());
const FbxLayerElementAccess<FbxColor> colorLayer(
pMesh->GetElementVertexColor(), pMesh->GetElementVertexColorCount());
const FbxLayerElementAccess<FbxVector2> uvLayer0(
pMesh->GetElementUV(0), pMesh->GetElementUVCount());
const FbxLayerElementAccess<FbxVector2> uvLayer1(
pMesh->GetElementUV(1), pMesh->GetElementUVCount());
const FbxSkinningAccess skinning(pMesh, pScene, pNode); const FbxSkinningAccess skinning(pMesh, pScene, pNode);
const FbxMaterialsAccess materials(pMesh, textureLocations); const FbxMaterialsAccess materials(pMesh, textureLocations);
const FbxBlendShapesAccess blendShapes(pMesh); const FbxBlendShapesAccess blendShapes(pMesh);
if (verboseOutput) { if (verboseOutput) {
fmt::printf( fmt::printf(
"mesh %d: %s (skinned: %s)\n", rawSurfaceIndex, meshName, "mesh %d: %s (skinned: %s)\n",
skinning.IsSkinned() ? raw.GetNode(raw.GetNodeById(skinning.GetRootNode())).name.c_str() : "NO"); rawSurfaceIndex,
meshName,
skinning.IsSkinned() ? raw.GetNode(raw.GetNodeById(skinning.GetRootNode())).name.c_str()
: "NO");
} }
// The FbxNode geometric transformation describes how a FbxNodeAttribute is offset from // The FbxNode geometric transformation describes how a FbxNodeAttribute is offset from
@ -120,17 +133,30 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
const FbxAMatrix meshTransform(meshTranslation, meshRotation, meshScaling); const FbxAMatrix meshTransform(meshTranslation, meshRotation, meshScaling);
const FbxMatrix transform = meshTransform; const FbxMatrix transform = meshTransform;
// Remove translation & scaling from transforms that will bi applied to normals, tangents & binormals // Remove translation & scaling from transforms that will bi applied to normals, tangents &
// binormals
const FbxMatrix normalTransform(FbxVector4(), meshRotation, meshScaling); const FbxMatrix normalTransform(FbxVector4(), meshRotation, meshScaling);
const FbxMatrix inverseTransposeTransform = normalTransform.Inverse().Transpose(); const FbxMatrix inverseTransposeTransform = normalTransform.Inverse().Transpose();
raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_POSITION); raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_POSITION);
if (normalLayer.LayerPresent()) { raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_NORMAL); } if (normalLayer.LayerPresent()) {
if (tangentLayer.LayerPresent()) { raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_TANGENT); } raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_NORMAL);
if (binormalLayer.LayerPresent()) { raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_BINORMAL); } }
if (colorLayer.LayerPresent()) { raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_COLOR); } if (tangentLayer.LayerPresent()) {
if (uvLayer0.LayerPresent()) { raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_UV0); } raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_TANGENT);
if (uvLayer1.LayerPresent()) { raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_UV1); } }
if (binormalLayer.LayerPresent()) {
raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_BINORMAL);
}
if (colorLayer.LayerPresent()) {
raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_COLOR);
}
if (uvLayer0.LayerPresent()) {
raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_UV0);
}
if (uvLayer1.LayerPresent()) {
raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_UV1);
}
if (skinning.IsSkinned()) { if (skinning.IsSkinned()) {
raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS); raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS);
raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_JOINT_INDICES); raw.AddVertexAttribute(RAW_VERTEX_ATTRIBUTE_JOINT_INDICES);
@ -141,13 +167,15 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
Mat4f scaleMatrix = Mat4f::FromScaleVector(Vec3f(scaleFactor, scaleFactor, scaleFactor)); Mat4f scaleMatrix = Mat4f::FromScaleVector(Vec3f(scaleFactor, scaleFactor, scaleFactor));
Mat4f invScaleMatrix = scaleMatrix.Inverse(); Mat4f invScaleMatrix = scaleMatrix.Inverse();
rawSurface.skeletonRootId = (skinning.IsSkinned()) ? skinning.GetRootNode() : pNode->GetUniqueID(); rawSurface.skeletonRootId =
(skinning.IsSkinned()) ? skinning.GetRootNode() : pNode->GetUniqueID();
for (int jointIndex = 0; jointIndex < skinning.GetNodeCount(); jointIndex++) { for (int jointIndex = 0; jointIndex < skinning.GetNodeCount(); jointIndex++) {
const long jointId = skinning.GetJointId(jointIndex); const long jointId = skinning.GetJointId(jointIndex);
raw.GetNode(raw.GetNodeById(jointId)).isJoint = true; raw.GetNode(raw.GetNodeById(jointId)).isJoint = true;
rawSurface.jointIds.emplace_back(jointId); rawSurface.jointIds.emplace_back(jointId);
rawSurface.inverseBindMatrices.push_back(invScaleMatrix * toMat4f(skinning.GetInverseBindMatrix(jointIndex)) * scaleMatrix); rawSurface.inverseBindMatrices.push_back(
invScaleMatrix * toMat4f(skinning.GetInverseBindMatrix(jointIndex)) * scaleMatrix);
rawSurface.jointGeometryMins.emplace_back(FLT_MAX, FLT_MAX, FLT_MAX); rawSurface.jointGeometryMins.emplace_back(FLT_MAX, FLT_MAX, FLT_MAX);
rawSurface.jointGeometryMaxs.emplace_back(-FLT_MAX, -FLT_MAX, -FLT_MAX); rawSurface.jointGeometryMaxs.emplace_back(-FLT_MAX, -FLT_MAX, -FLT_MAX);
} }
@ -156,16 +184,16 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
std::vector<const FbxBlendShapesAccess::TargetShape*> targetShapes; std::vector<const FbxBlendShapesAccess::TargetShape*> targetShapes;
for (size_t channelIx = 0; channelIx < blendShapes.GetChannelCount(); channelIx++) { for (size_t channelIx = 0; channelIx < blendShapes.GetChannelCount(); channelIx++) {
for (size_t targetIx = 0; targetIx < blendShapes.GetTargetShapeCount(channelIx); targetIx++) { for (size_t targetIx = 0; targetIx < blendShapes.GetTargetShapeCount(channelIx); targetIx++) {
const FbxBlendShapesAccess::TargetShape &shape = blendShapes.GetTargetShape(channelIx, targetIx); const FbxBlendShapesAccess::TargetShape& shape =
blendShapes.GetTargetShape(channelIx, targetIx);
targetShapes.push_back(&shape); targetShapes.push_back(&shape);
auto& blendChannel = blendShapes.GetBlendChannel(channelIx); auto& blendChannel = blendShapes.GetBlendChannel(channelIx);
rawSurface.blendChannels.push_back(RawBlendChannel { rawSurface.blendChannels.push_back(
static_cast<float>(blendChannel.deformPercent), RawBlendChannel{static_cast<float>(blendChannel.deformPercent),
shape.normals.LayerPresent(), shape.normals.LayerPresent(),
shape.tangents.LayerPresent(), shape.tangents.LayerPresent(),
blendChannel.name blendChannel.name});
});
} }
} }
@ -183,8 +211,13 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
if (fbxMaterial == nullptr) { if (fbxMaterial == nullptr) {
materialName = "DefaultMaterial"; materialName = "DefaultMaterial";
rawMatProps.reset(new RawTraditionalMatProps(RAW_SHADING_MODEL_LAMBERT, rawMatProps.reset(new RawTraditionalMatProps(
Vec3f(0, 0, 0), Vec4f(.5, .5, .5, 1), Vec3f(0, 0, 0), Vec3f(0, 0, 0), 0.5)); RAW_SHADING_MODEL_LAMBERT,
Vec3f(0, 0, 0),
Vec4f(.5, .5, .5, 1),
Vec3f(0, 0, 0),
Vec3f(0, 0, 0),
0.5));
} else { } else {
materialName = fbxMaterial->name; materialName = fbxMaterial->name;
@ -193,13 +226,15 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
if (tex != nullptr) { if (tex != nullptr) {
// dig out the inferred filename from the textureLocations map // dig out the inferred filename from the textureLocations map
FbxString inferredPath = textureLocations.find(tex)->second; FbxString inferredPath = textureLocations.find(tex)->second;
textures[usage] = raw.AddTexture(tex->GetName(), tex->GetFileName(), inferredPath.Buffer(), usage); textures[usage] =
raw.AddTexture(tex->GetName(), tex->GetFileName(), inferredPath.Buffer(), usage);
} }
}; };
std::shared_ptr<RawMatProps> matInfo; std::shared_ptr<RawMatProps> matInfo;
if (fbxMaterial->shadingModel == FbxRoughMetMaterialInfo::FBX_SHADER_METROUGH) { if (fbxMaterial->shadingModel == FbxRoughMetMaterialInfo::FBX_SHADER_METROUGH) {
FbxRoughMetMaterialInfo *fbxMatInfo = static_cast<FbxRoughMetMaterialInfo *>(fbxMaterial.get()); FbxRoughMetMaterialInfo* fbxMatInfo =
static_cast<FbxRoughMetMaterialInfo*>(fbxMaterial.get());
maybeAddTexture(fbxMatInfo->texColor, RAW_TEXTURE_USAGE_ALBEDO); maybeAddTexture(fbxMatInfo->texColor, RAW_TEXTURE_USAGE_ALBEDO);
maybeAddTexture(fbxMatInfo->texNormal, RAW_TEXTURE_USAGE_NORMAL); maybeAddTexture(fbxMatInfo->texNormal, RAW_TEXTURE_USAGE_NORMAL);
@ -208,11 +243,15 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
maybeAddTexture(fbxMatInfo->texMetallic, RAW_TEXTURE_USAGE_METALLIC); maybeAddTexture(fbxMatInfo->texMetallic, RAW_TEXTURE_USAGE_METALLIC);
maybeAddTexture(fbxMatInfo->texAmbientOcclusion, RAW_TEXTURE_USAGE_OCCLUSION); maybeAddTexture(fbxMatInfo->texAmbientOcclusion, RAW_TEXTURE_USAGE_OCCLUSION);
rawMatProps.reset(new RawMetRoughMatProps( rawMatProps.reset(new RawMetRoughMatProps(
RAW_SHADING_MODEL_PBR_MET_ROUGH, toVec4f(fbxMatInfo->colBase), toVec3f(fbxMatInfo->colEmissive), RAW_SHADING_MODEL_PBR_MET_ROUGH,
fbxMatInfo->emissiveIntensity, fbxMatInfo->metallic, fbxMatInfo->roughness)); toVec4f(fbxMatInfo->colBase),
toVec3f(fbxMatInfo->colEmissive),
fbxMatInfo->emissiveIntensity,
fbxMatInfo->metallic,
fbxMatInfo->roughness));
} else { } else {
FbxTraditionalMaterialInfo* fbxMatInfo =
FbxTraditionalMaterialInfo *fbxMatInfo = static_cast<FbxTraditionalMaterialInfo *>(fbxMaterial.get()); static_cast<FbxTraditionalMaterialInfo*>(fbxMaterial.get());
RawShadingModel shadingModel; RawShadingModel shadingModel;
if (fbxMaterial->shadingModel == "Lambert") { if (fbxMaterial->shadingModel == "Lambert") {
shadingModel = RAW_SHADING_MODEL_LAMBERT; shadingModel = RAW_SHADING_MODEL_LAMBERT;
@ -231,9 +270,13 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
maybeAddTexture(fbxMatInfo->texShininess, RAW_TEXTURE_USAGE_SHININESS); maybeAddTexture(fbxMatInfo->texShininess, RAW_TEXTURE_USAGE_SHININESS);
maybeAddTexture(fbxMatInfo->texAmbient, RAW_TEXTURE_USAGE_AMBIENT); maybeAddTexture(fbxMatInfo->texAmbient, RAW_TEXTURE_USAGE_AMBIENT);
maybeAddTexture(fbxMatInfo->texSpecular, RAW_TEXTURE_USAGE_SPECULAR); maybeAddTexture(fbxMatInfo->texSpecular, RAW_TEXTURE_USAGE_SPECULAR);
rawMatProps.reset(new RawTraditionalMatProps(shadingModel, rawMatProps.reset(new RawTraditionalMatProps(
toVec3f(fbxMatInfo->colAmbient), toVec4f(fbxMatInfo->colDiffuse), toVec3f(fbxMatInfo->colEmissive), shadingModel,
toVec3f(fbxMatInfo->colSpecular), fbxMatInfo->shininess)); toVec3f(fbxMatInfo->colAmbient),
toVec4f(fbxMatInfo->colDiffuse),
toVec3f(fbxMatInfo->colEmissive),
toVec3f(fbxMatInfo->colSpecular),
fbxMatInfo->shininess));
} }
} }
@ -245,15 +288,32 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
// Note that the default values here must be the same as the RawVertex default values! // Note that the default values here must be the same as the RawVertex default values!
const FbxVector4 fbxPosition = transform.MultNormalize(controlPoints[controlPointIndex]); const FbxVector4 fbxPosition = transform.MultNormalize(controlPoints[controlPointIndex]);
const FbxVector4 fbxNormal = normalLayer.GetElement( const FbxVector4 fbxNormal = normalLayer.GetElement(
polygonIndex, polygonVertexIndex, controlPointIndex, FbxVector4(0.0f, 0.0f, 0.0f, 0.0f), inverseTransposeTransform, true); polygonIndex,
polygonVertexIndex,
controlPointIndex,
FbxVector4(0.0f, 0.0f, 0.0f, 0.0f),
inverseTransposeTransform,
true);
const FbxVector4 fbxTangent = tangentLayer.GetElement( const FbxVector4 fbxTangent = tangentLayer.GetElement(
polygonIndex, polygonVertexIndex, controlPointIndex, FbxVector4(0.0f, 0.0f, 0.0f, 0.0f), inverseTransposeTransform, true); polygonIndex,
polygonVertexIndex,
controlPointIndex,
FbxVector4(0.0f, 0.0f, 0.0f, 0.0f),
inverseTransposeTransform,
true);
const FbxVector4 fbxBinormal = binormalLayer.GetElement( const FbxVector4 fbxBinormal = binormalLayer.GetElement(
polygonIndex, polygonVertexIndex, controlPointIndex, FbxVector4(0.0f, 0.0f, 0.0f, 0.0f), inverseTransposeTransform, true); polygonIndex,
const FbxColor fbxColor = colorLayer polygonVertexIndex,
.GetElement(polygonIndex, polygonVertexIndex, controlPointIndex, FbxColor(0.0f, 0.0f, 0.0f, 0.0f)); controlPointIndex,
const FbxVector2 fbxUV0 = uvLayer0.GetElement(polygonIndex, polygonVertexIndex, controlPointIndex, FbxVector2(0.0f, 0.0f)); FbxVector4(0.0f, 0.0f, 0.0f, 0.0f),
const FbxVector2 fbxUV1 = uvLayer1.GetElement(polygonIndex, polygonVertexIndex, controlPointIndex, FbxVector2(0.0f, 0.0f)); inverseTransposeTransform,
true);
const FbxColor fbxColor = colorLayer.GetElement(
polygonIndex, polygonVertexIndex, controlPointIndex, FbxColor(0.0f, 0.0f, 0.0f, 0.0f));
const FbxVector2 fbxUV0 = uvLayer0.GetElement(
polygonIndex, polygonVertexIndex, controlPointIndex, FbxVector2(0.0f, 0.0f));
const FbxVector2 fbxUV1 = uvLayer1.GetElement(
polygonIndex, polygonVertexIndex, controlPointIndex, FbxVector2(0.0f, 0.0f));
RawVertex& vertex = rawVertices[vertexIndex]; RawVertex& vertex = rawVertices[vertexIndex];
vertex.position[0] = (float)fbxPosition[0] * scaleFactor; vertex.position[0] = (float)fbxPosition[0] * scaleFactor;
@ -281,7 +341,8 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
vertex.jointWeights = skinning.GetVertexWeights(controlPointIndex); vertex.jointWeights = skinning.GetVertexWeights(controlPointIndex);
vertex.polarityUv0 = false; vertex.polarityUv0 = false;
// flag this triangle as transparent if any of its corner vertices substantially deviates from fully opaque // flag this triangle as transparent if any of its corner vertices substantially deviates from
// fully opaque
vertexTransparency |= colorLayer.LayerPresent() && (fabs(fbxColor.mAlpha - 1.0) > 1e-3); vertexTransparency |= colorLayer.LayerPresent() && (fabs(fbxColor.mAlpha - 1.0) > 1e-3);
rawSurface.bounds.AddPoint(vertex.position); rawSurface.bounds.AddPoint(vertex.position);
@ -291,16 +352,27 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
for (const auto* targetShape : targetShapes) { for (const auto* targetShape : targetShapes) {
RawBlendVertex blendVertex; RawBlendVertex blendVertex;
// the morph target data must be transformed just as with the vertex positions above // the morph target data must be transformed just as with the vertex positions above
const FbxVector4 &shapePosition = transform.MultNormalize(targetShape->positions[controlPointIndex]); const FbxVector4& shapePosition =
transform.MultNormalize(targetShape->positions[controlPointIndex]);
blendVertex.position = toVec3f(shapePosition - fbxPosition) * scaleFactor; blendVertex.position = toVec3f(shapePosition - fbxPosition) * scaleFactor;
if (targetShape->normals.LayerPresent()) { if (targetShape->normals.LayerPresent()) {
const FbxVector4& normal = targetShape->normals.GetElement( const FbxVector4& normal = targetShape->normals.GetElement(
polygonIndex, polygonVertexIndex, controlPointIndex, FbxVector4(0.0f, 0.0f, 0.0f, 0.0f), inverseTransposeTransform, true); polygonIndex,
polygonVertexIndex,
controlPointIndex,
FbxVector4(0.0f, 0.0f, 0.0f, 0.0f),
inverseTransposeTransform,
true);
blendVertex.normal = toVec3f(normal - fbxNormal); blendVertex.normal = toVec3f(normal - fbxNormal);
} }
if (targetShape->tangents.LayerPresent()) { if (targetShape->tangents.LayerPresent()) {
const FbxVector4& tangent = targetShape->tangents.GetElement( const FbxVector4& tangent = targetShape->tangents.GetElement(
polygonIndex, polygonVertexIndex, controlPointIndex, FbxVector4(0.0f, 0.0f, 0.0f, 0.0f), inverseTransposeTransform, true); polygonIndex,
polygonVertexIndex,
controlPointIndex,
FbxVector4(0.0f, 0.0f, 0.0f, 0.0f),
inverseTransposeTransform,
true);
blendVertex.tangent = toVec4f(tangent - fbxTangent); blendVertex.tangent = toVec4f(tangent - fbxTangent);
} }
vertex.blends.push_back(blendVertex); vertex.blends.push_back(blendVertex);
@ -310,18 +382,14 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
} }
if (skinning.IsSkinned()) { if (skinning.IsSkinned()) {
const int jointIndices[FbxSkinningAccess::MAX_WEIGHTS] = { const int jointIndices[FbxSkinningAccess::MAX_WEIGHTS] = {vertex.jointIndices[0],
vertex.jointIndices[0],
vertex.jointIndices[1], vertex.jointIndices[1],
vertex.jointIndices[2], vertex.jointIndices[2],
vertex.jointIndices[3] vertex.jointIndices[3]};
}; const float jointWeights[FbxSkinningAccess::MAX_WEIGHTS] = {vertex.jointWeights[0],
const float jointWeights[FbxSkinningAccess::MAX_WEIGHTS] = {
vertex.jointWeights[0],
vertex.jointWeights[1], vertex.jointWeights[1],
vertex.jointWeights[2], vertex.jointWeights[2],
vertex.jointWeights[3] vertex.jointWeights[3]};
};
const FbxMatrix skinningMatrix = const FbxMatrix skinningMatrix =
skinning.GetJointSkinningTransform(jointIndices[0]) * jointWeights[0] + skinning.GetJointSkinningTransform(jointIndices[0]) * jointWeights[0] +
skinning.GetJointSkinningTransform(jointIndices[1]) * jointWeights[1] + skinning.GetJointSkinningTransform(jointIndices[1]) * jointWeights[1] +
@ -332,7 +400,8 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
for (int i = 0; i < FbxSkinningAccess::MAX_WEIGHTS; i++) { for (int i = 0; i < FbxSkinningAccess::MAX_WEIGHTS; i++) {
if (jointWeights[i] > 0.0f) { if (jointWeights[i] > 0.0f) {
const FbxVector4 localPosition = const FbxVector4 localPosition =
skinning.GetJointInverseGlobalTransforms(jointIndices[i]).MultNormalize(globalPosition); skinning.GetJointInverseGlobalTransforms(jointIndices[i])
.MultNormalize(globalPosition);
Vec3f& mins = rawSurface.jointGeometryMins[jointIndices[i]]; Vec3f& mins = rawSurface.jointGeometryMins[jointIndices[i]];
mins[0] = std::min(mins[0], (float)localPosition[0]); mins[0] = std::min(mins[0], (float)localPosition[0]);
@ -349,8 +418,10 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
} }
if (textures[RAW_TEXTURE_USAGE_NORMAL] != -1) { if (textures[RAW_TEXTURE_USAGE_NORMAL] != -1) {
// Distinguish vertices that are used by triangles with a different texture polarity to avoid degenerate tangent space smoothing. // Distinguish vertices that are used by triangles with a different texture polarity to avoid
const bool polarity = TriangleTexturePolarity(rawVertices[0].uv0, rawVertices[1].uv0, rawVertices[2].uv0); // degenerate tangent space smoothing.
const bool polarity =
TriangleTexturePolarity(rawVertices[0].uv0, rawVertices[1].uv0, rawVertices[2].uv0);
rawVertices[0].polarityUv0 = polarity; rawVertices[0].polarityUv0 = polarity;
rawVertices[1].polarityUv0 = polarity; rawVertices[1].polarityUv0 = polarity;
rawVertices[2].polarityUv0 = polarity; rawVertices[2].polarityUv0 = polarity;
@ -361,22 +432,27 @@ static void ReadMesh(RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std:
rawVertexIndices[vertexIndex] = raw.AddVertex(rawVertices[vertexIndex]); rawVertexIndices[vertexIndex] = raw.AddVertex(rawVertices[vertexIndex]);
} }
const RawMaterialType materialType = GetMaterialType(raw, textures, vertexTransparency, skinning.IsSkinned()); const RawMaterialType materialType =
const int rawMaterialIndex = raw.AddMaterial(materialName, materialType, textures, rawMatProps, userProperties); GetMaterialType(raw, textures, vertexTransparency, skinning.IsSkinned());
const int rawMaterialIndex =
raw.AddMaterial(materialName, materialType, textures, rawMatProps, userProperties);
raw.AddTriangle(rawVertexIndices[0], rawVertexIndices[1], rawVertexIndices[2], rawMaterialIndex, rawSurfaceIndex); raw.AddTriangle(
rawVertexIndices[0],
rawVertexIndices[1],
rawVertexIndices[2],
rawMaterialIndex,
rawSurfaceIndex);
} }
} }
// ar : aspectY / aspectX // ar : aspectY / aspectX
double HFOV2VFOV(double h, double ar) double HFOV2VFOV(double h, double ar) {
{
return 2.0 * std::atan((ar)*std::tan((h * FBXSDK_PI_DIV_180) * 0.5)) * FBXSDK_180_DIV_PI; return 2.0 * std::atan((ar)*std::tan((h * FBXSDK_PI_DIV_180) * 0.5)) * FBXSDK_180_DIV_PI;
}; };
// ar : aspectX / aspectY // ar : aspectX / aspectY
double VFOV2HFOV(double v, double ar) double VFOV2HFOV(double v, double ar) {
{
return 2.0 * std::atan((ar)*std::tan((v * FBXSDK_PI_DIV_180) * 0.5)) * FBXSDK_180_DIV_PI; return 2.0 * std::atan((ar)*std::tan((v * FBXSDK_PI_DIV_180) * 0.5)) * FBXSDK_180_DIV_PI;
} }
@ -388,18 +464,20 @@ static void ReadLight(RawModel &raw, FbxScene *pScene, FbxNode *pNode) {
Vec3f color = toVec3f(pLight->Color.Get()); Vec3f color = toVec3f(pLight->Color.Get());
switch (pLight->LightType.Get()) { switch (pLight->LightType.Get()) {
case FbxLight::eDirectional: { case FbxLight::eDirectional: {
lightIx = raw.AddLight(pLight->GetName(), RAW_LIGHT_TYPE_DIRECTIONAL, lightIx = raw.AddLight(pLight->GetName(), RAW_LIGHT_TYPE_DIRECTIONAL, color, intensity, 0, 0);
color, intensity, 0, 0);
break; break;
} }
case FbxLight::ePoint: { case FbxLight::ePoint: {
lightIx = raw.AddLight(pLight->GetName(), RAW_LIGHT_TYPE_POINT, color, lightIx = raw.AddLight(pLight->GetName(), RAW_LIGHT_TYPE_POINT, color, intensity, 0, 0);
intensity, 0, 0);
break; break;
} }
case FbxLight::eSpot: { case FbxLight::eSpot: {
lightIx = raw.AddLight(pLight->GetName(), RAW_LIGHT_TYPE_SPOT, color, lightIx = raw.AddLight(
intensity, (float)pLight->InnerAngle.Get(), pLight->GetName(),
RAW_LIGHT_TYPE_SPOT,
color,
intensity,
(float)pLight->InnerAngle.Get(),
(float)pLight->OuterAngle.Get()); (float)pLight->OuterAngle.Get());
break; break;
} }
@ -415,8 +493,7 @@ static void ReadLight(RawModel &raw, FbxScene *pScene, FbxNode *pNode) {
} }
// Largely adopted from fbx example // Largely adopted from fbx example
static void ReadCamera(RawModel &raw, FbxScene *pScene, FbxNode *pNode) static void ReadCamera(RawModel& raw, FbxScene* pScene, FbxNode* pNode) {
{
const FbxCamera* pCamera = pNode->GetCamera(); const FbxCamera* pCamera = pNode->GetCamera();
double filmHeight = pCamera->GetApertureHeight(); double filmHeight = pCamera->GetApertureHeight();
@ -428,8 +505,7 @@ static void ReadCamera(RawModel &raw, FbxScene *pScene, FbxNode *pNode)
double fovx = 0.0f; double fovx = 0.0f;
double fovy = 0.0f; double fovy = 0.0f;
switch(pCamera->GetApertureMode()) switch (pCamera->GetApertureMode()) {
{
case FbxCamera::EApertureMode::eHorizAndVert: { case FbxCamera::EApertureMode::eHorizAndVert: {
fovx = pCamera->FieldOfViewX; fovx = pCamera->FieldOfViewX;
fovy = pCamera->FieldOfViewY; fovy = pCamera->FieldOfViewY;
@ -458,14 +534,21 @@ static void ReadCamera(RawModel &raw, FbxScene *pScene, FbxNode *pNode)
if (pCamera->ProjectionType.Get() == FbxCamera::EProjectionType::ePerspective) { if (pCamera->ProjectionType.Get() == FbxCamera::EProjectionType::ePerspective) {
raw.AddCameraPerspective( raw.AddCameraPerspective(
"", pNode->GetUniqueID(), (float) pCamera->FilmAspectRatio, "",
(float) fovx, (float) fovy, pNode->GetUniqueID(),
(float) pCamera->NearPlane, (float) pCamera->FarPlane); (float)pCamera->FilmAspectRatio,
(float)fovx,
(float)fovy,
(float)pCamera->NearPlane,
(float)pCamera->FarPlane);
} else { } else {
raw.AddCameraOrthographic( raw.AddCameraOrthographic(
"", pNode->GetUniqueID(), "",
(float) pCamera->OrthoZoom, (float) pCamera->OrthoZoom, pNode->GetUniqueID(),
(float) pCamera->FarPlane, (float) pCamera->NearPlane); (float)pCamera->OrthoZoom,
(float)pCamera->OrthoZoom,
(float)pCamera->FarPlane,
(float)pCamera->NearPlane);
} }
// Cameras in FBX coordinate space face +X when rotation is (0,0,0) // Cameras in FBX coordinate space face +X when rotation is (0,0,0)
@ -477,8 +560,7 @@ static void ReadCamera(RawModel &raw, FbxScene *pScene, FbxNode *pNode)
rawNode.rotation = rawNode.rotation * r; rawNode.rotation = rawNode.rotation * r;
} }
static void ReadNodeProperty(RawModel &raw, FbxNode *pNode, FbxProperty &prop) static void ReadNodeProperty(RawModel& raw, FbxNode* pNode, FbxProperty& prop) {
{
int nodeId = raw.GetNodeById(pNode->GetUniqueID()); int nodeId = raw.GetNodeById(pNode->GetUniqueID());
if (nodeId >= 0) { if (nodeId >= 0) {
RawNode& node = raw.GetNode(nodeId); RawNode& node = raw.GetNode(nodeId);
@ -487,16 +569,17 @@ static void ReadNodeProperty(RawModel &raw, FbxNode *pNode, FbxProperty &prop)
} }
static void ReadNodeAttributes( static void ReadNodeAttributes(
RawModel &raw, FbxScene *pScene, FbxNode *pNode, const std::map<const FbxTexture *, FbxString> &textureLocations) RawModel& raw,
{ FbxScene* pScene,
FbxNode* pNode,
const std::map<const FbxTexture*, FbxString>& textureLocations) {
if (!pNode->GetVisibility()) { if (!pNode->GetVisibility()) {
return; return;
} }
// Only support non-animated user defined properties for now // Only support non-animated user defined properties for now
FbxProperty objectProperty = pNode->GetFirstProperty(); FbxProperty objectProperty = pNode->GetFirstProperty();
while (objectProperty.IsValid()) while (objectProperty.IsValid()) {
{
if (objectProperty.GetFlag(FbxPropertyFlags::eUserDefined)) { if (objectProperty.GetFlag(FbxPropertyFlags::eUserDefined)) {
ReadNodeProperty(raw, pNode, objectProperty); ReadNodeProperty(raw, pNode, objectProperty);
} }
@ -552,25 +635,26 @@ static void ReadNodeAttributes(
* Compute the local scale vector to use for a given node. This is an imperfect hack to cope with * Compute the local scale vector to use for a given node. This is an imperfect hack to cope with
* the FBX node transform's eInheritRrs inheritance type, in which ancestral scale is ignored * the FBX node transform's eInheritRrs inheritance type, in which ancestral scale is ignored
*/ */
static FbxVector4 computeLocalScale(FbxNode *pNode, FbxTime pTime = FBXSDK_TIME_INFINITE) static FbxVector4 computeLocalScale(FbxNode* pNode, FbxTime pTime = FBXSDK_TIME_INFINITE) {
{
const FbxVector4 lScale = pNode->EvaluateLocalTransform(pTime).GetS(); const FbxVector4 lScale = pNode->EvaluateLocalTransform(pTime).GetS();
if (pNode->GetParent() == nullptr || if (pNode->GetParent() == nullptr ||
pNode->GetTransform().GetInheritType() != FbxTransform::eInheritRrs) { pNode->GetTransform().GetInheritType() != FbxTransform::eInheritRrs) {
return lScale; return lScale;
} }
// This is a very partial fix that is only correct for models that use identity scale in their rig's joints. // This is a very partial fix that is only correct for models that use identity scale in their
// We could write better support that compares local scale to parent's global scale and apply the ratio to // rig's joints. We could write better support that compares local scale to parent's global scale
// our local translation. We'll always want to return scale 1, though -- that's the only way to encode the // and apply the ratio to our local translation. We'll always want to return scale 1, though --
// missing 'S' (parent scale) in the transform chain. // that's the only way to encode the missing 'S' (parent scale) in the transform chain.
return FbxVector4(1, 1, 1, 1); return FbxVector4(1, 1, 1, 1);
} }
static void ReadNodeHierarchy( static void ReadNodeHierarchy(
RawModel &raw, FbxScene *pScene, FbxNode *pNode, RawModel& raw,
const long parentId, const std::string &path) FbxScene* pScene,
{ FbxNode* pNode,
const long parentId,
const std::string& path) {
const FbxUInt64 nodeId = pNode->GetUniqueID(); const FbxUInt64 nodeId = pNode->GetUniqueID();
const char* nodeName = pNode->GetName(); const char* nodeName = pNode->GetName();
const int nodeIndex = raw.AddNode(nodeId, nodeName, parentId); const int nodeIndex = raw.AddNode(nodeId, nodeName, parentId);
@ -588,7 +672,9 @@ static void ReadNodeHierarchy(
static int warnRrsCount = 0; static int warnRrsCount = 0;
if (lInheritType == FbxTransform::eInheritRrSs && parentId) { if (lInheritType == FbxTransform::eInheritRrSs && parentId) {
if (++warnRrSsCount == 1) { if (++warnRrSsCount == 1) {
fmt::printf("Warning: node %s uses unsupported transform inheritance type 'eInheritRrSs'.\n", newPath); fmt::printf(
"Warning: node %s uses unsupported transform inheritance type 'eInheritRrSs'.\n",
newPath);
fmt::printf(" (Further warnings of this type squelched.)\n"); fmt::printf(" (Further warnings of this type squelched.)\n");
} }
@ -616,7 +702,8 @@ static void ReadNodeHierarchy(
if (parentId) { if (parentId) {
RawNode& parentNode = raw.GetNode(raw.GetNodeById(parentId)); RawNode& parentNode = raw.GetNode(raw.GetNodeById(parentId));
// Add unique child name to the parent node. // Add unique child name to the parent node.
if (std::find(parentNode.childIds.begin(), parentNode.childIds.end(), nodeId) == parentNode.childIds.end()) { if (std::find(parentNode.childIds.begin(), parentNode.childIds.end(), nodeId) ==
parentNode.childIds.end()) {
parentNode.childIds.push_back(nodeId); parentNode.childIds.push_back(nodeId);
} }
} else { } else {
@ -629,8 +716,7 @@ static void ReadNodeHierarchy(
} }
} }
static void ReadAnimations(RawModel &raw, FbxScene *pScene) static void ReadAnimations(RawModel& raw, FbxScene* pScene) {
{
FbxTime::EMode eMode = FbxTime::eFrames24; FbxTime::EMode eMode = FbxTime::eFrames24;
const double epsilon = 1e-5f; const double epsilon = 1e-5f;
@ -692,17 +778,17 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene)
const FbxQuaternion localRotation = localTransform.GetQ(); const FbxQuaternion localRotation = localTransform.GetQ();
const FbxVector4 localScale = computeLocalScale(pNode, pTime); const FbxVector4 localScale = computeLocalScale(pNode, pTime);
hasTranslation |= ( hasTranslation |=
fabs(localTranslation[0] - baseTranslation[0]) > epsilon || (fabs(localTranslation[0] - baseTranslation[0]) > epsilon ||
fabs(localTranslation[1] - baseTranslation[1]) > epsilon || fabs(localTranslation[1] - baseTranslation[1]) > epsilon ||
fabs(localTranslation[2] - baseTranslation[2]) > epsilon); fabs(localTranslation[2] - baseTranslation[2]) > epsilon);
hasRotation |= ( hasRotation |=
fabs(localRotation[0] - baseRotation[0]) > epsilon || (fabs(localRotation[0] - baseRotation[0]) > epsilon ||
fabs(localRotation[1] - baseRotation[1]) > epsilon || fabs(localRotation[1] - baseRotation[1]) > epsilon ||
fabs(localRotation[2] - baseRotation[2]) > epsilon || fabs(localRotation[2] - baseRotation[2]) > epsilon ||
fabs(localRotation[3] - baseRotation[3]) > epsilon); fabs(localRotation[3] - baseRotation[3]) > epsilon);
hasScale |= ( hasScale |=
fabs(localScale[0] - baseScaling[0]) > epsilon || (fabs(localScale[0] - baseScaling[0]) > epsilon ||
fabs(localScale[1] - baseScaling[1]) > epsilon || fabs(localScale[1] - baseScaling[1]) > epsilon ||
fabs(localScale[2] - baseScaling[2]) > epsilon); fabs(localScale[2] - baseScaling[2]) > epsilon);
@ -714,7 +800,8 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene)
std::vector<FbxAnimCurve*> shapeAnimCurves; std::vector<FbxAnimCurve*> shapeAnimCurves;
FbxNodeAttribute* nodeAttr = pNode->GetNodeAttribute(); FbxNodeAttribute* nodeAttr = pNode->GetNodeAttribute();
if (nodeAttr != nullptr && nodeAttr->GetAttributeType() == FbxNodeAttribute::EType::eMesh) { 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... // it's inelegant to recreate this same access class multiple times, but it's also dirt
// cheap...
FbxBlendShapesAccess blendShapes(static_cast<FbxMesh*>(nodeAttr)); FbxBlendShapesAccess blendShapes(static_cast<FbxMesh*>(nodeAttr));
for (FbxLongLong frameIndex = firstFrameIndex; frameIndex <= lastFrameIndex; frameIndex++) { for (FbxLongLong frameIndex = firstFrameIndex; frameIndex <= lastFrameIndex; frameIndex++) {
@ -728,8 +815,8 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene)
int targetCount = static_cast<int>(blendShapes.GetTargetShapeCount(channelIx)); int targetCount = static_cast<int>(blendShapes.GetTargetShapeCount(channelIx));
// the target shape 'fullWeight' values are a strictly ascending list of floats (between // 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 // 0 and 100), forming a sequence of intervals -- this convenience function figures out
// 'p' lays between some certain target fullWeights, and if so where (from 0 to 1). // if 'p' lays between some certain target fullWeights, and if so where (from 0 to 1).
auto findInInterval = [&](const double p, const int n) { auto findInInterval = [&](const double p, const int n) {
if (n >= targetCount) { if (n >= targetCount) {
// p is certainly completely left of this interval // p is certainly completely left of this interval
@ -772,8 +859,8 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene)
} }
} }
// this is here because we have to fill in a weight for every channelIx/targetIx permutation, // this is here because we have to fill in a weight for every channelIx/targetIx
// regardless of whether or not they participate in this animation. // permutation, regardless of whether or not they participate in this animation.
channel.weights.push_back(0.0f); channel.weights.push_back(0.0f);
} }
} }
@ -803,7 +890,11 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene)
} }
if (verboseOutput) { if (verboseOutput) {
fmt::printf("\ranimation %d: %s (%d%%)", animIx, (const char *) animStackName, nodeIndex * 100 / nodeCount); fmt::printf(
"\ranimation %d: %s (%d%%)",
animIx,
(const char*)animStackName,
nodeIndex * 100 / nodeCount);
} }
} }
@ -811,19 +902,25 @@ static void ReadAnimations(RawModel &raw, FbxScene *pScene)
if (verboseOutput) { if (verboseOutput) {
fmt::printf( fmt::printf(
"\ranimation %d: %s (%d channels, %3.1f MB)\n", animIx, (const char *) animStackName, "\ranimation %d: %s (%d channels, %3.1f MB)\n",
(int) animation.channels.size(), (float) totalSizeInBytes * 1e-6f); animIx,
(const char*)animStackName,
(int)animation.channels.size(),
(float)totalSizeInBytes * 1e-6f);
} }
} }
} }
static std::string GetInferredFileName(const std::string &fbxFileName, const std::string &directory, const std::vector<std::string> &directoryFileList) static std::string GetInferredFileName(
{ const std::string& fbxFileName,
const std::string& directory,
const std::vector<std::string>& directoryFileList) {
if (FileUtils::FileExists(fbxFileName)) { if (FileUtils::FileExists(fbxFileName)) {
return fbxFileName; return fbxFileName;
} }
// Get the file name with file extension. // Get the file name with file extension.
const std::string fileName = StringUtils::GetFileNameString(StringUtils::GetCleanPathString(fbxFileName)); const std::string fileName =
StringUtils::GetFileNameString(StringUtils::GetCleanPathString(fbxFileName));
// Try to find a match with extension. // Try to find a match with extension.
for (const auto& file : directoryFileList) { for (const auto& file : directoryFileList) {
@ -856,10 +953,11 @@ static std::string GetInferredFileName(const std::string &fbxFileName, const std
path on the author's computer such as "C:\MyProject\TextureName.psd", and matches path on the author's computer such as "C:\MyProject\TextureName.psd", and matches
it to a list of existing texture files in the same directory as the FBX file. it to a list of existing texture files in the same directory as the FBX file.
*/ */
static void static void FindFbxTextures(
FindFbxTextures( FbxScene* pScene,
FbxScene *pScene, const char *fbxFileName, const char *extensions, std::map<const FbxTexture *, FbxString> &textureLocations) const char* fbxFileName,
{ const char* extensions,
std::map<const FbxTexture*, FbxString>& textureLocations) {
// Get the folder the FBX file is in. // Get the folder the FBX file is in.
const std::string folder = StringUtils::GetFolderString(fbxFileName); const std::string folder = StringUtils::GetFolderString(fbxFileName);
@ -869,7 +967,8 @@ FindFbxTextures(
// Search either in the folder with embedded textures or in the same folder as the FBX file. // Search either in the folder with embedded textures or in the same folder as the FBX file.
const std::string searchFolder = FileUtils::FolderExists(fbmFolderName) ? fbmFolderName : folder; const std::string searchFolder = FileUtils::FolderExists(fbmFolderName) ? fbmFolderName : folder;
// Get a list with all the texture files from either the folder with embedded textures or the same folder as the FBX file. // Get a list with all the texture files from either the folder with embedded textures or the same
// folder as the FBX file.
std::vector<std::string> fileList = FileUtils::ListFolderFiles(searchFolder.c_str(), extensions); std::vector<std::string> fileList = FileUtils::ListFolderFiles(searchFolder.c_str(), extensions);
// Try to match the FBX texture names with the actual files on disk. // Try to match the FBX texture names with the actual files on disk.
@ -878,18 +977,21 @@ FindFbxTextures(
if (pFileTexture == nullptr) { if (pFileTexture == nullptr) {
continue; continue;
} }
const std::string inferredName = GetInferredFileName(pFileTexture->GetFileName(), searchFolder, fileList); const std::string inferredName =
GetInferredFileName(pFileTexture->GetFileName(), searchFolder, fileList);
if (inferredName.empty()) { if (inferredName.empty()) {
fmt::printf("Warning: could not find a local image file for texture: %s.\n" fmt::printf(
"Original filename: %s\n", pFileTexture->GetName(), pFileTexture->GetFileName()); "Warning: could not find a local image file for texture: %s.\n"
"Original filename: %s\n",
pFileTexture->GetName(),
pFileTexture->GetFileName());
} }
// always extend the mapping, even for files we didn't find // always extend the mapping, even for files we didn't find
textureLocations.emplace(pFileTexture, inferredName.c_str()); textureLocations.emplace(pFileTexture, inferredName.c_str());
} }
} }
bool LoadFBXFile(RawModel &raw, const char *fbxFileName, const char *textureExtensions) bool LoadFBXFile(RawModel& raw, const char* fbxFileName, const char* textureExtensions) {
{
FbxManager* pManager = FbxManager::Create(); FbxManager* pManager = FbxManager::Create();
FbxIOSettings* pIoSettings = FbxIOSettings::Create(pManager, IOSROOT); FbxIOSettings* pIoSettings = FbxIOSettings::Create(pManager, IOSROOT);
pManager->SetIOSettings(pIoSettings); pManager->SetIOSettings(pIoSettings);
@ -944,37 +1046,68 @@ bool LoadFBXFile(RawModel &raw, const char *fbxFileName, const char *textureExte
} }
// convenience method for describing a property in JSON // convenience method for describing a property in JSON
json TranscribeProperty(FbxProperty &prop) json TranscribeProperty(FbxProperty& prop) {
{
using fbxsdk::EFbxType; using fbxsdk::EFbxType;
std::string ename; std::string ename;
// Convert property type // Convert property type
switch (prop.GetPropertyDataType().GetType()) { switch (prop.GetPropertyDataType().GetType()) {
case eFbxBool: ename = "eFbxBool"; break; case eFbxBool:
case eFbxChar: ename = "eFbxChar"; break; ename = "eFbxBool";
case eFbxUChar: ename = "eFbxUChar"; break; break;
case eFbxShort: ename = "eFbxShort"; break; case eFbxChar:
case eFbxUShort: ename = "eFbxUShort"; break; ename = "eFbxChar";
case eFbxInt: ename = "eFbxInt"; break; break;
case eFbxUInt: ename = "eFbxUint"; break; case eFbxUChar:
case eFbxLongLong: ename = "eFbxLongLong"; break; ename = "eFbxUChar";
case eFbxULongLong: ename = "eFbxULongLong"; break; break;
case eFbxFloat: ename = "eFbxFloat"; break; case eFbxShort:
case eFbxHalfFloat: ename = "eFbxHalfFloat"; break; ename = "eFbxShort";
case eFbxDouble: ename = "eFbxDouble"; break; break;
case eFbxDouble2: ename = "eFbxDouble2"; break; case eFbxUShort:
case eFbxDouble3: ename = "eFbxDouble3"; break; ename = "eFbxUShort";
case eFbxDouble4: ename = "eFbxDouble4"; break; break;
case eFbxString: ename = "eFbxString"; break; case eFbxInt:
ename = "eFbxInt";
break;
case eFbxUInt:
ename = "eFbxUint";
break;
case eFbxLongLong:
ename = "eFbxLongLong";
break;
case eFbxULongLong:
ename = "eFbxULongLong";
break;
case eFbxFloat:
ename = "eFbxFloat";
break;
case eFbxHalfFloat:
ename = "eFbxHalfFloat";
break;
case eFbxDouble:
ename = "eFbxDouble";
break;
case eFbxDouble2:
ename = "eFbxDouble2";
break;
case eFbxDouble3:
ename = "eFbxDouble3";
break;
case eFbxDouble4:
ename = "eFbxDouble4";
break;
case eFbxString:
ename = "eFbxString";
break;
// Use this as fallback because it does not give very descriptive names // Use this as fallback because it does not give very descriptive names
default: ename = prop.GetPropertyDataType().GetName(); break; default:
ename = prop.GetPropertyDataType().GetName();
break;
} }
json p = { json p = {{"type", ename}};
{"type", ename}
};
// Convert property value // Convert property value
switch (prop.GetPropertyDataType().GetType()) { switch (prop.GetPropertyDataType().GetType()) {
@ -1024,8 +1157,5 @@ json TranscribeProperty(FbxProperty &prop)
} }
} }
return { return {{prop.GetNameAsCStr(), p}};
{prop.GetNameAsCStr(), p}
};
} }

38
src/fbx/FbxBlendShapesAccess.cpp
View File

@ -9,37 +9,44 @@
#include "FbxBlendShapesAccess.hpp" #include "FbxBlendShapesAccess.hpp"
FbxBlendShapesAccess::TargetShape::TargetShape(const FbxShape *shape, FbxDouble fullWeight) : FbxBlendShapesAccess::TargetShape::TargetShape(const FbxShape* shape, FbxDouble fullWeight)
shape(shape), : shape(shape),
fullWeight(fullWeight), fullWeight(fullWeight),
count(shape->GetControlPointsCount()), count(shape->GetControlPointsCount()),
positions(shape->GetControlPoints()), positions(shape->GetControlPoints()),
normals(FbxLayerElementAccess<FbxVector4>(shape->GetElementNormal(), shape->GetElementNormalCount())), normals(FbxLayerElementAccess<FbxVector4>(
tangents(FbxLayerElementAccess<FbxVector4>(shape->GetElementTangent(), shape->GetElementTangentCount())) shape->GetElementNormal(),
{} shape->GetElementNormalCount())),
tangents(FbxLayerElementAccess<FbxVector4>(
shape->GetElementTangent(),
shape->GetElementTangentCount())) {}
FbxAnimCurve *FbxBlendShapesAccess::BlendChannel::ExtractAnimation(unsigned int animIx) const FbxAnimCurve* FbxBlendShapesAccess::BlendChannel::ExtractAnimation(unsigned int animIx) const {
{
FbxAnimStack* stack = mesh->GetScene()->GetSrcObject<FbxAnimStack>(animIx); FbxAnimStack* stack = mesh->GetScene()->GetSrcObject<FbxAnimStack>(animIx);
FbxAnimLayer* layer = stack->GetMember<FbxAnimLayer>(0); FbxAnimLayer* layer = stack->GetMember<FbxAnimLayer>(0);
return mesh->GetShapeChannel(blendShapeIx, channelIx, layer, true); return mesh->GetShapeChannel(blendShapeIx, channelIx, layer, true);
} }
FbxBlendShapesAccess::BlendChannel::BlendChannel( FbxBlendShapesAccess::BlendChannel::BlendChannel(
FbxMesh *mesh, const unsigned int blendShapeIx, const unsigned int channelIx, const FbxDouble deformPercent, FbxMesh* mesh,
const std::vector<FbxBlendShapesAccess::TargetShape> &targetShapes, std::string name) : mesh(mesh), const unsigned int blendShapeIx,
const unsigned int channelIx,
const FbxDouble deformPercent,
const std::vector<FbxBlendShapesAccess::TargetShape>& targetShapes,
std::string name)
: mesh(mesh),
blendShapeIx(blendShapeIx), blendShapeIx(blendShapeIx),
channelIx(channelIx), channelIx(channelIx),
deformPercent(deformPercent), deformPercent(deformPercent),
targetShapes(targetShapes), targetShapes(targetShapes),
name(name) name(name) {}
{}
std::vector<FbxBlendShapesAccess::BlendChannel> FbxBlendShapesAccess::extractChannels(FbxMesh *mesh) const std::vector<FbxBlendShapesAccess::BlendChannel> FbxBlendShapesAccess::extractChannels(
{ FbxMesh* mesh) const {
std::vector<BlendChannel> channels; std::vector<BlendChannel> channels;
for (int shapeIx = 0; shapeIx < mesh->GetDeformerCount(FbxDeformer::eBlendShape); shapeIx++) { for (int shapeIx = 0; shapeIx < mesh->GetDeformerCount(FbxDeformer::eBlendShape); shapeIx++) {
auto *fbxBlendShape = static_cast<FbxBlendShape *>(mesh->GetDeformer(shapeIx, FbxDeformer::eBlendShape)); auto* fbxBlendShape =
static_cast<FbxBlendShape*>(mesh->GetDeformer(shapeIx, FbxDeformer::eBlendShape));
for (int channelIx = 0; channelIx < fbxBlendShape->GetBlendShapeChannelCount(); ++channelIx) { for (int channelIx = 0; channelIx < fbxBlendShape->GetBlendShapeChannelCount(); ++channelIx) {
FbxBlendShapeChannel* fbxChannel = fbxBlendShape->GetBlendShapeChannel(channelIx); FbxBlendShapeChannel* fbxChannel = fbxBlendShape->GetBlendShapeChannel(channelIx);
@ -57,7 +64,8 @@ std::vector<FbxBlendShapesAccess::BlendChannel> FbxBlendShapesAccess::extractCha
FbxShape* fbxShape = fbxChannel->GetTargetShape(targetIx); FbxShape* fbxShape = fbxChannel->GetTargetShape(targetIx);
targetShapes.emplace_back(fbxShape, fullWeights[targetIx]); targetShapes.emplace_back(fbxShape, fullWeights[targetIx]);
} }
channels.emplace_back(mesh, shapeIx, channelIx, fbxChannel->DeformPercent * 0.01, targetShapes, name); channels.emplace_back(
mesh, shapeIx, channelIx, fbxChannel->DeformPercent * 0.01, targetShapes, name);
} }
} }
} }

58
src/fbx/FbxBlendShapesAccess.hpp
View File

@ -9,41 +9,41 @@
#pragma once #pragma once
#include <algorithm>
#include <fstream> #include <fstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <algorithm>
#include "FBX2glTF.h" #include "FBX2glTF.h"
#include "FbxLayerElementAccess.hpp" #include "FbxLayerElementAccess.hpp"
/** /**
* At the FBX level, each Mesh can have a set of FbxBlendShape deformers; organisational units that contain no data * At the FBX level, each Mesh can have a set of FbxBlendShape deformers; organisational units that
* of their own. The actual deformation is determined by one or more FbxBlendShapeChannels, whose influences are all * contain no data of their own. The actual deformation is determined by one or more
* additively applied to the mesh. In a simpler world, each such channel would extend each base vertex with alternate * FbxBlendShapeChannels, whose influences are all additively applied to the mesh. In a simpler
* position, and optionally normal and tangent. * 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 * It's not quite so simple, though. We also have progressive morphing, where one logical morph
* several concrete ones, each applied in sequence. For us, this means each channel contains a sequence of FbxShapes * actually consists of several concrete ones, each applied in sequence. For us, this means each
* (aka target shape); these are the actual data-holding entities that provide the alternate vertex attributes. As such * channel contains a sequence of FbxShapes (aka target shape); these are the actual data-holding
* a channel is given more weight, it moves from one target shape to another. * 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 * The total number of alternate sets of attributes, then, is the total number of target shapes
* of all the blend shapes of the mesh. * 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 * Each animation in the scene stack can yield one or zero FbxAnimCurves per channel (not target
* these curves to get the weight of the channel: this weight is further introspected on to figure out which target * shape). We evaluate these curves to get the weight of the channel: this weight is further
* shapes we're currently interpolation between. * introspected on to figure out which target shapes we're currently interpolation between.
*/ */
class FbxBlendShapesAccess class FbxBlendShapesAccess {
{
public: public:
/** /**
* A target shape is on a 1:1 basis with the eventual glTF morph target, and is the object which contains the * A target shape is on a 1:1 basis with the eventual glTF morph target, and is the object which
* actual morphed vertex data. * contains the actual morphed vertex data.
*/ */
struct TargetShape struct TargetShape {
{
explicit TargetShape(const FbxShape* shape, FbxDouble fullWeight); explicit TargetShape(const FbxShape* shape, FbxDouble fullWeight);
const FbxShape* shape; const FbxShape* shape;
@ -57,16 +57,14 @@ public:
/** /**
* A channel collects a sequence (often of length 1) of target shapes. * A channel collects a sequence (often of length 1) of target shapes.
*/ */
struct BlendChannel struct BlendChannel {
{
BlendChannel( BlendChannel(
FbxMesh* mesh, FbxMesh* mesh,
const unsigned int blendShapeIx, const unsigned int blendShapeIx,
const unsigned int channelIx, const unsigned int channelIx,
const FbxDouble deformPercent, const FbxDouble deformPercent,
const std::vector<TargetShape>& targetShapes, const std::vector<TargetShape>& targetShapes,
const std::string name const std::string name);
);
FbxAnimCurve* ExtractAnimation(unsigned int animIx) const; FbxAnimCurve* ExtractAnimation(unsigned int animIx) const;
@ -80,16 +78,18 @@ public:
const FbxDouble deformPercent; const FbxDouble deformPercent;
}; };
explicit FbxBlendShapesAccess(FbxMesh *mesh) : explicit FbxBlendShapesAccess(FbxMesh* mesh) : channels(extractChannels(mesh)) {}
channels(extractChannels(mesh))
{ }
size_t GetChannelCount() const { return channels.size(); } size_t GetChannelCount() const {
return channels.size();
}
const BlendChannel& GetBlendChannel(size_t channelIx) const { const BlendChannel& GetBlendChannel(size_t channelIx) const {
return channels.at(channelIx); return channels.at(channelIx);
} }
size_t GetTargetShapeCount(size_t channelIx) const { return channels[channelIx].targetShapes.size(); } size_t GetTargetShapeCount(size_t channelIx) const {
return channels[channelIx].targetShapes.size();
}
const TargetShape& GetTargetShape(size_t channelIx, size_t targetShapeIx) const { const TargetShape& GetTargetShape(size_t channelIx, size_t targetShapeIx) const {
return channels.at(channelIx).targetShapes[targetShapeIx]; return channels.at(channelIx).targetShapes[targetShapeIx];
} }

60
src/fbx/FbxLayerElementAccess.hpp
View File

@ -10,21 +10,26 @@
#include "FBX2glTF.h" #include "FBX2glTF.h"
template <typename _type_> template <typename _type_>
class FbxLayerElementAccess class FbxLayerElementAccess {
{
public: public:
FbxLayerElementAccess(const FbxLayerElementTemplate<_type_>* layer, int count); FbxLayerElementAccess(const FbxLayerElementTemplate<_type_>* layer, int count);
bool LayerPresent() const bool LayerPresent() const {
{
return (mappingMode != FbxLayerElement::eNone); return (mappingMode != FbxLayerElement::eNone);
} }
_type_ GetElement(const int polygonIndex, const int polygonVertexIndex, const int controlPointIndex, const _type_ defaultValue) const;
_type_ GetElement( _type_ GetElement(
const int polygonIndex, const int polygonVertexIndex, const int controlPointIndex, const _type_ defaultValue, const int polygonIndex,
const FbxMatrix &transform, const bool normalize) const; const int polygonVertexIndex,
const int controlPointIndex,
const _type_ defaultValue) const;
_type_ GetElement(
const int polygonIndex,
const int polygonVertexIndex,
const int controlPointIndex,
const _type_ defaultValue,
const FbxMatrix& transform,
const bool normalize) const;
private: private:
FbxLayerElement::EMappingMode mappingMode; FbxLayerElement::EMappingMode mappingMode;
@ -33,11 +38,10 @@ private:
}; };
template <typename _type_> template <typename _type_>
FbxLayerElementAccess<_type_>::FbxLayerElementAccess(const FbxLayerElementTemplate<_type_> *layer, int count) : FbxLayerElementAccess<_type_>::FbxLayerElementAccess(
mappingMode(FbxLayerElement::eNone), const FbxLayerElementTemplate<_type_>* layer,
elements(nullptr), int count)
indices(nullptr) : mappingMode(FbxLayerElement::eNone), elements(nullptr), indices(nullptr) {
{
if (count <= 0 || layer == nullptr) { if (count <= 0 || layer == nullptr) {
return; return;
} }
@ -47,19 +51,23 @@ FbxLayerElementAccess<_type_>::FbxLayerElementAccess(const FbxLayerElementTempla
newMappingMode == FbxLayerElement::eByPolygon) { newMappingMode == FbxLayerElement::eByPolygon) {
mappingMode = newMappingMode; mappingMode = newMappingMode;
elements = &layer->GetDirectArray(); elements = &layer->GetDirectArray();
indices = ( indices = (layer->GetReferenceMode() == FbxLayerElement::eIndexToDirect ||
layer->GetReferenceMode() == FbxLayerElement::eIndexToDirect || layer->GetReferenceMode() == FbxLayerElement::eIndex)
layer->GetReferenceMode() == FbxLayerElement::eIndex) ? &layer->GetIndexArray() : nullptr; ? &layer->GetIndexArray()
: nullptr;
} }
} }
template <typename _type_> template <typename _type_>
_type_ FbxLayerElementAccess<_type_>::GetElement( _type_ FbxLayerElementAccess<_type_>::GetElement(
const int polygonIndex, const int polygonVertexIndex, const int controlPointIndex, const _type_ defaultValue) const const int polygonIndex,
{ const int polygonVertexIndex,
const int controlPointIndex,
const _type_ defaultValue) const {
if (mappingMode != FbxLayerElement::eNone) { if (mappingMode != FbxLayerElement::eNone) {
int index = (mappingMode == FbxLayerElement::eByControlPoint) ? controlPointIndex : int index = (mappingMode == FbxLayerElement::eByControlPoint)
((mappingMode == FbxLayerElement::eByPolygonVertex) ? polygonVertexIndex : polygonIndex); ? controlPointIndex
: ((mappingMode == FbxLayerElement::eByPolygonVertex) ? polygonVertexIndex : polygonIndex);
index = (indices != nullptr) ? (*indices)[index] : index; index = (indices != nullptr) ? (*indices)[index] : index;
_type_ element = elements->GetAt(index); _type_ element = elements->GetAt(index);
return element; return element;
@ -69,11 +77,15 @@ _type_ FbxLayerElementAccess<_type_>::GetElement(
template <typename _type_> template <typename _type_>
_type_ FbxLayerElementAccess<_type_>::GetElement( _type_ FbxLayerElementAccess<_type_>::GetElement(
const int polygonIndex, const int polygonVertexIndex, const int controlPointIndex, const _type_ defaultValue, const int polygonIndex,
const FbxMatrix &transform, const bool normalize) const const int polygonVertexIndex,
{ const int controlPointIndex,
const _type_ defaultValue,
const FbxMatrix& transform,
const bool normalize) const {
if (mappingMode != FbxLayerElement::eNone) { if (mappingMode != FbxLayerElement::eNone) {
_type_ element = transform.MultNormalize(GetElement(polygonIndex, polygonVertexIndex, controlPointIndex, defaultValue)); _type_ element = transform.MultNormalize(
GetElement(polygonIndex, polygonVertexIndex, controlPointIndex, defaultValue));
if (normalize) { if (normalize) {
element.Normalize(); element.Normalize();
} }

3
src/fbx/FbxMaterialInfo.hpp
View File

@ -14,8 +14,7 @@
class FbxMaterialInfo { class FbxMaterialInfo {
public: public:
FbxMaterialInfo(const FbxString& name, const FbxString& shadingModel) FbxMaterialInfo(const FbxString& name, const FbxString& shadingModel)
: name(name), : name(name), shadingModel(shadingModel) {}
shadingModel(shadingModel) {}
const FbxString name; const FbxString name;
const FbxString shadingModel; const FbxString shadingModel;

48
src/fbx/FbxMaterialsAccess.cpp
View File

@ -10,21 +10,23 @@
#include "FbxMaterialsAccess.hpp" #include "FbxMaterialsAccess.hpp"
#include "Fbx2Raw.hpp" #include "Fbx2Raw.hpp"
FbxMaterialsAccess::FbxMaterialsAccess(const FbxMesh *pMesh, const std::map<const FbxTexture *, FbxString> &textureLocations) : FbxMaterialsAccess::FbxMaterialsAccess(
mappingMode(FbxGeometryElement::eNone), const FbxMesh* pMesh,
mesh(nullptr), const std::map<const FbxTexture*, FbxString>& textureLocations)
indices(nullptr) : mappingMode(FbxGeometryElement::eNone), mesh(nullptr), indices(nullptr) {
{
if (pMesh->GetElementMaterialCount() <= 0) { if (pMesh->GetElementMaterialCount() <= 0) {
return; return;
} }
const FbxGeometryElement::EMappingMode materialMappingMode = pMesh->GetElementMaterial()->GetMappingMode(); const FbxGeometryElement::EMappingMode materialMappingMode =
if (materialMappingMode != FbxGeometryElement::eByPolygon && materialMappingMode != FbxGeometryElement::eAllSame) { pMesh->GetElementMaterial()->GetMappingMode();
if (materialMappingMode != FbxGeometryElement::eByPolygon &&
materialMappingMode != FbxGeometryElement::eAllSame) {
return; return;
} }
const FbxGeometryElement::EReferenceMode materialReferenceMode = pMesh->GetElementMaterial()->GetReferenceMode(); const FbxGeometryElement::EReferenceMode materialReferenceMode =
pMesh->GetElementMaterial()->GetReferenceMode();
if (materialReferenceMode != FbxGeometryElement::eIndexToDirect) { if (materialReferenceMode != FbxGeometryElement::eIndexToDirect) {
return; return;
} }
@ -39,16 +41,15 @@ FbxMaterialsAccess::FbxMaterialsAccess(const FbxMesh *pMesh, const std::map<cons
continue; continue;
} }
FbxSurfaceMaterial* surfaceMaterial = mesh->GetNode()->GetSrcObject<FbxSurfaceMaterial>(materialNum); FbxSurfaceMaterial* surfaceMaterial =
mesh->GetNode()->GetSrcObject<FbxSurfaceMaterial>(materialNum);
if (materialNum >= summaries.size()) { if (materialNum >= summaries.size()) {
summaries.resize(materialNum + 1); summaries.resize(materialNum + 1);
} }
auto summary = summaries[materialNum]; auto summary = summaries[materialNum];
if (summary == nullptr) { if (summary == nullptr) {
summary = summaries[materialNum] = GetMaterialInfo( summary = summaries[materialNum] = GetMaterialInfo(surfaceMaterial, textureLocations);
surfaceMaterial,
textureLocations);
} }
if (materialNum >= userProperties.size()) { if (materialNum >= userProperties.size()) {
@ -56,8 +57,7 @@ FbxMaterialsAccess::FbxMaterialsAccess(const FbxMesh *pMesh, const std::map<cons
} }
if (userProperties[materialNum].empty()) { if (userProperties[materialNum].empty()) {
FbxProperty objectProperty = surfaceMaterial->GetFirstProperty(); FbxProperty objectProperty = surfaceMaterial->GetFirstProperty();
while (objectProperty.IsValid()) while (objectProperty.IsValid()) {
{
if (objectProperty.GetFlag(FbxPropertyFlags::eUserDefined)) { if (objectProperty.GetFlag(FbxPropertyFlags::eUserDefined)) {
userProperties[materialNum].push_back(TranscribeProperty(objectProperty).dump()); userProperties[materialNum].push_back(TranscribeProperty(objectProperty).dump());
} }
@ -67,10 +67,11 @@ FbxMaterialsAccess::FbxMaterialsAccess(const FbxMesh *pMesh, const std::map<cons
} }
} }
const std::shared_ptr<FbxMaterialInfo> FbxMaterialsAccess::GetMaterial(const int polygonIndex) const const std::shared_ptr<FbxMaterialInfo> FbxMaterialsAccess::GetMaterial(
{ const int polygonIndex) const {
if (mappingMode != FbxGeometryElement::eNone) { if (mappingMode != FbxGeometryElement::eNone) {
const int materialNum = indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0); const int materialNum =
indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0);
if (materialNum < 0) { if (materialNum < 0) {
return nullptr; return nullptr;
} }
@ -79,10 +80,10 @@ const std::shared_ptr<FbxMaterialInfo> FbxMaterialsAccess::GetMaterial(const int
return nullptr; return nullptr;
} }
const std::vector<std::string> FbxMaterialsAccess::GetUserProperties(const int polygonIndex) const const std::vector<std::string> FbxMaterialsAccess::GetUserProperties(const int polygonIndex) const {
{
if (mappingMode != FbxGeometryElement::eNone) { if (mappingMode != FbxGeometryElement::eNone) {
const int materialNum = indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0); const int materialNum =
indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0);
if (materialNum < 0) { if (materialNum < 0) {
return std::vector<std::string>(); return std::vector<std::string>();
} }
@ -91,9 +92,9 @@ const std::vector<std::string> FbxMaterialsAccess::GetUserProperties(const int p
return std::vector<std::string>(); return std::vector<std::string>();
} }
std::unique_ptr<FbxMaterialInfo> std::unique_ptr<FbxMaterialInfo> FbxMaterialsAccess::GetMaterialInfo(
FbxMaterialsAccess::GetMaterialInfo(FbxSurfaceMaterial *material, const std::map<const FbxTexture *, FbxString> &textureLocations) FbxSurfaceMaterial* material,
{ const std::map<const FbxTexture*, FbxString>& textureLocations) {
std::unique_ptr<FbxMaterialInfo> res; std::unique_ptr<FbxMaterialInfo> res;
res = FbxRoughMetMaterialInfo::From(material, textureLocations); res = FbxRoughMetMaterialInfo::From(material, textureLocations);
if (!res) { if (!res) {
@ -101,4 +102,3 @@ FbxMaterialsAccess::GetMaterialInfo(FbxSurfaceMaterial *material, const std::map
} }
return res; return res;
} }

15
src/fbx/FbxMaterialsAccess.hpp
View File

@ -11,21 +11,22 @@
#include "Fbx2Raw.hpp" #include "Fbx2Raw.hpp"
#include "FbxMaterialInfo.hpp" #include "FbxMaterialInfo.hpp"
#include "FbxTraditionalMaterialInfo.hpp"
#include "FbxRoughMetMaterialInfo.hpp" #include "FbxRoughMetMaterialInfo.hpp"
#include "FbxTraditionalMaterialInfo.hpp"
class FbxMaterialsAccess class FbxMaterialsAccess {
{
public: public:
FbxMaterialsAccess(
FbxMaterialsAccess(const FbxMesh *pMesh, const std::map<const FbxTexture *, FbxString> &textureLocations); const FbxMesh* pMesh,
const std::map<const FbxTexture*, FbxString>& textureLocations);
const std::shared_ptr<FbxMaterialInfo> GetMaterial(const int polygonIndex) const; const std::shared_ptr<FbxMaterialInfo> GetMaterial(const int polygonIndex) const;
const std::vector<std::string> GetUserProperties(const int polygonIndex) const; const std::vector<std::string> GetUserProperties(const int polygonIndex) const;
std::unique_ptr<FbxMaterialInfo> std::unique_ptr<FbxMaterialInfo> GetMaterialInfo(
GetMaterialInfo(FbxSurfaceMaterial *material, const std::map<const FbxTexture *, FbxString> &textureLocations); FbxSurfaceMaterial* material,
const std::map<const FbxTexture*, FbxString>& textureLocations);
private: private:
FbxGeometryElement::EMappingMode mappingMode; FbxGeometryElement::EMappingMode mappingMode;

21
src/fbx/FbxRoughMetMaterialInfo.cpp
View File

@ -9,18 +9,21 @@
#include "FbxRoughMetMaterialInfo.hpp" #include "FbxRoughMetMaterialInfo.hpp"
std::unique_ptr<FbxRoughMetMaterialInfo> std::unique_ptr<FbxRoughMetMaterialInfo> FbxRoughMetMaterialInfo::From(
FbxRoughMetMaterialInfo::From(FbxSurfaceMaterial *fbxMaterial, const std::map<const FbxTexture *, FbxString> &textureLocations) FbxSurfaceMaterial* fbxMaterial,
{ const std::map<const FbxTexture*, FbxString>& textureLocations) {
std::unique_ptr<FbxRoughMetMaterialInfo> res(new FbxRoughMetMaterialInfo(fbxMaterial->GetName(), FBX_SHADER_METROUGH)); std::unique_ptr<FbxRoughMetMaterialInfo> res(
new FbxRoughMetMaterialInfo(fbxMaterial->GetName(), FBX_SHADER_METROUGH));
const FbxProperty mayaProp = fbxMaterial->FindProperty("Maya"); const FbxProperty mayaProp = fbxMaterial->FindProperty("Maya");
if (mayaProp.GetPropertyDataType() != FbxCompoundDT) { if (mayaProp.GetPropertyDataType() != FbxCompoundDT) {
return nullptr; return nullptr;
} }
if (!fbxMaterial->ShadingModel.Get().IsEmpty()) { if (!fbxMaterial->ShadingModel.Get().IsEmpty()) {
::fmt::printf("Warning: Material %s has surprising shading model: %s\n", ::fmt::printf(
fbxMaterial->GetName(), fbxMaterial->ShadingModel.Get()); "Warning: Material %s has surprising shading model: %s\n",
fbxMaterial->GetName(),
fbxMaterial->ShadingModel.Get());
} }
auto getTex = [&](std::string propName) { auto getTex = [&](std::string propName) {
@ -36,8 +39,10 @@ FbxRoughMetMaterialInfo::From(FbxSurfaceMaterial *fbxMaterial, const std::map<co
} }
} }
} else if (verboseOutput && useProp.IsValid()) { } else if (verboseOutput && useProp.IsValid()) {
fmt::printf("Note: Property '%s' of material '%s' exists, but is flagged as 'do not use'.\n", fmt::printf(
propName, fbxMaterial->GetName()); "Note: Property '%s' of material '%s' exists, but is flagged as 'do not use'.\n",
propName,
fbxMaterial->GetName());
} }
return ptr; return ptr;
}; };

9
src/fbx/FbxRoughMetMaterialInfo.hpp
View File

@ -7,13 +7,13 @@
* of patent rights can be found in the PATENTS file in the same directory. * of patent rights can be found in the PATENTS file in the same directory.
*/ */
#include <algorithm>
#include <fstream> #include <fstream>
#include <string>
#include <set>
#include <map> #include <map>
#include <set>
#include <string>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include <algorithm>
#include "FbxMaterialInfo.hpp" #include "FbxMaterialInfo.hpp"
@ -25,8 +25,7 @@ struct FbxRoughMetMaterialInfo : FbxMaterialInfo {
const std::map<const FbxTexture*, FbxString>& textureLocations); const std::map<const FbxTexture*, FbxString>& textureLocations);
FbxRoughMetMaterialInfo(const FbxString& name, const FbxString& shadingModel) FbxRoughMetMaterialInfo(const FbxString& name, const FbxString& shadingModel)
: FbxMaterialInfo(name, shadingModel) : FbxMaterialInfo(name, shadingModel) {}
{}
const FbxFileTexture* texColor{}; const FbxFileTexture* texColor{};
FbxVector4 colBase{}; FbxVector4 colBase{};

21
src/fbx/FbxSkinningAccess.cpp
View File

@ -10,10 +10,10 @@
#include "FbxSkinningAccess.hpp" #include "FbxSkinningAccess.hpp"
FbxSkinningAccess::FbxSkinningAccess(const FbxMesh* pMesh, FbxScene* pScene, FbxNode* pNode) FbxSkinningAccess::FbxSkinningAccess(const FbxMesh* pMesh, FbxScene* pScene, FbxNode* pNode)
: rootIndex(-1) : rootIndex(-1) {
{
for (int deformerIndex = 0; deformerIndex < pMesh->GetDeformerCount(); deformerIndex++) { for (int deformerIndex = 0; deformerIndex < pMesh->GetDeformerCount(); deformerIndex++) {
FbxSkin *skin = reinterpret_cast< FbxSkin * >( pMesh->GetDeformer(deformerIndex, FbxDeformer::eSkin)); FbxSkin* skin =
reinterpret_cast<FbxSkin*>(pMesh->GetDeformer(deformerIndex, FbxDeformer::eSkin));
if (skin != nullptr) { if (skin != nullptr) {
const int clusterCount = skin->GetClusterCount(); const int clusterCount = skin->GetClusterCount();
if (clusterCount == 0) { if (clusterCount == 0) {
@ -47,7 +47,8 @@ FbxSkinningAccess::FbxSkinningAccess(const FbxMesh *pMesh, FbxScene *pScene, Fbx
jointIds.push_back(cluster->GetLink()->GetUniqueID()); jointIds.push_back(cluster->GetLink()->GetUniqueID());
const FbxAMatrix globalNodeTransform = cluster->GetLink()->EvaluateGlobalTransform(); const FbxAMatrix globalNodeTransform = cluster->GetLink()->EvaluateGlobalTransform();
jointSkinningTransforms.push_back(FbxMatrix(globalNodeTransform * globalBindposeInverseMatrix)); jointSkinningTransforms.push_back(
FbxMatrix(globalNodeTransform * globalBindposeInverseMatrix));
jointInverseGlobalTransforms.push_back(FbxMatrix(globalNodeTransform.Inverse())); jointInverseGlobalTransforms.push_back(FbxMatrix(globalNodeTransform.Inverse()));
for (int i = 0; i < indexCount; i++) { for (int i = 0; i < indexCount; i++) {
@ -60,14 +61,18 @@ FbxSkinningAccess::FbxSkinningAccess(const FbxMesh *pMesh, FbxScene *pScene, Fbx
vertexJointIndices[clusterIndices[i]][MAX_WEIGHTS - 1] = clusterIndex; vertexJointIndices[clusterIndices[i]][MAX_WEIGHTS - 1] = clusterIndex;
vertexJointWeights[clusterIndices[i]][MAX_WEIGHTS - 1] = (float)clusterWeights[i]; vertexJointWeights[clusterIndices[i]][MAX_WEIGHTS - 1] = (float)clusterWeights[i];
for (int j = MAX_WEIGHTS - 1; j > 0; j--) { for (int j = MAX_WEIGHTS - 1; j > 0; j--) {
if (vertexJointWeights[clusterIndices[i]][j - 1] >= vertexJointWeights[clusterIndices[i]][j]) { if (vertexJointWeights[clusterIndices[i]][j - 1] >=
vertexJointWeights[clusterIndices[i]][j]) {
break; break;
} }
std::swap(vertexJointIndices[clusterIndices[i]][j - 1], vertexJointIndices[clusterIndices[i]][j]); std::swap(
std::swap(vertexJointWeights[clusterIndices[i]][j - 1], vertexJointWeights[clusterIndices[i]][j]); vertexJointIndices[clusterIndices[i]][j - 1],
vertexJointIndices[clusterIndices[i]][j]);
std::swap(
vertexJointWeights[clusterIndices[i]][j - 1],
vertexJointWeights[clusterIndices[i]][j]);
} }
} }
} }
for (int i = 0; i < controlPointCount; i++) { for (int i = 0; i < controlPointCount; i++) {
vertexJointWeights[i] = vertexJointWeights[i].Normalized(); vertexJointWeights[i] = vertexJointWeights[i].Normalized();

48
src/fbx/FbxSkinningAccess.hpp
View File

@ -9,75 +9,63 @@
#pragma once #pragma once
#include <algorithm>
#include <fstream> #include <fstream>
#include <string>
#include <set>
#include <map> #include <map>
#include <set>
#include <string>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include <algorithm>
#include "FBX2glTF.h" #include "FBX2glTF.h"
class FbxSkinningAccess class FbxSkinningAccess {
{
public: public:
static const int MAX_WEIGHTS = 4; static const int MAX_WEIGHTS = 4;
FbxSkinningAccess(const FbxMesh* pMesh, FbxScene* pScene, FbxNode* pNode); FbxSkinningAccess(const FbxMesh* pMesh, FbxScene* pScene, FbxNode* pNode);
bool IsSkinned() const bool IsSkinned() const {
{
return (vertexJointWeights.size() > 0); return (vertexJointWeights.size() > 0);
} }
int GetNodeCount() const int GetNodeCount() const {
{
return (int)jointNodes.size(); return (int)jointNodes.size();
} }
FbxNode *GetJointNode(const int jointIndex) const FbxNode* GetJointNode(const int jointIndex) const {
{
return jointNodes[jointIndex]; return jointNodes[jointIndex];
} }
const long GetJointId(const int jointIndex) const const long GetJointId(const int jointIndex) const {
{
return jointIds[jointIndex]; return jointIds[jointIndex];
} }
const FbxMatrix &GetJointSkinningTransform(const int jointIndex) const const FbxMatrix& GetJointSkinningTransform(const int jointIndex) const {
{
return jointSkinningTransforms[jointIndex]; return jointSkinningTransforms[jointIndex];
} }
const FbxMatrix &GetJointInverseGlobalTransforms(const int jointIndex) const const FbxMatrix& GetJointInverseGlobalTransforms(const int jointIndex) const {
{
return jointInverseGlobalTransforms[jointIndex]; return jointInverseGlobalTransforms[jointIndex];
} }
const long GetRootNode() const const long GetRootNode() const {
{
assert(rootIndex != -1); assert(rootIndex != -1);
return jointIds[rootIndex]; return jointIds[rootIndex];
} }
const FbxAMatrix &GetInverseBindMatrix(const int jointIndex) const const FbxAMatrix& GetInverseBindMatrix(const int jointIndex) const {
{
return inverseBindMatrices[jointIndex]; return inverseBindMatrices[jointIndex];
} }
const Vec4i GetVertexIndices(const int controlPointIndex) const const Vec4i GetVertexIndices(const int controlPointIndex) const {
{ return (!vertexJointIndices.empty()) ? vertexJointIndices[controlPointIndex]
return (!vertexJointIndices.empty()) ? : Vec4i(0, 0, 0, 0);
vertexJointIndices[controlPointIndex] : Vec4i(0, 0, 0, 0);
} }
const Vec4f GetVertexWeights(const int controlPointIndex) const const Vec4f GetVertexWeights(const int controlPointIndex) const {
{ return (!vertexJointWeights.empty()) ? vertexJointWeights[controlPointIndex]
return (!vertexJointWeights.empty()) ? : Vec4f(0, 0, 0, 0);
vertexJointWeights[controlPointIndex] : Vec4f(0, 0, 0, 0);
} }
private: private:

45
src/fbx/FbxTraditionalMaterialInfo.cpp
View File

@ -9,9 +9,9 @@
#include "FbxTraditionalMaterialInfo.hpp" #include "FbxTraditionalMaterialInfo.hpp"
std::unique_ptr<FbxTraditionalMaterialInfo> std::unique_ptr<FbxTraditionalMaterialInfo> FbxTraditionalMaterialInfo::From(
FbxTraditionalMaterialInfo::From(FbxSurfaceMaterial *fbxMaterial, const std::map<const FbxTexture *, FbxString> &textureLocations) FbxSurfaceMaterial* fbxMaterial,
{ const std::map<const FbxTexture*, FbxString>& textureLocations) {
auto getSurfaceScalar = [&](const char* propName) -> std::tuple<FbxDouble, FbxFileTexture*> { auto getSurfaceScalar = [&](const char* propName) -> std::tuple<FbxDouble, FbxFileTexture*> {
const FbxProperty prop = fbxMaterial->FindProperty(propName); const FbxProperty prop = fbxMaterial->FindProperty(propName);
@ -40,7 +40,9 @@ FbxTraditionalMaterialInfo::From(FbxSurfaceMaterial *fbxMaterial, const std::map
return std::make_tuple(val, tex); return std::make_tuple(val, tex);
}; };
auto getSurfaceValues = [&](const char *colName, const char *facName) -> std::tuple<FbxVector4, FbxFileTexture *, FbxFileTexture *> { auto getSurfaceValues =
[&](const char* colName,
const char* facName) -> std::tuple<FbxVector4, FbxFileTexture*, FbxFileTexture*> {
const FbxProperty colProp = fbxMaterial->FindProperty(colName); const FbxProperty colProp = fbxMaterial->FindProperty(colName);
const FbxProperty facProp = fbxMaterial->FindProperty(facName); const FbxProperty facProp = fbxMaterial->FindProperty(facName);
@ -63,25 +65,29 @@ FbxTraditionalMaterialInfo::From(FbxSurfaceMaterial *fbxMaterial, const std::map
} }
auto val = FbxVector4( auto val = FbxVector4(
colorVal[0] * factorVal, colorVal[0] * factorVal, colorVal[1] * factorVal, colorVal[2] * factorVal, factorVal);
colorVal[1] * factorVal,
colorVal[2] * factorVal,
factorVal);
return std::make_tuple(val, colTex, facTex); return std::make_tuple(val, colTex, facTex);
}; };
std::string name = fbxMaterial->GetName(); std::string name = fbxMaterial->GetName();
std::unique_ptr<FbxTraditionalMaterialInfo> res(new FbxTraditionalMaterialInfo(name.c_str(), fbxMaterial->ShadingModel.Get())); std::unique_ptr<FbxTraditionalMaterialInfo> res(
new FbxTraditionalMaterialInfo(name.c_str(), fbxMaterial->ShadingModel.Get()));
// four properties are on the same structure and follow the same rules // four properties are on the same structure and follow the same rules
auto handleBasicProperty = [&](const char *colName, const char *facName) -> std::tuple<FbxVector4, FbxFileTexture *>{ auto handleBasicProperty = [&](const char* colName,
const char* facName) -> std::tuple<FbxVector4, FbxFileTexture*> {
FbxFileTexture *colTex, *facTex; FbxFileTexture *colTex, *facTex;
FbxVector4 vec; FbxVector4 vec;
std::tie(vec, colTex, facTex) = getSurfaceValues(colName, facName); std::tie(vec, colTex, facTex) = getSurfaceValues(colName, facName);
if (colTex) { if (colTex) {
if (facTex) { if (facTex) {
fmt::printf("Warning: Mat [%s]: Can't handle both %s and %s textures; discarding %s.\n", name, colName, facName, facName); fmt::printf(
"Warning: Mat [%s]: Can't handle both %s and %s textures; discarding %s.\n",
name,
colName,
facName,
facName);
} }
return std::make_tuple(vec, colTex); return std::make_tuple(vec, colTex);
} }
@ -109,15 +115,22 @@ FbxTraditionalMaterialInfo::From(FbxSurfaceMaterial *fbxMaterial, const std::map
FbxVector4 transparency; FbxVector4 transparency;
// extract any existing textures only so we can warn that we're throwing them away // extract any existing textures only so we can warn that we're throwing them away
FbxFileTexture *colTex, *facTex; FbxFileTexture *colTex, *facTex;
std::tie(transparency, colTex, facTex) = std::tie(transparency, colTex, facTex) = getSurfaceValues(
getSurfaceValues(FbxSurfaceMaterial::sTransparentColor, FbxSurfaceMaterial::sTransparencyFactor); FbxSurfaceMaterial::sTransparentColor, FbxSurfaceMaterial::sTransparencyFactor);
if (colTex) { if (colTex) {
fmt::printf("Warning: Mat [%s]: Can't handle texture for %s; discarding.\n", name, FbxSurfaceMaterial::sTransparentColor); fmt::printf(
"Warning: Mat [%s]: Can't handle texture for %s; discarding.\n",
name,
FbxSurfaceMaterial::sTransparentColor);
} }
if (facTex) { if (facTex) {
fmt::printf("Warning: Mat [%s]: Can't handle texture for %s; discarding.\n", name, FbxSurfaceMaterial::sTransparencyFactor); fmt::printf(
"Warning: Mat [%s]: Can't handle texture for %s; discarding.\n",
name,
FbxSurfaceMaterial::sTransparencyFactor);
} }
// FBX color is RGB, so we calculate the A channel as the average of the FBX transparency color vector // FBX color is RGB, so we calculate the A channel as the average of the FBX transparency color
// vector
res->colDiffuse[3] = 1.0 - (transparency[0] + transparency[1] + transparency[2]) / 3.0; res->colDiffuse[3] = 1.0 - (transparency[0] + transparency[1] + transparency[2]) / 3.0;
return res; return res;

9
src/fbx/FbxTraditionalMaterialInfo.hpp
View File

@ -7,13 +7,13 @@
* of patent rights can be found in the PATENTS file in the same directory. * of patent rights can be found in the PATENTS file in the same directory.
*/ */
#include <algorithm>
#include <fstream> #include <fstream>
#include <string>
#include <set>
#include <map> #include <map>
#include <set>
#include <string>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include <algorithm>
#include "FbxMaterialInfo.hpp" #include "FbxMaterialInfo.hpp"
@ -23,8 +23,7 @@ struct FbxTraditionalMaterialInfo : FbxMaterialInfo {
static constexpr const char* FBX_SHADER_PHONG = "Phong"; static constexpr const char* FBX_SHADER_PHONG = "Phong";
FbxTraditionalMaterialInfo(const FbxString& name, const FbxString& shadingModel) FbxTraditionalMaterialInfo(const FbxString& name, const FbxString& shadingModel)
: FbxMaterialInfo(name, shadingModel) : FbxMaterialInfo(name, shadingModel) {}
{}
FbxFileTexture* texAmbient{}; FbxFileTexture* texAmbient{};
FbxVector4 colAmbient{}; FbxVector4 colAmbient{};

19
src/fbx/materials/3dsMaxPhysicalMaterial.cpp
View File

@ -18,8 +18,10 @@ std::unique_ptr<FbxRoughMetMaterialInfo> Fbx3dsMaxPhysicalMaterialResolver::reso
FbxString shadingModel = fbxMaterial->ShadingModel.Get(); FbxString shadingModel = fbxMaterial->ShadingModel.Get();
if (!shadingModel.IsEmpty() && shadingModel != "unknown") { if (!shadingModel.IsEmpty() && shadingModel != "unknown") {
::fmt::printf("Warning: Material %s has surprising shading model: %s\n", ::fmt::printf(
fbxMaterial->GetName(), shadingModel); "Warning: Material %s has surprising shading model: %s\n",
fbxMaterial->GetName(),
shadingModel);
} }
auto getTex = [&](std::string propName) -> const FbxFileTexture* { auto getTex = [&](std::string propName) -> const FbxFileTexture* {
@ -35,8 +37,10 @@ std::unique_ptr<FbxRoughMetMaterialInfo> Fbx3dsMaxPhysicalMaterialResolver::reso
} }
} }
} else if (verboseOutput && useProp.IsValid()) { } else if (verboseOutput && useProp.IsValid()) {
fmt::printf("Note: property '%s' of 3dsMax Physical material '%s' exists, but is flagged as 'off'.\n", fmt::printf(
propName, fbxMaterial->GetName()); "Note: property '%s' of 3dsMax Physical material '%s' exists, but is flagged as 'off'.\n",
propName,
fbxMaterial->GetName());
} }
return ptr; return ptr;
}; };
@ -98,15 +102,12 @@ std::unique_ptr<FbxRoughMetMaterialInfo> Fbx3dsMaxPhysicalMaterialResolver::reso
const auto* bumpMap = getTex("bump"); const auto* bumpMap = getTex("bump");
const auto* displacementMap = getTex("displacement"); const auto* displacementMap = getTex("displacement");
std::unique_ptr<FbxRoughMetMaterialInfo> res( std::unique_ptr<FbxRoughMetMaterialInfo> res(new FbxRoughMetMaterialInfo(
new FbxRoughMetMaterialInfo(
fbxMaterial->GetName(), fbxMaterial->GetName(),
FbxRoughMetMaterialInfo::FBX_SHADER_METROUGH, FbxRoughMetMaterialInfo::FBX_SHADER_METROUGH,
baseCol, baseCol,
metalness, metalness,
roughness roughness));
)
);
res->texBaseColor = baseTex; res->texBaseColor = baseTex;
res->baseWeight = baseWeight; res->baseWeight = baseWeight;
res->texBaseWeight = baseWeightMap; res->texBaseWeight = baseWeightMap;

38
src/fbx/materials/FbxMaterials.cpp
View File

@ -11,21 +11,23 @@
#include "RoughnessMetallicMaterials.hpp" #include "RoughnessMetallicMaterials.hpp"
#include "TraditionalMaterials.hpp" #include "TraditionalMaterials.hpp"
FbxMaterialsAccess::FbxMaterialsAccess(const FbxMesh *pMesh, const std::map<const FbxTexture *, FbxString> &textureLocations) : FbxMaterialsAccess::FbxMaterialsAccess(
mappingMode(FbxGeometryElement::eNone), const FbxMesh* pMesh,
mesh(nullptr), const std::map<const FbxTexture*, FbxString>& textureLocations)
indices(nullptr) : mappingMode(FbxGeometryElement::eNone), mesh(nullptr), indices(nullptr) {
{
if (pMesh->GetElementMaterialCount() <= 0) { if (pMesh->GetElementMaterialCount() <= 0) {
return; return;
} }
const FbxGeometryElement::EMappingMode materialMappingMode = pMesh->GetElementMaterial()->GetMappingMode(); const FbxGeometryElement::EMappingMode materialMappingMode =
if (materialMappingMode != FbxGeometryElement::eByPolygon && materialMappingMode != FbxGeometryElement::eAllSame) { pMesh->GetElementMaterial()->GetMappingMode();
if (materialMappingMode != FbxGeometryElement::eByPolygon &&
materialMappingMode != FbxGeometryElement::eAllSame) {
return; return;
} }
const FbxGeometryElement::EReferenceMode materialReferenceMode = pMesh->GetElementMaterial()->GetReferenceMode(); const FbxGeometryElement::EReferenceMode materialReferenceMode =
pMesh->GetElementMaterial()->GetReferenceMode();
if (materialReferenceMode != FbxGeometryElement::eIndexToDirect) { if (materialReferenceMode != FbxGeometryElement::eIndexToDirect) {
return; return;
} }
@ -45,16 +47,16 @@ FbxMaterialsAccess::FbxMaterialsAccess(const FbxMesh *pMesh, const std::map<cons
auto summary = summaries[materialNum]; auto summary = summaries[materialNum];
if (summary == nullptr) { if (summary == nullptr) {
summary = summaries[materialNum] = GetMaterialInfo( summary = summaries[materialNum] = GetMaterialInfo(
mesh->GetNode()->GetSrcObject<FbxSurfaceMaterial>(materialNum), mesh->GetNode()->GetSrcObject<FbxSurfaceMaterial>(materialNum), textureLocations);
textureLocations);
} }
} }
} }
const std::shared_ptr<FbxMaterialInfo> FbxMaterialsAccess::GetMaterial(const int polygonIndex) const const std::shared_ptr<FbxMaterialInfo> FbxMaterialsAccess::GetMaterial(
{ const int polygonIndex) const {
if (mappingMode != FbxGeometryElement::eNone) { if (mappingMode != FbxGeometryElement::eNone) {
const int materialNum = indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0); const int materialNum =
indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0);
if (materialNum < 0) { if (materialNum < 0) {
return nullptr; return nullptr;
} }
@ -63,10 +65,11 @@ const std::shared_ptr<FbxMaterialInfo> FbxMaterialsAccess::GetMaterial(const int
return nullptr; return nullptr;
} }
std::unique_ptr<FbxMaterialInfo> std::unique_ptr<FbxMaterialInfo> FbxMaterialsAccess::GetMaterialInfo(
FbxMaterialsAccess::GetMaterialInfo(FbxSurfaceMaterial *material, const std::map<const FbxTexture *, FbxString> &textureLocations) FbxSurfaceMaterial* material,
{ const std::map<const FbxTexture*, FbxString>& textureLocations) {
std::unique_ptr<FbxMaterialInfo> res = FbxStingrayPBSMaterialResolver(material, textureLocations).resolve(); std::unique_ptr<FbxMaterialInfo> res =
FbxStingrayPBSMaterialResolver(material, textureLocations).resolve();
if (res == nullptr) { if (res == nullptr) {
res = Fbx3dsMaxPhysicalMaterialResolver(material, textureLocations).resolve(); res = Fbx3dsMaxPhysicalMaterialResolver(material, textureLocations).resolve();
if (res == nullptr) { if (res == nullptr) {
@ -75,4 +78,3 @@ FbxMaterialsAccess::GetMaterialInfo(FbxSurfaceMaterial *material, const std::map
} }
return res; return res;
} }

23
src/fbx/materials/FbxMaterials.hpp
View File

@ -17,24 +17,19 @@
class FbxMaterialInfo { class FbxMaterialInfo {
public: public:
FbxMaterialInfo(const FbxString& name, const FbxString& shadingModel) FbxMaterialInfo(const FbxString& name, const FbxString& shadingModel)
: name(name) : name(name), shadingModel(shadingModel) {}
, shadingModel(shadingModel)
{}
const FbxString name; const FbxString name;
const FbxString shadingModel; const FbxString shadingModel;
}; };
template <class T> template <class T>
class FbxMaterialResolver class FbxMaterialResolver {
{
public: public:
FbxMaterialResolver( FbxMaterialResolver(
FbxSurfaceMaterial* fbxMaterial, FbxSurfaceMaterial* fbxMaterial,
const std::map<const FbxTexture*, FbxString>& textureLocations) const std::map<const FbxTexture*, FbxString>& textureLocations)
: fbxMaterial(fbxMaterial) : fbxMaterial(fbxMaterial), textureLocations(textureLocations) {}
, textureLocations(textureLocations)
{}
virtual std::unique_ptr<T> resolve() const = 0; virtual std::unique_ptr<T> resolve() const = 0;
protected: protected:
@ -42,15 +37,17 @@ protected:
const std::map<const FbxTexture*, FbxString> textureLocations; const std::map<const FbxTexture*, FbxString> textureLocations;
}; };
class FbxMaterialsAccess class FbxMaterialsAccess {
{
public: public:
FbxMaterialsAccess(const FbxMesh *pMesh, const std::map<const FbxTexture *, FbxString> &textureLocations); FbxMaterialsAccess(
const FbxMesh* pMesh,
const std::map<const FbxTexture*, FbxString>& textureLocations);
const std::shared_ptr<FbxMaterialInfo> GetMaterial(const int polygonIndex) const; const std::shared_ptr<FbxMaterialInfo> GetMaterial(const int polygonIndex) const;
std::unique_ptr<FbxMaterialInfo> std::unique_ptr<FbxMaterialInfo> GetMaterialInfo(
GetMaterialInfo(FbxSurfaceMaterial *material, const std::map<const FbxTexture *, FbxString> &textureLocations); FbxSurfaceMaterial* material,
const std::map<const FbxTexture*, FbxString>& textureLocations);
private: private:
FbxGeometryElement::EMappingMode mappingMode; FbxGeometryElement::EMappingMode mappingMode;

18
src/fbx/materials/RoughnessMetallicMaterials.hpp
View File

@ -25,13 +25,11 @@ struct FbxRoughMetMaterialInfo : FbxMaterialInfo {
const FbxString& shadingModel, const FbxString& shadingModel,
FbxDouble4 baseColor, FbxDouble4 baseColor,
FbxDouble metallic, FbxDouble metallic,
FbxDouble roughness FbxDouble roughness)
) : FbxMaterialInfo(name, shadingModel),
: FbxMaterialInfo(name, shadingModel) baseColor(baseColor),
, baseColor(baseColor) metallic(metallic),
, metallic(metallic) roughness(roughness) {}
, roughness(roughness)
{}
const FbxVector4 baseColor; const FbxVector4 baseColor;
const FbxDouble metallic; const FbxDouble metallic;
@ -56,8 +54,7 @@ public:
FbxStingrayPBSMaterialResolver( FbxStingrayPBSMaterialResolver(
FbxSurfaceMaterial* fbxMaterial, FbxSurfaceMaterial* fbxMaterial,
const std::map<const FbxTexture*, FbxString>& textureLocations) const std::map<const FbxTexture*, FbxString>& textureLocations)
: FbxMaterialResolver(fbxMaterial, textureLocations) : FbxMaterialResolver(fbxMaterial, textureLocations) {}
{}
virtual std::unique_ptr<FbxRoughMetMaterialInfo> resolve() const; virtual std::unique_ptr<FbxRoughMetMaterialInfo> resolve() const;
}; };
@ -67,8 +64,7 @@ public:
Fbx3dsMaxPhysicalMaterialResolver( Fbx3dsMaxPhysicalMaterialResolver(
FbxSurfaceMaterial* fbxMaterial, FbxSurfaceMaterial* fbxMaterial,
const std::map<const FbxTexture*, FbxString>& textureLocations) const std::map<const FbxTexture*, FbxString>& textureLocations)
: FbxMaterialResolver(fbxMaterial, textureLocations) : FbxMaterialResolver(fbxMaterial, textureLocations) {}
{}
virtual std::unique_ptr<FbxRoughMetMaterialInfo> resolve() const; virtual std::unique_ptr<FbxRoughMetMaterialInfo> resolve() const;

19
src/fbx/materials/StingrayPBSMaterial.cpp
View File

@ -15,8 +15,10 @@ std::unique_ptr<FbxRoughMetMaterialInfo> FbxStingrayPBSMaterialResolver::resolve
return nullptr; return nullptr;
} }
if (!fbxMaterial->ShadingModel.Get().IsEmpty()) { if (!fbxMaterial->ShadingModel.Get().IsEmpty()) {
::fmt::printf("Warning: Material %s has surprising shading model: %s\n", ::fmt::printf(
fbxMaterial->GetName(), fbxMaterial->ShadingModel.Get()); "Warning: Material %s has surprising shading model: %s\n",
fbxMaterial->GetName(),
fbxMaterial->ShadingModel.Get());
} }
auto getTex = [&](std::string propName) { auto getTex = [&](std::string propName) {
@ -32,8 +34,10 @@ std::unique_ptr<FbxRoughMetMaterialInfo> FbxStingrayPBSMaterialResolver::resolve
} }
} }
} else if (verboseOutput && useProp.IsValid()) { } else if (verboseOutput && useProp.IsValid()) {
fmt::printf("Note: Property '%s' of Stingray PBS material '%s' exists, but is flagged as 'do not use'.\n", fmt::printf(
propName, fbxMaterial->GetName()); "Note: Property '%s' of Stingray PBS material '%s' exists, but is flagged as 'do not use'.\n",
propName,
fbxMaterial->GetName());
} }
return ptr; return ptr;
}; };
@ -49,15 +53,12 @@ std::unique_ptr<FbxRoughMetMaterialInfo> FbxStingrayPBSMaterialResolver::resolve
}; };
FbxDouble3 baseColor = getVec("base_color"); FbxDouble3 baseColor = getVec("base_color");
std::unique_ptr<FbxRoughMetMaterialInfo> res( std::unique_ptr<FbxRoughMetMaterialInfo> res(new FbxRoughMetMaterialInfo(
new FbxRoughMetMaterialInfo(
fbxMaterial->GetName(), fbxMaterial->GetName(),
FbxRoughMetMaterialInfo::FBX_SHADER_METROUGH, FbxRoughMetMaterialInfo::FBX_SHADER_METROUGH,
FbxDouble4(baseColor[0], baseColor[1], baseColor[2], 1), FbxDouble4(baseColor[0], baseColor[1], baseColor[2], 1),
getVal("metallic"), getVal("metallic"),
getVal("roughness") getVal("roughness")));
)
);
res->texNormal = getTex("normal"); res->texNormal = getTex("normal");
res->texBaseColor = getTex("color"); res->texBaseColor = getTex("color");
res->texAmbientOcclusion = getTex("ao"); res->texAmbientOcclusion = getTex("ao");

42
src/fbx/materials/TraditionalMaterials.cpp
View File

@ -9,8 +9,7 @@
#include "TraditionalMaterials.hpp" #include "TraditionalMaterials.hpp"
std::unique_ptr<FbxTraditionalMaterialInfo> FbxTraditionalMaterialResolver::resolve() const std::unique_ptr<FbxTraditionalMaterialInfo> FbxTraditionalMaterialResolver::resolve() const {
{
auto getSurfaceScalar = [&](const char* propName) -> std::tuple<FbxDouble, FbxFileTexture*> { auto getSurfaceScalar = [&](const char* propName) -> std::tuple<FbxDouble, FbxFileTexture*> {
const FbxProperty prop = fbxMaterial->FindProperty(propName); const FbxProperty prop = fbxMaterial->FindProperty(propName);
@ -39,7 +38,9 @@ std::unique_ptr<FbxTraditionalMaterialInfo> FbxTraditionalMaterialResolver::reso
return std::make_tuple(val, tex); return std::make_tuple(val, tex);
}; };
auto getSurfaceValues = [&](const char *colName, const char *facName) -> std::tuple<FbxVector4, FbxFileTexture *, FbxFileTexture *> { auto getSurfaceValues =
[&](const char* colName,
const char* facName) -> std::tuple<FbxVector4, FbxFileTexture*, FbxFileTexture*> {
const FbxProperty colProp = fbxMaterial->FindProperty(colName); const FbxProperty colProp = fbxMaterial->FindProperty(colName);
const FbxProperty facProp = fbxMaterial->FindProperty(facName); const FbxProperty facProp = fbxMaterial->FindProperty(facName);
@ -62,25 +63,29 @@ std::unique_ptr<FbxTraditionalMaterialInfo> FbxTraditionalMaterialResolver::reso
} }
auto val = FbxVector4( auto val = FbxVector4(
colorVal[0] * factorVal, colorVal[0] * factorVal, colorVal[1] * factorVal, colorVal[2] * factorVal, factorVal);
colorVal[1] * factorVal,
colorVal[2] * factorVal,
factorVal);
return std::make_tuple(val, colTex, facTex); return std::make_tuple(val, colTex, facTex);
}; };
std::string name = fbxMaterial->GetName(); std::string name = fbxMaterial->GetName();
std::unique_ptr<FbxTraditionalMaterialInfo> res(new FbxTraditionalMaterialInfo(name.c_str(), fbxMaterial->ShadingModel.Get())); std::unique_ptr<FbxTraditionalMaterialInfo> res(
new FbxTraditionalMaterialInfo(name.c_str(), fbxMaterial->ShadingModel.Get()));
// four properties are on the same structure and follow the same rules // four properties are on the same structure and follow the same rules
auto handleBasicProperty = [&](const char *colName, const char *facName) -> std::tuple<FbxVector4, FbxFileTexture *>{ auto handleBasicProperty = [&](const char* colName,
const char* facName) -> std::tuple<FbxVector4, FbxFileTexture*> {
FbxFileTexture *colTex, *facTex; FbxFileTexture *colTex, *facTex;
FbxVector4 vec; FbxVector4 vec;
std::tie(vec, colTex, facTex) = getSurfaceValues(colName, facName); std::tie(vec, colTex, facTex) = getSurfaceValues(colName, facName);
if (colTex) { if (colTex) {
if (facTex) { if (facTex) {
fmt::printf("Warning: Mat [%s]: Can't handle both %s and %s textures; discarding %s.\n", name, colName, facName, facName); fmt::printf(
"Warning: Mat [%s]: Can't handle both %s and %s textures; discarding %s.\n",
name,
colName,
facName,
facName);
} }
return std::make_tuple(vec, colTex); return std::make_tuple(vec, colTex);
} }
@ -108,15 +113,22 @@ std::unique_ptr<FbxTraditionalMaterialInfo> FbxTraditionalMaterialResolver::reso
FbxVector4 transparency; FbxVector4 transparency;
// extract any existing textures only so we can warn that we're throwing them away // extract any existing textures only so we can warn that we're throwing them away
FbxFileTexture *colTex, *facTex; FbxFileTexture *colTex, *facTex;
std::tie(transparency, colTex, facTex) = std::tie(transparency, colTex, facTex) = getSurfaceValues(
getSurfaceValues(FbxSurfaceMaterial::sTransparentColor, FbxSurfaceMaterial::sTransparencyFactor); FbxSurfaceMaterial::sTransparentColor, FbxSurfaceMaterial::sTransparencyFactor);
if (colTex) { if (colTex) {
fmt::printf("Warning: Mat [%s]: Can't handle texture for %s; discarding.\n", name, FbxSurfaceMaterial::sTransparentColor); fmt::printf(
"Warning: Mat [%s]: Can't handle texture for %s; discarding.\n",
name,
FbxSurfaceMaterial::sTransparentColor);
} }
if (facTex) { if (facTex) {
fmt::printf("Warning: Mat [%s]: Can't handle texture for %s; discarding.\n", name, FbxSurfaceMaterial::sTransparencyFactor); fmt::printf(
"Warning: Mat [%s]: Can't handle texture for %s; discarding.\n",
name,
FbxSurfaceMaterial::sTransparencyFactor);
} }
// FBX color is RGB, so we calculate the A channel as the average of the FBX transparency color vector // FBX color is RGB, so we calculate the A channel as the average of the FBX transparency color
// vector
res->colDiffuse[3] = 1.0 - (transparency[0] + transparency[1] + transparency[2]) / 3.0; res->colDiffuse[3] = 1.0 - (transparency[0] + transparency[1] + transparency[2]) / 3.0;
return res; return res;

6
src/fbx/materials/TraditionalMaterials.hpp
View File

@ -15,8 +15,7 @@ struct FbxTraditionalMaterialInfo : FbxMaterialInfo {
static constexpr const char* FBX_SHADER_PHONG = "Phong"; static constexpr const char* FBX_SHADER_PHONG = "Phong";
FbxTraditionalMaterialInfo(const FbxString& name, const FbxString& shadingModel) FbxTraditionalMaterialInfo(const FbxString& name, const FbxString& shadingModel)
: FbxMaterialInfo(name, shadingModel) : FbxMaterialInfo(name, shadingModel) {}
{}
FbxFileTexture* texAmbient{}; FbxFileTexture* texAmbient{};
FbxVector4 colAmbient{}; FbxVector4 colAmbient{};
@ -36,8 +35,7 @@ public:
FbxTraditionalMaterialResolver( FbxTraditionalMaterialResolver(
FbxSurfaceMaterial* fbxMaterial, FbxSurfaceMaterial* fbxMaterial,
const std::map<const FbxTexture*, FbxString>& textureLocations) const std::map<const FbxTexture*, FbxString>& textureLocations)
: FbxMaterialResolver(fbxMaterial, textureLocations) : FbxMaterialResolver(fbxMaterial, textureLocations) {}
{}
virtual std::unique_ptr<FbxTraditionalMaterialInfo> resolve() const; virtual std::unique_ptr<FbxTraditionalMaterialInfo> resolve() const;
}; };

17
src/gltf/GltfModel.cpp
View File

@ -9,8 +9,9 @@
#include "GltfModel.hpp" #include "GltfModel.hpp"
std::shared_ptr<BufferViewData> GltfModel::GetAlignedBufferView(BufferData &buffer, const BufferViewData::GL_ArrayType target) std::shared_ptr<BufferViewData> GltfModel::GetAlignedBufferView(
{ BufferData& buffer,
const BufferViewData::GL_ArrayType target) {
unsigned long bufferSize = this->binary->size(); unsigned long bufferSize = this->binary->size();
if ((bufferSize % 4) > 0) { if ((bufferSize % 4) > 0) {
bufferSize += (4 - (bufferSize % 4)); bufferSize += (4 - (bufferSize % 4));
@ -20,8 +21,8 @@ std::shared_ptr<BufferViewData> GltfModel::GetAlignedBufferView(BufferData &buff
} }
// add a bufferview on the fly and copy data into it // add a bufferview on the fly and copy data into it
std::shared_ptr<BufferViewData> GltfModel::AddRawBufferView(BufferData &buffer, const char *source, uint32_t bytes) std::shared_ptr<BufferViewData>
{ GltfModel::AddRawBufferView(BufferData& buffer, const char* source, uint32_t bytes) {
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE); auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
bufferView->byteLength = bytes; bufferView->byteLength = bytes;
@ -34,8 +35,9 @@ std::shared_ptr<BufferViewData> GltfModel::AddRawBufferView(BufferData &buffer,
return bufferView; return bufferView;
} }
std::shared_ptr<BufferViewData> GltfModel::AddBufferViewForFile(BufferData &buffer, const std::string &filename) std::shared_ptr<BufferViewData> GltfModel::AddBufferViewForFile(
{ BufferData& buffer,
const std::string& filename) {
// see if we've already created a BufferViewData for this precise file // see if we've already created a BufferViewData for this precise file
auto iter = filenameToBufferView.find(filename); auto iter = filenameToBufferView.find(filename);
if (iter != filenameToBufferView.end()) { if (iter != filenameToBufferView.end()) {
@ -62,8 +64,7 @@ std::shared_ptr<BufferViewData> GltfModel::AddBufferViewForFile(BufferData &buff
return result; return result;
} }
void GltfModel::serializeHolders(json &glTFJson) void GltfModel::serializeHolders(json& glTFJson) {
{
serializeHolder(glTFJson, "buffers", buffers); serializeHolder(glTFJson, "buffers", buffers);
serializeHolder(glTFJson, "bufferViews", bufferViews); serializeHolder(glTFJson, "bufferViews", bufferViews);
serializeHolder(glTFJson, "scenes", scenes); serializeHolder(glTFJson, "scenes", scenes);

76
src/gltf/GltfModel.hpp
View File

@ -30,21 +30,20 @@
#include "gltf/properties/TextureData.hpp" #include "gltf/properties/TextureData.hpp"
/** /**
* glTF 2.0 is based on the idea that data structs within a file are referenced by index; an accessor will * glTF 2.0 is based on the idea that data structs within a file are referenced by index; an
* point to the n:th buffer view, and so on. The Holder class takes a freshly instantiated class, and then * accessor will point to the n:th buffer view, and so on. The Holder class takes a freshly
* creates, stored, and returns a shared_ptr<T> for it. * instantiated class, and then creates, stored, and returns a shared_ptr<T> for it.
* *
* The idea is that every glTF resource in the file will live as long as the Holder does, and the Holders * The idea is that every glTF resource in the file will live as long as the Holder does, and the
* are all kept in the GLTFData struct. Clients may certainly cnhoose to perpetuate the full shared_ptr<T> * Holders are all kept in the GLTFData struct. Clients may certainly cnhoose to perpetuate the full
* reference counting type, but generally speaking we pass around simple T& and T* types because the GLTFData * shared_ptr<T> reference counting type, but generally speaking we pass around simple T& and T*
* struct will, by design, outlive all other activity that takes place during in a single conversion run. * types because the GLTFData struct will, by design, outlive all other activity that takes place
* during in a single conversion run.
*/ */
template <typename T> template <typename T>
class Holder class Holder {
{
public: public:
std::shared_ptr<T> hold(T *ptr) std::shared_ptr<T> hold(T* ptr) {
{
ptr->ix = ptrs.size(); ptr->ix = ptrs.size();
ptrs.emplace_back(ptr); ptrs.emplace_back(ptr);
return ptrs.back(); return ptrs.back();
@ -52,26 +51,31 @@ public:
std::vector<std::shared_ptr<T>> ptrs; std::vector<std::shared_ptr<T>> ptrs;
}; };
class GltfModel class GltfModel {
{
public: public:
explicit GltfModel(const GltfOptions& options) explicit GltfModel(const GltfOptions& options)
: binary(new std::vector<uint8_t>) : binary(new std::vector<uint8_t>),
, isGlb(options.outputBinary) isGlb(options.outputBinary),
, defaultSampler(nullptr) defaultSampler(nullptr),
, defaultBuffer(buffers.hold(buildDefaultBuffer(options))) defaultBuffer(buffers.hold(buildDefaultBuffer(options))) {
{
defaultSampler = samplers.hold(buildDefaultSampler()); defaultSampler = samplers.hold(buildDefaultSampler());
} }
std::shared_ptr<BufferViewData> GetAlignedBufferView(BufferData &buffer, const BufferViewData::GL_ArrayType target); std::shared_ptr<BufferViewData> GetAlignedBufferView(
std::shared_ptr<BufferViewData> AddRawBufferView(BufferData &buffer, const char *source, uint32_t bytes); BufferData& buffer,
std::shared_ptr<BufferViewData> AddBufferViewForFile(BufferData &buffer, const std::string &filename); const BufferViewData::GL_ArrayType target);
std::shared_ptr<BufferViewData>
AddRawBufferView(BufferData& buffer, const char* source, uint32_t bytes);
std::shared_ptr<BufferViewData> AddBufferViewForFile(
BufferData& buffer,
const std::string& filename);
template <class T> template <class T>
std::shared_ptr<AccessorData> AddAccessorWithView( std::shared_ptr<AccessorData> AddAccessorWithView(
BufferViewData &bufferView, const GLType &type, const std::vector<T> &source, std::string name) BufferViewData& bufferView,
{ const GLType& type,
const std::vector<T>& source,
std::string name) {
auto accessor = accessors.hold(new AccessorData(bufferView, type, name)); auto accessor = accessors.hold(new AccessorData(bufferView, type, name));
accessor->appendAsBinaryArray(source, *binary); accessor->appendAsBinaryArray(source, *binary);
bufferView.byteLength = accessor->byteLength(); bufferView.byteLength = accessor->byteLength();
@ -79,26 +83,28 @@ public:
} }
template <class T> template <class T>
std::shared_ptr<AccessorData> AddAccessorAndView( std::shared_ptr<AccessorData>
BufferData &buffer, const GLType &type, const std::vector<T> &source) AddAccessorAndView(BufferData& buffer, const GLType& type, const std::vector<T>& source) {
{
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE); auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
return AddAccessorWithView(*bufferView, type, source, std::string("")); return AddAccessorWithView(*bufferView, type, source, std::string(""));
} }
template <class T> template <class T>
std::shared_ptr<AccessorData> AddAccessorAndView( std::shared_ptr<AccessorData> AddAccessorAndView(
BufferData &buffer, const GLType &type, const std::vector<T> &source, std::string name) BufferData& buffer,
{ const GLType& type,
const std::vector<T>& source,
std::string name) {
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE); auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
return AddAccessorWithView(*bufferView, type, source, name); return AddAccessorWithView(*bufferView, type, source, name);
} }
template <class T> template <class T>
std::shared_ptr<AccessorData> AddAttributeToPrimitive( std::shared_ptr<AccessorData> AddAttributeToPrimitive(
BufferData &buffer, const RawModel &surfaceModel, PrimitiveData &primitive, BufferData& buffer,
const AttributeDefinition<T> &attrDef) const RawModel& surfaceModel,
{ PrimitiveData& primitive,
const AttributeDefinition<T>& attrDef) {
// copy attribute data into vector // copy attribute data into vector
std::vector<T> attribArr; std::vector<T> attribArr;
surfaceModel.GetAttributeArray<T>(attribArr, attrDef.rawAttributeIx); surfaceModel.GetAttributeArray<T>(attribArr, attrDef.rawAttributeIx);
@ -118,8 +124,7 @@ public:
}; };
template <class T> template <class T>
void serializeHolder(json &glTFJson, std::string key, const Holder<T> holder) void serializeHolder(json& glTFJson, std::string key, const Holder<T> holder) {
{
if (!holder.ptrs.empty()) { if (!holder.ptrs.empty()) {
std::vector<json> bits; std::vector<json> bits;
for (const auto& ptr : holder.ptrs) { for (const auto& ptr : holder.ptrs) {
@ -161,8 +166,7 @@ private:
return new SamplerData(); return new SamplerData();
} }
BufferData* buildDefaultBuffer(const GltfOptions& options) { BufferData* buildDefaultBuffer(const GltfOptions& options) {
return options.outputBinary ? return options.outputBinary ? new BufferData(binary)
new BufferData(binary) : : new BufferData(extBufferFilename, binary, options.embedResources);
new BufferData(extBufferFilename, binary, options.embedResources);
} }
}; };

263
src/gltf/Raw2Gltf.cpp
View File

@ -9,17 +9,17 @@
#include "Raw2Gltf.hpp" #include "Raw2Gltf.hpp"
#include <cstdint>
#include <cassert> #include <cassert>
#include <iostream> #include <cstdint>
#include <fstream> #include <fstream>
#include <iostream>
#include <stb_image.h> #include <stb_image.h>
#include <stb_image_write.h> #include <stb_image_write.h>
#include "utils/String_Utils.hpp"
#include "utils/Image_Utils.hpp"
#include <utils/File_Utils.hpp> #include <utils/File_Utils.hpp>
#include "utils/Image_Utils.hpp"
#include "utils/String_Utils.hpp"
#include "raw/RawModel.hpp" #include "raw/RawModel.hpp"
@ -38,8 +38,8 @@
#include "gltf/properties/SkinData.hpp" #include "gltf/properties/SkinData.hpp"
#include "gltf/properties/TextureData.hpp" #include "gltf/properties/TextureData.hpp"
#include "TextureBuilder.hpp"
#include "GltfModel.hpp" #include "GltfModel.hpp"
#include "TextureBuilder.hpp"
typedef uint32_t TriangleIndex; typedef uint32_t TriangleIndex;
@ -51,8 +51,7 @@ typedef uint32_t TriangleIndex;
* classes are guaranteed to stick around for the duration of the process. * classes are guaranteed to stick around for the duration of the process.
*/ */
template <typename T> template <typename T>
T &require(std::map<std::string, std::shared_ptr<T>> map, const std::string &key) T& require(std::map<std::string, std::shared_ptr<T>> map, const std::string& key) {
{
auto iter = map.find(key); auto iter = map.find(key);
assert(iter != map.end()); assert(iter != map.end());
T& result = *iter->second; T& result = *iter->second;
@ -60,16 +59,14 @@ T &require(std::map<std::string, std::shared_ptr<T>> map, const std::string &key
} }
template <typename T> template <typename T>
T &require(std::map<long, std::shared_ptr<T>> map, long key) T& require(std::map<long, std::shared_ptr<T>> map, long key) {
{
auto iter = map.find(key); auto iter = map.find(key);
assert(iter != map.end()); assert(iter != map.end());
T& result = *iter->second; T& result = *iter->second;
return result; return result;
} }
static const std::vector<TriangleIndex> getIndexArray(const RawModel &raw) static const std::vector<TriangleIndex> getIndexArray(const RawModel& raw) {
{
std::vector<TriangleIndex> result; std::vector<TriangleIndex> result;
for (int i = 0; i < raw.GetTriangleCount(); i++) { for (int i = 0; i < raw.GetTriangleCount(); i++) {
@ -89,14 +86,14 @@ ModelData *Raw2Gltf(
std::ofstream& gltfOutStream, std::ofstream& gltfOutStream,
const std::string& outputFolder, const std::string& outputFolder,
const RawModel& raw, const RawModel& raw,
const GltfOptions &options const GltfOptions& options) {
)
{
if (verboseOutput) { if (verboseOutput) {
fmt::printf("Building render model...\n"); fmt::printf("Building render model...\n");
for (int i = 0; i < raw.GetMaterialCount(); i++) { for (int i = 0; i < raw.GetMaterialCount(); i++) {
fmt::printf( fmt::printf(
"Material %d: %s [shading: %s]\n", i, raw.GetMaterial(i).name.c_str(), "Material %d: %s [shading: %s]\n",
i,
raw.GetMaterial(i).name.c_str(),
Describe(raw.GetMaterial(i).info->shadingModel)); Describe(raw.GetMaterial(i).info->shadingModel));
} }
if (raw.GetVertexCount() > 2 * raw.GetTriangleCount()) { if (raw.GetVertexCount() > 2 * raw.GetTriangleCount()) {
@ -130,7 +127,8 @@ ModelData *Raw2Gltf(
std::map<std::string, std::shared_ptr<TextureData>> textureByIndicesKey; std::map<std::string, std::shared_ptr<TextureData>> textureByIndicesKey;
std::map<long, std::shared_ptr<MeshData>> meshBySurfaceId; std::map<long, std::shared_ptr<MeshData>> meshBySurfaceId;
// for now, we only have one buffer; data->binary points to the same vector as that BufferData does. // for now, we only have one buffer; data->binary points to the same vector as that BufferData
// does.
BufferData& buffer = *gltf->defaultBuffer; BufferData& buffer = *gltf->defaultBuffer;
{ {
// //
@ -165,7 +163,8 @@ ModelData *Raw2Gltf(
const RawAnimation& animation = raw.GetAnimation(i); const RawAnimation& animation = raw.GetAnimation(i);
if (animation.channels.size() == 0) { if (animation.channels.size() == 0) {
fmt::printf("Warning: animation '%s' has zero channels. Skipping.\n", animation.name.c_str()); fmt::printf(
"Warning: animation '%s' has zero channels. Skipping.\n", animation.name.c_str());
continue; continue;
} }
@ -175,7 +174,10 @@ ModelData *Raw2Gltf(
AnimationData& aDat = *gltf->animations.hold(new AnimationData(animation.name, *accessor)); AnimationData& aDat = *gltf->animations.hold(new AnimationData(animation.name, *accessor));
if (verboseOutput) { if (verboseOutput) {
fmt::printf("Animation '%s' has %lu channels:\n", animation.name.c_str(), animation.channels.size()); fmt::printf(
"Animation '%s' has %lu channels:\n",
animation.name.c_str(),
animation.channels.size());
} }
for (size_t channelIx = 0; channelIx < animation.channels.size(); channelIx++) { for (size_t channelIx = 0; channelIx < animation.channels.size(); channelIx++) {
@ -185,22 +187,34 @@ ModelData *Raw2Gltf(
if (verboseOutput) { if (verboseOutput) {
fmt::printf( fmt::printf(
" Channel %lu (%s) has translations/rotations/scales/weights: [%lu, %lu, %lu, %lu]\n", " Channel %lu (%s) has translations/rotations/scales/weights: [%lu, %lu, %lu, %lu]\n",
channelIx, node.name.c_str(), channel.translations.size(), channel.rotations.size(), channelIx,
channel.scales.size(), channel.weights.size()); node.name.c_str(),
channel.translations.size(),
channel.rotations.size(),
channel.scales.size(),
channel.weights.size());
} }
NodeData& nDat = require(nodesById, node.id); NodeData& nDat = require(nodesById, node.id);
if (!channel.translations.empty()) { if (!channel.translations.empty()) {
aDat.AddNodeChannel(nDat, *gltf->AddAccessorAndView(buffer, GLT_VEC3F, channel.translations), "translation"); aDat.AddNodeChannel(
nDat,
*gltf->AddAccessorAndView(buffer, GLT_VEC3F, channel.translations),
"translation");
} }
if (!channel.rotations.empty()) { if (!channel.rotations.empty()) {
aDat.AddNodeChannel(nDat, *gltf->AddAccessorAndView(buffer, GLT_QUATF, channel.rotations), "rotation"); aDat.AddNodeChannel(
nDat, *gltf->AddAccessorAndView(buffer, GLT_QUATF, channel.rotations), "rotation");
} }
if (!channel.scales.empty()) { if (!channel.scales.empty()) {
aDat.AddNodeChannel(nDat, *gltf->AddAccessorAndView(buffer, GLT_VEC3F, channel.scales), "scale"); aDat.AddNodeChannel(
nDat, *gltf->AddAccessorAndView(buffer, GLT_VEC3F, channel.scales), "scale");
} }
if (!channel.weights.empty()) { if (!channel.weights.empty()) {
aDat.AddNodeChannel(nDat, *gltf->AddAccessorAndView(buffer, {CT_FLOAT, 1, "SCALAR"}, channel.weights), "weights"); aDat.AddNodeChannel(
nDat,
*gltf->AddAccessorAndView(buffer, {CT_FLOAT, 1, "SCALAR"}, channel.weights),
"weights");
} }
} }
} }
@ -220,8 +234,7 @@ ModelData *Raw2Gltf(
for (int materialIndex = 0; materialIndex < raw.GetMaterialCount(); materialIndex++) { for (int materialIndex = 0; materialIndex < raw.GetMaterialCount(); materialIndex++) {
const RawMaterial& material = raw.GetMaterial(materialIndex); const RawMaterial& material = raw.GetMaterial(materialIndex);
const bool isTransparent = const bool isTransparent = material.type == RAW_MATERIAL_TYPE_TRANSPARENT ||
material.type == RAW_MATERIAL_TYPE_TRANSPARENT ||
material.type == RAW_MATERIAL_TYPE_SKINNED_TRANSPARENT; material.type == RAW_MATERIAL_TYPE_SKINNED_TRANSPARENT;
Vec3f emissiveFactor; Vec3f emissiveFactor;
@ -229,7 +242,9 @@ ModelData *Raw2Gltf(
// acquire the texture of a specific RawTextureUsage as *TextData, or nullptr if none exists // acquire the texture of a specific RawTextureUsage as *TextData, or nullptr if none exists
auto simpleTex = [&](RawTextureUsage usage) -> std::shared_ptr<TextureData> { auto simpleTex = [&](RawTextureUsage usage) -> std::shared_ptr<TextureData> {
return (material.textures[usage] >= 0) ? textureBuilder.simple(material.textures[usage], "simple") : nullptr; return (material.textures[usage] >= 0)
? textureBuilder.simple(material.textures[usage], "simple")
: nullptr;
}; };
TextureData* normalTexture = simpleTex(RAW_TEXTURE_USAGE_NORMAL).get(); TextureData* normalTexture = simpleTex(RAW_TEXTURE_USAGE_NORMAL).get();
@ -251,7 +266,8 @@ ModelData *Raw2Gltf(
* Other values translate directly. * Other values translate directly.
*/ */
RawMetRoughMatProps* props = (RawMetRoughMatProps*)material.info.get(); RawMetRoughMatProps* props = (RawMetRoughMatProps*)material.info.get();
// merge metallic into the blue channel and roughness into the green, of a new combinatory texture // merge metallic into the blue channel and roughness into the green, of a new combinatory
// texture
aoMetRoughTex = textureBuilder.combine( aoMetRoughTex = textureBuilder.combine(
{ {
material.textures[RAW_TEXTURE_USAGE_OCCLUSION], material.textures[RAW_TEXTURE_USAGE_OCCLUSION],
@ -270,7 +286,8 @@ ModelData *Raw2Gltf(
roughness = props->roughness; roughness = props->roughness;
emissiveFactor = props->emissiveFactor; emissiveFactor = props->emissiveFactor;
emissiveIntensity = props->emissiveIntensity; emissiveIntensity = props->emissiveIntensity;
// add the occlusion texture only if actual occlusion pixels exist in the aoNetRough texture. // add the occlusion texture only if actual occlusion pixels exist in the aoNetRough
// texture.
if (material.textures[RAW_TEXTURE_USAGE_OCCLUSION] >= 0) { if (material.textures[RAW_TEXTURE_USAGE_OCCLUSION] >= 0) {
occlusionTexture = aoMetRoughTex.get(); occlusionTexture = aoMetRoughTex.get();
} }
@ -284,8 +301,7 @@ ModelData *Raw2Gltf(
diffuseFactor = props->diffuseFactor; diffuseFactor = props->diffuseFactor;
if (material.info->shadingModel == RAW_SHADING_MODEL_BLINN || if (material.info->shadingModel == RAW_SHADING_MODEL_BLINN ||
material.info->shadingModel == RAW_SHADING_MODEL_PHONG) material.info->shadingModel == RAW_SHADING_MODEL_PHONG) {
{
// blinn/phong hardcoded to 0.4 metallic // blinn/phong hardcoded to 0.4 metallic
metallic = 0.4f; metallic = 0.4f;
@ -295,15 +311,17 @@ ModelData *Raw2Gltf(
// shininess 6 -> roughness 0.5 // shininess 6 -> roughness 0.5
// shininess 16 -> roughness ~0.33 // shininess 16 -> roughness ~0.33
// as shininess ==> oo, roughness ==> 0 // as shininess ==> oo, roughness ==> 0
auto getRoughness = [&](float shininess) { auto getRoughness = [&](float shininess) { return sqrtf(2.0f / (2.0f + shininess)); };
return sqrtf(2.0f / (2.0f + shininess));
};
aoMetRoughTex = textureBuilder.combine( aoMetRoughTex = textureBuilder.combine(
{ material.textures[RAW_TEXTURE_USAGE_SHININESS], }, {
material.textures[RAW_TEXTURE_USAGE_SHININESS],
},
"ao_met_rough", "ao_met_rough",
[&](const std::vector<const TextureBuilder::pixel *> pixels) -> TextureBuilder::pixel { [&](const std::vector<const TextureBuilder::pixel*> pixels)
// do not multiply with props->shininess; that doesn't work like the other factors. -> TextureBuilder::pixel {
// do not multiply with props->shininess; that doesn't work like the other
// factors.
float shininess = props->shininess * (*pixels[0])[0]; float shininess = props->shininess * (*pixels[0])[0];
return {{0, getRoughness(shininess), metallic, 1}}; return {{0, getRoughness(shininess), metallic, 1}};
}, },
@ -327,7 +345,8 @@ ModelData *Raw2Gltf(
emissiveFactor = props->emissiveFactor; emissiveFactor = props->emissiveFactor;
emissiveIntensity = 1.0f; emissiveIntensity = 1.0f;
} }
pbrMetRough.reset(new PBRMetallicRoughness(baseColorTex.get(), aoMetRoughTex.get(), diffuseFactor, metallic, roughness)); pbrMetRough.reset(new PBRMetallicRoughness(
baseColorTex.get(), aoMetRoughTex.get(), diffuseFactor, metallic, roughness));
} }
std::shared_ptr<KHRCmnUnlitMaterial> khrCmnUnlitMat; std::shared_ptr<KHRCmnUnlitMaterial> khrCmnUnlitMat;
@ -350,7 +369,8 @@ ModelData *Raw2Gltf(
baseColorTex = simpleTex(RAW_TEXTURE_USAGE_DIFFUSE); baseColorTex = simpleTex(RAW_TEXTURE_USAGE_DIFFUSE);
} }
pbrMetRough.reset(new PBRMetallicRoughness(baseColorTex.get(), nullptr, diffuseFactor, 0.0f, 1.0f)); pbrMetRough.reset(
new PBRMetallicRoughness(baseColorTex.get(), nullptr, diffuseFactor, 0.0f, 1.0f));
khrCmnUnlitMat.reset(new KHRCmnUnlitMaterial()); khrCmnUnlitMat.reset(new KHRCmnUnlitMaterial());
} }
@ -358,11 +378,16 @@ ModelData *Raw2Gltf(
occlusionTexture = simpleTex(RAW_TEXTURE_USAGE_OCCLUSION).get(); occlusionTexture = simpleTex(RAW_TEXTURE_USAGE_OCCLUSION).get();
} }
std::shared_ptr<MaterialData> mData = gltf->materials.hold( std::shared_ptr<MaterialData> mData = gltf->materials.hold(new MaterialData(
new MaterialData( material.name,
material.name, isTransparent, material.info->shadingModel, isTransparent,
normalTexture, occlusionTexture, emissiveTexture, material.info->shadingModel,
emissiveFactor * emissiveIntensity, khrCmnUnlitMat, pbrMetRough)); normalTexture,
occlusionTexture,
emissiveTexture,
emissiveFactor * emissiveIntensity,
khrCmnUnlitMat,
pbrMetRough));
materialsByName[materialHash(material)] = mData; materialsByName[materialHash(material)] = mData;
if (options.enableUserProperties) { if (options.enableUserProperties) {
@ -375,7 +400,8 @@ ModelData *Raw2Gltf(
const RawSurface& rawSurface = surfaceModel.GetSurface(0); const RawSurface& rawSurface = surfaceModel.GetSurface(0);
const long surfaceId = rawSurface.id; const long surfaceId = rawSurface.id;
const RawMaterial &rawMaterial = surfaceModel.GetMaterial(surfaceModel.GetTriangle(0).materialIndex); const RawMaterial& rawMaterial =
surfaceModel.GetMaterial(surfaceModel.GetTriangle(0).materialIndex);
const MaterialData& mData = require(materialsByName, materialHash(rawMaterial)); const MaterialData& mData = require(materialsByName, materialHash(rawMaterial));
MeshData* mesh = nullptr; MeshData* mesh = nullptr;
@ -393,10 +419,9 @@ ModelData *Raw2Gltf(
mesh = meshPtr.get(); mesh = meshPtr.get();
} }
bool useLongIndices = bool useLongIndices = (options.useLongIndices == UseLongIndicesOptions::ALWAYS) ||
(options.useLongIndices == UseLongIndicesOptions::ALWAYS) (options.useLongIndices == UseLongIndicesOptions::AUTO &&
|| (options.useLongIndices == UseLongIndicesOptions::AUTO surfaceModel.GetVertexCount() > 65535);
&& surfaceModel.GetVertexCount() > 65535);
std::shared_ptr<PrimitiveData> primitive; std::shared_ptr<PrimitiveData> primitive;
if (options.draco.enabled) { if (options.draco.enabled) {
@ -414,13 +439,16 @@ ModelData *Raw2Gltf(
dracoMesh->SetFace(draco::FaceIndex(ii), face); dracoMesh->SetFace(draco::FaceIndex(ii), face);
} }
AccessorData &indexes = *gltf->accessors.hold(new AccessorData(useLongIndices ? GLT_UINT : GLT_USHORT)); AccessorData& indexes =
*gltf->accessors.hold(new AccessorData(useLongIndices ? GLT_UINT : GLT_USHORT));
indexes.count = 3 * triangleCount; indexes.count = 3 * triangleCount;
primitive.reset(new PrimitiveData(indexes, mData, dracoMesh)); primitive.reset(new PrimitiveData(indexes, mData, dracoMesh));
} else { } else {
const AccessorData& indexes = *gltf->AddAccessorWithView( const AccessorData& indexes = *gltf->AddAccessorWithView(
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ELEMENT_ARRAY_BUFFER), *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ELEMENT_ARRAY_BUFFER),
useLongIndices ? GLT_UINT : GLT_USHORT, getIndexArray(surfaceModel), std::string("")); useLongIndices ? GLT_UINT : GLT_USHORT,
getIndexArray(surfaceModel),
std::string(""));
primitive.reset(new PrimitiveData(indexes, mData)); primitive.reset(new PrimitiveData(indexes, mData));
}; };
@ -429,17 +457,25 @@ ModelData *Raw2Gltf(
// //
{ {
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_POSITION) != 0) { if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_POSITION) != 0) {
const AttributeDefinition<Vec3f> ATTR_POSITION("POSITION", &RawVertex::position, const AttributeDefinition<Vec3f> ATTR_POSITION(
GLT_VEC3F, draco::GeometryAttribute::POSITION, draco::DT_FLOAT32); "POSITION",
auto accessor = gltf->AddAttributeToPrimitive<Vec3f>( &RawVertex::position,
buffer, surfaceModel, *primitive, ATTR_POSITION); GLT_VEC3F,
draco::GeometryAttribute::POSITION,
draco::DT_FLOAT32);
auto accessor =
gltf->AddAttributeToPrimitive<Vec3f>(buffer, surfaceModel, *primitive, ATTR_POSITION);
accessor->min = toStdVec(rawSurface.bounds.min); accessor->min = toStdVec(rawSurface.bounds.min);
accessor->max = toStdVec(rawSurface.bounds.max); accessor->max = toStdVec(rawSurface.bounds.max);
} }
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_NORMAL) != 0) { if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_NORMAL) != 0) {
const AttributeDefinition<Vec3f> ATTR_NORMAL("NORMAL", &RawVertex::normal, const AttributeDefinition<Vec3f> ATTR_NORMAL(
GLT_VEC3F, draco::GeometryAttribute::NORMAL, draco::DT_FLOAT32); "NORMAL",
&RawVertex::normal,
GLT_VEC3F,
draco::GeometryAttribute::NORMAL,
draco::DT_FLOAT32);
gltf->AddAttributeToPrimitive<Vec3f>(buffer, surfaceModel, *primitive, ATTR_NORMAL); gltf->AddAttributeToPrimitive<Vec3f>(buffer, surfaceModel, *primitive, ATTR_NORMAL);
} }
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_TANGENT) != 0) { if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_TANGENT) != 0) {
@ -447,28 +483,48 @@ ModelData *Raw2Gltf(
gltf->AddAttributeToPrimitive<Vec4f>(buffer, surfaceModel, *primitive, ATTR_TANGENT); gltf->AddAttributeToPrimitive<Vec4f>(buffer, surfaceModel, *primitive, ATTR_TANGENT);
} }
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_COLOR) != 0) { if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_COLOR) != 0) {
const AttributeDefinition<Vec4f> ATTR_COLOR("COLOR_0", &RawVertex::color, GLT_VEC4F, const AttributeDefinition<Vec4f> ATTR_COLOR(
draco::GeometryAttribute::COLOR, draco::DT_FLOAT32); "COLOR_0",
&RawVertex::color,
GLT_VEC4F,
draco::GeometryAttribute::COLOR,
draco::DT_FLOAT32);
gltf->AddAttributeToPrimitive<Vec4f>(buffer, surfaceModel, *primitive, ATTR_COLOR); gltf->AddAttributeToPrimitive<Vec4f>(buffer, surfaceModel, *primitive, ATTR_COLOR);
} }
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_UV0) != 0) { if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_UV0) != 0) {
const AttributeDefinition<Vec2f> ATTR_TEXCOORD_0("TEXCOORD_0", &RawVertex::uv0, const AttributeDefinition<Vec2f> ATTR_TEXCOORD_0(
GLT_VEC2F, draco::GeometryAttribute::TEX_COORD, draco::DT_FLOAT32); "TEXCOORD_0",
&RawVertex::uv0,
GLT_VEC2F,
draco::GeometryAttribute::TEX_COORD,
draco::DT_FLOAT32);
gltf->AddAttributeToPrimitive<Vec2f>(buffer, surfaceModel, *primitive, ATTR_TEXCOORD_0); gltf->AddAttributeToPrimitive<Vec2f>(buffer, surfaceModel, *primitive, ATTR_TEXCOORD_0);
} }
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_UV1) != 0) { if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_UV1) != 0) {
const AttributeDefinition<Vec2f> ATTR_TEXCOORD_1("TEXCOORD_1", &RawVertex::uv1, const AttributeDefinition<Vec2f> ATTR_TEXCOORD_1(
GLT_VEC2F, draco::GeometryAttribute::TEX_COORD, draco::DT_FLOAT32); "TEXCOORD_1",
&RawVertex::uv1,
GLT_VEC2F,
draco::GeometryAttribute::TEX_COORD,
draco::DT_FLOAT32);
gltf->AddAttributeToPrimitive<Vec2f>(buffer, surfaceModel, *primitive, ATTR_TEXCOORD_1); gltf->AddAttributeToPrimitive<Vec2f>(buffer, surfaceModel, *primitive, ATTR_TEXCOORD_1);
} }
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_JOINT_INDICES) != 0) { if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_JOINT_INDICES) != 0) {
const AttributeDefinition<Vec4i> ATTR_JOINTS("JOINTS_0", &RawVertex::jointIndices, const AttributeDefinition<Vec4i> ATTR_JOINTS(
GLT_VEC4I, draco::GeometryAttribute::GENERIC, draco::DT_UINT16); "JOINTS_0",
&RawVertex::jointIndices,
GLT_VEC4I,
draco::GeometryAttribute::GENERIC,
draco::DT_UINT16);
gltf->AddAttributeToPrimitive<Vec4i>(buffer, surfaceModel, *primitive, ATTR_JOINTS); gltf->AddAttributeToPrimitive<Vec4i>(buffer, surfaceModel, *primitive, ATTR_JOINTS);
} }
if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS) != 0) { if ((surfaceModel.GetVertexAttributes() & RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS) != 0) {
const AttributeDefinition<Vec4f> ATTR_WEIGHTS("WEIGHTS_0", &RawVertex::jointWeights, const AttributeDefinition<Vec4f> ATTR_WEIGHTS(
GLT_VEC4F, draco::GeometryAttribute::GENERIC, draco::DT_FLOAT32); "WEIGHTS_0",
&RawVertex::jointWeights,
GLT_VEC4F,
draco::GeometryAttribute::GENERIC,
draco::DT_FLOAT32);
gltf->AddAttributeToPrimitive<Vec4f>(buffer, surfaceModel, *primitive, ATTR_WEIGHTS); gltf->AddAttributeToPrimitive<Vec4f>(buffer, surfaceModel, *primitive, ATTR_WEIGHTS);
} }
@ -494,7 +550,9 @@ ModelData *Raw2Gltf(
} }
std::shared_ptr<AccessorData> pAcc = gltf->AddAccessorWithView( std::shared_ptr<AccessorData> pAcc = gltf->AddAccessorWithView(
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER),
GLT_VEC3F, positions, channel.name); GLT_VEC3F,
positions,
channel.name);
pAcc->min = toStdVec(shapeBounds.min); pAcc->min = toStdVec(shapeBounds.min);
pAcc->max = toStdVec(shapeBounds.max); pAcc->max = toStdVec(shapeBounds.max);
@ -502,14 +560,18 @@ ModelData *Raw2Gltf(
if (!normals.empty()) { if (!normals.empty()) {
nAcc = gltf->AddAccessorWithView( nAcc = gltf->AddAccessorWithView(
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER),
GLT_VEC3F, normals, channel.name); GLT_VEC3F,
normals,
channel.name);
} }
std::shared_ptr<AccessorData> tAcc; std::shared_ptr<AccessorData> tAcc;
if (!tangents.empty()) { if (!tangents.empty()) {
nAcc = gltf->AddAccessorWithView( nAcc = gltf->AddAccessorWithView(
*gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER), *gltf->GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER),
GLT_VEC4F, tangents, channel.name); GLT_VEC4F,
tangents,
channel.name);
} }
primitive->AddTarget(pAcc.get(), nAcc.get(), tAcc.get()); primitive->AddTarget(pAcc.get(), nAcc.get(), tAcc.get());
@ -524,19 +586,24 @@ ModelData *Raw2Gltf(
encoder.SetSpeedOptions(dracoSpeed, dracoSpeed); encoder.SetSpeedOptions(dracoSpeed, dracoSpeed);
} }
if (options.draco.quantBitsPosition != -1) { if (options.draco.quantBitsPosition != -1) {
encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, options.draco.quantBitsPosition); encoder.SetAttributeQuantization(
draco::GeometryAttribute::POSITION, options.draco.quantBitsPosition);
} }
if (options.draco.quantBitsTexCoord != -1) { if (options.draco.quantBitsTexCoord != -1) {
encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD, options.draco.quantBitsTexCoord); encoder.SetAttributeQuantization(
draco::GeometryAttribute::TEX_COORD, options.draco.quantBitsTexCoord);
} }
if (options.draco.quantBitsNormal != -1) { if (options.draco.quantBitsNormal != -1) {
encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, options.draco.quantBitsNormal); encoder.SetAttributeQuantization(
draco::GeometryAttribute::NORMAL, options.draco.quantBitsNormal);
} }
if (options.draco.quantBitsColor != -1) { if (options.draco.quantBitsColor != -1) {
encoder.SetAttributeQuantization(draco::GeometryAttribute::COLOR, options.draco.quantBitsColor); encoder.SetAttributeQuantization(
draco::GeometryAttribute::COLOR, options.draco.quantBitsColor);
} }
if (options.draco.quantBitsGeneric != -1) { if (options.draco.quantBitsGeneric != -1) {
encoder.SetAttributeQuantization(draco::GeometryAttribute::GENERIC, options.draco.quantBitsGeneric); encoder.SetAttributeQuantization(
draco::GeometryAttribute::GENERIC, options.draco.quantBitsGeneric);
} }
draco::EncoderBuffer dracoBuffer; draco::EncoderBuffer dracoBuffer;
@ -560,8 +627,7 @@ ModelData *Raw2Gltf(
// //
// Assign mesh to node // Assign mesh to node
// //
if (node.surfaceId > 0) if (node.surfaceId > 0) {
{
int surfaceIndex = raw.GetSurfaceById(node.surfaceId); int surfaceIndex = raw.GetSurfaceById(node.surfaceId);
const RawSurface& rawSurface = raw.GetSurface(surfaceIndex); const RawSurface& rawSurface = raw.GetSurface(surfaceIndex);
@ -675,16 +741,31 @@ ModelData *Raw2Gltf(
if (options.outputBinary) { if (options.outputBinary) {
// note: glTF binary is little-endian // note: glTF binary is little-endian
const char glbHeader[] = { const char glbHeader[] = {
'g', 'l', 'T', 'F', // magic 'g',
0x02, 0x00, 0x00, 0x00, // version 'l',
0x00, 0x00, 0x00, 0x00, // total length: written in later 'T',
'F', // magic
0x02,
0x00,
0x00,
0x00, // version
0x00,
0x00,
0x00,
0x00, // total length: written in later
}; };
gltfOutStream.write(glbHeader, 12); gltfOutStream.write(glbHeader, 12);
// binary glTF 2.0 has a sub-header for each of the JSON and BIN chunks // binary glTF 2.0 has a sub-header for each of the JSON and BIN chunks
const char glb2JsonHeader[] = { const char glb2JsonHeader[] = {
0x00, 0x00, 0x00, 0x00, // chunk length: written in later 0x00,
'J', 'S', 'O', 'N', // chunk type: 0x4E4F534A aka JSON 0x00,
0x00,
0x00, // chunk length: written in later
'J',
'S',
'O',
'N', // chunk type: 0x4E4F534A aka JSON
}; };
gltfOutStream.write(glb2JsonHeader, 8); gltfOutStream.write(glb2JsonHeader, 8);
} }
@ -702,12 +783,8 @@ ModelData *Raw2Gltf(
extensionsRequired.push_back(KHR_DRACO_MESH_COMPRESSION); extensionsRequired.push_back(KHR_DRACO_MESH_COMPRESSION);
} }
json glTFJson { json glTFJson{{"asset", {{"generator", "FBX2glTF v" + FBX2GLTF_VERSION}, {"version", "2.0"}}},
{ "asset", { {"scene", rootScene.ix}};
{ "generator", "FBX2glTF v" + FBX2GLTF_VERSION },
{ "version", "2.0" }}},
{ "scene", rootScene.ix }
};
if (!extensionsUsed.empty()) { if (!extensionsUsed.empty()) {
glTFJson["extensionsUsed"] = extensionsUsed; glTFJson["extensionsUsed"] = extensionsUsed;
} }
@ -730,8 +807,14 @@ ModelData *Raw2Gltf(
uint32_t binHeader = (uint32_t)gltfOutStream.tellp(); uint32_t binHeader = (uint32_t)gltfOutStream.tellp();
// binary glTF 2.0 has a sub-header for each of the JSON and BIN chunks // binary glTF 2.0 has a sub-header for each of the JSON and BIN chunks
const char glb2BinaryHeader[] = { const char glb2BinaryHeader[] = {
0x00, 0x00, 0x00, 0x00, // chunk length: written in later 0x00,
'B', 'I', 'N', 0x00, // chunk type: 0x004E4942 aka BIN 0x00,
0x00,
0x00, // chunk length: written in later
'B',
'I',
'N',
0x00, // chunk type: 0x004E4942 aka BIN
}; };
gltfOutStream.write(glb2BinaryHeader, 8); gltfOutStream.write(glb2BinaryHeader, 8);

43
src/gltf/Raw2Gltf.hpp
View File

@ -27,8 +27,7 @@ const std::string extBufferFilename = "buffer.bin";
struct ComponentType { struct ComponentType {
// OpenGL Datatype enums // OpenGL Datatype enums
enum GL_DataType enum GL_DataType {
{
GL_BYTE = 5120, GL_BYTE = 5120,
GL_UNSIGNED_BYTE, GL_UNSIGNED_BYTE,
GL_SHORT, GL_SHORT,
@ -49,14 +48,15 @@ const ComponentType CT_FLOAT = {ComponentType::GL_FLOAT, 4};
// Map our low-level data types for glTF output // Map our low-level data types for glTF output
struct GLType { struct GLType {
GLType(const ComponentType& componentType, unsigned int count, const std::string dataType) GLType(const ComponentType& componentType, unsigned int count, const std::string dataType)
: componentType(componentType), : componentType(componentType), count(count), dataType(dataType) {}
count(count),
dataType(dataType)
{}
unsigned int byteStride() const { return componentType.size * count; } unsigned int byteStride() const {
return componentType.size * count;
}
void write(uint8_t *buf, const float scalar) const { *((float *) buf) = scalar; } void write(uint8_t* buf, const float scalar) const {
*((float*)buf) = scalar;
}
void write(uint8_t* buf, const uint32_t scalar) const { void write(uint8_t* buf, const uint32_t scalar) const {
switch (componentType.size) { switch (componentType.size) {
case 1: case 1:
@ -119,16 +119,14 @@ const GLType GLT_QUATF = {CT_FLOAT, 4, "VEC4"};
/** /**
* The base of any indexed glTF entity. * The base of any indexed glTF entity.
*/ */
struct Holdable struct Holdable {
{
uint32_t ix; uint32_t ix;
virtual json serialize() const = 0; virtual json serialize() const = 0;
}; };
template <class T> template <class T>
struct AttributeDefinition struct AttributeDefinition {
{
const std::string gltfName; const std::string gltfName;
const T RawVertex::*rawAttributeIx; const T RawVertex::*rawAttributeIx;
const GLType glType; const GLType glType;
@ -136,8 +134,11 @@ struct AttributeDefinition
const draco::DataType dracoComponentType; const draco::DataType dracoComponentType;
AttributeDefinition( AttributeDefinition(
const std::string gltfName, const T RawVertex::*rawAttributeIx, const GLType &_glType, const std::string gltfName,
const draco::GeometryAttribute::Type dracoAttribute, const draco::DataType dracoComponentType) const T RawVertex::*rawAttributeIx,
const GLType& _glType,
const draco::GeometryAttribute::Type dracoAttribute,
const draco::DataType dracoComponentType)
: gltfName(gltfName), : gltfName(gltfName),
rawAttributeIx(rawAttributeIx), rawAttributeIx(rawAttributeIx),
glType(_glType), glType(_glType),
@ -145,7 +146,9 @@ struct AttributeDefinition
dracoComponentType(dracoComponentType) {} dracoComponentType(dracoComponentType) {}
AttributeDefinition( AttributeDefinition(
const std::string gltfName, const T RawVertex::*rawAttributeIx, const GLType &_glType) const std::string gltfName,
const T RawVertex::*rawAttributeIx,
const GLType& _glType)
: gltfName(gltfName), : gltfName(gltfName),
rawAttributeIx(rawAttributeIx), rawAttributeIx(rawAttributeIx),
glType(_glType), glType(_glType),
@ -169,12 +172,9 @@ struct SceneData;
struct SkinData; struct SkinData;
struct TextureData; struct TextureData;
struct ModelData struct ModelData {
{
explicit ModelData(std::shared_ptr<const std::vector<uint8_t>> const& _binary) explicit ModelData(std::shared_ptr<const std::vector<uint8_t>> const& _binary)
: binary(_binary) : binary(_binary) {}
{
}
std::shared_ptr<const std::vector<uint8_t>> const binary; std::shared_ptr<const std::vector<uint8_t>> const binary;
}; };
@ -183,5 +183,4 @@ ModelData *Raw2Gltf(
std::ofstream& gltfOutStream, std::ofstream& gltfOutStream,
const std::string& outputFolder, const std::string& outputFolder,
const RawModel& raw, const RawModel& raw,
const GltfOptions &options const GltfOptions& options);
);

47
src/gltf/TextureBuilder.cpp
View File

@ -12,9 +12,9 @@
#include <stb_image.h> #include <stb_image.h>
#include <stb_image_write.h> #include <stb_image_write.h>
#include <utils/File_Utils.hpp>
#include <utils/Image_Utils.hpp> #include <utils/Image_Utils.hpp>
#include <utils/String_Utils.hpp> #include <utils/String_Utils.hpp>
#include <utils/File_Utils.hpp>
#include <gltf/properties/ImageData.hpp> #include <gltf/properties/ImageData.hpp>
#include <gltf/properties/TextureData.hpp> #include <gltf/properties/TextureData.hpp>
@ -34,8 +34,7 @@ std::shared_ptr<TextureData> TextureBuilder::combine(
const std::vector<int>& ixVec, const std::vector<int>& ixVec,
const std::string& tag, const std::string& tag,
const pixel_merger& computePixel, const pixel_merger& computePixel,
bool includeAlphaChannel) bool includeAlphaChannel) {
{
const std::string key = texIndicesKey(ixVec, tag); const std::string key = texIndicesKey(ixVec, tag);
auto iter = textureByIndicesKey.find(key); auto iter = textureByIndicesKey.find(key);
if (iter != textureByIndicesKey.end()) { if (iter != textureByIndicesKey.end()) {
@ -50,21 +49,24 @@ std::shared_ptr<TextureData> TextureBuilder::combine(
if (rawTexIx >= 0) { if (rawTexIx >= 0) {
const RawTexture& rawTex = raw.GetTexture(rawTexIx); const RawTexture& rawTex = raw.GetTexture(rawTexIx);
const std::string& fileLoc = rawTex.fileLocation; const std::string& fileLoc = rawTex.fileLocation;
const std::string &name = StringUtils::GetFileBaseString(StringUtils::GetFileNameString(fileLoc)); const std::string& name =
StringUtils::GetFileBaseString(StringUtils::GetFileNameString(fileLoc));
if (!fileLoc.empty()) { if (!fileLoc.empty()) {
info.pixels = stbi_load(fileLoc.c_str(), &info.width, &info.height, &info.channels, 0); info.pixels = stbi_load(fileLoc.c_str(), &info.width, &info.height, &info.channels, 0);
if (!info.pixels) { if (!info.pixels) {
fmt::printf("Warning: merge texture [%d](%s) could not be loaded.\n", fmt::printf("Warning: merge texture [%d](%s) could not be loaded.\n", rawTexIx, name);
rawTexIx,
name);
} else { } else {
if (width < 0) { if (width < 0) {
width = info.width; width = info.width;
height = info.height; height = info.height;
} else if (width != info.width || height != info.height) { } else if (width != info.width || height != info.height) {
fmt::printf("Warning: texture %s (%d, %d) can't be merged with previous texture(s) of dimension (%d, %d)\n", fmt::printf(
"Warning: texture %s (%d, %d) can't be merged with previous texture(s) of dimension (%d, %d)\n",
name, name,
info.width, info.height, width, height); info.width,
info.height,
width,
height);
// this is bad enough that we abort the whole merge // this is bad enough that we abort the whole merge
return nullptr; return nullptr;
} }
@ -121,11 +123,17 @@ std::shared_ptr<TextureData> TextureBuilder::combine(
std::vector<char> imgBuffer; std::vector<char> imgBuffer;
int res; int res;
if (png) { if (png) {
res = stbi_write_png_to_func(WriteToVectorContext, &imgBuffer, res = stbi_write_png_to_func(
width, height, channels, mergedPixels.data(), width * channels); WriteToVectorContext,
&imgBuffer,
width,
height,
channels,
mergedPixels.data(),
width * channels);
} else { } else {
res = stbi_write_jpg_to_func(WriteToVectorContext, &imgBuffer, res = stbi_write_jpg_to_func(
width, height, channels, mergedPixels.data(), 80); WriteToVectorContext, &imgBuffer, width, height, channels, mergedPixels.data(), 80);
} }
if (!res) { if (!res) {
fmt::printf("Warning: failed to generate merge texture '%s'.\n", mergedFilename); fmt::printf("Warning: failed to generate merge texture '%s'.\n", mergedFilename);
@ -134,7 +142,8 @@ std::shared_ptr<TextureData> TextureBuilder::combine(
ImageData* image; ImageData* image;
if (options.outputBinary) { if (options.outputBinary) {
const auto bufferView = gltf.AddRawBufferView(*gltf.defaultBuffer, imgBuffer.data(), imgBuffer.size()); const auto bufferView =
gltf.AddRawBufferView(*gltf.defaultBuffer, imgBuffer.data(), imgBuffer.size());
image = new ImageData(mergedName, *bufferView, png ? "image/png" : "image/jpeg"); image = new ImageData(mergedName, *bufferView, png ? "image/png" : "image/jpeg");
} else { } else {
const std::string imageFilename = mergedFilename + (png ? ".png" : ".jpg"); const std::string imageFilename = mergedFilename + (png ? ".png" : ".jpg");
@ -146,7 +155,8 @@ std::shared_ptr<TextureData> TextureBuilder::combine(
} }
if (fwrite(imgBuffer.data(), imgBuffer.size(), 1, fp) != 1) { if (fwrite(imgBuffer.data(), imgBuffer.size(), 1, fp) != 1) {
fmt::printf("Warning: Failed to write %lu bytes to file '%s'.\n", imgBuffer.size(), imagePath); fmt::printf(
"Warning: Failed to write %lu bytes to file '%s'.\n", imgBuffer.size(), imagePath);
fclose(fp); fclose(fp);
return nullptr; return nullptr;
} }
@ -185,8 +195,7 @@ std::shared_ptr<TextureData> TextureBuilder::simple(int rawTexIndex, const std::
} else if (!relativeFilename.empty()) { } else if (!relativeFilename.empty()) {
image = new ImageData(relativeFilename, relativeFilename); image = new ImageData(relativeFilename, relativeFilename);
std::string outputPath = outputFolder + StringUtils::NormalizePath(relativeFilename); std::string outputPath = outputFolder + StringUtils::NormalizePath(relativeFilename);
if (FileUtils::CopyFile(rawTexture.fileLocation, outputPath, true)) if (FileUtils::CopyFile(rawTexture.fileLocation, outputPath, true)) {
{
if (verboseOutput) { if (verboseOutput) {
fmt::printf("Copied texture '%s' to output folder: %s\n", textureName, outputPath); fmt::printf("Copied texture '%s' to output folder: %s\n", textureName, outputPath);
} }
@ -200,13 +209,11 @@ std::shared_ptr<TextureData> TextureBuilder::simple(int rawTexIndex, const std::
// fallback is tiny transparent PNG // fallback is tiny transparent PNG
image = new ImageData( image = new ImageData(
textureName, textureName,
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==" "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg==");
);
} }
std::shared_ptr<TextureData> texDat = gltf.textures.hold( std::shared_ptr<TextureData> texDat = gltf.textures.hold(
new TextureData(textureName, *gltf.defaultSampler, *gltf.images.hold(image))); new TextureData(textureName, *gltf.defaultSampler, *gltf.images.hold(image)));
textureByIndicesKey.insert(std::make_pair(key, texDat)); textureByIndicesKey.insert(std::make_pair(key, texDat));
return texDat; return texDat;
} }

30
src/gltf/TextureBuilder.hpp
View File

@ -17,26 +17,24 @@
#include "GltfModel.hpp" #include "GltfModel.hpp"
class TextureBuilder class TextureBuilder {
{
public: public:
using pixel = std::array<float, 4>; // pixel components are floats in [0, 1] using pixel = std::array<float, 4>; // pixel components are floats in [0, 1]
using pixel_merger = std::function<pixel(const std::vector<const pixel*>)>; using pixel_merger = std::function<pixel(const std::vector<const pixel*>)>;
TextureBuilder(const RawModel &raw, const GltfOptions &options, const std::string &outputFolder, GltfModel &gltf) TextureBuilder(
: raw(raw) const RawModel& raw,
, options(options) const GltfOptions& options,
, outputFolder(outputFolder) const std::string& outputFolder,
, gltf(gltf) GltfModel& gltf)
{} : raw(raw), options(options), outputFolder(outputFolder), gltf(gltf) {}
~TextureBuilder() {} ~TextureBuilder() {}
std::shared_ptr<TextureData> combine( std::shared_ptr<TextureData> combine(
const std::vector<int>& ixVec, const std::vector<int>& ixVec,
const std::string& tag, const std::string& tag,
const pixel_merger& mergeFunction, const pixel_merger& mergeFunction,
bool transparency bool transparency);
);
std::shared_ptr<TextureData> simple(int rawTexIndex, const std::string& tag); std::shared_ptr<TextureData> simple(int rawTexIndex, const std::string& tag);
@ -50,10 +48,14 @@ public:
static std::string describeChannel(int channels) { static std::string describeChannel(int channels) {
switch (channels) { switch (channels) {
case 1: return "G"; case 1:
case 2: return "GA"; return "G";
case 3: return "RGB"; case 2:
case 4: return "RGBA"; return "GA";
case 3:
return "RGB";
case 4:
return "RGBA";
default: default:
return fmt::format("?%d?", channels); return fmt::format("?%d?", channels);
} }

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

@ -16,26 +16,14 @@ AccessorData::AccessorData(const BufferViewData &bufferView, GLType type, std::s
type(std::move(type)), type(std::move(type)),
byteOffset(0), byteOffset(0),
count(0), count(0),
name(name) name(name) {}
{
}
AccessorData::AccessorData(GLType type) AccessorData::AccessorData(GLType type)
: Holdable(), : Holdable(), bufferView(-1), type(std::move(type)), byteOffset(0), count(0) {}
bufferView(-1),
type(std::move(type)),
byteOffset(0),
count(0)
{
}
json AccessorData::serialize() const json AccessorData::serialize() const {
{
json result{ json result{
{ "componentType", type.componentType.glType }, {"componentType", type.componentType.glType}, {"type", type.dataType}, {"count", count}};
{ "type", type.dataType },
{ "count", count }
};
if (bufferView >= 0) { if (bufferView >= 0) {
result["bufferView"] = bufferView; result["bufferView"] = bufferView;
result["byteOffset"] = byteOffset; result["byteOffset"] = byteOffset;

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

@ -11,16 +11,14 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct AccessorData : Holdable struct AccessorData : Holdable {
{
AccessorData(const BufferViewData& bufferView, GLType type, std::string name); AccessorData(const BufferViewData& bufferView, GLType type, std::string name);
explicit AccessorData(GLType type); explicit AccessorData(GLType type);
json serialize() const override; json serialize() const override;
template <class T> template <class T>
void appendAsBinaryArray(const std::vector<T> &in, std::vector<uint8_t> &out) void appendAsBinaryArray(const std::vector<T>& in, std::vector<uint8_t>& out) {
{
const unsigned int stride = type.byteStride(); const unsigned int stride = type.byteStride();
const size_t offset = out.size(); const size_t offset = out.size();
const size_t count = in.size(); const size_t count = in.size();
@ -33,7 +31,9 @@ struct AccessorData : Holdable
} }
} }
unsigned int byteLength() const { return type.byteStride() * count; } unsigned int byteLength() const {
return type.byteStride() * count;
}
const int bufferView; const int bufferView;
const GLType type; const GLType type;

43
src/gltf/properties/AnimationData.cpp
View File

@ -15,50 +15,35 @@
#include "NodeData.hpp" #include "NodeData.hpp"
AnimationData::AnimationData(std::string name, const AccessorData& timeAccessor) AnimationData::AnimationData(std::string name, const AccessorData& timeAccessor)
: Holdable(), : Holdable(), name(std::move(name)), timeAccessor(timeAccessor.ix) {}
name(std::move(name)),
timeAccessor(timeAccessor.ix) {}
// assumption: 1-to-1 relationship between channels and samplers; this is a simplification on what // assumption: 1-to-1 relationship between channels and samplers; this is a simplification on what
// glTF can express, but it means we can rely on samplerIx == channelIx throughout an animation // glTF can express, but it means we can rely on samplerIx == channelIx throughout an animation
void AnimationData::AddNodeChannel(const NodeData &node, const AccessorData &accessor, std::string path) void AnimationData::AddNodeChannel(
{ const NodeData& node,
const AccessorData& accessor,
std::string path) {
assert(channels.size() == samplers.size()); assert(channels.size() == samplers.size());
uint32_t ix = channels.size(); uint32_t ix = channels.size();
channels.emplace_back(channel_t(ix, node, std::move(path))); channels.emplace_back(channel_t(ix, node, std::move(path)));
samplers.emplace_back(sampler_t(timeAccessor, accessor.ix)); samplers.emplace_back(sampler_t(timeAccessor, accessor.ix));
} }
json AnimationData::serialize() const json AnimationData::serialize() const {
{ return {{"name", name}, {"channels", channels}, {"samplers", samplers}};
return {
{ "name", name },
{ "channels", channels },
{ "samplers", samplers }
};
} }
AnimationData::channel_t::channel_t(uint32_t ix, const NodeData& node, std::string path) AnimationData::channel_t::channel_t(uint32_t ix, const NodeData& node, std::string path)
: ix(ix), : ix(ix), node(node.ix), path(std::move(path)) {}
node(node.ix),
path(std::move(path))
{
}
AnimationData::sampler_t::sampler_t(uint32_t time, uint32_t output) AnimationData::sampler_t::sampler_t(uint32_t time, uint32_t output) : time(time), output(output) {}
: time(time),
output(output)
{
}
void to_json(json& j, const AnimationData::channel_t& data) { void to_json(json& j, const AnimationData::channel_t& data) {
j = json { j = json{{"sampler", data.ix},
{ "sampler", data.ix }, {
{ "target", { "target",
{ "node", data.node }, {{"node", data.node}, {"path", data.path}},
{ "path", data.path }}, }};
}
};
} }
void to_json(json& j, const AnimationData::sampler_t& data) { void to_json(json& j, const AnimationData::sampler_t& data) {

9
src/gltf/properties/AnimationData.hpp
View File

@ -11,8 +11,7 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct AnimationData : Holdable struct AnimationData : Holdable {
{
AnimationData(std::string name, const AccessorData& timeAccessor); AnimationData(std::string name, const AccessorData& timeAccessor);
// assumption: 1-to-1 relationship between channels and samplers; this is a simplification on what // assumption: 1-to-1 relationship between channels and samplers; this is a simplification on what
@ -21,8 +20,7 @@ struct AnimationData : Holdable
json serialize() const override; json serialize() const override;
struct channel_t struct channel_t {
{
channel_t(uint32_t _ix, const NodeData& node, std::string path); channel_t(uint32_t _ix, const NodeData& node, std::string path);
const uint32_t ix; const uint32_t ix;
@ -30,8 +28,7 @@ struct AnimationData : Holdable
const std::string path; const std::string path;
}; };
struct sampler_t struct sampler_t {
{
sampler_t(uint32_t time, uint32_t output); sampler_t(uint32_t time, uint32_t output);
const uint32_t time; const uint32_t time;

25
src/gltf/properties/BufferData.cpp
View File

@ -12,25 +12,16 @@
#include "BufferData.hpp" #include "BufferData.hpp"
BufferData::BufferData(const std::shared_ptr<const std::vector<uint8_t>>& binData) BufferData::BufferData(const std::shared_ptr<const std::vector<uint8_t>>& binData)
: Holdable(), : Holdable(), isGlb(true), binData(binData) {}
isGlb(true),
binData(binData)
{
}
BufferData::BufferData(std::string uri, const std::shared_ptr<const std::vector<uint8_t> > &binData, bool isEmbedded) BufferData::BufferData(
: Holdable(), std::string uri,
isGlb(false), const std::shared_ptr<const std::vector<uint8_t>>& binData,
uri(isEmbedded ? "" : std::move(uri)), bool isEmbedded)
binData(binData) : Holdable(), isGlb(false), uri(isEmbedded ? "" : std::move(uri)), binData(binData) {}
{
}
json BufferData::serialize() const json BufferData::serialize() const {
{ json result{{"byteLength", binData->size()}};
json result{
{"byteLength", binData->size()}
};
if (!isGlb) { if (!isGlb) {
if (!uri.empty()) { if (!uri.empty()) {
result["uri"] = uri; result["uri"] = uri;

8
src/gltf/properties/BufferData.hpp
View File

@ -11,11 +11,13 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct BufferData : Holdable struct BufferData : Holdable {
{
explicit BufferData(const std::shared_ptr<const std::vector<uint8_t>>& binData); explicit BufferData(const std::shared_ptr<const std::vector<uint8_t>>& binData);
BufferData(std::string uri, const std::shared_ptr<const std::vector<uint8_t> > &binData, bool isEmbedded = false); BufferData(
std::string uri,
const std::shared_ptr<const std::vector<uint8_t>>& binData,
bool isEmbedded = false);
json serialize() const override; json serialize() const override;

21
src/gltf/properties/BufferViewData.cpp
View File

@ -10,21 +10,14 @@
#include "BufferViewData.hpp" #include "BufferViewData.hpp"
#include "BufferData.hpp" #include "BufferData.hpp"
BufferViewData::BufferViewData(const BufferData &_buffer, const size_t _byteOffset, const GL_ArrayType _target) BufferViewData::BufferViewData(
: Holdable(), const BufferData& _buffer,
buffer(_buffer.ix), const size_t _byteOffset,
byteOffset((unsigned int) _byteOffset), const GL_ArrayType _target)
target(_target) : Holdable(), buffer(_buffer.ix), byteOffset((unsigned int)_byteOffset), target(_target) {}
{
}
json BufferViewData::serialize() const json BufferViewData::serialize() const {
{ json result{{"buffer", buffer}, {"byteLength", byteLength}, {"byteOffset", byteOffset}};
json result {
{ "buffer", buffer },
{ "byteLength", byteLength },
{ "byteOffset", byteOffset }
};
if (target != GL_ARRAY_NONE) { if (target != GL_ARRAY_NONE) {
result["target"] = target; result["target"] = target;
} }

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

@ -11,10 +11,8 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct BufferViewData : Holdable struct BufferViewData : Holdable {
{ enum GL_ArrayType {
enum GL_ArrayType
{
GL_ARRAY_NONE = 0, // no GL buffer is being set GL_ARRAY_NONE = 0, // no GL buffer is being set
GL_ARRAY_BUFFER = 34962, GL_ARRAY_BUFFER = 34962,
GL_ELEMENT_ARRAY_BUFFER = 34963 GL_ELEMENT_ARRAY_BUFFER = 34963

18
src/gltf/properties/CameraData.cpp
View File

@ -10,26 +10,14 @@
#include "CameraData.hpp" #include "CameraData.hpp"
CameraData::CameraData() CameraData::CameraData()
: Holdable(), : Holdable(), aspectRatio(0.0f), yfov(0.0f), xmag(0.0f), ymag(0.0f), znear(0.0f), zfar(0.0f) {}
aspectRatio(0.0f),
yfov(0.0f),
xmag(0.0f),
ymag(0.0f),
znear(0.0f),
zfar(0.0f)
{
}
json CameraData::serialize() const json CameraData::serialize() const {
{
json result{ json result{
{"name", name}, {"name", name},
{"type", type}, {"type", type},
}; };
json subResult { json subResult{{"znear", znear}, {"zfar", zfar}};
{ "znear", znear },
{ "zfar", zfar }
};
if (type == "perspective") { if (type == "perspective") {
subResult["aspectRatio"] = aspectRatio; subResult["aspectRatio"] = aspectRatio;
subResult["yfov"] = yfov; subResult["yfov"] = yfov;

3
src/gltf/properties/CameraData.hpp
View File

@ -12,8 +12,7 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
// TODO: this class needs some work // TODO: this class needs some work
struct CameraData : Holdable struct CameraData : Holdable {
{
CameraData(); CameraData();
json serialize() const override; json serialize() const override;

28
src/gltf/properties/ImageData.cpp
View File

@ -14,32 +14,14 @@
#include "BufferViewData.hpp" #include "BufferViewData.hpp"
ImageData::ImageData(std::string name, std::string uri) ImageData::ImageData(std::string name, std::string uri)
: Holdable(), : Holdable(), name(std::move(name)), uri(std::move(uri)), bufferView(-1) {}
name(std::move(name)),
uri(std::move(uri)),
bufferView(-1)
{
}
ImageData::ImageData(std::string name, const BufferViewData& bufferView, std::string mimeType) ImageData::ImageData(std::string name, const BufferViewData& bufferView, std::string mimeType)
: Holdable(), : Holdable(), name(std::move(name)), bufferView(bufferView.ix), mimeType(std::move(mimeType)) {}
name(std::move(name)),
bufferView(bufferView.ix),
mimeType(std::move(mimeType))
{
}
json ImageData::serialize() const json ImageData::serialize() const {
{
if (bufferView < 0) { if (bufferView < 0) {
return { return {{"name", name}, {"uri", uri}};
{ "name", name },
{ "uri", uri }
};
} }
return { return {{"name", name}, {"bufferView", bufferView}, {"mimeType", mimeType}};
{ "name", name },
{ "bufferView", bufferView },
{ "mimeType", mimeType }
};
} }

3
src/gltf/properties/ImageData.hpp
View File

@ -11,8 +11,7 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct ImageData : Holdable struct ImageData : Holdable {
{
ImageData(std::string name, std::string uri); ImageData(std::string name, std::string uri);
ImageData(std::string name, const BufferViewData& bufferView, std::string mimeType); ImageData(std::string name, const BufferViewData& bufferView, std::string mimeType);

21
src/gltf/properties/LightData.cpp
View File

@ -10,24 +10,21 @@
#include "LightData.hpp" #include "LightData.hpp"
LightData::LightData( LightData::LightData(
std::string name, Type type, Vec3f color, float intensity, std::string name,
float innerConeAngle, float outerConeAngle) Type type,
Vec3f color,
float intensity,
float innerConeAngle,
float outerConeAngle)
: Holdable(), : Holdable(),
type(type), type(type),
color(color), color(color),
intensity(intensity), intensity(intensity),
innerConeAngle(innerConeAngle), innerConeAngle(innerConeAngle),
outerConeAngle(outerConeAngle) outerConeAngle(outerConeAngle) {}
{
}
json LightData::serialize() const json LightData::serialize() const {
{ json result{{"name", name}, {"color", toStdVec(color)}, {"intensity", intensity}};
json result {
{ "name", name },
{ "color", toStdVec(color) },
{ "intensity", intensity }
};
switch (type) { switch (type) {
case Directional: case Directional:
result["type"] = "directional"; result["type"] = "directional";

12
src/gltf/properties/LightData.hpp
View File

@ -11,16 +11,20 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct LightData : Holdable struct LightData : Holdable {
{
enum Type { enum Type {
Directional, Directional,
Point, Point,
Spot, Spot,
}; };
LightData(std::string name, Type type, Vec3f color, float intensity, LightData(
float innerConeAngle, float outerConeAngle); std::string name,
Type type,
Vec3f color,
float intensity,
float innerConeAngle,
float outerConeAngle);
json serialize() const override; json serialize() const override;

72
src/gltf/properties/MaterialData.cpp
View File

@ -11,54 +11,47 @@
#include "TextureData.hpp" #include "TextureData.hpp"
// TODO: retrieve & pass in correct UV set from FBX // TODO: retrieve & pass in correct UV set from FBX
std::unique_ptr<Tex> Tex::ref(const TextureData *tex, uint32_t texCoord) std::unique_ptr<Tex> Tex::ref(const TextureData* tex, uint32_t texCoord) {
{
return std::unique_ptr<Tex>{(tex != nullptr) ? new Tex(tex->ix, texCoord) : nullptr}; return std::unique_ptr<Tex>{(tex != nullptr) ? new Tex(tex->ix, texCoord) : nullptr};
} }
Tex::Tex(uint32_t texRef, uint32_t texCoord) Tex::Tex(uint32_t texRef, uint32_t texCoord) : texRef(texRef), texCoord(texCoord) {}
: texRef(texRef),
texCoord(texCoord) {}
void to_json(json& j, const Tex& data) { void to_json(json& j, const Tex& data) {
j = json { j = json{{"index", data.texRef}, {"texCoord", data.texCoord}};
{ "index", data.texRef },
{ "texCoord", data.texCoord }
};
} }
KHRCmnUnlitMaterial::KHRCmnUnlitMaterial() KHRCmnUnlitMaterial::KHRCmnUnlitMaterial() {}
{
}
void to_json(json &j, const KHRCmnUnlitMaterial &d) void to_json(json& j, const KHRCmnUnlitMaterial& d) {
{
j = json({}); j = json({});
} }
inline float clamp(float d, float bottom = 0, float top = 1) { inline float clamp(float d, float bottom = 0, float top = 1) {
return std::max(bottom, std::min(top, d)); return std::max(bottom, std::min(top, d));
} }
inline Vec3f clamp(const Vec3f &vec, const Vec3f &bottom = VEC3F_ZERO, const Vec3f &top = VEC3F_ONE) { inline Vec3f
clamp(const Vec3f& vec, const Vec3f& bottom = VEC3F_ZERO, const Vec3f& top = VEC3F_ONE) {
return Vec3f::Max(bottom, Vec3f::Min(top, vec)); return Vec3f::Max(bottom, Vec3f::Min(top, vec));
} }
inline Vec4f clamp(const Vec4f &vec, const Vec4f &bottom = VEC4F_ZERO, const Vec4f &top = VEC4F_ONE) { inline Vec4f
clamp(const Vec4f& vec, const Vec4f& bottom = VEC4F_ZERO, const Vec4f& top = VEC4F_ONE) {
return Vec4f::Max(bottom, Vec4f::Min(top, vec)); return Vec4f::Max(bottom, Vec4f::Min(top, vec));
} }
PBRMetallicRoughness::PBRMetallicRoughness( PBRMetallicRoughness::PBRMetallicRoughness(
const TextureData *baseColorTexture, const TextureData *metRoughTexture, const TextureData* baseColorTexture,
const Vec4f &baseColorFactor, float metallic, float roughness) const TextureData* metRoughTexture,
const Vec4f& baseColorFactor,
float metallic,
float roughness)
: baseColorTexture(Tex::ref(baseColorTexture)), : baseColorTexture(Tex::ref(baseColorTexture)),
metRoughTexture(Tex::ref(metRoughTexture)), metRoughTexture(Tex::ref(metRoughTexture)),
baseColorFactor(clamp(baseColorFactor)), baseColorFactor(clamp(baseColorFactor)),
metallic(clamp(metallic)), metallic(clamp(metallic)),
roughness(clamp(roughness)) roughness(clamp(roughness)) {}
{
}
void to_json(json &j, const PBRMetallicRoughness &d) void to_json(json& j, const PBRMetallicRoughness& d) {
{
j = {}; j = {};
if (d.baseColorTexture != nullptr) { if (d.baseColorTexture != nullptr) {
j["baseColorTexture"] = *d.baseColorTexture; j["baseColorTexture"] = *d.baseColorTexture;
@ -79,9 +72,13 @@ void to_json(json &j, const PBRMetallicRoughness &d)
} }
MaterialData::MaterialData( MaterialData::MaterialData(
std::string name, bool isTransparent, const RawShadingModel shadingModel, std::string name,
const TextureData *normalTexture, const TextureData *occlusionTexture, bool isTransparent,
const TextureData *emissiveTexture, const Vec3f & emissiveFactor, const RawShadingModel shadingModel,
const TextureData* normalTexture,
const TextureData* occlusionTexture,
const TextureData* emissiveTexture,
const Vec3f& emissiveFactor,
std::shared_ptr<KHRCmnUnlitMaterial> const khrCmnConstantMaterial, std::shared_ptr<KHRCmnUnlitMaterial> const khrCmnConstantMaterial,
std::shared_ptr<PBRMetallicRoughness> const pbrMetallicRoughness) std::shared_ptr<PBRMetallicRoughness> const pbrMetallicRoughness)
: Holdable(), : Holdable(),
@ -95,18 +92,13 @@ MaterialData::MaterialData(
khrCmnConstantMaterial(khrCmnConstantMaterial), khrCmnConstantMaterial(khrCmnConstantMaterial),
pbrMetallicRoughness(pbrMetallicRoughness) {} pbrMetallicRoughness(pbrMetallicRoughness) {}
json MaterialData::serialize() const json MaterialData::serialize() const {
{ json result = {{"name", name},
json result = {
{ "name", name },
{"alphaMode", isTransparent ? "BLEND" : "OPAQUE"}, {"alphaMode", isTransparent ? "BLEND" : "OPAQUE"},
{ "extras", { {"extras",
{ "fromFBX", { {{"fromFBX",
{ "shadingModel", Describe(shadingModel) }, {{"shadingModel", Describe(shadingModel)},
{ "isTruePBR", shadingModel == RAW_SHADING_MODEL_PBR_MET_ROUGH } {"isTruePBR", shadingModel == RAW_SHADING_MODEL_PBR_MET_ROUGH}}}}}};
}}
}}
};
if (normalTexture != nullptr) { if (normalTexture != nullptr) {
result["normalTexture"] = *normalTexture; result["normalTexture"] = *normalTexture;
@ -129,13 +121,11 @@ json MaterialData::serialize() const
result["extensions"] = extensions; result["extensions"] = extensions;
} }
for (const auto& i : userProperties) for (const auto& i : userProperties) {
{
auto& prop_map = result["extras"]["fromFBX"]["userProperties"]; auto& prop_map = result["extras"]["fromFBX"]["userProperties"];
json j = json::parse(i); json j = json::parse(i);
for (const auto& k : json::iterator_wrapper(j)) for (const auto& k : json::iterator_wrapper(j)) {
{
prop_map[k.key()] = k.value(); prop_map[k.key()] = k.value();
} }
} }

29
src/gltf/properties/MaterialData.hpp
View File

@ -13,8 +13,7 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct Tex struct Tex {
{
static std::unique_ptr<Tex> ref(const TextureData* tex, uint32_t texCoord = 0); static std::unique_ptr<Tex> ref(const TextureData* tex, uint32_t texCoord = 0);
explicit Tex(uint32_t texRef, uint32_t texCoord); explicit Tex(uint32_t texRef, uint32_t texCoord);
@ -22,16 +21,17 @@ struct Tex
const uint32_t texCoord; const uint32_t texCoord;
}; };
struct KHRCmnUnlitMaterial struct KHRCmnUnlitMaterial {
{
KHRCmnUnlitMaterial(); KHRCmnUnlitMaterial();
}; };
struct PBRMetallicRoughness struct PBRMetallicRoughness {
{
PBRMetallicRoughness( PBRMetallicRoughness(
const TextureData *baseColorTexture, const TextureData *metRoughTexture, const TextureData* baseColorTexture,
const Vec4f &baseColorFactor, float metallic = 0.1f, float roughness = 0.6f); const TextureData* metRoughTexture,
const Vec4f& baseColorFactor,
float metallic = 0.1f,
float roughness = 0.6f);
std::unique_ptr<Tex> baseColorTexture; std::unique_ptr<Tex> baseColorTexture;
std::unique_ptr<Tex> metRoughTexture; std::unique_ptr<Tex> metRoughTexture;
@ -40,12 +40,15 @@ struct PBRMetallicRoughness
const float roughness; const float roughness;
}; };
struct MaterialData : Holdable struct MaterialData : Holdable {
{
MaterialData( MaterialData(
std::string name, bool isTransparent, RawShadingModel shadingModel, std::string name,
const TextureData *normalTexture, const TextureData *occlusionTexture, bool isTransparent,
const TextureData *emissiveTexture, const Vec3f &emissiveFactor, RawShadingModel shadingModel,
const TextureData* normalTexture,
const TextureData* occlusionTexture,
const TextureData* emissiveTexture,
const Vec3f& emissiveFactor,
std::shared_ptr<KHRCmnUnlitMaterial> const khrCmnConstantMaterial, std::shared_ptr<KHRCmnUnlitMaterial> const khrCmnConstantMaterial,
std::shared_ptr<PBRMetallicRoughness> const pbrMetallicRoughness); std::shared_ptr<PBRMetallicRoughness> const pbrMetallicRoughness);

14
src/gltf/properties/MeshData.cpp
View File

@ -11,22 +11,14 @@
#include "PrimitiveData.hpp" #include "PrimitiveData.hpp"
MeshData::MeshData(const std::string& name, const std::vector<float>& weights) MeshData::MeshData(const std::string& name, const std::vector<float>& weights)
: Holdable(), : Holdable(), name(name), weights(weights) {}
name(name),
weights(weights)
{
}
json MeshData::serialize() const json MeshData::serialize() const {
{
json jsonPrimitivesArray = json::array(); json jsonPrimitivesArray = json::array();
for (const auto& primitive : primitives) { for (const auto& primitive : primitives) {
jsonPrimitivesArray.push_back(*primitive); jsonPrimitivesArray.push_back(*primitive);
} }
json result = { json result = {{"name", name}, {"primitives", jsonPrimitivesArray}};
{ "name", name },
{ "primitives", jsonPrimitivesArray }
};
if (!weights.empty()) { if (!weights.empty()) {
result["weights"] = weights; result["weights"] = weights;
} }

6
src/gltf/properties/MeshData.hpp
View File

@ -17,12 +17,10 @@
#include "PrimitiveData.hpp" #include "PrimitiveData.hpp"
struct MeshData : Holdable struct MeshData : Holdable {
{
MeshData(const std::string& name, const std::vector<float>& weights); MeshData(const std::string& name, const std::vector<float>& weights);
void AddPrimitive(std::shared_ptr<PrimitiveData> primitive) void AddPrimitive(std::shared_ptr<PrimitiveData> primitive) {
{
primitives.push_back(std::move(primitive)); primitives.push_back(std::move(primitive));
} }

35
src/gltf/properties/NodeData.cpp
View File

@ -10,8 +10,11 @@
#include "NodeData.hpp" #include "NodeData.hpp"
NodeData::NodeData( NodeData::NodeData(
std::string name, const Vec3f &translation, std::string name,
const Quatf &rotation, const Vec3f &scale, bool isJoint) const Vec3f& translation,
const Quatf& rotation,
const Vec3f& scale,
bool isJoint)
: Holdable(), : Holdable(),
name(std::move(name)), name(std::move(name)),
isJoint(isJoint), isJoint(isJoint),
@ -22,43 +25,35 @@ NodeData::NodeData(
mesh(-1), mesh(-1),
camera(-1), camera(-1),
light(-1), light(-1),
skin(-1) skin(-1) {}
{
}
void NodeData::AddChildNode(uint32_t childIx) void NodeData::AddChildNode(uint32_t childIx) {
{
children.push_back(childIx); children.push_back(childIx);
} }
void NodeData::SetMesh(uint32_t meshIx) void NodeData::SetMesh(uint32_t meshIx) {
{
assert(mesh < 0); assert(mesh < 0);
assert(!isJoint); assert(!isJoint);
mesh = meshIx; mesh = meshIx;
} }
void NodeData::SetSkin(uint32_t skinIx) void NodeData::SetSkin(uint32_t skinIx) {
{
assert(skin < 0); assert(skin < 0);
assert(!isJoint); assert(!isJoint);
skin = skinIx; skin = skinIx;
} }
void NodeData::SetCamera(uint32_t cameraIndex) void NodeData::SetCamera(uint32_t cameraIndex) {
{
assert(!isJoint); assert(!isJoint);
camera = cameraIndex; camera = cameraIndex;
} }
void NodeData::SetLight(uint32_t lightIndex) void NodeData::SetLight(uint32_t lightIndex) {
{
assert(!isJoint); assert(!isJoint);
light = lightIndex; light = lightIndex;
} }
json NodeData::serialize() const json NodeData::serialize() const {
{
json result = {{"name", name}}; json result = {{"name", name}};
// if any of the T/R/S have NaN components, just leave them out of the glTF // if any of the T/R/S have NaN components, just leave them out of the glTF
@ -96,13 +91,11 @@ json NodeData::serialize() const
} }
} }
for (const auto& i : userProperties) for (const auto& i : userProperties) {
{
auto& prop_map = result["extras"]["fromFBX"]["userProperties"]; auto& prop_map = result["extras"]["fromFBX"]["userProperties"];
json j = json::parse(i); json j = json::parse(i);
for (const auto& k : json::iterator_wrapper(j)) for (const auto& k : json::iterator_wrapper(j)) {
{
prop_map[k.key()] = k.value(); prop_map[k.key()] = k.value();
} }
} }

10
src/gltf/properties/NodeData.hpp
View File

@ -11,9 +11,13 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct NodeData : Holdable struct NodeData : Holdable {
{ NodeData(
NodeData(std::string name, const Vec3f &translation, const Quatf &rotation, const Vec3f &scale, bool isJoint); std::string name,
const Vec3f& translation,
const Quatf& rotation,
const Vec3f& scale,
bool isJoint);
void AddChildNode(uint32_t childIx); void AddChildNode(uint32_t childIx);
void SetMesh(uint32_t meshIx); void SetMesh(uint32_t meshIx);

52
src/gltf/properties/PrimitiveData.cpp
View File

@ -9,11 +9,14 @@
#include "PrimitiveData.hpp" #include "PrimitiveData.hpp"
#include "MaterialData.hpp"
#include "AccessorData.hpp" #include "AccessorData.hpp"
#include "BufferViewData.hpp" #include "BufferViewData.hpp"
#include "MaterialData.hpp"
PrimitiveData::PrimitiveData(const AccessorData &indices, const MaterialData &material, std::shared_ptr<draco::Mesh> dracoMesh) PrimitiveData::PrimitiveData(
const AccessorData& indices,
const MaterialData& material,
std::shared_ptr<draco::Mesh> dracoMesh)
: indices(indices.ix), : indices(indices.ix),
material(material.ix), material(material.ix),
mode(TRIANGLES), mode(TRIANGLES),
@ -25,35 +28,28 @@ PrimitiveData::PrimitiveData(const AccessorData &indices, const MaterialData &ma
material(material.ix), material(material.ix),
mode(TRIANGLES), mode(TRIANGLES),
dracoMesh(nullptr), dracoMesh(nullptr),
dracoBufferView(-1) dracoBufferView(-1) {}
{
}
void PrimitiveData::AddAttrib(std::string name, const AccessorData &accessor) void PrimitiveData::AddAttrib(std::string name, const AccessorData& accessor) {
{
attributes[name] = accessor.ix; attributes[name] = accessor.ix;
} }
void PrimitiveData::NoteDracoBuffer(const BufferViewData &data) void PrimitiveData::NoteDracoBuffer(const BufferViewData& data) {
{
dracoBufferView = data.ix; dracoBufferView = data.ix;
} }
void PrimitiveData::AddTarget(const AccessorData *positions, const AccessorData *normals, const AccessorData *tangents) void PrimitiveData::AddTarget(
{ const AccessorData* positions,
const AccessorData* normals,
const AccessorData* tangents) {
targetAccessors.push_back(std::make_tuple( targetAccessors.push_back(std::make_tuple(
positions->ix, positions->ix,
normals != nullptr ? normals->ix : -1, normals != nullptr ? normals->ix : -1,
tangents != nullptr ? tangents ->ix : -1 tangents != nullptr ? tangents->ix : -1));
));
} }
void to_json(json& j, const PrimitiveData& d) { void to_json(json& j, const PrimitiveData& d) {
j = { j = {{"material", d.material}, {"mode", d.mode}, {"attributes", d.attributes}};
{ "material", d.material },
{ "mode", d.mode },
{ "attributes", d.attributes }
};
if (d.indices >= 0) { if (d.indices >= 0) {
j["indices"] = d.indices; j["indices"] = d.indices;
} }
@ -63,19 +59,21 @@ void to_json(json &j, const PrimitiveData &d) {
for (auto accessor : d.targetAccessors) { for (auto accessor : d.targetAccessors) {
std::tie(pIx, nIx, tIx) = accessor; std::tie(pIx, nIx, tIx) = accessor;
json target{}; json target{};
if (pIx >= 0) { target["POSITION"] = pIx; } if (pIx >= 0) {
if (nIx >= 0) { target["NORMAL"] = nIx; } target["POSITION"] = pIx;
if (tIx >= 0) { target["TANGENT"] = tIx; } }
if (nIx >= 0) {
target["NORMAL"] = nIx;
}
if (tIx >= 0) {
target["TANGENT"] = tIx;
}
targets.push_back(target); targets.push_back(target);
} }
j["targets"] = targets; j["targets"] = targets;
} }
if (!d.dracoAttributes.empty()) { if (!d.dracoAttributes.empty()) {
j["extensions"] = { j["extensions"] = {{KHR_DRACO_MESH_COMPRESSION,
{ KHR_DRACO_MESH_COMPRESSION, { {{"bufferView", d.dracoBufferView}, {"attributes", d.dracoAttributes}}}};
{ "bufferView", d.dracoBufferView },
{ "attributes", d.dracoAttributes }
}}
};
} }
} }

28
src/gltf/properties/PrimitiveData.hpp
View File

@ -11,10 +11,8 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct PrimitiveData struct PrimitiveData {
{ enum MeshMode {
enum MeshMode
{
POINTS = 0, POINTS = 0,
LINES, LINES,
LINE_LOOP, LINE_LOOP,
@ -24,22 +22,32 @@ struct PrimitiveData
TRIANGLE_FAN TRIANGLE_FAN
}; };
PrimitiveData(const AccessorData &indices, const MaterialData &material, std::shared_ptr<draco::Mesh> dracoMesh); PrimitiveData(
const AccessorData& indices,
const MaterialData& material,
std::shared_ptr<draco::Mesh> dracoMesh);
PrimitiveData(const AccessorData& indices, const MaterialData& material); PrimitiveData(const AccessorData& indices, const MaterialData& material);
void AddAttrib(std::string name, const AccessorData& accessor); void AddAttrib(std::string name, const AccessorData& accessor);
void AddTarget(const AccessorData *positions, const AccessorData *normals, const AccessorData *tangents); void AddTarget(
const AccessorData* positions,
const AccessorData* normals,
const AccessorData* tangents);
template <class T> template <class T>
void AddDracoAttrib(const AttributeDefinition<T> attribute, const std::vector<T> &attribArr) void AddDracoAttrib(const AttributeDefinition<T> attribute, const std::vector<T>& attribArr) {
{
draco::PointAttribute att; draco::PointAttribute att;
int8_t componentCount = attribute.glType.count; int8_t componentCount = attribute.glType.count;
att.Init( att.Init(
attribute.dracoAttribute, nullptr, componentCount, attribute.dracoComponentType, attribute.dracoAttribute,
false, componentCount * draco::DataTypeLength(attribute.dracoComponentType), 0); nullptr,
componentCount,
attribute.dracoComponentType,
false,
componentCount * draco::DataTypeLength(attribute.dracoComponentType),
0);
const int dracoAttId = dracoMesh->AddAttribute(att, true, attribArr.size()); const int dracoAttId = dracoMesh->AddAttribute(att, true, attribArr.size());
draco::PointAttribute* attPtr = dracoMesh->attribute(dracoAttId); draco::PointAttribute* attPtr = dracoMesh->attribute(dracoAttId);

8
src/gltf/properties/SamplerData.hpp
View File

@ -11,13 +11,9 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct SamplerData : Holdable struct SamplerData : Holdable {
{
// this is where magFilter, minFilter, wrapS and wrapT would go, should we want it // this is where magFilter, minFilter, wrapS and wrapT would go, should we want it
SamplerData() SamplerData() : Holdable() {}
: Holdable()
{
}
json serialize() const override { json serialize() const override {
return json::object(); return json::object();

14
src/gltf/properties/SceneData.cpp
View File

@ -12,17 +12,9 @@
#include "NodeData.hpp" #include "NodeData.hpp"
SceneData::SceneData(std::string name, const NodeData& rootNode) SceneData::SceneData(std::string name, const NodeData& rootNode)
: Holdable(), : Holdable(), name(std::move(name)), nodes({rootNode.ix}) {}
name(std::move(name)),
nodes({rootNode.ix})
{
}
json SceneData::serialize() const json SceneData::serialize() const {
{
assert(nodes.size() <= 1); assert(nodes.size() <= 1);
return { return {{"name", name}, {"nodes", nodes}};
{ "name", name },
{ "nodes", nodes }
};
} }

3
src/gltf/properties/SceneData.hpp
View File

@ -11,8 +11,7 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct SceneData : Holdable struct SceneData : Holdable {
{
SceneData(std::string name, const NodeData& rootNode); SceneData(std::string name, const NodeData& rootNode);
json serialize() const override; json serialize() const override;

16
src/gltf/properties/SkinData.cpp
View File

@ -13,20 +13,16 @@
#include "NodeData.hpp" #include "NodeData.hpp"
SkinData::SkinData( SkinData::SkinData(
const std::vector<uint32_t> joints, const AccessorData &inverseBindMatricesAccessor, const std::vector<uint32_t> joints,
const AccessorData& inverseBindMatricesAccessor,
const NodeData& skeletonRootNode) const NodeData& skeletonRootNode)
: Holdable(), : Holdable(),
joints(joints), joints(joints),
inverseBindMatrices(inverseBindMatricesAccessor.ix), inverseBindMatrices(inverseBindMatricesAccessor.ix),
skeletonRootNode(skeletonRootNode.ix) skeletonRootNode(skeletonRootNode.ix) {}
{
}
json SkinData::serialize() const json SkinData::serialize() const {
{ return {{"joints", joints},
return {
{ "joints", joints },
{"inverseBindMatrices", inverseBindMatrices}, {"inverseBindMatrices", inverseBindMatrices},
{ "skeleton", skeletonRootNode } {"skeleton", skeletonRootNode}};
};
} }

6
src/gltf/properties/SkinData.hpp
View File

@ -11,10 +11,10 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct SkinData : Holdable struct SkinData : Holdable {
{
SkinData( SkinData(
const std::vector<uint32_t> joints, const AccessorData &inverseBindMatricesAccessor, const std::vector<uint32_t> joints,
const AccessorData& inverseBindMatricesAccessor,
const NodeData& skeletonRootNode); const NodeData& skeletonRootNode);
json serialize() const override; json serialize() const override;

16
src/gltf/properties/TextureData.cpp
View File

@ -13,18 +13,8 @@
#include "SamplerData.hpp" #include "SamplerData.hpp"
TextureData::TextureData(std::string name, const SamplerData& sampler, const ImageData& source) TextureData::TextureData(std::string name, const SamplerData& sampler, const ImageData& source)
: Holdable(), : Holdable(), name(std::move(name)), sampler(sampler.ix), source(source.ix) {}
name(std::move(name)),
sampler(sampler.ix),
source(source.ix)
{
}
json TextureData::serialize() const json TextureData::serialize() const {
{ return {{"name", name}, {"sampler", sampler}, {"source", source}};
return {
{ "name", name },
{ "sampler", sampler },
{ "source", source }
};
} }

3
src/gltf/properties/TextureData.hpp
View File

@ -11,8 +11,7 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct TextureData : Holdable struct TextureData : Holdable {
{
TextureData(std::string name, const SamplerData& sampler, const ImageData& source); TextureData(std::string name, const SamplerData& sampler, const ImageData& source);
json serialize() const override; json serialize() const override;

12
src/mathfu.hpp
View File

@ -11,18 +11,17 @@
#include <fbxsdk.h> #include <fbxsdk.h>
#include <mathfu/vector.h>
#include <mathfu/matrix.h> #include <mathfu/matrix.h>
#include <mathfu/quaternion.h> #include <mathfu/quaternion.h>
#include <mathfu/rect.h> #include <mathfu/rect.h>
#include <mathfu/vector.h>
/** /**
* All the mathfu:: implementations of our core data types. * All the mathfu:: implementations of our core data types.
*/ */
template <class T, int d> template <class T, int d>
struct Bounds struct Bounds {
{
mathfu::Vector<T, d> min; mathfu::Vector<T, d> min;
mathfu::Vector<T, d> max; mathfu::Vector<T, d> max;
bool initialized = false; bool initialized = false;
@ -63,8 +62,8 @@ typedef Bounds<float, 3> Boundsf;
#define VEC4F_ONE (Vec4f{1.0f}) #define VEC4F_ONE (Vec4f{1.0f})
#define VEC4F_ZERO (Vec4f{0.0f}) #define VEC4F_ZERO (Vec4f{0.0f})
template<class T, int d> inline std::vector<T> toStdVec(const mathfu::Vector <T, d> &vec) template <class T, int d>
{ inline std::vector<T> toStdVec(const mathfu::Vector<T, d>& vec) {
std::vector<T> result(d); std::vector<T> result(d);
for (int ii = 0; ii < d; ii++) { for (int ii = 0; ii < d; ii++) {
result[ii] = vec[ii]; result[ii] = vec[ii];
@ -72,7 +71,8 @@ template<class T, int d> inline std::vector<T> toStdVec(const mathfu::Vector <T,
return result; return result;
} }
template<class T> std::vector<T> toStdVec(const mathfu::Quaternion<T> &quat) { template <class T>
std::vector<T> toStdVec(const mathfu::Quaternion<T>& quat) {
return std::vector<T>{quat.vector()[0], quat.vector()[1], quat.vector()[2], quat.scalar()}; return std::vector<T>{quat.vector()[0], quat.vector()[1], quat.vector()[2], quat.scalar()};
} }

255
src/raw/RawModel.cpp
View File

@ -9,64 +9,68 @@
#include "RawModel.hpp" #include "RawModel.hpp"
#include <vector>
#include <string>
#include <unordered_map>
#include <cmath> #include <cmath>
#include <map> #include <map>
#include <set> #include <set>
#include <string>
#include <unordered_map>
#include <vector>
#if defined(__unix__) #if defined(__unix__)
#include <algorithm> #include <algorithm>
#endif #endif
#include "utils/String_Utils.hpp"
#include "utils/Image_Utils.hpp" #include "utils/Image_Utils.hpp"
#include "utils/String_Utils.hpp"
bool RawVertex::operator==(const RawVertex &other) const bool RawVertex::operator==(const RawVertex& other) const {
{ return (position == other.position) && (normal == other.normal) && (tangent == other.tangent) &&
return (position == other.position) && (binormal == other.binormal) && (color == other.color) && (uv0 == other.uv0) &&
(normal == other.normal) && (uv1 == other.uv1) && (jointIndices == other.jointIndices) &&
(tangent == other.tangent) && (jointWeights == other.jointWeights) && (polarityUv0 == other.polarityUv0) &&
(binormal == other.binormal) && (blendSurfaceIx == other.blendSurfaceIx) && (blends == other.blends);
(color == other.color) &&
(uv0 == other.uv0) &&
(uv1 == other.uv1) &&
(jointIndices == other.jointIndices) &&
(jointWeights == other.jointWeights) &&
(polarityUv0 == other.polarityUv0) &&
(blendSurfaceIx == other.blendSurfaceIx) &&
(blends == other.blends);
} }
size_t RawVertex::Difference(const RawVertex &other) const size_t RawVertex::Difference(const RawVertex& other) const {
{
size_t attributes = 0; size_t attributes = 0;
if (position != other.position) { attributes |= RAW_VERTEX_ATTRIBUTE_POSITION; } if (position != other.position) {
if (normal != other.normal) { attributes |= RAW_VERTEX_ATTRIBUTE_NORMAL; } attributes |= RAW_VERTEX_ATTRIBUTE_POSITION;
if (tangent != other.tangent) { attributes |= RAW_VERTEX_ATTRIBUTE_TANGENT; } }
if (binormal != other.binormal) { attributes |= RAW_VERTEX_ATTRIBUTE_BINORMAL; } if (normal != other.normal) {
if (color != other.color) { attributes |= RAW_VERTEX_ATTRIBUTE_COLOR; } attributes |= RAW_VERTEX_ATTRIBUTE_NORMAL;
if (uv0 != other.uv0) { attributes |= RAW_VERTEX_ATTRIBUTE_UV0; } }
if (uv1 != other.uv1) { attributes |= RAW_VERTEX_ATTRIBUTE_UV1; } if (tangent != other.tangent) {
attributes |= RAW_VERTEX_ATTRIBUTE_TANGENT;
}
if (binormal != other.binormal) {
attributes |= RAW_VERTEX_ATTRIBUTE_BINORMAL;
}
if (color != other.color) {
attributes |= RAW_VERTEX_ATTRIBUTE_COLOR;
}
if (uv0 != other.uv0) {
attributes |= RAW_VERTEX_ATTRIBUTE_UV0;
}
if (uv1 != other.uv1) {
attributes |= RAW_VERTEX_ATTRIBUTE_UV1;
}
// Always need both or neither. // Always need both or neither.
if (jointIndices != other.jointIndices) { attributes |= RAW_VERTEX_ATTRIBUTE_JOINT_INDICES | RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS; } if (jointIndices != other.jointIndices) {
if (jointWeights != other.jointWeights) { attributes |= RAW_VERTEX_ATTRIBUTE_JOINT_INDICES | RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS; } attributes |= RAW_VERTEX_ATTRIBUTE_JOINT_INDICES | RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS;
}
if (jointWeights != other.jointWeights) {
attributes |= RAW_VERTEX_ATTRIBUTE_JOINT_INDICES | RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS;
}
return attributes; return attributes;
} }
RawModel::RawModel() RawModel::RawModel() : vertexAttributes(0) {}
: vertexAttributes(0)
{
}
void RawModel::AddVertexAttribute(const RawVertexAttribute attrib) void RawModel::AddVertexAttribute(const RawVertexAttribute attrib) {
{
vertexAttributes |= attrib; vertexAttributes |= attrib;
} }
int RawModel::AddVertex(const RawVertex &vertex) int RawModel::AddVertex(const RawVertex& vertex) {
{
auto it = vertexHash.find(vertex); auto it = vertexHash.find(vertex);
if (it != vertexHash.end()) { if (it != vertexHash.end()) {
return it->second; return it->second;
@ -76,15 +80,22 @@ int RawModel::AddVertex(const RawVertex &vertex)
return (int)vertices.size() - 1; return (int)vertices.size() - 1;
} }
int RawModel::AddTriangle(const int v0, const int v1, const int v2, const int materialIndex, const int surfaceIndex) int RawModel::AddTriangle(
{ const int v0,
const int v1,
const int v2,
const int materialIndex,
const int surfaceIndex) {
const RawTriangle triangle = {{v0, v1, v2}, materialIndex, surfaceIndex}; const RawTriangle triangle = {{v0, v1, v2}, materialIndex, surfaceIndex};
triangles.push_back(triangle); triangles.push_back(triangle);
return (int)triangles.size() - 1; return (int)triangles.size() - 1;
} }
int RawModel::AddTexture(const std::string &name, const std::string &fileName, const std::string &fileLocation, RawTextureUsage usage) int RawModel::AddTexture(
{ const std::string& name,
const std::string& fileName,
const std::string& fileLocation,
RawTextureUsage usage) {
if (name.empty()) { if (name.empty()) {
return -1; return -1;
} }
@ -94,26 +105,32 @@ int RawModel::AddTexture(const std::string &name, const std::string &fileName, c
} }
} }
const ImageUtils::ImageProperties const ImageUtils::ImageProperties properties = ImageUtils::GetImageProperties(
properties = ImageUtils::GetImageProperties(!fileLocation.empty() ? fileLocation.c_str() : fileName.c_str()); !fileLocation.empty() ? fileLocation.c_str() : fileName.c_str());
RawTexture texture; RawTexture texture;
texture.name = name; texture.name = name;
texture.width = properties.width; texture.width = properties.width;
texture.height = properties.height; texture.height = properties.height;
texture.mipLevels = (int) ceilf(log2f(std::max((float) properties.width, (float) properties.height))); texture.mipLevels =
(int)ceilf(log2f(std::max((float)properties.width, (float)properties.height)));
texture.usage = usage; texture.usage = usage;
texture.occlusion = (properties.occlusion == ImageUtils::IMAGE_TRANSPARENT) ? texture.occlusion = (properties.occlusion == ImageUtils::IMAGE_TRANSPARENT)
RAW_TEXTURE_OCCLUSION_TRANSPARENT : RAW_TEXTURE_OCCLUSION_OPAQUE; ? RAW_TEXTURE_OCCLUSION_TRANSPARENT
: RAW_TEXTURE_OCCLUSION_OPAQUE;
texture.fileName = fileName; texture.fileName = fileName;
texture.fileLocation = fileLocation; texture.fileLocation = fileLocation;
textures.emplace_back(texture); textures.emplace_back(texture);
return (int)textures.size() - 1; return (int)textures.size() - 1;
} }
int RawModel::AddMaterial(const RawMaterial &material) int RawModel::AddMaterial(const RawMaterial& material) {
{ return AddMaterial(
return AddMaterial(material.name.c_str(), material.type, material.textures, material.info, material.userProperties); material.name.c_str(),
material.type,
material.textures,
material.info,
material.userProperties);
} }
int RawModel::AddMaterial( int RawModel::AddMaterial(
@ -121,8 +138,7 @@ int RawModel::AddMaterial(
const RawMaterialType materialType, const RawMaterialType materialType,
const int textures[RAW_TEXTURE_USAGE_MAX], const int textures[RAW_TEXTURE_USAGE_MAX],
std::shared_ptr<RawMatProps> materialInfo, std::shared_ptr<RawMatProps> materialInfo,
const std::vector<std::string>& userProperties) const std::vector<std::string>& userProperties) {
{
for (size_t i = 0; i < materials.size(); i++) { for (size_t i = 0; i < materials.size(); i++) {
if (materials[i].name != name) { if (materials[i].name != name) {
continue; continue;
@ -139,8 +155,7 @@ int RawModel::AddMaterial(
} }
if (materials[i].userProperties.size() != userProperties.size()) { if (materials[i].userProperties.size() != userProperties.size()) {
match = false; match = false;
} } else {
else {
for (int j = 0; match && j < userProperties.size(); j++) { for (int j = 0; match && j < userProperties.size(); j++) {
match = match && (materials[i].userProperties[j] == userProperties[j]); match = match && (materials[i].userProperties[j] == userProperties[j]);
} }
@ -171,8 +186,7 @@ int RawModel::AddLight(
const Vec3f color, const Vec3f color,
const float intensity, const float intensity,
const float innerConeAngle, const float innerConeAngle,
const float outerConeAngle) const float outerConeAngle) {
{
for (size_t i = 0; i < lights.size(); i++) { for (size_t i = 0; i < lights.size(); i++) {
if (lights[i].name != name || lights[i].type != lightType) { if (lights[i].name != name || lights[i].type != lightType) {
continue; continue;
@ -198,9 +212,7 @@ int RawModel::AddLight(
return (int)lights.size() - 1; return (int)lights.size() - 1;
} }
int RawModel::AddSurface(const RawSurface& surface) {
int RawModel::AddSurface(const RawSurface &surface)
{
for (size_t i = 0; i < surfaces.size(); i++) { for (size_t i = 0; i < surfaces.size(); i++) {
if (StringUtils::CompareNoCase(surfaces[i].name, surface.name) == 0) { if (StringUtils::CompareNoCase(surfaces[i].name, surface.name) == 0) {
return (int)i; return (int)i;
@ -211,8 +223,7 @@ int RawModel::AddSurface(const RawSurface &surface)
return (int)(surfaces.size() - 1); return (int)(surfaces.size() - 1);
} }
int RawModel::AddSurface(const char *name, const long surfaceId) int RawModel::AddSurface(const char* name, const long surfaceId) {
{
assert(name[0] != '\0'); assert(name[0] != '\0');
for (size_t i = 0; i < surfaces.size(); i++) { for (size_t i = 0; i < surfaces.size(); i++) {
@ -230,14 +241,12 @@ int RawModel::AddSurface(const char *name, const long surfaceId)
return (int)(surfaces.size() - 1); return (int)(surfaces.size() - 1);
} }
int RawModel::AddAnimation(const RawAnimation &animation) int RawModel::AddAnimation(const RawAnimation& animation) {
{
animations.emplace_back(animation); animations.emplace_back(animation);
return (int)(animations.size() - 1); return (int)(animations.size() - 1);
} }
int RawModel::AddNode(const RawNode &node) int RawModel::AddNode(const RawNode& node) {
{
for (size_t i = 0; i < nodes.size(); i++) { for (size_t i = 0; i < nodes.size(); i++) {
if (nodes[i].id == node.id) { if (nodes[i].id == node.id) {
return (int)i; return (int)i;
@ -249,9 +258,13 @@ int RawModel::AddNode(const RawNode &node)
} }
int RawModel::AddCameraPerspective( int RawModel::AddCameraPerspective(
const char *name, const long nodeId, const float aspectRatio, const float fovDegreesX, const float fovDegreesY, const float nearZ, const char* name,
const float farZ) const long nodeId,
{ const float aspectRatio,
const float fovDegreesX,
const float fovDegreesY,
const float nearZ,
const float farZ) {
RawCamera camera; RawCamera camera;
camera.name = name; camera.name = name;
camera.nodeId = nodeId; camera.nodeId = nodeId;
@ -266,8 +279,12 @@ int RawModel::AddCameraPerspective(
} }
int RawModel::AddCameraOrthographic( int RawModel::AddCameraOrthographic(
const char *name, const long nodeId, const float magX, const float magY, const float nearZ, const float farZ) const char* name,
{ const long nodeId,
const float magX,
const float magY,
const float nearZ,
const float farZ) {
RawCamera camera; RawCamera camera;
camera.name = name; camera.name = name;
camera.nodeId = nodeId; camera.nodeId = nodeId;
@ -280,8 +297,7 @@ int RawModel::AddCameraOrthographic(
return (int)cameras.size() - 1; return (int)cameras.size() - 1;
} }
int RawModel::AddNode(const long id, const char *name, const long parentId) int RawModel::AddNode(const long id, const char* name, const long parentId) {
{
assert(name[0] != '\0'); assert(name[0] != '\0');
for (size_t i = 0; i < nodes.size(); i++) { for (size_t i = 0; i < nodes.size(); i++) {
@ -305,8 +321,7 @@ int RawModel::AddNode(const long id, const char *name, const long parentId)
return (int)nodes.size() - 1; return (int)nodes.size() - 1;
} }
void RawModel::Condense() void RawModel::Condense() {
{
// Only keep surfaces that are referenced by one or more triangles. // Only keep surfaces that are referenced by one or more triangles.
{ {
std::vector<RawSurface> oldSurfaces = surfaces; std::vector<RawSurface> oldSurfaces = surfaces;
@ -323,7 +338,8 @@ void RawModel::Condense()
} }
// clear out references to meshes that no longer exist // clear out references to meshes that no longer exist
for (auto& node : nodes) { for (auto& node : nodes) {
if (node.surfaceId != 0 && survivingSurfaceIds.find(node.surfaceId) == survivingSurfaceIds.end()) { if (node.surfaceId != 0 &&
survivingSurfaceIds.find(node.surfaceId) == survivingSurfaceIds.end()) {
node.surfaceId = 0; node.surfaceId = 0;
} }
} }
@ -353,7 +369,8 @@ void RawModel::Condense()
for (int j = 0; j < RAW_TEXTURE_USAGE_MAX; j++) { for (int j = 0; j < RAW_TEXTURE_USAGE_MAX; j++) {
if (material.textures[j] >= 0) { if (material.textures[j] >= 0) {
const RawTexture& texture = oldTextures[material.textures[j]]; const RawTexture& texture = oldTextures[material.textures[j]];
const int textureIndex = AddTexture(texture.name, texture.fileName, texture.fileLocation, texture.usage); const int textureIndex =
AddTexture(texture.name, texture.fileName, texture.fileLocation, texture.usage);
textures[textureIndex] = texture; textures[textureIndex] = texture;
material.textures[j] = textureIndex; material.textures[j] = textureIndex;
} }
@ -376,8 +393,7 @@ void RawModel::Condense()
} }
} }
void RawModel::TransformGeometry(ComputeNormalsOption normals) void RawModel::TransformGeometry(ComputeNormalsOption normals) {
{
switch (normals) { switch (normals) {
case ComputeNormalsOption::NEVER: case ComputeNormalsOption::NEVER:
break; break;
@ -404,8 +420,7 @@ void RawModel::TransformGeometry(ComputeNormalsOption normals)
} }
} }
void RawModel::TransformTextures(const std::vector<std::function<Vec2f(Vec2f)>> &transforms) void RawModel::TransformTextures(const std::vector<std::function<Vec2f(Vec2f)>>& transforms) {
{
for (auto& vertice : vertices) { for (auto& vertice : vertices) {
if ((vertexAttributes & RAW_VERTEX_ATTRIBUTE_UV0) != 0) { if ((vertexAttributes & RAW_VERTEX_ATTRIBUTE_UV0) != 0) {
for (const auto& fun : transforms) { for (const auto& fun : transforms) {
@ -420,10 +435,8 @@ void RawModel::TransformTextures(const std::vector<std::function<Vec2f(Vec2f)>>
} }
} }
struct TriangleModelSortPos struct TriangleModelSortPos {
{ static bool Compare(const RawTriangle& a, const RawTriangle& b) {
static bool Compare(const RawTriangle &a, const RawTriangle &b)
{
if (a.materialIndex != b.materialIndex) { if (a.materialIndex != b.materialIndex) {
return a.materialIndex < b.materialIndex; return a.materialIndex < b.materialIndex;
} }
@ -434,10 +447,8 @@ struct TriangleModelSortPos
} }
}; };
struct TriangleModelSortNeg struct TriangleModelSortNeg {
{ static bool Compare(const RawTriangle& a, const RawTriangle& b) {
static bool Compare(const RawTriangle &a, const RawTriangle &b)
{
if (a.materialIndex != b.materialIndex) { if (a.materialIndex != b.materialIndex) {
return a.materialIndex < b.materialIndex; return a.materialIndex < b.materialIndex;
} }
@ -449,8 +460,10 @@ struct TriangleModelSortNeg
}; };
void RawModel::CreateMaterialModels( void RawModel::CreateMaterialModels(
std::vector<RawModel> &materialModels, bool shortIndices, const int keepAttribs, const bool forceDiscrete) const std::vector<RawModel>& materialModels,
{ bool shortIndices,
const int keepAttribs,
const bool forceDiscrete) const {
// Sort all triangles based on material first, then surface, then first vertex index. // Sort all triangles based on material first, then surface, then first vertex index.
std::vector<RawTriangle> sortedTriangles; std::vector<RawTriangle> sortedTriangles;
@ -487,7 +500,8 @@ void RawModel::CreateMaterialModels(
std::sort(opaqueTriangles.begin(), opaqueTriangles.end(), TriangleModelSortPos::Compare); std::sort(opaqueTriangles.begin(), opaqueTriangles.end(), TriangleModelSortPos::Compare);
// Sort the transparent triangles in the reverse direction. // Sort the transparent triangles in the reverse direction.
std::sort(transparentTriangles.begin(), transparentTriangles.end(), TriangleModelSortNeg::Compare); std::sort(
transparentTriangles.begin(), transparentTriangles.end(), TriangleModelSortNeg::Compare);
// Add the triangles to the sorted list. // Add the triangles to the sorted list.
for (const auto& opaqueTriangle : opaqueTriangles) { for (const auto& opaqueTriangle : opaqueTriangles) {
@ -515,13 +529,11 @@ void RawModel::CreateMaterialModels(
// Create a separate model for each material. // Create a separate model for each material.
RawModel* model; RawModel* model;
for (size_t i = 0; i < sortedTriangles.size(); i++) { for (size_t i = 0; i < sortedTriangles.size(); i++) {
if (sortedTriangles[i].materialIndex < 0 || sortedTriangles[i].surfaceIndex < 0) { if (sortedTriangles[i].materialIndex < 0 || sortedTriangles[i].surfaceIndex < 0) {
continue; continue;
} }
if (i == 0 || if (i == 0 || (shortIndices && model->GetVertexCount() >= 0xFFFE) ||
(shortIndices && model->GetVertexCount() >= 0xFFFE) ||
sortedTriangles[i].materialIndex != sortedTriangles[i - 1].materialIndex || sortedTriangles[i].materialIndex != sortedTriangles[i - 1].materialIndex ||
(sortedTriangles[i].surfaceIndex != sortedTriangles[i - 1].surfaceIndex && (sortedTriangles[i].surfaceIndex != sortedTriangles[i - 1].surfaceIndex &&
(forceDiscrete || surfaces[sortedTriangles[i].surfaceIndex].discrete || (forceDiscrete || surfaces[sortedTriangles[i].surfaceIndex].discrete ||
@ -565,28 +577,43 @@ void RawModel::CreateMaterialModels(
keep |= RAW_VERTEX_ATTRIBUTE_UV0; keep |= RAW_VERTEX_ATTRIBUTE_UV0;
} }
if (mat.textures[RAW_TEXTURE_USAGE_NORMAL] != -1) { if (mat.textures[RAW_TEXTURE_USAGE_NORMAL] != -1) {
keep |= RAW_VERTEX_ATTRIBUTE_NORMAL | keep |= RAW_VERTEX_ATTRIBUTE_NORMAL | RAW_VERTEX_ATTRIBUTE_TANGENT |
RAW_VERTEX_ATTRIBUTE_TANGENT | RAW_VERTEX_ATTRIBUTE_BINORMAL | RAW_VERTEX_ATTRIBUTE_UV0;
RAW_VERTEX_ATTRIBUTE_BINORMAL |
RAW_VERTEX_ATTRIBUTE_UV0;
} }
if (mat.textures[RAW_TEXTURE_USAGE_SPECULAR] != -1) { if (mat.textures[RAW_TEXTURE_USAGE_SPECULAR] != -1) {
keep |= RAW_VERTEX_ATTRIBUTE_NORMAL | keep |= RAW_VERTEX_ATTRIBUTE_NORMAL | RAW_VERTEX_ATTRIBUTE_UV0;
RAW_VERTEX_ATTRIBUTE_UV0;
} }
if (mat.textures[RAW_TEXTURE_USAGE_EMISSIVE] != -1) { if (mat.textures[RAW_TEXTURE_USAGE_EMISSIVE] != -1) {
keep |= RAW_VERTEX_ATTRIBUTE_UV1; keep |= RAW_VERTEX_ATTRIBUTE_UV1;
} }
} }
if ((keep & RAW_VERTEX_ATTRIBUTE_POSITION) == 0) { vertex.position = defaultVertex.position; } if ((keep & RAW_VERTEX_ATTRIBUTE_POSITION) == 0) {
if ((keep & RAW_VERTEX_ATTRIBUTE_NORMAL) == 0) { vertex.normal = defaultVertex.normal; } vertex.position = defaultVertex.position;
if ((keep & RAW_VERTEX_ATTRIBUTE_TANGENT) == 0) { vertex.tangent = defaultVertex.tangent; } }
if ((keep & RAW_VERTEX_ATTRIBUTE_BINORMAL) == 0) { vertex.binormal = defaultVertex.binormal; } if ((keep & RAW_VERTEX_ATTRIBUTE_NORMAL) == 0) {
if ((keep & RAW_VERTEX_ATTRIBUTE_COLOR) == 0) { vertex.color = defaultVertex.color; } vertex.normal = defaultVertex.normal;
if ((keep & RAW_VERTEX_ATTRIBUTE_UV0) == 0) { vertex.uv0 = defaultVertex.uv0; } }
if ((keep & RAW_VERTEX_ATTRIBUTE_UV1) == 0) { vertex.uv1 = defaultVertex.uv1; } if ((keep & RAW_VERTEX_ATTRIBUTE_TANGENT) == 0) {
if ((keep & RAW_VERTEX_ATTRIBUTE_JOINT_INDICES) == 0) { vertex.jointIndices = defaultVertex.jointIndices; } vertex.tangent = defaultVertex.tangent;
if ((keep & RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS) == 0) { vertex.jointWeights = defaultVertex.jointWeights; } }
if ((keep & RAW_VERTEX_ATTRIBUTE_BINORMAL) == 0) {
vertex.binormal = defaultVertex.binormal;
}
if ((keep & RAW_VERTEX_ATTRIBUTE_COLOR) == 0) {
vertex.color = defaultVertex.color;
}
if ((keep & RAW_VERTEX_ATTRIBUTE_UV0) == 0) {
vertex.uv0 = defaultVertex.uv0;
}
if ((keep & RAW_VERTEX_ATTRIBUTE_UV1) == 0) {
vertex.uv1 = defaultVertex.uv1;
}
if ((keep & RAW_VERTEX_ATTRIBUTE_JOINT_INDICES) == 0) {
vertex.jointIndices = defaultVertex.jointIndices;
}
if ((keep & RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS) == 0) {
vertex.jointWeights = defaultVertex.jointWeights;
}
} }
verts[j] = model->AddVertex(vertex); verts[j] = model->AddVertex(vertex);
@ -599,8 +626,7 @@ void RawModel::CreateMaterialModels(
} }
} }
int RawModel::GetNodeById(const long nodeId) const int RawModel::GetNodeById(const long nodeId) const {
{
for (size_t i = 0; i < nodes.size(); i++) { for (size_t i = 0; i < nodes.size(); i++) {
if (nodes[i].id == nodeId) { if (nodes[i].id == nodeId) {
return (int)i; return (int)i;
@ -609,8 +635,7 @@ int RawModel::GetNodeById(const long nodeId) const
return -1; return -1;
} }
int RawModel::GetSurfaceById(const long surfaceId) const int RawModel::GetSurfaceById(const long surfaceId) const {
{
for (size_t i = 0; i < surfaces.size(); i++) { for (size_t i = 0; i < surfaces.size(); i++) {
if (surfaces[i].id == surfaceId) { if (surfaces[i].id == surfaceId) {
return (int)i; return (int)i;
@ -619,8 +644,7 @@ int RawModel::GetSurfaceById(const long surfaceId) const
return -1; return -1;
} }
Vec3f RawModel::getFaceNormal(int verts[3]) const Vec3f RawModel::getFaceNormal(int verts[3]) const {
{
const float l0 = (vertices[verts[1]].position - vertices[verts[0]].position).LengthSquared(); const float l0 = (vertices[verts[1]].position - vertices[verts[0]].position).LengthSquared();
const float l1 = (vertices[verts[2]].position - vertices[verts[1]].position).LengthSquared(); const float l1 = (vertices[verts[2]].position - vertices[verts[1]].position).LengthSquared();
const float l2 = (vertices[verts[0]].position - vertices[verts[2]].position).LengthSquared(); const float l2 = (vertices[verts[0]].position - vertices[verts[2]].position).LengthSquared();
@ -642,8 +666,7 @@ Vec3f RawModel::getFaceNormal(int verts[3]) const
return result.Normalized() * angle * area; return result.Normalized() * angle * area;
} }
size_t RawModel::CalculateNormals(bool onlyBroken) size_t RawModel::CalculateNormals(bool onlyBroken) {
{
Vec3f averagePos = Vec3f{0.0f}; Vec3f averagePos = Vec3f{0.0f};
std::set<int> brokenVerts; std::set<int> brokenVerts;
for (int vertIx = 0; vertIx < vertices.size(); vertIx++) { for (int vertIx = 0; vertIx < vertices.size(); vertIx++) {

353
src/raw/RawModel.hpp
View File

@ -9,15 +9,13 @@
#pragma once #pragma once
#include <unordered_map>
#include <functional> #include <functional>
#include <set> #include <set>
#include <unordered_map>
#include "FBX2glTF.h" #include "FBX2glTF.h"
enum RawVertexAttribute {
enum RawVertexAttribute
{
RAW_VERTEX_ATTRIBUTE_POSITION = 1 << 0, RAW_VERTEX_ATTRIBUTE_POSITION = 1 << 0,
RAW_VERTEX_ATTRIBUTE_NORMAL = 1 << 1, RAW_VERTEX_ATTRIBUTE_NORMAL = 1 << 1,
RAW_VERTEX_ATTRIBUTE_TANGENT = 1 << 2, RAW_VERTEX_ATTRIBUTE_TANGENT = 1 << 2,
@ -31,26 +29,18 @@ enum RawVertexAttribute
RAW_VERTEX_ATTRIBUTE_AUTO = 1 << 31 RAW_VERTEX_ATTRIBUTE_AUTO = 1 << 31
}; };
struct RawBlendVertex struct RawBlendVertex {
{
Vec3f position{}; Vec3f position{};
Vec3f normal{}; Vec3f normal{};
Vec4f tangent{}; Vec4f tangent{};
bool operator==(const RawBlendVertex& other) const { bool operator==(const RawBlendVertex& other) const {
return position == other.position && return position == other.position && normal == other.normal && tangent == other.tangent;
normal == other.normal &&
tangent == other.tangent;
} }
}; };
struct RawVertex struct RawVertex {
{ RawVertex() : polarityUv0(false), pad1(false), pad2(false), pad3(false) {}
RawVertex() :
polarityUv0(false),
pad1(false),
pad2(false),
pad3(false) {}
Vec3f position{0.0f}; Vec3f position{0.0f};
Vec3f normal{0.0f}; Vec3f normal{0.0f};
@ -63,9 +53,11 @@ struct RawVertex
Vec4f jointWeights{0.0f}; Vec4f jointWeights{0.0f};
// end of members that directly correspond to vertex attributes // 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 // if this vertex participates in a blend shape setup, the surfaceIx of its dedicated mesh;
// otherwise, -1
int blendSurfaceIx = -1; int blendSurfaceIx = -1;
// the size of this vector is always identical to the size of the corresponding RawSurface.blendChannels // the size of this vector is always identical to the size of the corresponding
// RawSurface.blendChannels
std::vector<RawBlendVertex> blends{}; std::vector<RawBlendVertex> blends{};
bool polarityUv0; bool polarityUv0;
@ -77,11 +69,9 @@ struct RawVertex
size_t Difference(const RawVertex& other) const; size_t Difference(const RawVertex& other) const;
}; };
class VertexHasher class VertexHasher {
{
public: public:
size_t operator()(const RawVertex &v) const size_t operator()(const RawVertex& v) const {
{
size_t seed = 5381; size_t seed = 5381;
const auto hasher = std::hash<float>{}; const auto hasher = std::hash<float>{};
seed ^= hasher(v.position[0]) + 0x9e3779b9 + (seed << 6) + (seed >> 2); seed ^= hasher(v.position[0]) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
@ -91,15 +81,13 @@ public:
} }
}; };
struct RawTriangle struct RawTriangle {
{
int verts[3]; int verts[3];
int materialIndex; int materialIndex;
int surfaceIndex; int surfaceIndex;
}; };
enum RawShadingModel enum RawShadingModel {
{
RAW_SHADING_MODEL_UNKNOWN = -1, RAW_SHADING_MODEL_UNKNOWN = -1,
RAW_SHADING_MODEL_CONSTANT, RAW_SHADING_MODEL_CONSTANT,
RAW_SHADING_MODEL_LAMBERT, RAW_SHADING_MODEL_LAMBERT,
@ -111,18 +99,25 @@ enum RawShadingModel
inline std::string Describe(RawShadingModel model) { inline std::string Describe(RawShadingModel model) {
switch (model) { switch (model) {
case RAW_SHADING_MODEL_UNKNOWN: return "<unknown>"; case RAW_SHADING_MODEL_UNKNOWN:
case RAW_SHADING_MODEL_CONSTANT: return "Constant"; return "<unknown>";
case RAW_SHADING_MODEL_LAMBERT: return "Lambert"; case RAW_SHADING_MODEL_CONSTANT:
case RAW_SHADING_MODEL_BLINN: return "Blinn"; return "Constant";
case RAW_SHADING_MODEL_PHONG: return "Phong"; case RAW_SHADING_MODEL_LAMBERT:
case RAW_SHADING_MODEL_PBR_MET_ROUGH: return "Metallic/Roughness"; return "Lambert";
case RAW_SHADING_MODEL_MAX: default: return "<unknown>"; case RAW_SHADING_MODEL_BLINN:
return "Blinn";
case RAW_SHADING_MODEL_PHONG:
return "Phong";
case RAW_SHADING_MODEL_PBR_MET_ROUGH:
return "Metallic/Roughness";
case RAW_SHADING_MODEL_MAX:
default:
return "<unknown>";
} }
} }
enum RawTextureUsage enum RawTextureUsage {
{
RAW_TEXTURE_USAGE_NONE = -1, RAW_TEXTURE_USAGE_NONE = -1,
RAW_TEXTURE_USAGE_AMBIENT, RAW_TEXTURE_USAGE_AMBIENT,
RAW_TEXTURE_USAGE_DIFFUSE, RAW_TEXTURE_USAGE_DIFFUSE,
@ -138,32 +133,39 @@ enum RawTextureUsage
RAW_TEXTURE_USAGE_MAX RAW_TEXTURE_USAGE_MAX
}; };
inline std::string Describe(RawTextureUsage usage) inline std::string Describe(RawTextureUsage usage) {
{
switch (usage) { switch (usage) {
case RAW_TEXTURE_USAGE_NONE: return "<none>"; case RAW_TEXTURE_USAGE_NONE:
case RAW_TEXTURE_USAGE_AMBIENT: return "ambient"; return "<none>";
case RAW_TEXTURE_USAGE_DIFFUSE: return "diffuse"; case RAW_TEXTURE_USAGE_AMBIENT:
case RAW_TEXTURE_USAGE_NORMAL: return "normal"; return "ambient";
case RAW_TEXTURE_USAGE_SPECULAR: return "specular"; case RAW_TEXTURE_USAGE_DIFFUSE:
case RAW_TEXTURE_USAGE_SHININESS: return "shininess"; return "diffuse";
case RAW_TEXTURE_USAGE_EMISSIVE: return "emissive"; case RAW_TEXTURE_USAGE_NORMAL:
case RAW_TEXTURE_USAGE_REFLECTION: return "reflection"; return "normal";
case RAW_TEXTURE_USAGE_OCCLUSION: return "occlusion"; case RAW_TEXTURE_USAGE_SPECULAR:
case RAW_TEXTURE_USAGE_ROUGHNESS: return "roughness"; return "specular";
case RAW_TEXTURE_USAGE_METALLIC: return "metallic"; case RAW_TEXTURE_USAGE_SHININESS:
case RAW_TEXTURE_USAGE_MAX:default: return "unknown"; return "shininess";
case RAW_TEXTURE_USAGE_EMISSIVE:
return "emissive";
case RAW_TEXTURE_USAGE_REFLECTION:
return "reflection";
case RAW_TEXTURE_USAGE_OCCLUSION:
return "occlusion";
case RAW_TEXTURE_USAGE_ROUGHNESS:
return "roughness";
case RAW_TEXTURE_USAGE_METALLIC:
return "metallic";
case RAW_TEXTURE_USAGE_MAX:
default:
return "unknown";
} }
}; };
enum RawTextureOcclusion enum RawTextureOcclusion { RAW_TEXTURE_OCCLUSION_OPAQUE, RAW_TEXTURE_OCCLUSION_TRANSPARENT };
{
RAW_TEXTURE_OCCLUSION_OPAQUE,
RAW_TEXTURE_OCCLUSION_TRANSPARENT
};
struct RawTexture struct RawTexture {
{
std::string name; // logical name in FBX file std::string name; // logical name in FBX file
int width; int width;
int height; int height;
@ -174,8 +176,7 @@ struct RawTexture
std::string fileLocation; // inferred path in local filesystem, or "" std::string fileLocation; // inferred path in local filesystem, or ""
}; };
enum RawMaterialType enum RawMaterialType {
{
RAW_MATERIAL_TYPE_OPAQUE, RAW_MATERIAL_TYPE_OPAQUE,
RAW_MATERIAL_TYPE_TRANSPARENT, RAW_MATERIAL_TYPE_TRANSPARENT,
RAW_MATERIAL_TYPE_SKINNED_OPAQUE, RAW_MATERIAL_TYPE_SKINNED_OPAQUE,
@ -183,13 +184,15 @@ enum RawMaterialType
}; };
struct RawMatProps { struct RawMatProps {
explicit RawMatProps(RawShadingModel shadingModel) explicit RawMatProps(RawShadingModel shadingModel) : shadingModel(shadingModel) {}
: shadingModel(shadingModel)
{}
const RawShadingModel shadingModel; const RawShadingModel shadingModel;
virtual bool operator!=(const RawMatProps &other) const { return !(*this == other); } virtual bool operator!=(const RawMatProps& other) const {
virtual bool operator==(const RawMatProps &other) const { return shadingModel == other.shadingModel; }; return !(*this == other);
}
virtual bool operator==(const RawMatProps& other) const {
return shadingModel == other.shadingModel;
};
}; };
struct RawTraditionalMatProps : RawMatProps { struct RawTraditionalMatProps : RawMatProps {
@ -199,14 +202,13 @@ struct RawTraditionalMatProps : RawMatProps {
const Vec4f&& diffuseFactor, const Vec4f&& diffuseFactor,
const Vec3f&& emissiveFactor, const Vec3f&& emissiveFactor,
const Vec3f&& specularFactor, const Vec3f&& specularFactor,
const float shininess const float shininess)
) : RawMatProps(shadingModel), : RawMatProps(shadingModel),
ambientFactor(ambientFactor), ambientFactor(ambientFactor),
diffuseFactor(diffuseFactor), diffuseFactor(diffuseFactor),
emissiveFactor(emissiveFactor), emissiveFactor(emissiveFactor),
specularFactor(specularFactor), specularFactor(specularFactor),
shininess(shininess) shininess(shininess) {}
{}
const Vec3f ambientFactor; const Vec3f ambientFactor;
const Vec4f diffuseFactor; const Vec4f diffuseFactor;
@ -217,10 +219,8 @@ struct RawTraditionalMatProps : RawMatProps {
bool operator==(const RawMatProps& other) const override { bool operator==(const RawMatProps& other) const override {
if (RawMatProps::operator==(other)) { if (RawMatProps::operator==(other)) {
const auto& typed = (RawTraditionalMatProps&)other; const auto& typed = (RawTraditionalMatProps&)other;
return ambientFactor == typed.ambientFactor && return ambientFactor == typed.ambientFactor && diffuseFactor == typed.diffuseFactor &&
diffuseFactor == typed.diffuseFactor && specularFactor == typed.specularFactor && emissiveFactor == typed.emissiveFactor &&
specularFactor == typed.specularFactor &&
emissiveFactor == typed.emissiveFactor &&
shininess == typed.shininess; shininess == typed.shininess;
} }
return false; return false;
@ -234,14 +234,13 @@ struct RawMetRoughMatProps : RawMatProps {
const Vec3f&& emissiveFactor, const Vec3f&& emissiveFactor,
float emissiveIntensity, float emissiveIntensity,
float metallic, float metallic,
float roughness float roughness)
) : RawMatProps(shadingModel), : RawMatProps(shadingModel),
diffuseFactor(diffuseFactor), diffuseFactor(diffuseFactor),
emissiveFactor(emissiveFactor), emissiveFactor(emissiveFactor),
emissiveIntensity(emissiveIntensity), emissiveIntensity(emissiveIntensity),
metallic(metallic), metallic(metallic),
roughness(roughness) roughness(roughness) {}
{}
const Vec4f diffuseFactor; const Vec4f diffuseFactor;
const Vec3f emissiveFactor; const Vec3f emissiveFactor;
const float emissiveIntensity; const float emissiveIntensity;
@ -251,19 +250,15 @@ struct RawMetRoughMatProps : RawMatProps {
bool operator==(const RawMatProps& other) const override { bool operator==(const RawMatProps& other) const override {
if (RawMatProps::operator==(other)) { if (RawMatProps::operator==(other)) {
const auto& typed = (RawMetRoughMatProps&)other; const auto& typed = (RawMetRoughMatProps&)other;
return diffuseFactor == typed.diffuseFactor && return diffuseFactor == typed.diffuseFactor && emissiveFactor == typed.emissiveFactor &&
emissiveFactor == typed.emissiveFactor && emissiveIntensity == typed.emissiveIntensity && metallic == typed.metallic &&
emissiveIntensity == typed.emissiveIntensity &&
metallic == typed.metallic &&
roughness == typed.roughness; roughness == typed.roughness;
} }
return false; return false;
} }
}; };
struct RawMaterial {
struct RawMaterial
{
std::string name; std::string name;
RawMaterialType type; RawMaterialType type;
std::shared_ptr<RawMatProps> info; std::shared_ptr<RawMatProps> info;
@ -271,15 +266,13 @@ struct RawMaterial
std::vector<std::string> userProperties; std::vector<std::string> userProperties;
}; };
enum RawLightType enum RawLightType {
{
RAW_LIGHT_TYPE_DIRECTIONAL, RAW_LIGHT_TYPE_DIRECTIONAL,
RAW_LIGHT_TYPE_POINT, RAW_LIGHT_TYPE_POINT,
RAW_LIGHT_TYPE_SPOT, RAW_LIGHT_TYPE_SPOT,
}; };
struct RawLight struct RawLight {
{
std::string name; std::string name;
RawLightType type; RawLightType type;
Vec3f color; Vec3f color;
@ -288,16 +281,14 @@ struct RawLight
float outerConeAngle; // only meaningful for spot float outerConeAngle; // only meaningful for spot
}; };
struct RawBlendChannel struct RawBlendChannel {
{
float defaultDeform; float defaultDeform;
bool hasNormals; bool hasNormals;
bool hasTangents; bool hasTangents;
std::string name; std::string name;
}; };
struct RawSurface struct RawSurface {
{
long id; long id;
std::string name; // The name of this surface std::string name; // The name of this surface
long skeletonRootId; // The id of the root node of the skeleton. long skeletonRootId; // The id of the root node of the skeleton.
@ -310,8 +301,7 @@ struct RawSurface
bool discrete; bool discrete;
}; };
struct RawChannel struct RawChannel {
{
int nodeIndex; int nodeIndex;
std::vector<Vec3f> translations; std::vector<Vec3f> translations;
std::vector<Quatf> rotations; std::vector<Quatf> rotations;
@ -319,26 +309,19 @@ struct RawChannel
std::vector<float> weights; std::vector<float> weights;
}; };
struct RawAnimation struct RawAnimation {
{
std::string name; std::string name;
std::vector<float> times; std::vector<float> times;
std::vector<RawChannel> channels; std::vector<RawChannel> channels;
}; };
struct RawCamera struct RawCamera {
{
std::string name; std::string name;
long nodeId; long nodeId;
enum enum { CAMERA_MODE_PERSPECTIVE, CAMERA_MODE_ORTHOGRAPHIC } mode;
{
CAMERA_MODE_PERSPECTIVE,
CAMERA_MODE_ORTHOGRAPHIC
} mode;
struct struct {
{
float aspectRatio; float aspectRatio;
float fovDegreesX; float fovDegreesX;
float fovDegreesY; float fovDegreesY;
@ -346,8 +329,7 @@ struct RawCamera
float farZ; float farZ;
} perspective; } perspective;
struct struct {
{
float magX; float magX;
float magY; float magY;
float nearZ; float nearZ;
@ -355,8 +337,7 @@ struct RawCamera
} orthographic; } orthographic;
}; };
struct RawNode struct RawNode {
{
bool isJoint; bool isJoint;
long id; long id;
std::string name; std::string name;
@ -370,36 +351,67 @@ struct RawNode
std::vector<std::string> userProperties; std::vector<std::string> userProperties;
}; };
class RawModel class RawModel {
{
public: public:
RawModel(); RawModel();
// Add geometry. // Add geometry.
void AddVertexAttribute(const RawVertexAttribute attrib); void AddVertexAttribute(const RawVertexAttribute attrib);
int AddVertex(const RawVertex& vertex); int AddVertex(const RawVertex& vertex);
int AddTriangle(const int v0, const int v1, const int v2, const int materialIndex, const int surfaceIndex); int AddTriangle(
int AddTexture(const std::string &name, const std::string &fileName, const std::string &fileLocation, RawTextureUsage usage); const int v0,
const int v1,
const int v2,
const int materialIndex,
const int surfaceIndex);
int AddTexture(
const std::string& name,
const std::string& fileName,
const std::string& fileLocation,
RawTextureUsage usage);
int AddMaterial(const RawMaterial& material); int AddMaterial(const RawMaterial& material);
int AddMaterial( int AddMaterial(
const char *name, const RawMaterialType materialType, const int textures[RAW_TEXTURE_USAGE_MAX], const char* name,
std::shared_ptr<RawMatProps> materialInfo, const std::vector<std::string>& userProperties); const RawMaterialType materialType,
int AddLight(const char *name, RawLightType lightType, Vec3f color, float intensity, const int textures[RAW_TEXTURE_USAGE_MAX],
float innerConeAngle, float outerConeAngle); std::shared_ptr<RawMatProps> materialInfo,
const std::vector<std::string>& userProperties);
int AddLight(
const char* name,
RawLightType lightType,
Vec3f color,
float intensity,
float innerConeAngle,
float outerConeAngle);
int AddSurface(const RawSurface& suface); int AddSurface(const RawSurface& suface);
int AddSurface(const char* name, long surfaceId); int AddSurface(const char* name, long surfaceId);
int AddAnimation(const RawAnimation& animation); int AddAnimation(const RawAnimation& animation);
int AddCameraPerspective( int AddCameraPerspective(
const char *name, const long nodeId, const float aspectRatio, const float fovDegreesX, const float fovDegreesY, const char* name,
const float nearZ, const float farZ); const long nodeId,
int const float aspectRatio,
AddCameraOrthographic(const char *name, const long nodeId, const float magX, const float magY, const float nearZ, const float farZ); const float fovDegreesX,
const float fovDegreesY,
const float nearZ,
const float farZ);
int AddCameraOrthographic(
const char* name,
const long nodeId,
const float magX,
const float magY,
const float nearZ,
const float farZ);
int AddNode(const RawNode& node); int AddNode(const RawNode& node);
int AddNode(const long id, const char* name, const long parentId); int AddNode(const long id, const char* name, const long parentId);
void SetRootNode(const long nodeId) { rootNodeId = nodeId; } void SetRootNode(const long nodeId) {
const long GetRootNode() const { return rootNodeId; } rootNodeId = nodeId;
}
const long GetRootNode() const {
return rootNodeId;
}
// Remove unused vertices, textures or materials after removing vertex attributes, textures, materials or surfaces. // Remove unused vertices, textures or materials after removing vertex attributes, textures,
// materials or surfaces.
void Condense(); void Condense();
void TransformGeometry(ComputeNormalsOption); void TransformGeometry(ComputeNormalsOption);
@ -409,58 +421,104 @@ public:
size_t CalculateNormals(bool); size_t CalculateNormals(bool);
// Get the attributes stored per vertex. // Get the attributes stored per vertex.
int GetVertexAttributes() const { return vertexAttributes; } int GetVertexAttributes() const {
return vertexAttributes;
}
// Iterate over the vertices. // Iterate over the vertices.
int GetVertexCount() const { return (int) vertices.size(); } int GetVertexCount() const {
const RawVertex &GetVertex(const int index) const { return vertices[index]; } return (int)vertices.size();
}
const RawVertex& GetVertex(const int index) const {
return vertices[index];
}
// Iterate over the triangles. // Iterate over the triangles.
int GetTriangleCount() const { return (int) triangles.size(); } int GetTriangleCount() const {
const RawTriangle &GetTriangle(const int index) const { return triangles[index]; } return (int)triangles.size();
}
const RawTriangle& GetTriangle(const int index) const {
return triangles[index];
}
// Iterate over the textures. // Iterate over the textures.
int GetTextureCount() const { return (int) textures.size(); } int GetTextureCount() const {
const RawTexture &GetTexture(const int index) const { return textures[index]; } return (int)textures.size();
}
const RawTexture& GetTexture(const int index) const {
return textures[index];
}
// Iterate over the materials. // Iterate over the materials.
int GetMaterialCount() const { return (int) materials.size(); } int GetMaterialCount() const {
const RawMaterial &GetMaterial(const int index) const { return materials[index]; } return (int)materials.size();
}
const RawMaterial& GetMaterial(const int index) const {
return materials[index];
}
// Iterate over the surfaces. // Iterate over the surfaces.
int GetSurfaceCount() const { return (int) surfaces.size(); } int GetSurfaceCount() const {
const RawSurface &GetSurface(const int index) const { return surfaces[index]; } return (int)surfaces.size();
RawSurface &GetSurface(const int index) { return surfaces[index]; } }
const RawSurface& GetSurface(const int index) const {
return surfaces[index];
}
RawSurface& GetSurface(const int index) {
return surfaces[index];
}
int GetSurfaceById(const long id) const; int GetSurfaceById(const long id) const;
// Iterate over the animations. // Iterate over the animations.
int GetAnimationCount() const { return (int) animations.size(); } int GetAnimationCount() const {
const RawAnimation &GetAnimation(const int index) const { return animations[index]; } return (int)animations.size();
}
const RawAnimation& GetAnimation(const int index) const {
return animations[index];
}
// Iterate over the cameras. // Iterate over the cameras.
int GetCameraCount() const { return (int) cameras.size(); } int GetCameraCount() const {
const RawCamera &GetCamera(const int index) const { return cameras[index]; } return (int)cameras.size();
}
const RawCamera& GetCamera(const int index) const {
return cameras[index];
}
// Iterate over the lights. // Iterate over the lights.
int GetLightCount() const { return (int) lights.size(); } int GetLightCount() const {
const RawLight &GetLight(const int index) const { return lights[index]; } return (int)lights.size();
}
const RawLight& GetLight(const int index) const {
return lights[index];
}
// Iterate over the nodes. // Iterate over the nodes.
int GetNodeCount() const { return (int) nodes.size(); } int GetNodeCount() const {
const RawNode &GetNode(const int index) const { return nodes[index]; } return (int)nodes.size();
RawNode &GetNode(const int index) { return nodes[index]; } }
const RawNode& GetNode(const int index) const {
return nodes[index];
}
RawNode& GetNode(const int index) {
return nodes[index];
}
int GetNodeById(const long nodeId) const; int GetNodeById(const long nodeId) const;
// Create individual attribute arrays. // Create individual attribute arrays.
// Returns true if the vertices store the particular attribute. // Returns true if the vertices store the particular attribute.
template <typename _attrib_type_> template <typename _attrib_type_>
void GetAttributeArray(std::vector<_attrib_type_> &out, const _attrib_type_ RawVertex::* ptr) const; void GetAttributeArray(std::vector<_attrib_type_>& out, const _attrib_type_ RawVertex::*ptr)
const;
// Create an array with a raw model for each material. // Create an array with a raw model for each material.
// Multiple surfaces with the same material will turn into a single model. // Multiple surfaces with the same material will turn into a single model.
// However, surfaces that are marked as 'discrete' will turn into separate models. // However, surfaces that are marked as 'discrete' will turn into separate models.
void CreateMaterialModels( void CreateMaterialModels(
std::vector<RawModel> &materialModels, bool shortIndices, const int keepAttribs, const bool forceDiscrete) const; std::vector<RawModel>& materialModels,
bool shortIndices,
const int keepAttribs,
const bool forceDiscrete) const;
private: private:
Vec3f getFaceNormal(int verts[3]) const; Vec3f getFaceNormal(int verts[3]) const;
@ -480,8 +538,9 @@ private:
}; };
template <typename _attrib_type_> template <typename _attrib_type_>
void RawModel::GetAttributeArray(std::vector<_attrib_type_> &out, const _attrib_type_ RawVertex::* ptr) const void RawModel::GetAttributeArray(
{ std::vector<_attrib_type_>& out,
const _attrib_type_ RawVertex::*ptr) const {
out.resize(vertices.size()); out.resize(vertices.size());
for (size_t i = 0; i < vertices.size(); i++) { for (size_t i = 0; i < vertices.size(); i++) {
out[i] = vertices[i].*ptr; out[i] = vertices[i].*ptr;

50
src/utils/File_Utils.cpp
View File

@ -9,20 +9,20 @@
#include "File_Utils.hpp" #include "File_Utils.hpp"
#include <fstream>
#include <string> #include <string>
#include <vector> #include <vector>
#include <fstream>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#if defined(__unix__) || defined(__APPLE__) #if defined(__unix__) || defined(__APPLE__)
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <dirent.h> #include <dirent.h>
#include <errno.h> #include <errno.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#define _getcwd getcwd #define _getcwd getcwd
#define _mkdir(a) mkdir(a, 0777) #define _mkdir(a) mkdir(a, 0777)
@ -41,8 +41,7 @@
namespace FileUtils { namespace FileUtils {
std::string GetCurrentFolder() std::string GetCurrentFolder() {
{
char cwd[StringUtils::MAX_PATH_LENGTH]; char cwd[StringUtils::MAX_PATH_LENGTH];
if (!_getcwd(cwd, sizeof(cwd))) { if (!_getcwd(cwd, sizeof(cwd))) {
return std::string(); return std::string();
@ -57,14 +56,12 @@ namespace FileUtils {
return std::string(cwd); return std::string(cwd);
} }
bool FileExists(const std::string &filePath) bool FileExists(const std::string& filePath) {
{
std::ifstream stream(filePath); std::ifstream stream(filePath);
return stream.good(); return stream.good();
} }
bool FolderExists(const std::string &folderPath) bool FolderExists(const std::string& folderPath) {
{
#if defined(__unix__) || defined(__APPLE__) #if defined(__unix__) || defined(__APPLE__)
DIR* dir = opendir(folderPath.c_str()); DIR* dir = opendir(folderPath.c_str());
if (dir) { if (dir) {
@ -74,16 +71,14 @@ namespace FileUtils {
return false; return false;
#else #else
const DWORD ftyp = GetFileAttributesA(folderPath.c_str()); const DWORD ftyp = GetFileAttributesA(folderPath.c_str());
if ( ftyp == INVALID_FILE_ATTRIBUTES ) if (ftyp == INVALID_FILE_ATTRIBUTES) {
{
return false; // bad path return false; // bad path
} }
return (ftyp & FILE_ATTRIBUTE_DIRECTORY) != 0; return (ftyp & FILE_ATTRIBUTE_DIRECTORY) != 0;
#endif #endif
} }
bool MatchExtension(const char *fileExtension, const char *matchExtensions) bool MatchExtension(const char* fileExtension, const char* matchExtensions) {
{
if (matchExtensions[0] == '\0') { if (matchExtensions[0] == '\0') {
return true; return true;
} }
@ -91,9 +86,11 @@ namespace FileUtils {
fileExtension++; fileExtension++;
} }
for (const char* end = matchExtensions; end[0] != '\0';) { for (const char* end = matchExtensions; end[0] != '\0';) {
for (; end[0] == ';'; end++) {} for (; end[0] == ';'; end++) {
}
const char* ext = end; const char* ext = end;
for (; end[0] != ';' && end[0] != '\0'; end++) {} for (; end[0] != ';' && end[0] != '\0'; end++) {
}
#if defined(__unix__) || defined(__APPLE__) #if defined(__unix__) || defined(__APPLE__)
if (strncasecmp(fileExtension, ext, end - ext) == 0) if (strncasecmp(fileExtension, ext, end - ext) == 0)
#else #else
@ -106,8 +103,7 @@ namespace FileUtils {
return false; return false;
} }
std::vector<std::string> ListFolderFiles(const char *folder, const char *matchExtensions) std::vector<std::string> ListFolderFiles(const char* folder, const char* matchExtensions) {
{
std::vector<std::string> fileList; std::vector<std::string> fileList;
#if defined(__unix__) || defined(__APPLE__) #if defined(__unix__) || defined(__APPLE__)
DIR* dir = opendir(strlen(folder) > 0 ? folder : "."); DIR* dir = opendir(strlen(folder) > 0 ? folder : ".");
@ -140,10 +136,8 @@ namespace FileUtils {
WIN32_FIND_DATA FindFileData; WIN32_FIND_DATA FindFileData;
HANDLE hFind = FindFirstFile(pathStr.c_str(), &FindFileData); HANDLE hFind = FindFirstFile(pathStr.c_str(), &FindFileData);
if ( hFind != INVALID_HANDLE_VALUE ) if (hFind != INVALID_HANDLE_VALUE) {
{ do {
do
{
if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) { if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
std::string fileName = FindFileData.cFileName; std::string fileName = FindFileData.cFileName;
std::string::size_type extPos = fileName.rfind('.'); std::string::size_type extPos = fileName.rfind('.');
@ -160,8 +154,7 @@ namespace FileUtils {
return fileList; return fileList;
} }
bool CreatePath(const char *path) bool CreatePath(const char* path) {
{
#if defined(__unix__) || defined(__APPLE__) #if defined(__unix__) || defined(__APPLE__)
StringUtils::PathSeparator separator = StringUtils::PATH_UNIX; StringUtils::PathSeparator separator = StringUtils::PATH_UNIX;
#else #else
@ -210,7 +203,12 @@ namespace FileUtils {
if (srcSize == dstSize) { if (srcSize == dstSize) {
return true; return true;
} }
fmt::printf("Warning: Only copied %lu bytes to %s, when %s is %lu bytes long.\n", dstSize, dstFilename, srcFilename, srcSize); fmt::printf(
"Warning: Only copied %lu bytes to %s, when %s is %lu bytes long.\n",
dstSize,
dstFilename,
srcFilename,
srcSize);
return false; return false;
} }
} } // namespace FileUtils

7
src/utils/File_Utils.hpp
View File

@ -24,5 +24,8 @@ namespace FileUtils {
bool CreatePath(const char* path); bool CreatePath(const char* path);
bool CopyFile(const std::string &srcFilename, const std::string &dstFilename, bool createPath = false); bool CopyFile(
} const std::string& srcFilename,
const std::string& dstFilename,
bool createPath = false);
} // namespace FileUtils

13
src/utils/Image_Utils.cpp
View File

@ -9,8 +9,8 @@
#include "Image_Utils.hpp" #include "Image_Utils.hpp"
#include <string>
#include <algorithm> #include <algorithm>
#include <string>
#define STB_IMAGE_IMPLEMENTATION #define STB_IMAGE_IMPLEMENTATION
@ -22,8 +22,7 @@
namespace ImageUtils { namespace ImageUtils {
static bool imageHasTransparentPixels(FILE *f) static bool imageHasTransparentPixels(FILE* f) {
{
int width, height, channels; int width, height, channels;
// RGBA: we have to load the pixels to figure out if the image is fully opaque // RGBA: we have to load the pixels to figure out if the image is fully opaque
uint8_t* pixels = stbi_load_from_file(f, &width, &height, &channels, 0); uint8_t* pixels = stbi_load_from_file(f, &width, &height, &channels, 0);
@ -39,8 +38,7 @@ namespace ImageUtils {
return false; return false;
} }
ImageProperties GetImageProperties(char const *filePath) ImageProperties GetImageProperties(char const* filePath) {
{
ImageProperties result = { ImageProperties result = {
1, 1,
1, 1,
@ -61,8 +59,7 @@ namespace ImageUtils {
return result; return result;
} }
std::string suffixToMimeType(std::string suffix) std::string suffixToMimeType(std::string suffix) {
{
std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower); std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
if (suffix == "jpg" || suffix == "jpeg") { if (suffix == "jpg" || suffix == "jpeg") {
@ -74,4 +71,4 @@ namespace ImageUtils {
return "image/unknown"; return "image/unknown";
} }
} } // namespace ImageUtils

15
src/utils/Image_Utils.hpp
View File

@ -13,14 +13,9 @@
namespace ImageUtils { namespace ImageUtils {
enum ImageOcclusion enum ImageOcclusion { IMAGE_OPAQUE, IMAGE_TRANSPARENT };
{
IMAGE_OPAQUE,
IMAGE_TRANSPARENT
};
struct ImageProperties struct ImageProperties {
{
int width; int width;
int height; int height;
ImageOcclusion occlusion; ImageOcclusion occlusion;
@ -29,9 +24,9 @@ namespace ImageUtils {
ImageProperties GetImageProperties(char const* filePath); ImageProperties GetImageProperties(char const* filePath);
/** /**
* Very simple method for mapping filename suffix to mime type. The glTF 2.0 spec only accepts values * Very simple method for mapping filename suffix to mime type. The glTF 2.0 spec only accepts
* "image/jpeg" and "image/png" so we don't need to get too fancy. * values "image/jpeg" and "image/png" so we don't need to get too fancy.
*/ */
std::string suffixToMimeType(std::string suffix); std::string suffixToMimeType(std::string suffix);
} } // namespace ImageUtils

35
src/utils/String_Utils.cpp
View File

@ -11,8 +11,7 @@
namespace StringUtils { namespace StringUtils {
PathSeparator operator!(const PathSeparator &s) PathSeparator operator!(const PathSeparator& s) {
{
return (s == PATH_WIN) ? PATH_UNIX : PATH_WIN; return (s == PATH_WIN) ? PATH_UNIX : PATH_WIN;
} }
@ -23,54 +22,49 @@ namespace StringUtils {
return PATH_WIN; return PATH_WIN;
#endif #endif
} }
const std::string NormalizePath(const std::string &path) const std::string NormalizePath(const std::string& path) {
{
PathSeparator separator = GetPathSeparator(); PathSeparator separator = GetPathSeparator();
char replace; char replace;
if (separator == PATH_WIN) { if (separator == PATH_WIN) {
replace = PATH_UNIX; replace = PATH_UNIX;
} } else {
else {
replace = PATH_WIN; replace = PATH_WIN;
} }
std::string normalizedPath = path; std::string normalizedPath = path;
for (size_t s = normalizedPath.find(replace, 0); s != std::string::npos; s = normalizedPath.find(replace, s)) { for (size_t s = normalizedPath.find(replace, 0); s != std::string::npos;
s = normalizedPath.find(replace, s)) {
normalizedPath[s] = separator; normalizedPath[s] = separator;
} }
return normalizedPath; return normalizedPath;
} }
const std::string GetFolderString(const std::string &path) const std::string GetFolderString(const std::string& path) {
{
size_t s = path.rfind(PATH_WIN); size_t s = path.rfind(PATH_WIN);
s = (s != std::string::npos) ? s : path.rfind(PATH_UNIX); s = (s != std::string::npos) ? s : path.rfind(PATH_UNIX);
return path.substr(0, s + 1); return path.substr(0, s + 1);
} }
const std::string GetCleanPathString(const std::string &path, const PathSeparator separator) const std::string GetCleanPathString(const std::string& path, const PathSeparator separator) {
{
std::string cleanPath = path; std::string cleanPath = path;
for (size_t s = cleanPath.find(!separator, 0); s != std::string::npos; s = cleanPath.find(!separator, s)) { for (size_t s = cleanPath.find(!separator, 0); s != std::string::npos;
s = cleanPath.find(!separator, s)) {
cleanPath[s] = separator; cleanPath[s] = separator;
} }
return cleanPath; return cleanPath;
} }
const std::string GetFileNameString(const std::string &path) const std::string GetFileNameString(const std::string& path) {
{
size_t s = path.rfind(PATH_WIN); size_t s = path.rfind(PATH_WIN);
s = (s != std::string::npos) ? s : path.rfind(PATH_UNIX); s = (s != std::string::npos) ? s : path.rfind(PATH_UNIX);
return path.substr(s + 1, std::string::npos); return path.substr(s + 1, std::string::npos);
} }
const std::string GetFileBaseString(const std::string &path) const std::string GetFileBaseString(const std::string& path) {
{
const std::string fileName = GetFileNameString(path); const std::string fileName = GetFileNameString(path);
return fileName.substr(0, fileName.rfind('.')).c_str(); return fileName.substr(0, fileName.rfind('.')).c_str();
} }
const std::string GetFileSuffixString(const std::string &path) const std::string GetFileSuffixString(const std::string& path) {
{
const std::string fileName = GetFileNameString(path); const std::string fileName = GetFileNameString(path);
size_t pos = fileName.rfind('.'); size_t pos = fileName.rfind('.');
if (pos == std::string::npos) { if (pos == std::string::npos) {
@ -79,9 +73,8 @@ namespace StringUtils {
return fileName.substr(++pos); return fileName.substr(++pos);
} }
int CompareNoCase(const std::string &s1, const std::string &s2) int CompareNoCase(const std::string& s1, const std::string& s2) {
{
return strncasecmp(s1.c_str(), s2.c_str(), MAX_PATH_LENGTH); return strncasecmp(s1.c_str(), s2.c_str(), MAX_PATH_LENGTH);
} }
} } // namespace StringUtils

19
src/utils/String_Utils.hpp
View File

@ -9,10 +9,10 @@
#pragma once #pragma once
#include <string> #include <cstdarg>
#include <cstdio> #include <cstdio>
#include <cstring> #include <cstring>
#include <cstdarg> #include <string>
#if defined(_MSC_VER) #if defined(_MSC_VER)
#define strncasecmp _strnicmp #define strncasecmp _strnicmp
@ -23,22 +23,19 @@ namespace StringUtils {
static const unsigned int MAX_PATH_LENGTH = 1024; static const unsigned int MAX_PATH_LENGTH = 1024;
enum PathSeparator enum PathSeparator { PATH_WIN = '\\', PATH_UNIX = '/' };
{
PATH_WIN = '\\',
PATH_UNIX = '/'
};
PathSeparator operator!(const PathSeparator& s); PathSeparator operator!(const PathSeparator& s);
PathSeparator GetPathSeparator(); PathSeparator GetPathSeparator();
const std::string NormalizePath(const std::string& path); const std::string NormalizePath(const std::string& path);
const std::string GetCleanPathString(const std::string &path, const PathSeparator separator = PATH_WIN); const std::string GetCleanPathString(
const std::string& path,
const PathSeparator separator = PATH_WIN);
template <size_t size> template <size_t size>
void GetCleanPath(char (&dest)[size], const char *path, const PathSeparator separator = PATH_WIN) void GetCleanPath(char (&dest)[size], const char* path, const PathSeparator separator = PATH_WIN) {
{
size_t len = size - 1; size_t len = size - 1;
strncpy(dest, path, len); strncpy(dest, path, len);
char* destPtr = dest; char* destPtr = dest;
@ -54,4 +51,4 @@ namespace StringUtils {
int CompareNoCase(const std::string& s1, const std::string& s2); int CompareNoCase(const std::string& s1, const std::string& s2);
} } // namespace StringUtils