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

Apply clang-format to all our source. (#149) 

Apply clang-format to all our source.
This commit is contained in:
Pär Winzell 2018-12-18 23:30:29 -08:00 committed by GitHub
parent be1b75431d
commit 5730d1c301
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
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;

1852
src/fbx/Fbx2Raw.cpp
View File

File diff suppressed because it is too large Load Diff

4
src/fbx/Fbx2Raw.hpp
View File

@ -11,6 +11,6 @@
#include "raw/RawModel.hpp" #include "raw/RawModel.hpp"
bool LoadFBXFile(RawModel &raw, const char *fbxFileName, const char *textureExtensions); bool LoadFBXFile(RawModel& raw, const char* fbxFileName, const char* textureExtensions);
json TranscribeProperty(FbxProperty &prop); json TranscribeProperty(FbxProperty& prop);

94
src/fbx/FbxBlendShapesAccess.cpp
View File

@ -9,57 +9,65 @@
#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,
blendShapeIx(blendShapeIx), const unsigned int channelIx,
channelIx(channelIx), const FbxDouble deformPercent,
deformPercent(deformPercent), const std::vector<FbxBlendShapesAccess::TargetShape>& targetShapes,
targetShapes(targetShapes), std::string name)
name(name) : mesh(mesh),
{} blendShapeIx(blendShapeIx),
channelIx(channelIx),
deformPercent(deformPercent),
targetShapes(targetShapes),
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);
if (fbxChannel->GetTargetShapeCount() > 0) { if (fbxChannel->GetTargetShapeCount() > 0) {
std::vector<TargetShape> targetShapes; std::vector<TargetShape> targetShapes;
const double *fullWeights = fbxChannel->GetTargetShapeFullWeights(); const double* fullWeights = fbxChannel->GetTargetShapeFullWeights();
std::string name = std::string(fbxChannel->GetName()); std::string name = std::string(fbxChannel->GetName());
if (verboseOutput) { if (verboseOutput) {
fmt::printf("\rblendshape channel: %s\n", name); fmt::printf("\rblendshape channel: %s\n", name);
}
for (int targetIx = 0; targetIx < fbxChannel->GetTargetShapeCount(); targetIx ++) {
FbxShape *fbxShape = fbxChannel->GetTargetShape(targetIx);
targetShapes.emplace_back(fbxShape, fullWeights[targetIx]);
}
channels.emplace_back(mesh, shapeIx, channelIx, fbxChannel->DeformPercent * 0.01, targetShapes, name);
}
} }
for (int targetIx = 0; targetIx < fbxChannel->GetTargetShapeCount(); targetIx++) {
FbxShape* fbxShape = fbxChannel->GetTargetShape(targetIx);
targetShapes.emplace_back(fbxShape, fullWeights[targetIx]);
}
channels.emplace_back(
mesh, shapeIx, channelIx, fbxChannel->DeformPercent * 0.01, targetShapes, name);
}
} }
return channels; }
return channels;
} }

138
src/fbx/FbxBlendShapesAccess.hpp
View File

@ -9,97 +9,97 @@
#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
* A target shape is on a 1:1 basis with the eventual glTF morph target, and is the object which contains the * contains the actual morphed vertex data.
* 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;
const FbxDouble fullWeight; const FbxDouble fullWeight;
const unsigned int count; const unsigned int count;
const FbxVector4 *positions; const FbxVector4* positions;
const FbxLayerElementAccess<FbxVector4> normals; const FbxLayerElementAccess<FbxVector4> normals;
const FbxLayerElementAccess<FbxVector4> tangents; const FbxLayerElementAccess<FbxVector4> tangents;
}; };
/** /**
* 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;
FbxMesh *const mesh; FbxMesh* const mesh;
const unsigned int blendShapeIx; const unsigned int blendShapeIx;
const unsigned int channelIx; const unsigned int channelIx;
const std::vector<TargetShape> targetShapes; const std::vector<TargetShape> targetShapes;
const std::string name; const std::string name;
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 {
const BlendChannel &GetBlendChannel(size_t channelIx) const { return channels.size();
return channels.at(channelIx); }
} const BlendChannel& GetBlendChannel(size_t channelIx) const {
return channels.at(channelIx);
}
size_t GetTargetShapeCount(size_t channelIx) const { return channels[channelIx].targetShapes.size(); } size_t GetTargetShapeCount(size_t channelIx) const {
const TargetShape &GetTargetShape(size_t channelIx, size_t targetShapeIx) const { return channels[channelIx].targetShapes.size();
return channels.at(channelIx).targetShapes[targetShapeIx]; }
} const TargetShape& GetTargetShape(size_t channelIx, size_t targetShapeIx) const {
return channels.at(channelIx).targetShapes[targetShapeIx];
}
FbxAnimCurve * GetAnimation(size_t channelIx, size_t animIx) const { FbxAnimCurve* GetAnimation(size_t channelIx, size_t animIx) const {
return channels.at(channelIx).ExtractAnimation(animIx); return channels.at(channelIx).ExtractAnimation(animIx);
} }
private: private:
std::vector<BlendChannel> extractChannels(FbxMesh *mesh) const; std::vector<BlendChannel> extractChannels(FbxMesh* mesh) const;
const std::vector<BlendChannel> channels; const std::vector<BlendChannel> channels;
}; };

130
src/fbx/FbxLayerElementAccess.hpp
View File

@ -9,75 +9,87 @@
#pragma once #pragma once
#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 {
return (mappingMode != FbxLayerElement::eNone);
}
bool LayerPresent() const _type_ GetElement(
{ const int polygonIndex,
return (mappingMode != FbxLayerElement::eNone); 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;
_type_ GetElement(const int polygonIndex, const int polygonVertexIndex, const int controlPointIndex, const _type_ defaultValue) const; private:
_type_ GetElement( FbxLayerElement::EMappingMode mappingMode;
const int polygonIndex, const int polygonVertexIndex, const int controlPointIndex, const _type_ defaultValue, const FbxLayerElementArrayTemplate<_type_>* elements;
const FbxMatrix &transform, const bool normalize) const; const FbxLayerElementArrayTemplate<int>* indices;
private:
FbxLayerElement::EMappingMode mappingMode;
const FbxLayerElementArrayTemplate<_type_> *elements;
const FbxLayerElementArrayTemplate<int> *indices;
}; };
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; }
} const FbxLayerElement::EMappingMode newMappingMode = layer->GetMappingMode();
const FbxLayerElement::EMappingMode newMappingMode = layer->GetMappingMode(); if (newMappingMode == FbxLayerElement::eByControlPoint ||
if (newMappingMode == FbxLayerElement::eByControlPoint || newMappingMode == FbxLayerElement::eByPolygonVertex ||
newMappingMode == FbxLayerElement::eByPolygonVertex || newMappingMode == FbxLayerElement::eByPolygon) {
newMappingMode == FbxLayerElement::eByPolygon) { mappingMode = newMappingMode;
mappingMode = newMappingMode; elements = &layer->GetDirectArray();
elements = &layer->GetDirectArray(); indices = (layer->GetReferenceMode() == FbxLayerElement::eIndexToDirect ||
indices = ( layer->GetReferenceMode() == FbxLayerElement::eIndex)
layer->GetReferenceMode() == FbxLayerElement::eIndexToDirect || ? &layer->GetIndexArray()
layer->GetReferenceMode() == FbxLayerElement::eIndex) ? &layer->GetIndexArray() : nullptr; : 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,
if (mappingMode != FbxLayerElement::eNone) { const int controlPointIndex,
int index = (mappingMode == FbxLayerElement::eByControlPoint) ? controlPointIndex : const _type_ defaultValue) const {
((mappingMode == FbxLayerElement::eByPolygonVertex) ? polygonVertexIndex : polygonIndex); if (mappingMode != FbxLayerElement::eNone) {
index = (indices != nullptr) ? (*indices)[index] : index; int index = (mappingMode == FbxLayerElement::eByControlPoint)
_type_ element = elements->GetAt(index); ? controlPointIndex
return element; : ((mappingMode == FbxLayerElement::eByPolygonVertex) ? polygonVertexIndex : polygonIndex);
} index = (indices != nullptr) ? (*indices)[index] : index;
return defaultValue; _type_ element = elements->GetAt(index);
return element;
}
return defaultValue;
} }
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,
if (mappingMode != FbxLayerElement::eNone) { const _type_ defaultValue,
_type_ element = transform.MultNormalize(GetElement(polygonIndex, polygonVertexIndex, controlPointIndex, defaultValue)); const FbxMatrix& transform,
if (normalize) { const bool normalize) const {
element.Normalize(); if (mappingMode != FbxLayerElement::eNone) {
} _type_ element = transform.MultNormalize(
return element; GetElement(polygonIndex, polygonVertexIndex, controlPointIndex, defaultValue));
if (normalize) {
element.Normalize();
} }
return defaultValue; return element;
}
return defaultValue;
} }

11
src/fbx/FbxMaterialInfo.hpp
View File

@ -12,11 +12,10 @@
#include "FBX2glTF.h" #include "FBX2glTF.h"
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;
}; };

152
src/fbx/FbxMaterialsAccess.cpp
View File

@ -10,95 +10,95 @@
#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();
if (materialMappingMode != FbxGeometryElement::eByPolygon &&
materialMappingMode != FbxGeometryElement::eAllSame) {
return;
}
const FbxGeometryElement::EReferenceMode materialReferenceMode =
pMesh->GetElementMaterial()->GetReferenceMode();
if (materialReferenceMode != FbxGeometryElement::eIndexToDirect) {
return;
}
mappingMode = materialMappingMode;
mesh = pMesh;
indices = &pMesh->GetElementMaterial()->GetIndexArray();
for (int ii = 0; ii < indices->GetCount(); ii++) {
int materialNum = indices->GetAt(ii);
if (materialNum < 0) {
continue;
} }
const FbxGeometryElement::EMappingMode materialMappingMode = pMesh->GetElementMaterial()->GetMappingMode(); FbxSurfaceMaterial* surfaceMaterial =
if (materialMappingMode != FbxGeometryElement::eByPolygon && materialMappingMode != FbxGeometryElement::eAllSame) { mesh->GetNode()->GetSrcObject<FbxSurfaceMaterial>(materialNum);
return;
if (materialNum >= summaries.size()) {
summaries.resize(materialNum + 1);
}
auto summary = summaries[materialNum];
if (summary == nullptr) {
summary = summaries[materialNum] = GetMaterialInfo(surfaceMaterial, textureLocations);
} }
const FbxGeometryElement::EReferenceMode materialReferenceMode = pMesh->GetElementMaterial()->GetReferenceMode(); if (materialNum >= userProperties.size()) {
if (materialReferenceMode != FbxGeometryElement::eIndexToDirect) { userProperties.resize(materialNum + 1);
return;
} }
if (userProperties[materialNum].empty()) {
mappingMode = materialMappingMode; FbxProperty objectProperty = surfaceMaterial->GetFirstProperty();
mesh = pMesh; while (objectProperty.IsValid()) {
indices = &pMesh->GetElementMaterial()->GetIndexArray(); if (objectProperty.GetFlag(FbxPropertyFlags::eUserDefined)) {
userProperties[materialNum].push_back(TranscribeProperty(objectProperty).dump());
for (int ii = 0; ii < indices->GetCount(); ii++) {
int materialNum = indices->GetAt(ii);
if (materialNum < 0) {
continue;
}
FbxSurfaceMaterial* surfaceMaterial = mesh->GetNode()->GetSrcObject<FbxSurfaceMaterial>(materialNum);
if (materialNum >= summaries.size()) {
summaries.resize(materialNum + 1);
}
auto summary = summaries[materialNum];
if (summary == nullptr) {
summary = summaries[materialNum] = GetMaterialInfo(
surfaceMaterial,
textureLocations);
}
if (materialNum >= userProperties.size()) {
userProperties.resize(materialNum + 1);
}
if (userProperties[materialNum].empty()) {
FbxProperty objectProperty = surfaceMaterial->GetFirstProperty();
while (objectProperty.IsValid())
{
if (objectProperty.GetFlag(FbxPropertyFlags::eUserDefined)) {
userProperties[materialNum].push_back(TranscribeProperty(objectProperty).dump());
}
objectProperty = surfaceMaterial->GetNextProperty(objectProperty);
}
} }
objectProperty = surfaceMaterial->GetNextProperty(objectProperty);
}
} }
}
} }
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 =
if (materialNum < 0) { indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0);
return nullptr; if (materialNum < 0) {
} return nullptr;
return summaries.at((unsigned long) materialNum);
} }
return nullptr; return summaries.at((unsigned long)materialNum);
}
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 =
const int materialNum = indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0); indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0);
if (materialNum < 0) { if (materialNum < 0) {
return std::vector<std::string>(); return std::vector<std::string>();
}
return userProperties.at((unsigned long)materialNum);
} }
return std::vector<std::string>(); return userProperties.at((unsigned long)materialNum);
}
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) {
res = FbxTraditionalMaterialInfo::From(material, textureLocations); res = FbxTraditionalMaterialInfo::From(material, textureLocations);
} }
return res; return res;
} }

33
src/fbx/FbxMaterialsAccess.hpp
View File

@ -11,26 +11,27 @@
#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(
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; const std::vector<std::string> GetUserProperties(const int polygonIndex) const;
const std::vector<std::string> GetUserProperties(const int polygonIndex) const; std::unique_ptr<FbxMaterialInfo> GetMaterialInfo(
FbxSurfaceMaterial* material,
const std::map<const FbxTexture*, FbxString>& textureLocations);
std::unique_ptr<FbxMaterialInfo> private:
GetMaterialInfo(FbxSurfaceMaterial *material, const std::map<const FbxTexture *, FbxString> &textureLocations); FbxGeometryElement::EMappingMode mappingMode;
std::vector<std::shared_ptr<FbxMaterialInfo>> summaries{};
private: std::vector<std::vector<std::string>> userProperties;
FbxGeometryElement::EMappingMode mappingMode; const FbxMesh* mesh;
std::vector<std::shared_ptr<FbxMaterialInfo>> summaries {}; const FbxLayerElementArrayTemplate<int>* indices;
std::vector<std::vector<std::string>> userProperties;
const FbxMesh *mesh;
const FbxLayerElementArrayTemplate<int> *indices;
}; };

103
src/fbx/FbxRoughMetMaterialInfo.cpp
View File

@ -7,62 +7,67 @@
* 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 "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) {
const FbxFileTexture *ptr = nullptr; const FbxFileTexture* ptr = nullptr;
const FbxProperty useProp = mayaProp.FindHierarchical(("use_" + propName + "_map").c_str()); const FbxProperty useProp = mayaProp.FindHierarchical(("use_" + propName + "_map").c_str());
if (useProp.IsValid() && useProp.Get<bool>()) { if (useProp.IsValid() && useProp.Get<bool>()) {
const FbxProperty texProp = mayaProp.FindHierarchical(("TEX_" + propName + "_map").c_str()); const FbxProperty texProp = mayaProp.FindHierarchical(("TEX_" + propName + "_map").c_str());
if (texProp.IsValid()) { if (texProp.IsValid()) {
ptr = texProp.GetSrcObject<FbxFileTexture>(); ptr = texProp.GetSrcObject<FbxFileTexture>();
if (ptr != nullptr && textureLocations.find(ptr) == textureLocations.end()) { if (ptr != nullptr && textureLocations.find(ptr) == textureLocations.end()) {
ptr = nullptr; ptr = nullptr;
}
}
} else if (verboseOutput && useProp.IsValid()) {
fmt::printf("Note: Property '%s' of material '%s' exists, but is flagged as 'do not use'.\n",
propName, fbxMaterial->GetName());
} }
return ptr; }
}; } else if (verboseOutput && useProp.IsValid()) {
fmt::printf(
"Note: Property '%s' of material '%s' exists, but is flagged as 'do not use'.\n",
propName,
fbxMaterial->GetName());
}
return ptr;
};
auto getVec = [&](std::string propName) -> FbxDouble3 { auto getVec = [&](std::string propName) -> FbxDouble3 {
const FbxProperty vecProp = mayaProp.FindHierarchical(propName.c_str()); const FbxProperty vecProp = mayaProp.FindHierarchical(propName.c_str());
return vecProp.IsValid() ? vecProp.Get<FbxDouble3>() : FbxDouble3(1, 1, 1); return vecProp.IsValid() ? vecProp.Get<FbxDouble3>() : FbxDouble3(1, 1, 1);
}; };
auto getVal = [&](std::string propName) -> FbxDouble { auto getVal = [&](std::string propName) -> FbxDouble {
const FbxProperty vecProp = mayaProp.FindHierarchical(propName .c_str()); const FbxProperty vecProp = mayaProp.FindHierarchical(propName.c_str());
return vecProp.IsValid() ? vecProp.Get<FbxDouble>() : 0; return vecProp.IsValid() ? vecProp.Get<FbxDouble>() : 0;
}; };
res->texNormal = getTex("normal"); res->texNormal = getTex("normal");
res->texColor = getTex("color"); res->texColor = getTex("color");
res->colBase = getVec("base_color"); res->colBase = getVec("base_color");
res->texAmbientOcclusion = getTex("ao"); res->texAmbientOcclusion = getTex("ao");
res->texEmissive = getTex("emissive"); res->texEmissive = getTex("emissive");
res->colEmissive = getVec("emissive"); res->colEmissive = getVec("emissive");
res->emissiveIntensity = getVal("emissive_intensity"); res->emissiveIntensity = getVal("emissive_intensity");
res->texMetallic = getTex("metallic"); res->texMetallic = getTex("metallic");
res->metallic = getVal("metallic"); res->metallic = getVal("metallic");
res->texRoughness = getTex("roughness"); res->texRoughness = getTex("roughness");
res->roughness = getVal("roughness"); res->roughness = getVal("roughness");
return res; return res;
} }

41
src/fbx/FbxRoughMetMaterialInfo.hpp
View File

@ -7,36 +7,35 @@
* 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"
struct FbxRoughMetMaterialInfo : FbxMaterialInfo { struct FbxRoughMetMaterialInfo : FbxMaterialInfo {
static constexpr const char *FBX_SHADER_METROUGH = "MetallicRoughness"; static constexpr const char* FBX_SHADER_METROUGH = "MetallicRoughness";
static std::unique_ptr<FbxRoughMetMaterialInfo> From( static std::unique_ptr<FbxRoughMetMaterialInfo> From(
FbxSurfaceMaterial *fbxMaterial, FbxSurfaceMaterial* fbxMaterial,
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{};
const FbxFileTexture *texNormal {}; const FbxFileTexture* texNormal{};
const FbxFileTexture *texMetallic {}; const FbxFileTexture* texMetallic{};
FbxDouble metallic {}; FbxDouble metallic{};
const FbxFileTexture *texRoughness {}; const FbxFileTexture* texRoughness{};
FbxDouble roughness {}; FbxDouble roughness{};
const FbxFileTexture *texEmissive {}; const FbxFileTexture* texEmissive{};
FbxVector4 colEmissive {}; FbxVector4 colEmissive{};
FbxDouble emissiveIntensity {}; FbxDouble emissiveIntensity{};
const FbxFileTexture *texAmbientOcclusion {}; const FbxFileTexture* texAmbientOcclusion{};
}; };

155
src/fbx/FbxSkinningAccess.cpp
View File

@ -9,84 +9,89 @@
#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 =
FbxSkin *skin = reinterpret_cast< FbxSkin * >( pMesh->GetDeformer(deformerIndex, FbxDeformer::eSkin)); 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) {
continue; continue;
} }
int controlPointCount = pMesh->GetControlPointsCount(); int controlPointCount = pMesh->GetControlPointsCount();
vertexJointIndices.resize(controlPointCount, Vec4i(0, 0, 0, 0)); vertexJointIndices.resize(controlPointCount, Vec4i(0, 0, 0, 0));
vertexJointWeights.resize(controlPointCount, Vec4f(0.0f, 0.0f, 0.0f, 0.0f)); vertexJointWeights.resize(controlPointCount, Vec4f(0.0f, 0.0f, 0.0f, 0.0f));
for (int clusterIndex = 0; clusterIndex < clusterCount; clusterIndex++) { for (int clusterIndex = 0; clusterIndex < clusterCount; clusterIndex++) {
FbxCluster *cluster = skin->GetCluster(clusterIndex); FbxCluster* cluster = skin->GetCluster(clusterIndex);
const int indexCount = cluster->GetControlPointIndicesCount(); const int indexCount = cluster->GetControlPointIndicesCount();
const int *clusterIndices = cluster->GetControlPointIndices(); const int* clusterIndices = cluster->GetControlPointIndices();
const double *clusterWeights = cluster->GetControlPointWeights(); const double* clusterWeights = cluster->GetControlPointWeights();
assert(cluster->GetLinkMode() == FbxCluster::eNormalize); assert(cluster->GetLinkMode() == FbxCluster::eNormalize);
// Transform link matrix. // Transform link matrix.
FbxAMatrix transformLinkMatrix; FbxAMatrix transformLinkMatrix;
cluster->GetTransformLinkMatrix(transformLinkMatrix); cluster->GetTransformLinkMatrix(transformLinkMatrix);
// The transformation of the mesh at binding time // The transformation of the mesh at binding time
FbxAMatrix transformMatrix; FbxAMatrix transformMatrix;
cluster->GetTransformMatrix(transformMatrix); cluster->GetTransformMatrix(transformMatrix);
// Inverse bind matrix. // Inverse bind matrix.
FbxAMatrix globalBindposeInverseMatrix = transformLinkMatrix.Inverse() * transformMatrix; FbxAMatrix globalBindposeInverseMatrix = transformLinkMatrix.Inverse() * transformMatrix;
inverseBindMatrices.emplace_back(globalBindposeInverseMatrix); inverseBindMatrices.emplace_back(globalBindposeInverseMatrix);
jointNodes.push_back(cluster->GetLink()); jointNodes.push_back(cluster->GetLink());
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(
jointInverseGlobalTransforms.push_back(FbxMatrix(globalNodeTransform.Inverse())); FbxMatrix(globalNodeTransform * globalBindposeInverseMatrix));
jointInverseGlobalTransforms.push_back(FbxMatrix(globalNodeTransform.Inverse()));
for (int i = 0; i < indexCount; i++) {
if (clusterIndices[i] < 0 || clusterIndices[i] >= controlPointCount) { for (int i = 0; i < indexCount; i++) {
continue; if (clusterIndices[i] < 0 || clusterIndices[i] >= controlPointCount) {
} continue;
if (clusterWeights[i] <= vertexJointWeights[clusterIndices[i]][MAX_WEIGHTS - 1]) { }
continue; if (clusterWeights[i] <= vertexJointWeights[clusterIndices[i]][MAX_WEIGHTS - 1]) {
} continue;
vertexJointIndices[clusterIndices[i]][MAX_WEIGHTS - 1] = clusterIndex; }
vertexJointWeights[clusterIndices[i]][MAX_WEIGHTS - 1] = (float) clusterWeights[i]; vertexJointIndices[clusterIndices[i]][MAX_WEIGHTS - 1] = clusterIndex;
for (int j = MAX_WEIGHTS - 1; j > 0; j--) { vertexJointWeights[clusterIndices[i]][MAX_WEIGHTS - 1] = (float)clusterWeights[i];
if (vertexJointWeights[clusterIndices[i]][j - 1] >= vertexJointWeights[clusterIndices[i]][j]) { for (int j = MAX_WEIGHTS - 1; j > 0; j--) {
break; if (vertexJointWeights[clusterIndices[i]][j - 1] >=
} vertexJointWeights[clusterIndices[i]][j]) {
std::swap(vertexJointIndices[clusterIndices[i]][j - 1], vertexJointIndices[clusterIndices[i]][j]); break;
std::swap(vertexJointWeights[clusterIndices[i]][j - 1], vertexJointWeights[clusterIndices[i]][j]);
}
}
}
for (int i = 0; i < controlPointCount; i++) {
vertexJointWeights[i] = vertexJointWeights[i].Normalized();
} }
std::swap(
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++) {
vertexJointWeights[i] = vertexJointWeights[i].Normalized();
}
} }
}
rootIndex = -1; rootIndex = -1;
for (size_t i = 0; i < jointNodes.size() && rootIndex == -1; i++) { for (size_t i = 0; i < jointNodes.size() && rootIndex == -1; i++) {
rootIndex = (int) i; rootIndex = (int)i;
FbxNode *parent = jointNodes[i]->GetParent(); FbxNode* parent = jointNodes[i]->GetParent();
if (parent == nullptr) { if (parent == nullptr) {
break; break;
}
for (size_t j = 0; j < jointNodes.size(); j++) {
if (jointNodes[j] == parent) {
rootIndex = -1;
break;
}
}
} }
for (size_t j = 0; j < jointNodes.size(); j++) {
if (jointNodes[j] == parent) {
rootIndex = -1;
break;
}
}
}
} }

110
src/fbx/FbxSkinningAccess.hpp
View File

@ -9,84 +9,72 @@
#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 {
return (vertexJointWeights.size() > 0);
}
bool IsSkinned() const int GetNodeCount() const {
{ return (int)jointNodes.size();
return (vertexJointWeights.size() > 0); }
}
int GetNodeCount() const FbxNode* GetJointNode(const int jointIndex) const {
{ return jointNodes[jointIndex];
return (int) jointNodes.size(); }
}
FbxNode *GetJointNode(const int jointIndex) const const long GetJointId(const int jointIndex) const {
{ return jointIds[jointIndex];
return jointNodes[jointIndex]; }
}
const long GetJointId(const int jointIndex) const const FbxMatrix& GetJointSkinningTransform(const int jointIndex) const {
{ return jointSkinningTransforms[jointIndex];
return jointIds[jointIndex]; }
}
const FbxMatrix &GetJointSkinningTransform(const int jointIndex) const const FbxMatrix& GetJointInverseGlobalTransforms(const int jointIndex) const {
{ return jointInverseGlobalTransforms[jointIndex];
return jointSkinningTransforms[jointIndex]; }
}
const FbxMatrix &GetJointInverseGlobalTransforms(const int jointIndex) const const long GetRootNode() const {
{ assert(rootIndex != -1);
return jointInverseGlobalTransforms[jointIndex]; return jointIds[rootIndex];
} }
const long GetRootNode() const const FbxAMatrix& GetInverseBindMatrix(const int jointIndex) const {
{ return inverseBindMatrices[jointIndex];
assert(rootIndex != -1); }
return jointIds[rootIndex];
}
const FbxAMatrix &GetInverseBindMatrix(const int jointIndex) const const Vec4i GetVertexIndices(const int controlPointIndex) const {
{ return (!vertexJointIndices.empty()) ? vertexJointIndices[controlPointIndex]
return inverseBindMatrices[jointIndex]; : Vec4i(0, 0, 0, 0);
} }
const Vec4i GetVertexIndices(const int controlPointIndex) const const Vec4f GetVertexWeights(const int controlPointIndex) const {
{ return (!vertexJointWeights.empty()) ? vertexJointWeights[controlPointIndex]
return (!vertexJointIndices.empty()) ? : Vec4f(0, 0, 0, 0);
vertexJointIndices[controlPointIndex] : Vec4i(0, 0, 0, 0); }
}
const Vec4f GetVertexWeights(const int controlPointIndex) const private:
{ int rootIndex;
return (!vertexJointWeights.empty()) ? std::vector<long> jointIds;
vertexJointWeights[controlPointIndex] : Vec4f(0, 0, 0, 0); std::vector<FbxNode*> jointNodes;
} std::vector<FbxMatrix> jointSkinningTransforms;
std::vector<FbxMatrix> jointInverseGlobalTransforms;
private: std::vector<FbxAMatrix> inverseBindMatrices;
int rootIndex; std::vector<Vec4i> vertexJointIndices;
std::vector<long> jointIds; std::vector<Vec4f> vertexJointWeights;
std::vector<FbxNode *> jointNodes;
std::vector<FbxMatrix> jointSkinningTransforms;
std::vector<FbxMatrix> jointInverseGlobalTransforms;
std::vector<FbxAMatrix> inverseBindMatrices;
std::vector<Vec4i> vertexJointIndices;
std::vector<Vec4f> vertexJointWeights;
}; };

215
src/fbx/FbxTraditionalMaterialInfo.cpp
View File

@ -9,116 +9,129 @@
#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);
FbxDouble val(0); FbxDouble val(0);
FbxFileTexture *tex = prop.GetSrcObject<FbxFileTexture>(); FbxFileTexture* tex = prop.GetSrcObject<FbxFileTexture>();
if (tex != nullptr && textureLocations.find(tex) == textureLocations.end()) { if (tex != nullptr && textureLocations.find(tex) == textureLocations.end()) {
tex = nullptr; tex = nullptr;
} }
if (tex == nullptr && prop.IsValid()) { if (tex == nullptr && prop.IsValid()) {
val = prop.Get<FbxDouble>(); val = prop.Get<FbxDouble>();
} }
return std::make_tuple(val, tex); return std::make_tuple(val, tex);
}; };
auto getSurfaceVector = [&](const char *propName) -> std::tuple<FbxDouble3, FbxFileTexture *> { auto getSurfaceVector = [&](const char* propName) -> std::tuple<FbxDouble3, FbxFileTexture*> {
const FbxProperty prop = fbxMaterial->FindProperty(propName); const FbxProperty prop = fbxMaterial->FindProperty(propName);
FbxDouble3 val(1, 1, 1); FbxDouble3 val(1, 1, 1);
FbxFileTexture *tex = prop.GetSrcObject<FbxFileTexture>(); FbxFileTexture* tex = prop.GetSrcObject<FbxFileTexture>();
if (tex != nullptr && textureLocations.find(tex) == textureLocations.end()) { if (tex != nullptr && textureLocations.find(tex) == textureLocations.end()) {
tex = nullptr; tex = nullptr;
} }
if (tex == nullptr && prop.IsValid()) { if (tex == nullptr && prop.IsValid()) {
val = prop.Get<FbxDouble3>(); val = prop.Get<FbxDouble3>();
} }
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 FbxProperty colProp = fbxMaterial->FindProperty(colName); [&](const char* colName,
const FbxProperty facProp = fbxMaterial->FindProperty(facName); const char* facName) -> std::tuple<FbxVector4, FbxFileTexture*, FbxFileTexture*> {
const FbxProperty colProp = fbxMaterial->FindProperty(colName);
const FbxProperty facProp = fbxMaterial->FindProperty(facName);
FbxDouble3 colorVal(1, 1, 1); FbxDouble3 colorVal(1, 1, 1);
FbxDouble factorVal(1); FbxDouble factorVal(1);
FbxFileTexture *colTex = colProp.GetSrcObject<FbxFileTexture>(); FbxFileTexture* colTex = colProp.GetSrcObject<FbxFileTexture>();
if (colTex != nullptr && textureLocations.find(colTex) == textureLocations.end()) { if (colTex != nullptr && textureLocations.find(colTex) == textureLocations.end()) {
colTex = nullptr; colTex = nullptr;
} }
if (colTex == nullptr && colProp.IsValid()) { if (colTex == nullptr && colProp.IsValid()) {
colorVal = colProp.Get<FbxDouble3>(); colorVal = colProp.Get<FbxDouble3>();
} }
FbxFileTexture *facTex = facProp.GetSrcObject<FbxFileTexture>(); FbxFileTexture* facTex = facProp.GetSrcObject<FbxFileTexture>();
if (facTex != nullptr && textureLocations.find(facTex) == textureLocations.end()) { if (facTex != nullptr && textureLocations.find(facTex) == textureLocations.end()) {
facTex = nullptr; facTex = nullptr;
} }
if (facTex == nullptr && facProp.IsValid()) { if (facTex == nullptr && facProp.IsValid()) {
factorVal = facProp.Get<FbxDouble>(); factorVal = facProp.Get<FbxDouble>();
} }
auto val = FbxVector4( auto val = FbxVector4(
colorVal[0] * factorVal, colorVal[0] * factorVal, colorVal[1] * factorVal, colorVal[2] * factorVal, factorVal);
colorVal[1] * factorVal, return std::make_tuple(val, colTex, facTex);
colorVal[2] * factorVal, };
factorVal);
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,
FbxFileTexture *colTex, *facTex; const char* facName) -> std::tuple<FbxVector4, FbxFileTexture*> {
FbxVector4 vec;
std::tie(vec, colTex, facTex) = getSurfaceValues(colName, facName);
if (colTex) {
if (facTex) {
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, facTex);
};
std::tie(res->colAmbient, res->texAmbient) =
handleBasicProperty(FbxSurfaceMaterial::sAmbient, FbxSurfaceMaterial::sAmbientFactor);
std::tie(res->colSpecular, res->texSpecular) =
handleBasicProperty(FbxSurfaceMaterial::sSpecular, FbxSurfaceMaterial::sSpecularFactor);
std::tie(res->colDiffuse, res->texDiffuse) =
handleBasicProperty(FbxSurfaceMaterial::sDiffuse, FbxSurfaceMaterial::sDiffuseFactor);
std::tie(res->colEmissive, res->texEmissive) =
handleBasicProperty(FbxSurfaceMaterial::sEmissive, FbxSurfaceMaterial::sEmissiveFactor);
// the normal map can only ever be a map, ignore everything else
tie(std::ignore, res->texNormal) = getSurfaceVector(FbxSurfaceMaterial::sNormalMap);
// shininess can be a map or a factor; afaict the map is always 'ShininessExponent' and the
// value is always found in 'Shininess' but only sometimes in 'ShininessExponent'.
tie(std::ignore, res->texShininess) = getSurfaceScalar("ShininessExponent");
tie(res->shininess, std::ignore) = getSurfaceScalar("Shininess");
// for transparency we just want a constant vector value;
FbxVector4 transparency;
// 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) = FbxVector4 vec;
getSurfaceValues(FbxSurfaceMaterial::sTransparentColor, FbxSurfaceMaterial::sTransparencyFactor);
if (colTex) {
fmt::printf("Warning: Mat [%s]: Can't handle texture for %s; discarding.\n", name, FbxSurfaceMaterial::sTransparentColor);
}
if (facTex) {
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
res->colDiffuse[3] = 1.0 - (transparency[0] + transparency[1] + transparency[2])/3.0;
return res; std::tie(vec, colTex, facTex) = getSurfaceValues(colName, facName);
if (colTex) {
if (facTex) {
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, facTex);
};
std::tie(res->colAmbient, res->texAmbient) =
handleBasicProperty(FbxSurfaceMaterial::sAmbient, FbxSurfaceMaterial::sAmbientFactor);
std::tie(res->colSpecular, res->texSpecular) =
handleBasicProperty(FbxSurfaceMaterial::sSpecular, FbxSurfaceMaterial::sSpecularFactor);
std::tie(res->colDiffuse, res->texDiffuse) =
handleBasicProperty(FbxSurfaceMaterial::sDiffuse, FbxSurfaceMaterial::sDiffuseFactor);
std::tie(res->colEmissive, res->texEmissive) =
handleBasicProperty(FbxSurfaceMaterial::sEmissive, FbxSurfaceMaterial::sEmissiveFactor);
// the normal map can only ever be a map, ignore everything else
tie(std::ignore, res->texNormal) = getSurfaceVector(FbxSurfaceMaterial::sNormalMap);
// shininess can be a map or a factor; afaict the map is always 'ShininessExponent' and the
// value is always found in 'Shininess' but only sometimes in 'ShininessExponent'.
tie(std::ignore, res->texShininess) = getSurfaceScalar("ShininessExponent");
tie(res->shininess, std::ignore) = getSurfaceScalar("Shininess");
// for transparency we just want a constant vector value;
FbxVector4 transparency;
// extract any existing textures only so we can warn that we're throwing them away
FbxFileTexture *colTex, *facTex;
std::tie(transparency, colTex, facTex) = getSurfaceValues(
FbxSurfaceMaterial::sTransparentColor, FbxSurfaceMaterial::sTransparencyFactor);
if (colTex) {
fmt::printf(
"Warning: Mat [%s]: Can't handle texture for %s; discarding.\n",
name,
FbxSurfaceMaterial::sTransparentColor);
}
if (facTex) {
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
res->colDiffuse[3] = 1.0 - (transparency[0] + transparency[1] + transparency[2]) / 3.0;
return res;
} }

45
src/fbx/FbxTraditionalMaterialInfo.hpp
View File

@ -7,38 +7,37 @@
* 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"
struct FbxTraditionalMaterialInfo : FbxMaterialInfo { struct FbxTraditionalMaterialInfo : FbxMaterialInfo {
static constexpr const char *FBX_SHADER_LAMBERT = "Lambert"; static constexpr const char* FBX_SHADER_LAMBERT = "Lambert";
static constexpr const char *FBX_SHADER_BLINN = "Blinn"; static constexpr const char* FBX_SHADER_BLINN = "Blinn";
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{};
FbxFileTexture *texSpecular {}; FbxFileTexture* texSpecular{};
FbxVector4 colSpecular {}; FbxVector4 colSpecular{};
FbxFileTexture *texDiffuse {}; FbxFileTexture* texDiffuse{};
FbxVector4 colDiffuse {}; FbxVector4 colDiffuse{};
FbxFileTexture *texEmissive {}; FbxFileTexture* texEmissive{};
FbxVector4 colEmissive {}; FbxVector4 colEmissive{};
FbxFileTexture *texNormal {}; FbxFileTexture* texNormal{};
FbxFileTexture *texShininess {}; FbxFileTexture* texShininess{};
FbxDouble shininess {}; FbxDouble shininess{};
static std::unique_ptr<FbxTraditionalMaterialInfo> From( static std::unique_ptr<FbxTraditionalMaterialInfo> From(
FbxSurfaceMaterial *fbxMaterial, FbxSurfaceMaterial* fbxMaterial,
const std::map<const FbxTexture *, FbxString> &textureLocations); const std::map<const FbxTexture*, FbxString>& textureLocations);
}; };

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

@ -10,116 +10,117 @@
#include "RoughnessMetallicMaterials.hpp" #include "RoughnessMetallicMaterials.hpp"
std::unique_ptr<FbxRoughMetMaterialInfo> Fbx3dsMaxPhysicalMaterialResolver::resolve() const { std::unique_ptr<FbxRoughMetMaterialInfo> Fbx3dsMaxPhysicalMaterialResolver::resolve() const {
const FbxProperty topProp = fbxMaterial->FindProperty("3dsMax"); const FbxProperty topProp = fbxMaterial->FindProperty("3dsMax");
if (topProp.GetPropertyDataType() != FbxCompoundDT) { if (topProp.GetPropertyDataType() != FbxCompoundDT) {
return nullptr; return nullptr;
} }
const FbxProperty props = fbxMaterial->FindProperty("Parameters"); const FbxProperty props = fbxMaterial->FindProperty("Parameters");
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* {
const FbxFileTexture *ptr = nullptr; const FbxFileTexture* ptr = nullptr;
const FbxProperty useProp = props.FindHierarchical((propName + "_map_on").c_str()); const FbxProperty useProp = props.FindHierarchical((propName + "_map_on").c_str());
if (useProp.IsValid() && useProp.Get<bool>()) { if (useProp.IsValid() && useProp.Get<bool>()) {
const FbxProperty texProp = useProp.FindHierarchical((propName + "_map").c_str()); const FbxProperty texProp = useProp.FindHierarchical((propName + "_map").c_str());
if (texProp.IsValid()) { if (texProp.IsValid()) {
ptr = texProp.GetSrcObject<FbxFileTexture>(); ptr = texProp.GetSrcObject<FbxFileTexture>();
if (ptr != nullptr && textureLocations.find(ptr) == textureLocations.end()) { if (ptr != nullptr && textureLocations.find(ptr) == textureLocations.end()) {
ptr = nullptr; ptr = nullptr;
}
}
} else if (verboseOutput && useProp.IsValid()) {
fmt::printf("Note: property '%s' of 3dsMax Physical material '%s' exists, but is flagged as 'off'.\n",
propName, fbxMaterial->GetName());
} }
return ptr; }
}; } else if (verboseOutput && useProp.IsValid()) {
fmt::printf(
int materialMode = getValue(props, "material_mode", 0); "Note: property '%s' of 3dsMax Physical material '%s' exists, but is flagged as 'off'.\n",
fmt::printf("Note: 3dsMax Physical material has material_mode = %d.\n", materialMode); propName,
fbxMaterial->GetName());
// baseWeight && baseColor
FbxDouble baseWeight = getValue(props, "base_weight", 1.0);
const auto *baseWeightMap = getTex("base_weight");
FbxDouble4 baseCol = getValue(props, "base_color", FbxDouble4(0.5, 0.5, 0.5, 1.0));
const auto *baseTex = getTex("base_color");
double emissiveWeight = getValue(props, "emission", 0.0);
const auto *emissiveWeightMap = getTex("emission");
FbxDouble4 emissiveColor = getValue(props, "emit_color", FbxDouble4(1, 1, 1, 1));
const auto *emissiveColorMap = getTex("emit_color");
// TODO: emit_luminance, emit_kelvin?
// roughness & metalness: supported
double roughness = getValue(props, "roughness", 0.0);
const auto *roughnessMap = getTex("roughness");
double metalness = getValue(props, "metalness", 0.0);
const auto *metalnessMap = getTex("metalness");
// TODO: does invertRoughness affect roughness_map too?
bool invertRoughness = getValue(props, "inv_roughness", false);
if (invertRoughness) {
roughness = 1.0f - roughness;
} }
return ptr;
};
// TODO: attempt to bake transparency > 0.0f into the alpha of baseColour? int materialMode = getValue(props, "material_mode", 0);
double transparency = getValue(props, "transparency", 0.0); fmt::printf("Note: 3dsMax Physical material has material_mode = %d.\n", materialMode);
const auto *transparencyMap = getTex("transparency");
// SSS: not supported // baseWeight && baseColor
double scattering = getValue(props, "scattering", 0.0); FbxDouble baseWeight = getValue(props, "base_weight", 1.0);
const auto *scatteringMap = getTex("scattering"); const auto* baseWeightMap = getTex("base_weight");
FbxDouble4 baseCol = getValue(props, "base_color", FbxDouble4(0.5, 0.5, 0.5, 1.0));
const auto* baseTex = getTex("base_color");
// reflectivity: not supported double emissiveWeight = getValue(props, "emission", 0.0);
double reflectivityWeight = getValue(props, "reflectivity", 1.); const auto* emissiveWeightMap = getTex("emission");
const auto *reflectivityWeightMap = getTex("reflectivity"); FbxDouble4 emissiveColor = getValue(props, "emit_color", FbxDouble4(1, 1, 1, 1));
FbxDouble4 reflectivityColor = getValue(props, "refl_color", FbxDouble4(1, 1, 1, 1)); const auto* emissiveColorMap = getTex("emit_color");
const auto *reflectivityColorMap = getTex("refl_color"); // TODO: emit_luminance, emit_kelvin?
// coatings: not supported // roughness & metalness: supported
double coating = getValue(props, "coating", 0.0); double roughness = getValue(props, "roughness", 0.0);
const auto* roughnessMap = getTex("roughness");
double metalness = getValue(props, "metalness", 0.0);
const auto* metalnessMap = getTex("metalness");
// diffuse roughness: not supported // TODO: does invertRoughness affect roughness_map too?
double diffuseRoughness = getValue(props, "diff_roughness", 0.); bool invertRoughness = getValue(props, "inv_roughness", false);
if (invertRoughness) {
roughness = 1.0f - roughness;
}
// explicit brdf curve control: not supported // TODO: attempt to bake transparency > 0.0f into the alpha of baseColour?
bool isBrdfMode = getValue(props, "brdf_mode", false); double transparency = getValue(props, "transparency", 0.0);
const auto* transparencyMap = getTex("transparency");
// anisotrophy: not supported // SSS: not supported
double anisotropy = getValue(props, "anisotropy", 1.0); double scattering = getValue(props, "scattering", 0.0);
const auto* scatteringMap = getTex("scattering");
// TODO: how the heck do we combine these to generate a normal map? // reflectivity: not supported
const auto *bumpMap = getTex("bump"); double reflectivityWeight = getValue(props, "reflectivity", 1.);
const auto *displacementMap = getTex("displacement"); const auto* reflectivityWeightMap = getTex("reflectivity");
FbxDouble4 reflectivityColor = getValue(props, "refl_color", FbxDouble4(1, 1, 1, 1));
const auto* reflectivityColorMap = getTex("refl_color");
std::unique_ptr<FbxRoughMetMaterialInfo> res( // coatings: not supported
new FbxRoughMetMaterialInfo( double coating = getValue(props, "coating", 0.0);
fbxMaterial->GetName(),
FbxRoughMetMaterialInfo::FBX_SHADER_METROUGH,
baseCol,
metalness,
roughness
)
);
res->texBaseColor = baseTex;
res->baseWeight = baseWeight;
res->texBaseWeight = baseWeightMap;
res->texMetallic = metalnessMap; // diffuse roughness: not supported
res->texRoughness = roughnessMap; double diffuseRoughness = getValue(props, "diff_roughness", 0.);
res->texNormal = bumpMap; // TODO LOL NO NONO // explicit brdf curve control: not supported
bool isBrdfMode = getValue(props, "brdf_mode", false);
res->emissive = emissiveColor; // anisotrophy: not supported
res->emissiveIntensity = emissiveWeight; double anisotropy = getValue(props, "anisotropy", 1.0);
res->texEmissive = emissiveColorMap;
res->texEmissiveWeight = emissiveWeightMap;
return res; // TODO: how the heck do we combine these to generate a normal map?
const auto* bumpMap = getTex("bump");
const auto* displacementMap = getTex("displacement");
std::unique_ptr<FbxRoughMetMaterialInfo> res(new FbxRoughMetMaterialInfo(
fbxMaterial->GetName(),
FbxRoughMetMaterialInfo::FBX_SHADER_METROUGH,
baseCol,
metalness,
roughness));
res->texBaseColor = baseTex;
res->baseWeight = baseWeight;
res->texBaseWeight = baseWeightMap;
res->texMetallic = metalnessMap;
res->texRoughness = roughnessMap;
res->texNormal = bumpMap; // TODO LOL NO NONO
res->emissive = emissiveColor;
res->emissiveIntensity = emissiveWeight;
res->texEmissive = emissiveColorMap;
res->texEmissiveWeight = emissiveWeightMap;
return res;
} }

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

@ -11,68 +11,70 @@
#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();
return; if (materialMappingMode != FbxGeometryElement::eByPolygon &&
} materialMappingMode != FbxGeometryElement::eAllSame) {
return;
}
const FbxGeometryElement::EReferenceMode materialReferenceMode = pMesh->GetElementMaterial()->GetReferenceMode(); const FbxGeometryElement::EReferenceMode materialReferenceMode =
if (materialReferenceMode != FbxGeometryElement::eIndexToDirect) { pMesh->GetElementMaterial()->GetReferenceMode();
return; if (materialReferenceMode != FbxGeometryElement::eIndexToDirect) {
} return;
}
mappingMode = materialMappingMode; mappingMode = materialMappingMode;
mesh = pMesh; mesh = pMesh;
indices = &pMesh->GetElementMaterial()->GetIndexArray(); indices = &pMesh->GetElementMaterial()->GetIndexArray();
for (int ii = 0; ii < indices->GetCount(); ii++) { for (int ii = 0; ii < indices->GetCount(); ii++) {
int materialNum = indices->GetAt(ii); int materialNum = indices->GetAt(ii);
if (materialNum < 0) { if (materialNum < 0) {
continue; continue;
}
if (materialNum >= summaries.size()) {
summaries.resize(materialNum + 1);
}
auto summary = summaries[materialNum];
if (summary == nullptr) {
summary = summaries[materialNum] = GetMaterialInfo(
mesh->GetNode()->GetSrcObject<FbxSurfaceMaterial>(materialNum),
textureLocations);
}
} }
if (materialNum >= summaries.size()) {
summaries.resize(materialNum + 1);
}
auto summary = summaries[materialNum];
if (summary == nullptr) {
summary = summaries[materialNum] = GetMaterialInfo(
mesh->GetNode()->GetSrcObject<FbxSurfaceMaterial>(materialNum), 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 =
if (materialNum < 0) { indices->GetAt((mappingMode == FbxGeometryElement::eByPolygon) ? polygonIndex : 0);
return nullptr; if (materialNum < 0) {
} return nullptr;
return summaries.at((unsigned long) materialNum);
} }
return nullptr; return summaries.at((unsigned long)materialNum);
}
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) {
res = Fbx3dsMaxPhysicalMaterialResolver(material, textureLocations).resolve();
if (res == nullptr) { if (res == nullptr) {
res = Fbx3dsMaxPhysicalMaterialResolver(material, textureLocations).resolve(); res = FbxTraditionalMaterialResolver(material, textureLocations).resolve();
if (res == nullptr) {
res = FbxTraditionalMaterialResolver(material, textureLocations).resolve();
}
} }
return res; }
return res;
} }

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

@ -15,46 +15,43 @@
#include "FBX2glTF.h" #include "FBX2glTF.h"
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), textureLocations(textureLocations) {}
: fbxMaterial(fbxMaterial) virtual std::unique_ptr<T> resolve() const = 0;
, textureLocations(textureLocations)
{}
virtual std::unique_ptr<T> resolve() const = 0;
protected: protected:
const FbxSurfaceMaterial *fbxMaterial; const FbxSurfaceMaterial* fbxMaterial;
const std::map<const FbxTexture *, FbxString> textureLocations; const std::map<const FbxTexture*, FbxString> textureLocations;
}; };
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;
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;
std::vector<std::shared_ptr<FbxMaterialInfo>> summaries {}; std::vector<std::shared_ptr<FbxMaterialInfo>> summaries{};
const FbxMesh *mesh; const FbxMesh* mesh;
const FbxLayerElementArrayTemplate<int> *indices; const FbxLayerElementArrayTemplate<int>* indices;
}; };

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

@ -14,68 +14,64 @@
#include "FbxMaterials.hpp" #include "FbxMaterials.hpp"
struct FbxRoughMetMaterialInfo : FbxMaterialInfo { struct FbxRoughMetMaterialInfo : FbxMaterialInfo {
static constexpr const char *FBX_SHADER_METROUGH = "MetallicRoughness"; static constexpr const char* FBX_SHADER_METROUGH = "MetallicRoughness";
static std::unique_ptr<FbxRoughMetMaterialInfo> From( static std::unique_ptr<FbxRoughMetMaterialInfo> From(
FbxSurfaceMaterial *fbxMaterial, FbxSurfaceMaterial* fbxMaterial,
const std::map<const FbxTexture *, FbxString> &textureLocations); const std::map<const FbxTexture*, FbxString>& textureLocations);
FbxRoughMetMaterialInfo( FbxRoughMetMaterialInfo(
const FbxString &name, const FbxString& name,
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;
const FbxDouble roughness; const FbxDouble roughness;
FbxDouble baseWeight = 1; FbxDouble baseWeight = 1;
FbxVector4 emissive = FbxVector4(0, 0, 0, 1); FbxVector4 emissive = FbxVector4(0, 0, 0, 1);
FbxDouble emissiveIntensity = 1; FbxDouble emissiveIntensity = 1;
const FbxFileTexture *texNormal = nullptr; const FbxFileTexture* texNormal = nullptr;
const FbxFileTexture *texBaseColor = nullptr; const FbxFileTexture* texBaseColor = nullptr;
const FbxFileTexture *texBaseWeight = nullptr; const FbxFileTexture* texBaseWeight = nullptr;
const FbxFileTexture *texMetallic = nullptr; const FbxFileTexture* texMetallic = nullptr;
const FbxFileTexture *texRoughness = nullptr; const FbxFileTexture* texRoughness = nullptr;
const FbxFileTexture *texEmissive = nullptr; const FbxFileTexture* texEmissive = nullptr;
const FbxFileTexture *texEmissiveWeight = nullptr; const FbxFileTexture* texEmissiveWeight = nullptr;
const FbxFileTexture *texAmbientOcclusion = nullptr; const FbxFileTexture* texAmbientOcclusion = nullptr;
}; };
class FbxStingrayPBSMaterialResolver : FbxMaterialResolver<FbxRoughMetMaterialInfo> { class FbxStingrayPBSMaterialResolver : FbxMaterialResolver<FbxRoughMetMaterialInfo> {
public: 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;
}; };
class Fbx3dsMaxPhysicalMaterialResolver : FbxMaterialResolver<FbxRoughMetMaterialInfo> { class Fbx3dsMaxPhysicalMaterialResolver : FbxMaterialResolver<FbxRoughMetMaterialInfo> {
public: 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;
private: private:
template<typename T> template <typename T>
T getValue(const FbxProperty &props, std::string propName, const T& default) const { T getValue(const FbxProperty& props, std::string propName, const T& default) const {
const FbxProperty prop = props.FindHierarchical(propName.c_str()); const FbxProperty prop = props.FindHierarchical(propName.c_str());
return prop.IsValid() ? prop.Get<T>() : default; return prop.IsValid() ? prop.Get<T>() : default;
} }
}; };

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

@ -10,62 +10,63 @@
#include "RoughnessMetallicMaterials.hpp" #include "RoughnessMetallicMaterials.hpp"
std::unique_ptr<FbxRoughMetMaterialInfo> FbxStingrayPBSMaterialResolver::resolve() const { std::unique_ptr<FbxRoughMetMaterialInfo> FbxStingrayPBSMaterialResolver::resolve() const {
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) {
const FbxFileTexture *ptr = nullptr; const FbxFileTexture* ptr = nullptr;
const FbxProperty useProp = mayaProp.FindHierarchical(("use_" + propName + "_map").c_str()); const FbxProperty useProp = mayaProp.FindHierarchical(("use_" + propName + "_map").c_str());
if (useProp.IsValid() && useProp.Get<bool>()) { if (useProp.IsValid() && useProp.Get<bool>()) {
const FbxProperty texProp = mayaProp.FindHierarchical(("TEX_" + propName + "_map").c_str()); const FbxProperty texProp = mayaProp.FindHierarchical(("TEX_" + propName + "_map").c_str());
if (texProp.IsValid()) { if (texProp.IsValid()) {
ptr = texProp.GetSrcObject<FbxFileTexture>(); ptr = texProp.GetSrcObject<FbxFileTexture>();
if (ptr != nullptr && textureLocations.find(ptr) == textureLocations.end()) { if (ptr != nullptr && textureLocations.find(ptr) == textureLocations.end()) {
ptr = nullptr; ptr = nullptr;
}
}
} else if (verboseOutput && useProp.IsValid()) {
fmt::printf("Note: Property '%s' of Stingray PBS material '%s' exists, but is flagged as 'do not use'.\n",
propName, fbxMaterial->GetName());
} }
return ptr; }
}; } else if (verboseOutput && useProp.IsValid()) {
fmt::printf(
"Note: Property '%s' of Stingray PBS material '%s' exists, but is flagged as 'do not use'.\n",
propName,
fbxMaterial->GetName());
}
return ptr;
};
auto getVec = [&](std::string propName) -> FbxDouble3 { auto getVec = [&](std::string propName) -> FbxDouble3 {
const FbxProperty vecProp = mayaProp.FindHierarchical(propName.c_str()); const FbxProperty vecProp = mayaProp.FindHierarchical(propName.c_str());
return vecProp.IsValid() ? vecProp.Get<FbxDouble3>() : FbxDouble3(1, 1, 1); return vecProp.IsValid() ? vecProp.Get<FbxDouble3>() : FbxDouble3(1, 1, 1);
}; };
auto getVal = [&](std::string propName) -> FbxDouble { auto getVal = [&](std::string propName) -> FbxDouble {
const FbxProperty vecProp = mayaProp.FindHierarchical(propName .c_str()); const FbxProperty vecProp = mayaProp.FindHierarchical(propName.c_str());
return vecProp.IsValid() ? vecProp.Get<FbxDouble>() : 0; return vecProp.IsValid() ? vecProp.Get<FbxDouble>() : 0;
}; };
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->texBaseColor = getTex("color");
); res->texAmbientOcclusion = getTex("ao");
res->texNormal = getTex("normal"); res->texEmissive = getTex("emissive");
res->texBaseColor = getTex("color"); res->emissive = getVec("emissive");
res->texAmbientOcclusion = getTex("ao"); res->emissiveIntensity = getVal("emissive_intensity");
res->texEmissive = getTex("emissive"); res->texMetallic = getTex("metallic");
res->emissive = getVec("emissive"); res->texRoughness = getTex("roughness");
res->emissiveIntensity = getVal("emissive_intensity");
res->texMetallic = getTex("metallic");
res->texRoughness = getTex("roughness");
return res; return res;
}; };

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

@ -9,115 +9,127 @@
#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);
FbxDouble val(0); FbxDouble val(0);
FbxFileTexture *tex = prop.GetSrcObject<FbxFileTexture>(); FbxFileTexture* tex = prop.GetSrcObject<FbxFileTexture>();
if (tex != nullptr && textureLocations.find(tex) == textureLocations.end()) { if (tex != nullptr && textureLocations.find(tex) == textureLocations.end()) {
tex = nullptr; tex = nullptr;
} }
if (tex == nullptr && prop.IsValid()) { if (tex == nullptr && prop.IsValid()) {
val = prop.Get<FbxDouble>(); val = prop.Get<FbxDouble>();
} }
return std::make_tuple(val, tex); return std::make_tuple(val, tex);
}; };
auto getSurfaceVector = [&](const char *propName) -> std::tuple<FbxDouble3, FbxFileTexture *> { auto getSurfaceVector = [&](const char* propName) -> std::tuple<FbxDouble3, FbxFileTexture*> {
const FbxProperty prop = fbxMaterial->FindProperty(propName); const FbxProperty prop = fbxMaterial->FindProperty(propName);
FbxDouble3 val(1, 1, 1); FbxDouble3 val(1, 1, 1);
FbxFileTexture *tex = prop.GetSrcObject<FbxFileTexture>(); FbxFileTexture* tex = prop.GetSrcObject<FbxFileTexture>();
if (tex != nullptr && textureLocations.find(tex) == textureLocations.end()) { if (tex != nullptr && textureLocations.find(tex) == textureLocations.end()) {
tex = nullptr; tex = nullptr;
} }
if (tex == nullptr && prop.IsValid()) { if (tex == nullptr && prop.IsValid()) {
val = prop.Get<FbxDouble3>(); val = prop.Get<FbxDouble3>();
} }
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 FbxProperty colProp = fbxMaterial->FindProperty(colName); [&](const char* colName,
const FbxProperty facProp = fbxMaterial->FindProperty(facName); const char* facName) -> std::tuple<FbxVector4, FbxFileTexture*, FbxFileTexture*> {
const FbxProperty colProp = fbxMaterial->FindProperty(colName);
const FbxProperty facProp = fbxMaterial->FindProperty(facName);
FbxDouble3 colorVal(1, 1, 1); FbxDouble3 colorVal(1, 1, 1);
FbxDouble factorVal(1); FbxDouble factorVal(1);
FbxFileTexture *colTex = colProp.GetSrcObject<FbxFileTexture>(); FbxFileTexture* colTex = colProp.GetSrcObject<FbxFileTexture>();
if (colTex != nullptr && textureLocations.find(colTex) == textureLocations.end()) { if (colTex != nullptr && textureLocations.find(colTex) == textureLocations.end()) {
colTex = nullptr; colTex = nullptr;
} }
if (colTex == nullptr && colProp.IsValid()) { if (colTex == nullptr && colProp.IsValid()) {
colorVal = colProp.Get<FbxDouble3>(); colorVal = colProp.Get<FbxDouble3>();
} }
FbxFileTexture *facTex = facProp.GetSrcObject<FbxFileTexture>(); FbxFileTexture* facTex = facProp.GetSrcObject<FbxFileTexture>();
if (facTex != nullptr && textureLocations.find(facTex) == textureLocations.end()) { if (facTex != nullptr && textureLocations.find(facTex) == textureLocations.end()) {
facTex = nullptr; facTex = nullptr;
} }
if (facTex == nullptr && facProp.IsValid()) { if (facTex == nullptr && facProp.IsValid()) {
factorVal = facProp.Get<FbxDouble>(); factorVal = facProp.Get<FbxDouble>();
} }
auto val = FbxVector4( auto val = FbxVector4(
colorVal[0] * factorVal, colorVal[0] * factorVal, colorVal[1] * factorVal, colorVal[2] * factorVal, factorVal);
colorVal[1] * factorVal, return std::make_tuple(val, colTex, facTex);
colorVal[2] * factorVal, };
factorVal);
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,
FbxFileTexture *colTex, *facTex; const char* facName) -> std::tuple<FbxVector4, FbxFileTexture*> {
FbxVector4 vec;
std::tie(vec, colTex, facTex) = getSurfaceValues(colName, facName);
if (colTex) {
if (facTex) {
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, facTex);
};
std::tie(res->colAmbient, res->texAmbient) =
handleBasicProperty(FbxSurfaceMaterial::sAmbient, FbxSurfaceMaterial::sAmbientFactor);
std::tie(res->colSpecular, res->texSpecular) =
handleBasicProperty(FbxSurfaceMaterial::sSpecular, FbxSurfaceMaterial::sSpecularFactor);
std::tie(res->colDiffuse, res->texDiffuse) =
handleBasicProperty(FbxSurfaceMaterial::sDiffuse, FbxSurfaceMaterial::sDiffuseFactor);
std::tie(res->colEmissive, res->texEmissive) =
handleBasicProperty(FbxSurfaceMaterial::sEmissive, FbxSurfaceMaterial::sEmissiveFactor);
// the normal map can only ever be a map, ignore everything else
tie(std::ignore, res->texNormal) = getSurfaceVector(FbxSurfaceMaterial::sNormalMap);
// shininess can be a map or a factor; afaict the map is always 'ShininessExponent' and the
// value is always found in 'Shininess' but only sometimes in 'ShininessExponent'.
tie(std::ignore, res->texShininess) = getSurfaceScalar("ShininessExponent");
tie(res->shininess, std::ignore) = getSurfaceScalar("Shininess");
// for transparency we just want a constant vector value;
FbxVector4 transparency;
// 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) = FbxVector4 vec;
getSurfaceValues(FbxSurfaceMaterial::sTransparentColor, FbxSurfaceMaterial::sTransparencyFactor);
if (colTex) {
fmt::printf("Warning: Mat [%s]: Can't handle texture for %s; discarding.\n", name, FbxSurfaceMaterial::sTransparentColor);
}
if (facTex) {
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
res->colDiffuse[3] = 1.0 - (transparency[0] + transparency[1] + transparency[2])/3.0;
return res; std::tie(vec, colTex, facTex) = getSurfaceValues(colName, facName);
if (colTex) {
if (facTex) {
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, facTex);
};
std::tie(res->colAmbient, res->texAmbient) =
handleBasicProperty(FbxSurfaceMaterial::sAmbient, FbxSurfaceMaterial::sAmbientFactor);
std::tie(res->colSpecular, res->texSpecular) =
handleBasicProperty(FbxSurfaceMaterial::sSpecular, FbxSurfaceMaterial::sSpecularFactor);
std::tie(res->colDiffuse, res->texDiffuse) =
handleBasicProperty(FbxSurfaceMaterial::sDiffuse, FbxSurfaceMaterial::sDiffuseFactor);
std::tie(res->colEmissive, res->texEmissive) =
handleBasicProperty(FbxSurfaceMaterial::sEmissive, FbxSurfaceMaterial::sEmissiveFactor);
// the normal map can only ever be a map, ignore everything else
tie(std::ignore, res->texNormal) = getSurfaceVector(FbxSurfaceMaterial::sNormalMap);
// shininess can be a map or a factor; afaict the map is always 'ShininessExponent' and the
// value is always found in 'Shininess' but only sometimes in 'ShininessExponent'.
tie(std::ignore, res->texShininess) = getSurfaceScalar("ShininessExponent");
tie(res->shininess, std::ignore) = getSurfaceScalar("Shininess");
// for transparency we just want a constant vector value;
FbxVector4 transparency;
// extract any existing textures only so we can warn that we're throwing them away
FbxFileTexture *colTex, *facTex;
std::tie(transparency, colTex, facTex) = getSurfaceValues(
FbxSurfaceMaterial::sTransparentColor, FbxSurfaceMaterial::sTransparencyFactor);
if (colTex) {
fmt::printf(
"Warning: Mat [%s]: Can't handle texture for %s; discarding.\n",
name,
FbxSurfaceMaterial::sTransparentColor);
}
if (facTex) {
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
res->colDiffuse[3] = 1.0 - (transparency[0] + transparency[1] + transparency[2]) / 3.0;
return res;
} }

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

@ -10,34 +10,32 @@
#include "FbxMaterials.hpp" #include "FbxMaterials.hpp"
struct FbxTraditionalMaterialInfo : FbxMaterialInfo { struct FbxTraditionalMaterialInfo : FbxMaterialInfo {
static constexpr const char *FBX_SHADER_LAMBERT = "Lambert"; static constexpr const char* FBX_SHADER_LAMBERT = "Lambert";
static constexpr const char *FBX_SHADER_BLINN = "Blinn"; static constexpr const char* FBX_SHADER_BLINN = "Blinn";
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{};
FbxFileTexture *texSpecular {}; FbxFileTexture* texSpecular{};
FbxVector4 colSpecular {}; FbxVector4 colSpecular{};
FbxFileTexture *texDiffuse {}; FbxFileTexture* texDiffuse{};
FbxVector4 colDiffuse {}; FbxVector4 colDiffuse{};
FbxFileTexture *texEmissive {}; FbxFileTexture* texEmissive{};
FbxVector4 colEmissive {}; FbxVector4 colEmissive{};
FbxFileTexture *texNormal {}; FbxFileTexture* texNormal{};
FbxFileTexture *texShininess {}; FbxFileTexture* texShininess{};
FbxDouble shininess {}; FbxDouble shininess{};
}; };
class FbxTraditionalMaterialResolver : FbxMaterialResolver<FbxTraditionalMaterialInfo> { class FbxTraditionalMaterialResolver : FbxMaterialResolver<FbxTraditionalMaterialInfo> {
public: 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;
}; };

135
src/gltf/GltfModel.cpp
View File

@ -1,85 +1,86 @@
/** /**
* Copyright (c) 2014-present, Facebook, Inc. * Copyright (c) 2014-present, Facebook, Inc.
* All rights reserved. * All rights reserved.
* *
* This source code is licensed under the BSD-style license found in the * This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant * LICENSE file in the root directory of this source tree. An additional grant
* 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 "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,
unsigned long bufferSize = this->binary->size(); const BufferViewData::GL_ArrayType target) {
if ((bufferSize % 4) > 0) { unsigned long bufferSize = this->binary->size();
bufferSize += (4 - (bufferSize % 4)); if ((bufferSize % 4) > 0) {
this->binary->resize(bufferSize); bufferSize += (4 - (bufferSize % 4));
} this->binary->resize(bufferSize);
return this->bufferViews.hold(new BufferViewData(buffer, bufferSize, target)); }
return this->bufferViews.hold(new BufferViewData(buffer, bufferSize, target));
} }
// 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;
// make space for the new bytes (possibly moving the underlying data) // make space for the new bytes (possibly moving the underlying data)
unsigned long bufferSize = this->binary->size(); unsigned long bufferSize = this->binary->size();
this->binary->resize(bufferSize + bytes); this->binary->resize(bufferSize + bytes);
// and copy them into place // and copy them into place
memcpy(&(*this->binary)[bufferSize], source, bytes); memcpy(&(*this->binary)[bufferSize], source, bytes);
return bufferView; return bufferView;
} }
std::shared_ptr<BufferViewData> GltfModel::AddBufferViewForFile(BufferData &buffer, const std::string &filename) std::shared_ptr<BufferViewData> GltfModel::AddBufferViewForFile(
{ BufferData& buffer,
// see if we've already created a BufferViewData for this precise file const std::string& filename) {
auto iter = filenameToBufferView.find(filename); // see if we've already created a BufferViewData for this precise file
if (iter != filenameToBufferView.end()) { auto iter = filenameToBufferView.find(filename);
return iter->second; if (iter != filenameToBufferView.end()) {
} return iter->second;
}
std::shared_ptr<BufferViewData> result; std::shared_ptr<BufferViewData> result;
std::ifstream file(filename, std::ios::binary | std::ios::ate); std::ifstream file(filename, std::ios::binary | std::ios::ate);
if (file) { if (file) {
std::streamsize size = file.tellg(); std::streamsize size = file.tellg();
file.seekg(0, std::ios::beg); file.seekg(0, std::ios::beg);
std::vector<char> fileBuffer(size); std::vector<char> fileBuffer(size);
if (file.read(fileBuffer.data(), size)) { if (file.read(fileBuffer.data(), size)) {
result = AddRawBufferView(buffer, fileBuffer.data(), size); result = AddRawBufferView(buffer, fileBuffer.data(), size);
} else {
fmt::printf("Warning: Couldn't read %lu bytes from %s, skipping file.\n", size, filename);
}
} else { } else {
fmt::printf("Warning: Couldn't open file %s, skipping file.\n", filename); fmt::printf("Warning: Couldn't read %lu bytes from %s, skipping file.\n", size, filename);
} }
// note that we persist here not only success, but also failure, as nullptr } else {
filenameToBufferView[filename] = result; fmt::printf("Warning: Couldn't open file %s, skipping file.\n", filename);
return result; }
// note that we persist here not only success, but also failure, as nullptr
filenameToBufferView[filename] = 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); serializeHolder(glTFJson, "accessors", accessors);
serializeHolder(glTFJson, "accessors", accessors); serializeHolder(glTFJson, "images", images);
serializeHolder(glTFJson, "images", images); serializeHolder(glTFJson, "samplers", samplers);
serializeHolder(glTFJson, "samplers", samplers); serializeHolder(glTFJson, "textures", textures);
serializeHolder(glTFJson, "textures", textures); serializeHolder(glTFJson, "materials", materials);
serializeHolder(glTFJson, "materials", materials); serializeHolder(glTFJson, "meshes", meshes);
serializeHolder(glTFJson, "meshes", meshes); serializeHolder(glTFJson, "skins", skins);
serializeHolder(glTFJson, "skins", skins); serializeHolder(glTFJson, "animations", animations);
serializeHolder(glTFJson, "animations", animations); serializeHolder(glTFJson, "cameras", cameras);
serializeHolder(glTFJson, "cameras", cameras); serializeHolder(glTFJson, "nodes", nodes);
serializeHolder(glTFJson, "nodes", nodes); if (!lights.ptrs.empty()) {
if (!lights.ptrs.empty()) { json lightsJson = json::object();
json lightsJson = json::object(); serializeHolder(lightsJson, "lights", lights);
serializeHolder(lightsJson, "lights", lights); glTFJson["extensions"][KHR_LIGHTS_PUNCTUAL] = lightsJson;
glTFJson["extensions"][KHR_LIGHTS_PUNCTUAL] = lightsJson; }
}
} }

264
src/gltf/GltfModel.hpp
View File

@ -1,11 +1,11 @@
/** /**
* Copyright (c) 2014-present, Facebook, Inc. * Copyright (c) 2014-present, Facebook, Inc.
* All rights reserved. * All rights reserved.
* *
* This source code is licensed under the BSD-style license found in the * This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant * LICENSE file in the root directory of this source tree. An additional grant
* 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.
*/ */
#pragma once #pragma once
@ -30,139 +30,143 @@
#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> */
class Holder template <typename T>
{ 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(); }
} 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>
AddRawBufferView(BufferData& buffer, const char* source, uint32_t bytes);
std::shared_ptr<BufferViewData> AddBufferViewForFile(
BufferData& buffer,
const std::string& filename);
template <class T>
std::shared_ptr<AccessorData> AddAccessorWithView(
BufferViewData& bufferView,
const GLType& type,
const std::vector<T>& source,
std::string name) {
auto accessor = accessors.hold(new AccessorData(bufferView, type, name));
accessor->appendAsBinaryArray(source, *binary);
bufferView.byteLength = accessor->byteLength();
return accessor;
}
template <class T>
std::shared_ptr<AccessorData>
AddAccessorAndView(BufferData& buffer, const GLType& type, const std::vector<T>& source) {
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
return AddAccessorWithView(*bufferView, type, source, std::string(""));
}
template <class T>
std::shared_ptr<AccessorData> AddAccessorAndView(
BufferData& buffer,
const GLType& type,
const std::vector<T>& source,
std::string name) {
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
return AddAccessorWithView(*bufferView, type, source, name);
}
template <class T>
std::shared_ptr<AccessorData> AddAttributeToPrimitive(
BufferData& buffer,
const RawModel& surfaceModel,
PrimitiveData& primitive,
const AttributeDefinition<T>& attrDef) {
// copy attribute data into vector
std::vector<T> attribArr;
surfaceModel.GetAttributeArray<T>(attribArr, attrDef.rawAttributeIx);
std::shared_ptr<AccessorData> accessor;
if (attrDef.dracoComponentType != draco::DT_INVALID && primitive.dracoMesh != nullptr) {
primitive.AddDracoAttrib(attrDef, attribArr);
accessor = accessors.hold(new AccessorData(attrDef.glType));
accessor->count = attribArr.size();
} else {
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER);
accessor = AddAccessorWithView(*bufferView, attrDef.glType, attribArr, std::string(""));
} }
primitive.AddAttrib(attrDef.gltfName, *accessor);
return accessor;
};
std::shared_ptr<BufferViewData> GetAlignedBufferView(BufferData &buffer, const BufferViewData::GL_ArrayType target); template <class T>
std::shared_ptr<BufferViewData> AddRawBufferView(BufferData &buffer, const char *source, uint32_t bytes); void serializeHolder(json& glTFJson, std::string key, const Holder<T> holder) {
std::shared_ptr<BufferViewData> AddBufferViewForFile(BufferData &buffer, const std::string &filename); if (!holder.ptrs.empty()) {
std::vector<json> bits;
template<class T> for (const auto& ptr : holder.ptrs) {
std::shared_ptr<AccessorData> AddAccessorWithView( bits.push_back(ptr->serialize());
BufferViewData &bufferView, const GLType &type, const std::vector<T> &source, std::string name) }
{ glTFJson[key] = bits;
auto accessor = accessors.hold(new AccessorData(bufferView, type, name));
accessor->appendAsBinaryArray(source, *binary);
bufferView.byteLength = accessor->byteLength();
return accessor;
} }
}
template<class T> void serializeHolders(json& glTFJson);
std::shared_ptr<AccessorData> AddAccessorAndView(
BufferData &buffer, const GLType &type, const std::vector<T> &source)
{
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
return AddAccessorWithView(*bufferView, type, source, std::string(""));
}
template<class T> const bool isGlb;
std::shared_ptr<AccessorData> AddAccessorAndView(
BufferData &buffer, const GLType &type, const std::vector<T> &source, std::string name)
{
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_NONE);
return AddAccessorWithView(*bufferView, type, source, name);
}
template<class T> // cache BufferViewData instances that've already been created from a given filename
std::shared_ptr<AccessorData> AddAttributeToPrimitive( std::map<std::string, std::shared_ptr<BufferViewData>> filenameToBufferView;
BufferData &buffer, const RawModel &surfaceModel, PrimitiveData &primitive,
const AttributeDefinition<T> &attrDef)
{
// copy attribute data into vector
std::vector<T> attribArr;
surfaceModel.GetAttributeArray<T>(attribArr, attrDef.rawAttributeIx);
std::shared_ptr<AccessorData> accessor; std::shared_ptr<std::vector<uint8_t>> binary;
if (attrDef.dracoComponentType != draco::DT_INVALID && primitive.dracoMesh != nullptr) {
primitive.AddDracoAttrib(attrDef, attribArr);
accessor = accessors.hold(new AccessorData(attrDef.glType)); Holder<BufferData> buffers;
accessor->count = attribArr.size(); Holder<BufferViewData> bufferViews;
} else { Holder<AccessorData> accessors;
auto bufferView = GetAlignedBufferView(buffer, BufferViewData::GL_ARRAY_BUFFER); Holder<ImageData> images;
accessor = AddAccessorWithView(*bufferView, attrDef.glType, attribArr, std::string("")); Holder<SamplerData> samplers;
} Holder<TextureData> textures;
primitive.AddAttrib(attrDef.gltfName, *accessor); Holder<MaterialData> materials;
return accessor; Holder<MeshData> meshes;
}; Holder<SkinData> skins;
Holder<AnimationData> animations;
Holder<CameraData> cameras;
Holder<NodeData> nodes;
Holder<SceneData> scenes;
Holder<LightData> lights;
template<class T> std::shared_ptr<SamplerData> defaultSampler;
void serializeHolder(json &glTFJson, std::string key, const Holder<T> holder) std::shared_ptr<BufferData> defaultBuffer;
{
if (!holder.ptrs.empty()) {
std::vector<json> bits;
for (const auto &ptr : holder.ptrs) {
bits.push_back(ptr->serialize());
}
glTFJson[key] = bits;
}
}
void serializeHolders(json &glTFJson); private:
SamplerData* buildDefaultSampler() {
const bool isGlb; return new SamplerData();
}
// cache BufferViewData instances that've already been created from a given filename BufferData* buildDefaultBuffer(const GltfOptions& options) {
std::map<std::string, std::shared_ptr<BufferViewData>> filenameToBufferView; return options.outputBinary ? new BufferData(binary)
: new BufferData(extBufferFilename, binary, options.embedResources);
std::shared_ptr<std::vector<uint8_t>> binary; }
Holder<BufferData> buffers;
Holder<BufferViewData> bufferViews;
Holder<AccessorData> accessors;
Holder<ImageData> images;
Holder<SamplerData> samplers;
Holder<TextureData> textures;
Holder<MaterialData> materials;
Holder<MeshData> meshes;
Holder<SkinData> skins;
Holder<AnimationData> animations;
Holder<CameraData> cameras;
Holder<NodeData> nodes;
Holder<SceneData> scenes;
Holder<LightData> lights;
std::shared_ptr<SamplerData> defaultSampler;
std::shared_ptr<BufferData> defaultBuffer;
private:
SamplerData *buildDefaultSampler() {
return new SamplerData();
}
BufferData *buildDefaultBuffer(const GltfOptions &options) {
return options.outputBinary ?
new BufferData(binary) :
new BufferData(extBufferFilename, binary, options.embedResources);
}
}; };

1435
src/gltf/Raw2Gltf.cpp
View File

File diff suppressed because it is too large Load Diff

227
src/gltf/Raw2Gltf.hpp
View File

@ -19,138 +19,141 @@
#include "FBX2glTF.h" #include "FBX2glTF.h"
#include "raw/RawModel.hpp" #include "raw/RawModel.hpp"
const std::string KHR_DRACO_MESH_COMPRESSION = "KHR_draco_mesh_compression"; const std::string KHR_DRACO_MESH_COMPRESSION = "KHR_draco_mesh_compression";
const std::string KHR_MATERIALS_CMN_UNLIT = "KHR_materials_unlit"; const std::string KHR_MATERIALS_CMN_UNLIT = "KHR_materials_unlit";
const std::string KHR_LIGHTS_PUNCTUAL = "KHR_lights_punctual"; const std::string KHR_LIGHTS_PUNCTUAL = "KHR_lights_punctual";
const std::string extBufferFilename = "buffer.bin"; 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, GL_UNSIGNED_SHORT,
GL_UNSIGNED_SHORT, GL_INT,
GL_INT, GL_UNSIGNED_INT,
GL_UNSIGNED_INT, GL_FLOAT
GL_FLOAT };
};
const GL_DataType glType; const GL_DataType glType;
const unsigned int size; const unsigned int size;
}; };
const ComponentType CT_USHORT = {ComponentType::GL_UNSIGNED_SHORT, 2}; const ComponentType CT_USHORT = {ComponentType::GL_UNSIGNED_SHORT, 2};
const ComponentType CT_UINT = {ComponentType::GL_UNSIGNED_INT, 4}; const ComponentType CT_UINT = {ComponentType::GL_UNSIGNED_INT, 4};
const ComponentType CT_FLOAT = {ComponentType::GL_FLOAT, 4}; 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 {
void write(uint8_t *buf, const uint32_t scalar) const { *((float*)buf) = scalar;
switch(componentType.size) { }
case 1: void write(uint8_t* buf, const uint32_t scalar) const {
*buf = (uint8_t)scalar; switch (componentType.size) {
break; case 1:
case 2: *buf = (uint8_t)scalar;
*((uint16_t *) buf) = (uint16_t)scalar; break;
break; case 2:
case 4: *((uint16_t*)buf) = (uint16_t)scalar;
*((uint32_t *) buf) = scalar; break;
break; case 4:
} *((uint32_t*)buf) = scalar;
break;
} }
}
template<class T, int d> template <class T, int d>
void write(uint8_t *buf, const mathfu::Vector<T, d> &vector) const { void write(uint8_t* buf, const mathfu::Vector<T, d>& vector) const {
for (int ii = 0; ii < d; ii ++) { for (int ii = 0; ii < d; ii++) {
((T *)buf)[ii] = vector(ii); ((T*)buf)[ii] = vector(ii);
}
} }
template<class T, int d> }
void write(uint8_t *buf, const mathfu::Matrix<T, d> &matrix) const { template <class T, int d>
// three matrix types require special alignment considerations that we don't handle void write(uint8_t* buf, const mathfu::Matrix<T, d>& matrix) const {
// https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#data-alignment // three matrix types require special alignment considerations that we don't handle
assert(!(sizeof(T) == 1 && d == 2)); // https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#data-alignment
assert(!(sizeof(T) == 1 && d == 3)); assert(!(sizeof(T) == 1 && d == 2));
assert(!(sizeof(T) == 2 && d == 2)); assert(!(sizeof(T) == 1 && d == 3));
for (int col = 0; col < d; col ++) { assert(!(sizeof(T) == 2 && d == 2));
for (int row = 0; row < d; row ++) { for (int col = 0; col < d; col++) {
// glTF matrices are column-major for (int row = 0; row < d; row++) {
((T *)buf)[col * d + row] = matrix(row, col); // glTF matrices are column-major
} ((T*)buf)[col * d + row] = matrix(row, col);
} }
} }
template<class T> }
void write(uint8_t *buf, const mathfu::Quaternion<T> &quaternion) const { template <class T>
for (int ii = 0; ii < 3; ii++) { void write(uint8_t* buf, const mathfu::Quaternion<T>& quaternion) const {
((T *)buf)[ii] = quaternion.vector()(ii); for (int ii = 0; ii < 3; ii++) {
} ((T*)buf)[ii] = quaternion.vector()(ii);
((T *)buf)[3] = quaternion.scalar();
} }
((T*)buf)[3] = quaternion.scalar();
}
const ComponentType componentType; const ComponentType componentType;
const uint8_t count; const uint8_t count;
const std::string dataType; const std::string dataType;
}; };
const GLType GLT_FLOAT = {CT_FLOAT, 1, "SCALAR"}; const GLType GLT_FLOAT = {CT_FLOAT, 1, "SCALAR"};
const GLType GLT_USHORT = {CT_USHORT, 1, "SCALAR"}; const GLType GLT_USHORT = {CT_USHORT, 1, "SCALAR"};
const GLType GLT_UINT = {CT_UINT, 1, "SCALAR"}; const GLType GLT_UINT = {CT_UINT, 1, "SCALAR"};
const GLType GLT_VEC2F = {CT_FLOAT, 2, "VEC2"}; const GLType GLT_VEC2F = {CT_FLOAT, 2, "VEC2"};
const GLType GLT_VEC3F = {CT_FLOAT, 3, "VEC3"}; const GLType GLT_VEC3F = {CT_FLOAT, 3, "VEC3"};
const GLType GLT_VEC4F = {CT_FLOAT, 4, "VEC4"}; const GLType GLT_VEC4F = {CT_FLOAT, 4, "VEC4"};
const GLType GLT_VEC4I = {CT_USHORT, 4, "VEC4"}; const GLType GLT_VEC4I = {CT_USHORT, 4, "VEC4"};
const GLType GLT_MAT2F = {CT_USHORT, 4, "MAT2"}; const GLType GLT_MAT2F = {CT_USHORT, 4, "MAT2"};
const GLType GLT_MAT3F = {CT_USHORT, 9, "MAT3"}; const GLType GLT_MAT3F = {CT_USHORT, 9, "MAT3"};
const GLType GLT_MAT4F = {CT_FLOAT, 16, "MAT4"}; const GLType GLT_MAT4F = {CT_FLOAT, 16, "MAT4"};
const GLType GLT_QUATF = {CT_FLOAT, 4, "VEC4"}; 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; const draco::GeometryAttribute::Type dracoAttribute;
const draco::GeometryAttribute::Type dracoAttribute; 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,
: gltfName(gltfName), const GLType& _glType,
rawAttributeIx(rawAttributeIx), const draco::GeometryAttribute::Type dracoAttribute,
glType(_glType), const draco::DataType dracoComponentType)
dracoAttribute(dracoAttribute), : gltfName(gltfName),
dracoComponentType(dracoComponentType) {} rawAttributeIx(rawAttributeIx),
glType(_glType),
dracoAttribute(dracoAttribute),
dracoComponentType(dracoComponentType) {}
AttributeDefinition( AttributeDefinition(
const std::string gltfName, const T RawVertex::*rawAttributeIx, const GLType &_glType) const std::string gltfName,
: gltfName(gltfName), const T RawVertex::*rawAttributeIx,
rawAttributeIx(rawAttributeIx), const GLType& _glType)
glType(_glType), : gltfName(gltfName),
dracoAttribute(draco::GeometryAttribute::INVALID), rawAttributeIx(rawAttributeIx),
dracoComponentType(draco::DataType::DT_INVALID) {} glType(_glType),
dracoAttribute(draco::GeometryAttribute::INVALID),
dracoComponentType(draco::DataType::DT_INVALID) {}
}; };
struct AccessorData; struct AccessorData;
@ -169,19 +172,15 @@ 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;
}; };
ModelData *Raw2Gltf( 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);
);

369
src/gltf/TextureBuilder.cpp
View File

@ -1,212 +1,219 @@
/** /**
* Copyright (c) 2014-present, Facebook, Inc. * Copyright (c) 2014-present, Facebook, Inc.
* All rights reserved. * All rights reserved.
* *
* This source code is licensed under the BSD-style license found in the * This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant * LICENSE file in the root directory of this source tree. An additional grant
* 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 "TextureBuilder.hpp" #include "TextureBuilder.hpp"
#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>
// keep track of some texture data as we load them // keep track of some texture data as we load them
struct TexInfo { struct TexInfo {
explicit TexInfo(int rawTexIx) : rawTexIx(rawTexIx) {} explicit TexInfo(int rawTexIx) : rawTexIx(rawTexIx) {}
const int rawTexIx; const int rawTexIx;
int width {}; int width{};
int height {}; int height{};
int channels {}; int channels{};
uint8_t *pixels {}; uint8_t* pixels{};
}; };
std::shared_ptr<TextureData> TextureBuilder::combine( 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()) { return iter->second;
return iter->second; }
}
int width = -1, height = -1; int width = -1, height = -1;
std::string mergedFilename = tag; std::string mergedFilename = tag;
std::vector<TexInfo> texes { }; std::vector<TexInfo> texes{};
for (const int rawTexIx : ixVec) { for (const int rawTexIx : ixVec) {
TexInfo info(rawTexIx); TexInfo info(rawTexIx);
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 =
if (!fileLoc.empty()) { StringUtils::GetFileBaseString(StringUtils::GetFileNameString(fileLoc));
info.pixels = stbi_load(fileLoc.c_str(), &info.width, &info.height, &info.channels, 0); if (!fileLoc.empty()) {
if (!info.pixels) { info.pixels = stbi_load(fileLoc.c_str(), &info.width, &info.height, &info.channels, 0);
fmt::printf("Warning: merge texture [%d](%s) could not be loaded.\n", if (!info.pixels) {
rawTexIx, fmt::printf("Warning: merge texture [%d](%s) could not be loaded.\n", rawTexIx, name);
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(
fmt::printf("Warning: texture %s (%d, %d) can't be merged with previous texture(s) of dimension (%d, %d)\n", "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,
// this is bad enough that we abort the whole merge info.height,
return nullptr; width,
} height);
mergedFilename += "_" + name; // this is bad enough that we abort the whole merge
}
}
}
texes.push_back(info);
}
// at the moment, the best choice of filename is also the best choice of name
const std::string mergedName = mergedFilename;
if (width < 0) {
// no textures to merge; bail
return nullptr;
}
// TODO: which channel combinations make sense in input files?
// write 3 or 4 channels depending on whether or not we need transparency
int channels = includeAlphaChannel ? 4 : 3;
std::vector<uint8_t> mergedPixels(static_cast<size_t>(channels * width * height));
std::vector<pixel> pixels(texes.size());
std::vector<const pixel *> pixelPointers(texes.size());
for (int xx = 0; xx < width; xx ++) {
for (int yy = 0; yy < height; yy ++) {
pixels.clear();
for (int jj = 0; jj < texes.size(); jj ++) {
const TexInfo &tex = texes[jj];
// each texture's structure will depend on its channel count
int ii = tex.channels * (xx + yy*width);
int kk = 0;
if (tex.pixels != nullptr) {
for (; kk < tex.channels; kk ++) {
pixels[jj][kk] = tex.pixels[ii++] / 255.0f;
}
}
for (; kk < pixels[jj].size(); kk ++) {
pixels[jj][kk] = 1.0f;
}
pixelPointers[jj] = &pixels[jj];
}
const pixel merged = computePixel(pixelPointers);
int ii = channels * (xx + yy*width);
for (int jj = 0; jj < channels; jj ++) {
mergedPixels[ii + jj] = static_cast<uint8_t>(fmax(0, fmin(255.0f, merged[jj] * 255.0f)));
}
}
}
// write a .png iff we need transparency in the destination texture
bool png = includeAlphaChannel;
std::vector<char> imgBuffer;
int res;
if (png) {
res = stbi_write_png_to_func(WriteToVectorContext, &imgBuffer,
width, height, channels, mergedPixels.data(), width * channels);
} else {
res = stbi_write_jpg_to_func(WriteToVectorContext, &imgBuffer,
width, height, channels, mergedPixels.data(), 80);
}
if (!res) {
fmt::printf("Warning: failed to generate merge texture '%s'.\n", mergedFilename);
return nullptr;
}
ImageData *image;
if (options.outputBinary) {
const auto bufferView = gltf.AddRawBufferView(*gltf.defaultBuffer, imgBuffer.data(), imgBuffer.size());
image = new ImageData(mergedName, *bufferView, png ? "image/png" : "image/jpeg");
} else {
const std::string imageFilename = mergedFilename + (png ? ".png" : ".jpg");
const std::string imagePath = outputFolder + imageFilename;
FILE *fp = fopen(imagePath.c_str(), "wb");
if (fp == nullptr) {
fmt::printf("Warning:: Couldn't write file '%s' for writing.\n", imagePath);
return nullptr; return nullptr;
}
mergedFilename += "_" + name;
} }
}
if (fwrite(imgBuffer.data(), imgBuffer.size(), 1, fp) != 1) {
fmt::printf("Warning: Failed to write %lu bytes to file '%s'.\n", imgBuffer.size(), imagePath);
fclose(fp);
return nullptr;
}
fclose(fp);
if (verboseOutput) {
fmt::printf("Wrote %lu bytes to texture '%s'.\n", imgBuffer.size(), imagePath);
}
image = new ImageData(mergedName, imageFilename);
} }
std::shared_ptr<TextureData> texDat = gltf.textures.hold( texes.push_back(info);
new TextureData(mergedName, *gltf.defaultSampler, *gltf.images.hold(image))); }
textureByIndicesKey.insert(std::make_pair(key, texDat)); // at the moment, the best choice of filename is also the best choice of name
return texDat; const std::string mergedName = mergedFilename;
if (width < 0) {
// no textures to merge; bail
return nullptr;
}
// TODO: which channel combinations make sense in input files?
// write 3 or 4 channels depending on whether or not we need transparency
int channels = includeAlphaChannel ? 4 : 3;
std::vector<uint8_t> mergedPixels(static_cast<size_t>(channels * width * height));
std::vector<pixel> pixels(texes.size());
std::vector<const pixel*> pixelPointers(texes.size());
for (int xx = 0; xx < width; xx++) {
for (int yy = 0; yy < height; yy++) {
pixels.clear();
for (int jj = 0; jj < texes.size(); jj++) {
const TexInfo& tex = texes[jj];
// each texture's structure will depend on its channel count
int ii = tex.channels * (xx + yy * width);
int kk = 0;
if (tex.pixels != nullptr) {
for (; kk < tex.channels; kk++) {
pixels[jj][kk] = tex.pixels[ii++] / 255.0f;
}
}
for (; kk < pixels[jj].size(); kk++) {
pixels[jj][kk] = 1.0f;
}
pixelPointers[jj] = &pixels[jj];
}
const pixel merged = computePixel(pixelPointers);
int ii = channels * (xx + yy * width);
for (int jj = 0; jj < channels; jj++) {
mergedPixels[ii + jj] = static_cast<uint8_t>(fmax(0, fmin(255.0f, merged[jj] * 255.0f)));
}
}
}
// write a .png iff we need transparency in the destination texture
bool png = includeAlphaChannel;
std::vector<char> imgBuffer;
int res;
if (png) {
res = stbi_write_png_to_func(
WriteToVectorContext,
&imgBuffer,
width,
height,
channels,
mergedPixels.data(),
width * channels);
} else {
res = stbi_write_jpg_to_func(
WriteToVectorContext, &imgBuffer, width, height, channels, mergedPixels.data(), 80);
}
if (!res) {
fmt::printf("Warning: failed to generate merge texture '%s'.\n", mergedFilename);
return nullptr;
}
ImageData* image;
if (options.outputBinary) {
const auto bufferView =
gltf.AddRawBufferView(*gltf.defaultBuffer, imgBuffer.data(), imgBuffer.size());
image = new ImageData(mergedName, *bufferView, png ? "image/png" : "image/jpeg");
} else {
const std::string imageFilename = mergedFilename + (png ? ".png" : ".jpg");
const std::string imagePath = outputFolder + imageFilename;
FILE* fp = fopen(imagePath.c_str(), "wb");
if (fp == nullptr) {
fmt::printf("Warning:: Couldn't write file '%s' for writing.\n", imagePath);
return nullptr;
}
if (fwrite(imgBuffer.data(), imgBuffer.size(), 1, fp) != 1) {
fmt::printf(
"Warning: Failed to write %lu bytes to file '%s'.\n", imgBuffer.size(), imagePath);
fclose(fp);
return nullptr;
}
fclose(fp);
if (verboseOutput) {
fmt::printf("Wrote %lu bytes to texture '%s'.\n", imgBuffer.size(), imagePath);
}
image = new ImageData(mergedName, imageFilename);
}
std::shared_ptr<TextureData> texDat = gltf.textures.hold(
new TextureData(mergedName, *gltf.defaultSampler, *gltf.images.hold(image)));
textureByIndicesKey.insert(std::make_pair(key, texDat));
return texDat;
} }
/** Create a new TextureData for the given RawTexture index, or return a previously created one. */ /** Create a new TextureData for the given RawTexture index, or return a previously created one. */
std::shared_ptr<TextureData> TextureBuilder::simple(int rawTexIndex, const std::string &tag) { std::shared_ptr<TextureData> TextureBuilder::simple(int rawTexIndex, const std::string& tag) {
const std::string key = texIndicesKey({ rawTexIndex }, tag); const std::string key = texIndicesKey({rawTexIndex}, tag);
auto iter = textureByIndicesKey.find(key); auto iter = textureByIndicesKey.find(key);
if (iter != textureByIndicesKey.end()) { if (iter != textureByIndicesKey.end()) {
return iter->second; return iter->second;
}
const RawTexture& rawTexture = raw.GetTexture(rawTexIndex);
const std::string textureName = StringUtils::GetFileBaseString(rawTexture.name);
const std::string relativeFilename = StringUtils::GetFileNameString(rawTexture.fileLocation);
ImageData* image = nullptr;
if (options.outputBinary) {
auto bufferView = gltf.AddBufferViewForFile(*gltf.defaultBuffer, rawTexture.fileLocation);
if (bufferView) {
std::string suffix = StringUtils::GetFileSuffixString(rawTexture.fileLocation);
image = new ImageData(relativeFilename, *bufferView, ImageUtils::suffixToMimeType(suffix));
} }
const RawTexture &rawTexture = raw.GetTexture(rawTexIndex); } else if (!relativeFilename.empty()) {
const std::string textureName = StringUtils::GetFileBaseString(rawTexture.name); image = new ImageData(relativeFilename, relativeFilename);
const std::string relativeFilename = StringUtils::GetFileNameString(rawTexture.fileLocation); std::string outputPath = outputFolder + StringUtils::NormalizePath(relativeFilename);
if (FileUtils::CopyFile(rawTexture.fileLocation, outputPath, true)) {
ImageData *image = nullptr; if (verboseOutput) {
if (options.outputBinary) { fmt::printf("Copied texture '%s' to output folder: %s\n", textureName, outputPath);
auto bufferView = gltf.AddBufferViewForFile(*gltf.defaultBuffer, rawTexture.fileLocation); }
if (bufferView) { } else {
std::string suffix = StringUtils::GetFileSuffixString(rawTexture.fileLocation); // no point commenting further on read/write error; CopyFile() does enough of that, and we
image = new ImageData(relativeFilename, *bufferView, ImageUtils::suffixToMimeType(suffix)); // certainly want to to add an image struct to the glTF JSON, with the correct relative path
} // reference, even if the copy failed.
} else if (!relativeFilename.empty()) {
image = new ImageData(relativeFilename, relativeFilename);
std::string outputPath = outputFolder + StringUtils::NormalizePath(relativeFilename);
if (FileUtils::CopyFile(rawTexture.fileLocation, outputPath, true))
{
if (verboseOutput) {
fmt::printf("Copied texture '%s' to output folder: %s\n", textureName, outputPath);
}
} else {
// no point commenting further on read/write error; CopyFile() does enough of that, and we
// certainly want to to add an image struct to the glTF JSON, with the correct relative path
// reference, even if the copy failed.
}
}
if (!image) {
// fallback is tiny transparent PNG
image = new ImageData(
textureName,
"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
);
} }
}
if (!image) {
// fallback is tiny transparent PNG
image = new ImageData(
textureName,
"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;
} }

114
src/gltf/TextureBuilder.hpp
View File

@ -1,11 +1,11 @@
/** /**
* Copyright (c) 2014-present, Facebook, Inc. * Copyright (c) 2014-present, Facebook, Inc.
* All rights reserved. * All rights reserved.
* *
* This source code is licensed under the BSD-style license found in the * This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree. An additional grant * LICENSE file in the root directory of this source tree. An additional grant
* 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.
*/ */
#pragma once #pragma once
@ -17,60 +17,62 @@
#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);
static std::string texIndicesKey(const std::vector<int> &ixVec, const std::string &tag) { static std::string texIndicesKey(const std::vector<int>& ixVec, const std::string& tag) {
std::string result = tag; std::string result = tag;
for (int ix : ixVec) { for (int ix : ixVec) {
result += "_" + std::to_string(ix); result += "_" + std::to_string(ix);
}
return result;
};
static std::string describeChannel(int channels) {
switch(channels) {
case 1: return "G";
case 2: return "GA";
case 3: return "RGB";
case 4: return "RGBA";
default:
return fmt::format("?%d?", channels);
}
};
static void WriteToVectorContext(void *context, void *data, int size) {
auto *vec = static_cast<std::vector<char> *>(context);
for (int ii = 0; ii < size; ii ++) {
vec->push_back(((char *) data)[ii]);
}
} }
return result;
};
private: static std::string describeChannel(int channels) {
const RawModel &raw; switch (channels) {
const GltfOptions &options; case 1:
const std::string outputFolder; return "G";
GltfModel &gltf; case 2:
return "GA";
case 3:
return "RGB";
case 4:
return "RGBA";
default:
return fmt::format("?%d?", channels);
}
};
std::map<std::string, std::shared_ptr<TextureData>> textureByIndicesKey; static void WriteToVectorContext(void* context, void* data, int size) {
auto* vec = static_cast<std::vector<char>*>(context);
for (int ii = 0; ii < size; ii++) {
vec->push_back(((char*)data)[ii]);
}
}
private:
const RawModel& raw;
const GltfOptions& options;
const std::string outputFolder;
GltfModel& gltf;
std::map<std::string, std::shared_ptr<TextureData>> textureByIndicesKey;
}; };

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

@ -10,44 +10,32 @@
#include "AccessorData.hpp" #include "AccessorData.hpp"
#include "BufferViewData.hpp" #include "BufferViewData.hpp"
AccessorData::AccessorData(const BufferViewData &bufferView, GLType type, std::string name) AccessorData::AccessorData(const BufferViewData& bufferView, GLType type, std::string name)
: Holdable(), : Holdable(),
bufferView(bufferView.ix), bufferView(bufferView.ix),
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}, {"type", type.dataType}, {"count", count}};
{ "componentType", type.componentType.glType }, if (bufferView >= 0) {
{ "type", type.dataType }, result["bufferView"] = bufferView;
{ "count", count } result["byteOffset"] = byteOffset;
}; }
if (bufferView >= 0) { if (!min.empty()) {
result["bufferView"] = bufferView; result["min"] = min;
result["byteOffset"] = byteOffset; }
} if (!max.empty()) {
if (!min.empty()) { result["max"] = max;
result["min"] = min; }
} if (name.length() > 0) {
if (!max.empty()) { result["name"] = name;
result["max"] = max; }
} return result;
if (name.length() > 0) {
result["name"] = name;
}
return result;
} }

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

@ -11,36 +11,36 @@
#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();
this->count = (unsigned int) count; this->count = (unsigned int)count;
out.resize(offset + count * stride); out.resize(offset + count * stride);
for (int ii = 0; ii < count; ii ++) { for (int ii = 0; ii < count; ii++) {
type.write(&out[offset + ii * stride], in[ii]); type.write(&out[offset + ii * stride], in[ii]);
}
} }
}
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;
unsigned int byteOffset; unsigned int byteOffset;
unsigned int count; unsigned int count;
std::vector<float> min; std::vector<float> min;
std::vector<float> max; std::vector<float> max;
std::string name; std::string name;
}; };

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

@ -14,57 +14,42 @@
#include "AccessorData.hpp" #include "AccessorData.hpp"
#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,
assert(channels.size() == samplers.size()); const AccessorData& accessor,
uint32_t ix = channels.size(); std::string path) {
channels.emplace_back(channel_t(ix, node, std::move(path))); assert(channels.size() == samplers.size());
samplers.emplace_back(sampler_t(timeAccessor, accessor.ix)); uint32_t ix = channels.size();
channels.emplace_back(channel_t(ix, node, std::move(path)));
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) : time(time), output(output) {}
{
void to_json(json& j, const AnimationData::channel_t& data) {
j = json{{"sampler", data.ix},
{
"target",
{{"node", data.node}, {"path", data.path}},
}};
} }
AnimationData::sampler_t::sampler_t(uint32_t time, uint32_t output) void to_json(json& j, const AnimationData::sampler_t& data) {
: time(time), j = json{
output(output) {"input", data.time},
{ {"interpolation", "LINEAR"},
} {"output", data.output},
};
void to_json(json &j, const AnimationData::channel_t &data) {
j = json {
{ "sampler", data.ix },
{ "target", {
{ "node", data.node },
{ "path", data.path }},
}
};
}
void to_json(json &j, const AnimationData::sampler_t &data) {
j = json {
{ "input", data.time },
{ "interpolation", "LINEAR" },
{ "output", data.output },
};
} }

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

@ -11,38 +11,35 @@
#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
// 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 AddNodeChannel(const NodeData &node, const AccessorData &accessor, std::string path); void AddNodeChannel(const NodeData& node, const AccessorData& accessor, std::string path);
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;
const uint32_t node; const uint32_t node;
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;
const uint32_t output; const uint32_t output;
}; };
const std::string name; const std::string name;
const uint32_t timeAccessor; const uint32_t timeAccessor;
std::vector<channel_t> channels; std::vector<channel_t> channels;
std::vector<sampler_t> samplers; std::vector<sampler_t> samplers;
}; };
void to_json(json &j, const AnimationData::channel_t &data); void to_json(json& j, const AnimationData::channel_t& data);
void to_json(json &j, const AnimationData::sampler_t &data); void to_json(json& j, const AnimationData::sampler_t& data);

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

@ -11,33 +11,24 @@
#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{ if (!isGlb) {
{"byteLength", binData->size()} if (!uri.empty()) {
}; result["uri"] = uri;
if (!isGlb) { } else {
if (!uri.empty()) { std::string encoded = base64::encode(*binData);
result["uri"] = uri; result["uri"] = "data:application/octet-stream;base64," + encoded;
} else {
std::string encoded = base64::encode(*binData);
result["uri"] = "data:application/octet-stream;base64," + encoded;
}
} }
return result; }
return result;
} }

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

@ -11,15 +11,17 @@
#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;
const bool isGlb; const bool isGlb;
const std::string uri; const std::string uri;
const std::shared_ptr<const std::vector<uint8_t> > binData; // TODO this is just weird const std::shared_ptr<const std::vector<uint8_t>> binData; // TODO this is just weird
}; };

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

@ -10,23 +10,16 @@
#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 { if (target != GL_ARRAY_NONE) {
{ "buffer", buffer }, result["target"] = target;
{ "byteLength", byteLength }, }
{ "byteOffset", byteOffset } return result;
};
if (target != GL_ARRAY_NONE) {
result["target"] = target;
}
return result;
} }

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

@ -11,22 +11,20 @@
#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_BUFFER = 34962,
GL_ARRAY_NONE = 0, // no GL buffer is being set GL_ELEMENT_ARRAY_BUFFER = 34963
GL_ARRAY_BUFFER = 34962, };
GL_ELEMENT_ARRAY_BUFFER = 34963
};
BufferViewData(const BufferData &_buffer, const size_t _byteOffset, const GL_ArrayType _target); BufferViewData(const BufferData& _buffer, const size_t _byteOffset, const GL_ArrayType _target);
json serialize() const override; json serialize() const override;
const unsigned int buffer; const unsigned int buffer;
const unsigned int byteOffset; const unsigned int byteOffset;
const GL_ArrayType target; const GL_ArrayType target;
unsigned int byteLength = 0; unsigned int byteLength = 0;
}; };

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

@ -10,33 +10,21 @@
#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{{"znear", znear}, {"zfar", zfar}};
json subResult { if (type == "perspective") {
{ "znear", znear }, subResult["aspectRatio"] = aspectRatio;
{ "zfar", zfar } subResult["yfov"] = yfov;
}; } else {
if (type == "perspective") { subResult["xmag"] = xmag;
subResult["aspectRatio"] = aspectRatio; subResult["ymag"] = ymag;
subResult["yfov"] = yfov; }
} else { result[type] = subResult;
subResult["xmag"] = xmag; return result;
subResult["ymag"] = ymag;
}
result[type] = subResult;
return result;
} }

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

@ -12,17 +12,16 @@
#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;
std::string name; std::string name;
std::string type; std::string type;
float aspectRatio; float aspectRatio;
float yfov; float yfov;
float xmag; float xmag;
float ymag; float ymag;
float znear; float znear;
float zfar; float zfar;
}; };

34
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 {{"name", name}, {"uri", uri}};
return { }
{ "name", name }, return {{"name", name}, {"bufferView", bufferView}, {"mimeType", mimeType}};
{ "uri", uri }
};
}
return {
{ "name", name },
{ "bufferView", bufferView },
{ "mimeType", mimeType }
};
} }

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

@ -11,15 +11,14 @@
#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);
json serialize() const override; json serialize() const override;
const std::string name; const std::string name;
const std::string uri; // non-empty in gltf mode const std::string uri; // non-empty in gltf mode
const int32_t bufferView; // non-negative in glb mode const int32_t bufferView; // non-negative in glb mode
const std::string mimeType; const std::string mimeType;
}; };

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

@ -10,34 +10,31 @@
#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 { switch (type) {
{ "name", name }, case Directional:
{ "color", toStdVec(color) }, result["type"] = "directional";
{ "intensity", intensity } break;
}; case Point:
switch(type) { result["type"] = "point";
case Directional: break;
result["type"] = "directional"; case Spot:
break; result["type"] = "spot";
case Point: break;
result["type"] = "point"; }
break; return result;
case Spot:
result["type"] = "spot";
break;
}
return result;
} }

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

@ -11,23 +11,27 @@
#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;
const std::string name; const std::string name;
const Type type; const Type type;
const Vec3f color; const Vec3f color;
const float intensity; const float intensity;
const float innerConeAngle; const float innerConeAngle;
const float outerConeAngle; const float outerConeAngle;
}; };

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

@ -11,77 +11,74 @@
#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
return Vec3f::Max(bottom, Vec3f::Min(top, vec)); clamp(const Vec3f& vec, const Vec3f& bottom = VEC3F_ZERO, const Vec3f& top = VEC3F_ONE) {
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
return Vec4f::Max(bottom, Vec4f::Min(top, vec)); clamp(const Vec4f& vec, const Vec4f& bottom = VEC4F_ZERO, const Vec4f& top = VEC4F_ONE) {
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; }
} if (d.baseColorFactor.LengthSquared() > 0) {
if (d.baseColorFactor.LengthSquared() > 0) { j["baseColorFactor"] = toStdVec(d.baseColorFactor);
j["baseColorFactor"] = toStdVec(d.baseColorFactor); }
} if (d.metRoughTexture != nullptr) {
if (d.metRoughTexture != nullptr) { j["metallicRoughnessTexture"] = *d.metRoughTexture;
j["metallicRoughnessTexture"] = *d.metRoughTexture; // if a texture is provided, throw away metallic/roughness values
// if a texture is provided, throw away metallic/roughness values j["roughnessFactor"] = 1.0f;
j["roughnessFactor"] = 1.0f; j["metallicFactor"] = 1.0f;
j["metallicFactor"] = 1.0f; } else {
} else { // without a texture, however, use metallic/roughness as constants
// without a texture, however, use metallic/roughness as constants j["metallicFactor"] = d.metallic;
j["metallicFactor"] = d.metallic; j["roughnessFactor"] = d.roughness;
j["roughnessFactor"] = d.roughness; }
}
} }
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,50 +92,43 @@ MaterialData::MaterialData(
khrCmnConstantMaterial(khrCmnConstantMaterial), khrCmnConstantMaterial(khrCmnConstantMaterial),
pbrMetallicRoughness(pbrMetallicRoughness) {} pbrMetallicRoughness(pbrMetallicRoughness) {}
json MaterialData::serialize() const json MaterialData::serialize() const {
{ json result = {{"name", name},
json result = { {"alphaMode", isTransparent ? "BLEND" : "OPAQUE"},
{ "name", name }, {"extras",
{ "alphaMode", isTransparent ? "BLEND" : "OPAQUE" }, {{"fromFBX",
{ "extras", { {{"shadingModel", Describe(shadingModel)},
{ "fromFBX", { {"isTruePBR", shadingModel == RAW_SHADING_MODEL_PBR_MET_ROUGH}}}}}};
{ "shadingModel", Describe(shadingModel) },
{ "isTruePBR", shadingModel == RAW_SHADING_MODEL_PBR_MET_ROUGH }
}}
}}
};
if (normalTexture != nullptr) { if (normalTexture != nullptr) {
result["normalTexture"] = *normalTexture; result["normalTexture"] = *normalTexture;
} }
if (occlusionTexture != nullptr) { if (occlusionTexture != nullptr) {
result["occlusionTexture"] = *occlusionTexture; result["occlusionTexture"] = *occlusionTexture;
} }
if (emissiveTexture != nullptr) { if (emissiveTexture != nullptr) {
result["emissiveTexture"] = *emissiveTexture; result["emissiveTexture"] = *emissiveTexture;
} }
if (emissiveFactor.LengthSquared() > 0) { if (emissiveFactor.LengthSquared() > 0) {
result["emissiveFactor"] = toStdVec(emissiveFactor); result["emissiveFactor"] = toStdVec(emissiveFactor);
} }
if (pbrMetallicRoughness != nullptr) { if (pbrMetallicRoughness != nullptr) {
result["pbrMetallicRoughness"] = *pbrMetallicRoughness; result["pbrMetallicRoughness"] = *pbrMetallicRoughness;
} }
if (khrCmnConstantMaterial != nullptr) { if (khrCmnConstantMaterial != nullptr) {
json extensions = { }; json extensions = {};
extensions[KHR_MATERIALS_CMN_UNLIT] = *khrCmnConstantMaterial; extensions[KHR_MATERIALS_CMN_UNLIT] = *khrCmnConstantMaterial;
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();
}
} }
}
return result; return result;
} }

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

@ -13,58 +13,61 @@
#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);
const uint32_t texRef; const uint32_t texRef;
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 *baseColorTexture, const TextureData *metRoughTexture, const TextureData* metRoughTexture,
const Vec4f &baseColorFactor, float metallic = 0.1f, float roughness = 0.6f); 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;
const Vec4f baseColorFactor; const Vec4f baseColorFactor;
const float metallic; const float metallic;
const float roughness; const float roughness;
}; };
struct MaterialData : Holdable struct MaterialData : Holdable {
{ MaterialData(
MaterialData( std::string name,
std::string name, bool isTransparent, RawShadingModel shadingModel, bool isTransparent,
const TextureData *normalTexture, const TextureData *occlusionTexture, RawShadingModel shadingModel,
const TextureData *emissiveTexture, const Vec3f &emissiveFactor, const TextureData* normalTexture,
std::shared_ptr<KHRCmnUnlitMaterial> const khrCmnConstantMaterial, const TextureData* occlusionTexture,
std::shared_ptr<PBRMetallicRoughness> const pbrMetallicRoughness); const TextureData* emissiveTexture,
const Vec3f& emissiveFactor,
std::shared_ptr<KHRCmnUnlitMaterial> const khrCmnConstantMaterial,
std::shared_ptr<PBRMetallicRoughness> const pbrMetallicRoughness);
json serialize() const override; json serialize() const override;
const std::string name; const std::string name;
const RawShadingModel shadingModel; const RawShadingModel shadingModel;
const bool isTransparent; const bool isTransparent;
const std::unique_ptr<const Tex> normalTexture; const std::unique_ptr<const Tex> normalTexture;
const std::unique_ptr<const Tex> occlusionTexture; const std::unique_ptr<const Tex> occlusionTexture;
const std::unique_ptr<const Tex> emissiveTexture; const std::unique_ptr<const Tex> emissiveTexture;
const Vec3f emissiveFactor; const Vec3f emissiveFactor;
const std::shared_ptr<const KHRCmnUnlitMaterial> khrCmnConstantMaterial; const std::shared_ptr<const KHRCmnUnlitMaterial> khrCmnConstantMaterial;
const std::shared_ptr<const PBRMetallicRoughness> pbrMetallicRoughness; const std::shared_ptr<const PBRMetallicRoughness> pbrMetallicRoughness;
std::vector<std::string> userProperties; std::vector<std::string> userProperties;
}; };
void to_json(json &j, const Tex &data); void to_json(json& j, const Tex& data);
void to_json(json &j, const KHRCmnUnlitMaterial &d); void to_json(json& j, const KHRCmnUnlitMaterial& d);
void to_json(json &j, const PBRMetallicRoughness &d); void to_json(json& j, const PBRMetallicRoughness& d);

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

@ -10,25 +10,17 @@
#include "MeshData.hpp" #include "MeshData.hpp"
#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 = {{"name", name}, {"primitives", jsonPrimitivesArray}};
json result = { if (!weights.empty()) {
{ "name", name }, result["weights"] = weights;
{ "primitives", jsonPrimitivesArray } }
}; return result;
if (!weights.empty()) {
result["weights"] = weights;
}
return result;
} }

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

@ -17,18 +17,16 @@
#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)); }
}
json serialize() const override; json serialize() const override;
const std::string name; const std::string name;
const std::vector<float> weights; const std::vector<float> weights;
std::vector<std::shared_ptr<PrimitiveData>> primitives; std::vector<std::shared_ptr<PrimitiveData>> primitives;
}; };

139
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,90 +25,80 @@ NodeData::NodeData(
mesh(-1), mesh(-1),
camera(-1), camera(-1),
light(-1), light(-1),
skin(-1) skin(-1) {}
{
void NodeData::AddChildNode(uint32_t childIx) {
children.push_back(childIx);
} }
void NodeData::AddChildNode(uint32_t childIx) void NodeData::SetMesh(uint32_t meshIx) {
{ assert(mesh < 0);
children.push_back(childIx); assert(!isJoint);
mesh = meshIx;
} }
void NodeData::SetMesh(uint32_t meshIx) void NodeData::SetSkin(uint32_t skinIx) {
{ assert(skin < 0);
assert(mesh < 0); assert(!isJoint);
assert(!isJoint); skin = skinIx;
mesh = meshIx;
} }
void NodeData::SetSkin(uint32_t skinIx) void NodeData::SetCamera(uint32_t cameraIndex) {
{ assert(!isJoint);
assert(skin < 0); camera = cameraIndex;
assert(!isJoint);
skin = skinIx;
} }
void NodeData::SetCamera(uint32_t cameraIndex) void NodeData::SetLight(uint32_t lightIndex) {
{ assert(!isJoint);
assert(!isJoint); light = lightIndex;
camera = cameraIndex;
} }
void NodeData::SetLight(uint32_t lightIndex) json NodeData::serialize() const {
{ json result = {{"name", name}};
assert(!isJoint);
light = lightIndex;
}
json NodeData::serialize() const // if any of the T/R/S have NaN components, just leave them out of the glTF
{ auto maybeAdd = [&](std::string key, std::vector<float> vec) -> void {
json result = { { "name", name } }; if (std::none_of(vec.begin(), vec.end(), [&](float n) { return std::isnan(n); })) {
result[key] = vec;
// if any of the T/R/S have NaN components, just leave them out of the glTF
auto maybeAdd = [&](std::string key, std::vector<float> vec) -> void {
if (std::none_of(vec.begin(), vec.end(), [&](float n) { return std::isnan(n); })) {
result[key] = vec;
}
};
maybeAdd("translation", toStdVec(translation));
maybeAdd("rotation", toStdVec(rotation));
maybeAdd("scale", toStdVec(scale));
if (!children.empty()) {
result["children"] = children;
} }
if (isJoint) { };
// sanity-check joint node maybeAdd("translation", toStdVec(translation));
assert(mesh < 0 && skin < 0); maybeAdd("rotation", toStdVec(rotation));
} else { maybeAdd("scale", toStdVec(scale));
// non-joint node
if (mesh >= 0) { if (!children.empty()) {
result["mesh"] = mesh; result["children"] = children;
} }
if (!skeletons.empty()) { if (isJoint) {
result["skeletons"] = skeletons; // sanity-check joint node
} assert(mesh < 0 && skin < 0);
if (skin >= 0) { } else {
result["skin"] = skin; // non-joint node
} if (mesh >= 0) {
if (camera >= 0) { result["mesh"] = mesh;
result["camera"] = camera;
}
if (light >= 0) {
result["extensions"][KHR_LIGHTS_PUNCTUAL]["light"] = light;
}
} }
if (!skeletons.empty()) {
for (const auto& i : userProperties) result["skeletons"] = skeletons;
{
auto& prop_map = result["extras"]["fromFBX"]["userProperties"];
json j = json::parse(i);
for (const auto& k : json::iterator_wrapper(j))
{
prop_map[k.key()] = k.value();
}
} }
if (skin >= 0) {
result["skin"] = skin;
}
if (camera >= 0) {
result["camera"] = camera;
}
if (light >= 0) {
result["extensions"][KHR_LIGHTS_PUNCTUAL]["light"] = light;
}
}
return result; for (const auto& i : userProperties) {
auto& prop_map = result["extras"]["fromFBX"]["userProperties"];
json j = json::parse(i);
for (const auto& k : json::iterator_wrapper(j)) {
prop_map[k.key()] = k.value();
}
}
return result;
} }

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

@ -11,28 +11,32 @@
#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);
void SetSkin(uint32_t skinIx); void SetSkin(uint32_t skinIx);
void SetCamera(uint32_t camera); void SetCamera(uint32_t camera);
void SetLight(uint32_t light); void SetLight(uint32_t light);
json serialize() const override; json serialize() const override;
const std::string name; const std::string name;
const bool isJoint; const bool isJoint;
Vec3f translation; Vec3f translation;
Quatf rotation; Quatf rotation;
Vec3f scale; Vec3f scale;
std::vector<uint32_t> children; std::vector<uint32_t> children;
int32_t mesh; int32_t mesh;
int32_t camera; int32_t camera;
int32_t light; int32_t light;
int32_t skin; int32_t skin;
std::vector<std::string> skeletons; std::vector<std::string> skeletons;
std::vector<std::string> userProperties; std::vector<std::string> userProperties;
}; };

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

@ -9,73 +9,71 @@
#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),
dracoMesh(dracoMesh), dracoMesh(dracoMesh),
dracoBufferView(-1) {} dracoBufferView(-1) {}
PrimitiveData::PrimitiveData(const AccessorData &indices, const MaterialData &material) PrimitiveData::PrimitiveData(const AccessorData& indices, const MaterialData& material)
: indices(indices.ix), : indices(indices.ix),
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) {
attributes[name] = accessor.ix;
} }
void PrimitiveData::AddAttrib(std::string name, const AccessorData &accessor) void PrimitiveData::NoteDracoBuffer(const BufferViewData& data) {
{ dracoBufferView = data.ix;
attributes[name] = accessor.ix;
} }
void PrimitiveData::NoteDracoBuffer(const BufferViewData &data) void PrimitiveData::AddTarget(
{ const AccessorData* positions,
dracoBufferView = data.ix; const AccessorData* normals,
const AccessorData* tangents) {
targetAccessors.push_back(std::make_tuple(
positions->ix,
normals != nullptr ? normals->ix : -1,
tangents != nullptr ? tangents->ix : -1));
} }
void PrimitiveData::AddTarget(const AccessorData *positions, const AccessorData *normals, const AccessorData *tangents) void to_json(json& j, const PrimitiveData& d) {
{ j = {{"material", d.material}, {"mode", d.mode}, {"attributes", d.attributes}};
targetAccessors.push_back(std::make_tuple( if (d.indices >= 0) {
positions->ix, j["indices"] = d.indices;
normals != nullptr ? normals->ix : -1, }
tangents != nullptr ? tangents ->ix : -1 if (!d.targetAccessors.empty()) {
)); json targets{};
} int pIx, nIx, tIx;
for (auto accessor : d.targetAccessors) {
void to_json(json &j, const PrimitiveData &d) { std::tie(pIx, nIx, tIx) = accessor;
j = { json target{};
{ "material", d.material }, if (pIx >= 0) {
{ "mode", d.mode }, target["POSITION"] = pIx;
{ "attributes", d.attributes } }
}; if (nIx >= 0) {
if (d.indices >= 0) { target["NORMAL"] = nIx;
j["indices"] = d.indices; }
} if (tIx >= 0) {
if (!d.targetAccessors.empty()) { target["TANGENT"] = tIx;
json targets {}; }
int pIx, nIx, tIx; targets.push_back(target);
for (auto accessor : d.targetAccessors) {
std::tie(pIx, nIx, tIx) = accessor;
json target {};
if (pIx >= 0) { target["POSITION"] = pIx; }
if (nIx >= 0) { target["NORMAL"] = nIx; }
if (tIx >= 0) { target["TANGENT"] = tIx; }
targets.push_back(target);
}
j["targets"] = targets;
}
if (!d.dracoAttributes.empty()) {
j["extensions"] = {
{ KHR_DRACO_MESH_COMPRESSION, {
{ "bufferView", d.dracoBufferView },
{ "attributes", d.dracoAttributes }
}}
};
} }
j["targets"] = targets;
}
if (!d.dracoAttributes.empty()) {
j["extensions"] = {{KHR_DRACO_MESH_COMPRESSION,
{{"bufferView", d.dracoBufferView}, {"attributes", d.dracoAttributes}}}};
}
} }

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

@ -11,62 +11,70 @@
#include "gltf/Raw2Gltf.hpp" #include "gltf/Raw2Gltf.hpp"
struct PrimitiveData struct PrimitiveData {
{ enum MeshMode {
enum MeshMode POINTS = 0,
{ LINES,
POINTS = 0, LINE_LOOP,
LINES, LINE_STRIP,
LINE_LOOP, TRIANGLES,
LINE_STRIP, TRIANGLE_STRIP,
TRIANGLES, TRIANGLE_FAN
TRIANGLE_STRIP, };
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,
attribute.dracoAttribute, nullptr, componentCount, attribute.dracoComponentType, nullptr,
false, componentCount * draco::DataTypeLength(attribute.dracoComponentType), 0); 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);
std::vector<uint8_t> buf(sizeof(T)); std::vector<uint8_t> buf(sizeof(T));
for (uint32_t ii = 0; ii < attribArr.size(); ii++) { for (uint32_t ii = 0; ii < attribArr.size(); ii++) {
uint8_t *ptr = &buf[0]; uint8_t* ptr = &buf[0];
attribute.glType.write(ptr, attribArr[ii]); attribute.glType.write(ptr, attribArr[ii]);
attPtr->SetAttributeValue(attPtr->mapped_index(draco::PointIndex(ii)), ptr); attPtr->SetAttributeValue(attPtr->mapped_index(draco::PointIndex(ii)), ptr);
}
dracoAttributes[attribute.gltfName] = dracoAttId;
} }
void NoteDracoBuffer(const BufferViewData &data); dracoAttributes[attribute.gltfName] = dracoAttId;
}
const int indices; void NoteDracoBuffer(const BufferViewData& data);
const unsigned int material;
const MeshMode mode;
std::vector<std::tuple<int, int, int>> targetAccessors {}; const int indices;
const unsigned int material;
const MeshMode mode;
std::map<std::string, int> attributes; std::vector<std::tuple<int, int, int>> targetAccessors{};
std::map<std::string, int> dracoAttributes;
std::shared_ptr<draco::Mesh> dracoMesh; std::map<std::string, int> attributes;
int dracoBufferView; std::map<std::string, int> dracoAttributes;
std::shared_ptr<draco::Mesh> dracoMesh;
int dracoBufferView;
}; };
void to_json(json &j, const PrimitiveData &d); void to_json(json& j, const PrimitiveData& d);

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

@ -11,15 +11,11 @@
#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() : Holdable() {}
SamplerData()
: Holdable()
{
}
json serialize() const override { json serialize() const override {
return json::object(); return json::object();
} }
}; };

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

@ -11,18 +11,10 @@
#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 {{"name", name}, {"nodes", nodes}};
return {
{ "name", name },
{ "nodes", nodes }
};
} }

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

@ -11,12 +11,11 @@
#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;
const std::string name; const std::string name;
std::vector<uint32_t> nodes; std::vector<uint32_t> nodes;
}; };

20
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 NodeData &skeletonRootNode) const AccessorData& inverseBindMatricesAccessor,
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 { {"inverseBindMatrices", inverseBindMatrices},
{ "joints", joints }, {"skeleton", skeletonRootNode}};
{ "inverseBindMatrices", inverseBindMatrices },
{ "skeleton", skeletonRootNode }
};
} }

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

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

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

@ -12,19 +12,9 @@
#include "ImageData.hpp" #include "ImageData.hpp"
#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 }
};
} }

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

@ -11,13 +11,12 @@
#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;
const std::string name; const std::string name;
const uint32_t sampler; const uint32_t sampler;
const uint32_t source; const uint32_t source;
}; };

138
src/mathfu.hpp
View File

@ -11,93 +11,93 @@
#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;
void Clear() { void Clear() {
min = mathfu::Vector<T, d>(); min = mathfu::Vector<T, d>();
max = mathfu::Vector<T, d>(); max = mathfu::Vector<T, d>();
initialized = false; initialized = false;
} }
void AddPoint(const mathfu::Vector<T, d> &p) { void AddPoint(const mathfu::Vector<T, d>& p) {
if (initialized) { if (initialized) {
for (int ii = 0; ii < d; ii ++) { for (int ii = 0; ii < d; ii++) {
min(ii) = std::min(min(ii), p(ii)); min(ii) = std::min(min(ii), p(ii));
max(ii) = std::max(max(ii), p(ii)); max(ii) = std::max(max(ii), p(ii));
} }
} else { } else {
min = p; min = p;
max = p; max = p;
initialized = true; initialized = true;
}
} }
}
}; };
typedef mathfu::Vector<uint16_t, 4> Vec4i; typedef mathfu::Vector<uint16_t, 4> Vec4i;
typedef mathfu::Matrix<uint16_t, 4> Mat4i; typedef mathfu::Matrix<uint16_t, 4> Mat4i;
typedef mathfu::Vector<float, 2> Vec2f; typedef mathfu::Vector<float, 2> Vec2f;
typedef mathfu::Vector<float, 3> Vec3f; typedef mathfu::Vector<float, 3> Vec3f;
typedef mathfu::Vector<float, 4> Vec4f; typedef mathfu::Vector<float, 4> Vec4f;
typedef mathfu::Matrix<float, 2> Mat2f; typedef mathfu::Matrix<float, 2> Mat2f;
typedef mathfu::Matrix<float, 3> Mat3f; typedef mathfu::Matrix<float, 3> Mat3f;
typedef mathfu::Matrix<float, 4> Mat4f; typedef mathfu::Matrix<float, 4> Mat4f;
typedef mathfu::Quaternion<float> Quatf; typedef mathfu::Quaternion<float> Quatf;
typedef Bounds<float, 3> Boundsf; typedef Bounds<float, 3> Boundsf;
#define VEC3F_ONE (Vec3f {1.0f}) #define VEC3F_ONE (Vec3f{1.0f})
#define VEC3F_ZERO (Vec3f {0.0f}) #define VEC3F_ZERO (Vec3f{0.0f})
#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];
}
return result;
}
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()};
}
inline Vec3f toVec3f(const FbxDouble3& v) {
return Vec3f((float)v[0], (float)v[1], (float)v[2]);
}
inline Vec3f toVec3f(const FbxVector4& v) {
return Vec3f((float)v[0], (float)v[1], (float)v[2]);
}
inline Vec4f toVec4f(const FbxVector4& v) {
return Vec4f((float)v[0], (float)v[1], (float)v[2], (float)v[3]);
}
inline Mat4f toMat4f(const FbxAMatrix& m) {
auto result = Mat4f();
for (int row = 0; row < 4; row++) {
for (int col = 0; col < 4; col++) {
result(row, col) = (float)m[row][col];
} }
return result; }
return result;
} }
template<class T> std::vector<T> toStdVec(const mathfu::Quaternion<T> &quat) { inline Quatf toQuatf(const FbxQuaternion& q) {
return std::vector<T> { quat.vector()[0], quat.vector()[1], quat.vector()[2], quat.scalar() }; return Quatf((float)q[3], (float)q[0], (float)q[1], (float)q[2]);
}
inline Vec3f toVec3f(const FbxDouble3 &v) {
return Vec3f((float) v[0], (float) v[1], (float) v[2]);
}
inline Vec3f toVec3f(const FbxVector4 &v) {
return Vec3f((float) v[0], (float) v[1], (float) v[2]);
}
inline Vec4f toVec4f(const FbxVector4 &v) {
return Vec4f((float) v[0], (float) v[1], (float) v[2], (float) v[3]);
}
inline Mat4f toMat4f(const FbxAMatrix &m) {
auto result = Mat4f();
for (int row = 0; row < 4; row ++) {
for (int col = 0; col < 4; col ++) {
result(row, col) = (float) m[row][col];
}
}
return result;
}
inline Quatf toQuatf(const FbxQuaternion &q) {
return Quatf((float) q[3], (float) q[0], (float) q[1], (float) q[2]);
} }

1147
src/raw/RawModel.cpp
View File

File diff suppressed because it is too large Load Diff

831
src/raw/RawModel.hpp
View File

@ -9,481 +9,540 @@
#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 {
RAW_VERTEX_ATTRIBUTE_POSITION = 1 << 0,
RAW_VERTEX_ATTRIBUTE_NORMAL = 1 << 1,
RAW_VERTEX_ATTRIBUTE_TANGENT = 1 << 2,
RAW_VERTEX_ATTRIBUTE_BINORMAL = 1 << 3,
RAW_VERTEX_ATTRIBUTE_COLOR = 1 << 4,
RAW_VERTEX_ATTRIBUTE_UV0 = 1 << 5,
RAW_VERTEX_ATTRIBUTE_UV1 = 1 << 6,
RAW_VERTEX_ATTRIBUTE_JOINT_INDICES = 1 << 7,
RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS = 1 << 8,
enum RawVertexAttribute RAW_VERTEX_ATTRIBUTE_AUTO = 1 << 31
{
RAW_VERTEX_ATTRIBUTE_POSITION = 1 << 0,
RAW_VERTEX_ATTRIBUTE_NORMAL = 1 << 1,
RAW_VERTEX_ATTRIBUTE_TANGENT = 1 << 2,
RAW_VERTEX_ATTRIBUTE_BINORMAL = 1 << 3,
RAW_VERTEX_ATTRIBUTE_COLOR = 1 << 4,
RAW_VERTEX_ATTRIBUTE_UV0 = 1 << 5,
RAW_VERTEX_ATTRIBUTE_UV1 = 1 << 6,
RAW_VERTEX_ATTRIBUTE_JOINT_INDICES = 1 << 7,
RAW_VERTEX_ATTRIBUTE_JOINT_WEIGHTS = 1 << 8,
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};
Vec3f binormal { 0.0f }; Vec3f binormal{0.0f};
Vec4f tangent { 0.0f }; Vec4f tangent{0.0f};
Vec4f color { 0.0f }; Vec4f color{0.0f};
Vec2f uv0 { 0.0f }; Vec2f uv0{0.0f};
Vec2f uv1 { 0.0f }; Vec2f uv1{0.0f};
Vec4i jointIndices { 0, 0, 0, 0 }; Vec4i jointIndices{0, 0, 0, 0};
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;
int blendSurfaceIx = -1; // otherwise, -1
// the size of this vector is always identical to the size of the corresponding RawSurface.blendChannels int blendSurfaceIx = -1;
std::vector<RawBlendVertex> blends { }; // the size of this vector is always identical to the size of the corresponding
// RawSurface.blendChannels
std::vector<RawBlendVertex> blends{};
bool polarityUv0; bool polarityUv0;
bool pad1; bool pad1;
bool pad2; bool pad2;
bool pad3; bool pad3;
bool operator==(const RawVertex &other) const; bool operator==(const RawVertex& other) const;
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;
{ const auto hasher = std::hash<float>{};
size_t seed = 5381; seed ^= hasher(v.position[0]) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
const auto hasher = std::hash<float>{}; seed ^= hasher(v.position[1]) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= hasher(v.position[0]) + 0x9e3779b9 + (seed<<6) + (seed>>2); seed ^= hasher(v.position[2]) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= hasher(v.position[1]) + 0x9e3779b9 + (seed<<6) + (seed>>2); return seed;
seed ^= hasher(v.position[2]) + 0x9e3779b9 + (seed<<6) + (seed>>2); }
return seed;
}
}; };
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, RAW_SHADING_MODEL_BLINN,
RAW_SHADING_MODEL_BLINN, RAW_SHADING_MODEL_PHONG,
RAW_SHADING_MODEL_PHONG, RAW_SHADING_MODEL_PBR_MET_ROUGH,
RAW_SHADING_MODEL_PBR_MET_ROUGH, RAW_SHADING_MODEL_MAX
RAW_SHADING_MODEL_MAX
}; };
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, RAW_TEXTURE_USAGE_NORMAL,
RAW_TEXTURE_USAGE_NORMAL, RAW_TEXTURE_USAGE_SPECULAR,
RAW_TEXTURE_USAGE_SPECULAR, RAW_TEXTURE_USAGE_SHININESS,
RAW_TEXTURE_USAGE_SHININESS, RAW_TEXTURE_USAGE_EMISSIVE,
RAW_TEXTURE_USAGE_EMISSIVE, RAW_TEXTURE_USAGE_REFLECTION,
RAW_TEXTURE_USAGE_REFLECTION, RAW_TEXTURE_USAGE_ALBEDO,
RAW_TEXTURE_USAGE_ALBEDO, RAW_TEXTURE_USAGE_OCCLUSION,
RAW_TEXTURE_USAGE_OCCLUSION, RAW_TEXTURE_USAGE_ROUGHNESS,
RAW_TEXTURE_USAGE_ROUGHNESS, RAW_TEXTURE_USAGE_METALLIC,
RAW_TEXTURE_USAGE_METALLIC, 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:
case RAW_TEXTURE_USAGE_NONE: return "<none>"; return "<none>";
case RAW_TEXTURE_USAGE_AMBIENT: return "ambient"; case RAW_TEXTURE_USAGE_AMBIENT:
case RAW_TEXTURE_USAGE_DIFFUSE: return "diffuse"; return "ambient";
case RAW_TEXTURE_USAGE_NORMAL: return "normal"; case RAW_TEXTURE_USAGE_DIFFUSE:
case RAW_TEXTURE_USAGE_SPECULAR: return "specular"; return "diffuse";
case RAW_TEXTURE_USAGE_SHININESS: return "shininess"; case RAW_TEXTURE_USAGE_NORMAL:
case RAW_TEXTURE_USAGE_EMISSIVE: return "emissive"; return "normal";
case RAW_TEXTURE_USAGE_REFLECTION: return "reflection"; case RAW_TEXTURE_USAGE_SPECULAR:
case RAW_TEXTURE_USAGE_OCCLUSION: return "occlusion"; return "specular";
case RAW_TEXTURE_USAGE_ROUGHNESS: return "roughness"; case RAW_TEXTURE_USAGE_SHININESS:
case RAW_TEXTURE_USAGE_METALLIC: return "metallic"; return "shininess";
case RAW_TEXTURE_USAGE_MAX:default: return "unknown"; 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, struct RawTexture {
RAW_TEXTURE_OCCLUSION_TRANSPARENT std::string name; // logical name in FBX file
int width;
int height;
int mipLevels;
RawTextureUsage usage;
RawTextureOcclusion occlusion;
std::string fileName; // original filename in FBX file
std::string fileLocation; // inferred path in local filesystem, or ""
}; };
struct RawTexture enum RawMaterialType {
{ RAW_MATERIAL_TYPE_OPAQUE,
std::string name; // logical name in FBX file RAW_MATERIAL_TYPE_TRANSPARENT,
int width; RAW_MATERIAL_TYPE_SKINNED_OPAQUE,
int height; RAW_MATERIAL_TYPE_SKINNED_TRANSPARENT,
int mipLevels;
RawTextureUsage usage;
RawTextureOcclusion occlusion;
std::string fileName; // original filename in FBX file
std::string fileLocation; // inferred path in local filesystem, or ""
};
enum RawMaterialType
{
RAW_MATERIAL_TYPE_OPAQUE,
RAW_MATERIAL_TYPE_TRANSPARENT,
RAW_MATERIAL_TYPE_SKINNED_OPAQUE,
RAW_MATERIAL_TYPE_SKINNED_TRANSPARENT,
}; };
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 {
RawTraditionalMatProps( RawTraditionalMatProps(
RawShadingModel shadingModel, RawShadingModel shadingModel,
const Vec3f &&ambientFactor, const Vec3f&& ambientFactor,
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;
const Vec3f emissiveFactor; const Vec3f emissiveFactor;
const Vec3f specularFactor; const Vec3f specularFactor;
const float shininess; const float shininess;
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 && shininess == typed.shininess;
emissiveFactor == typed.emissiveFactor &&
shininess == typed.shininess;
}
return false;
} }
return false;
}
}; };
struct RawMetRoughMatProps : RawMatProps { struct RawMetRoughMatProps : RawMatProps {
RawMetRoughMatProps( RawMetRoughMatProps(
RawShadingModel shadingModel, RawShadingModel shadingModel,
const Vec4f &&diffuseFactor, const Vec4f&& diffuseFactor,
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; const float metallic;
const float metallic; const float roughness;
const float roughness;
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 && roughness == typed.roughness;
metallic == typed.metallic &&
roughness == typed.roughness;
}
return false;
} }
return false;
}
}; };
struct RawMaterial {
struct RawMaterial std::string name;
{ RawMaterialType type;
std::string name; std::shared_ptr<RawMatProps> info;
RawMaterialType type; int textures[RAW_TEXTURE_USAGE_MAX];
std::shared_ptr<RawMatProps> info; std::vector<std::string> userProperties;
int textures[RAW_TEXTURE_USAGE_MAX];
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; float intensity;
float intensity; float innerConeAngle; // only meaningful for spot
float innerConeAngle; // only meaningful for spot 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. Bounds<float, 3> bounds;
Bounds<float, 3> bounds; std::vector<long> jointIds;
std::vector<long> jointIds; std::vector<Vec3f> jointGeometryMins;
std::vector<Vec3f> jointGeometryMins; std::vector<Vec3f> jointGeometryMaxs;
std::vector<Vec3f> jointGeometryMaxs; std::vector<Mat4f> inverseBindMatrices;
std::vector<Mat4f> inverseBindMatrices; std::vector<RawBlendChannel> blendChannels;
std::vector<RawBlendChannel> blendChannels; 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; std::vector<Vec3f> scales;
std::vector<Vec3f> scales; 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; float nearZ;
float nearZ; float farZ;
float farZ; } perspective;
} perspective;
struct struct {
{ float magX;
float magX; float magY;
float magY; float nearZ;
float nearZ; float farZ;
float farZ; } orthographic;
} orthographic;
}; };
struct RawNode struct RawNode {
{ bool isJoint;
bool isJoint; long id;
long id; std::string name;
std::string name; long parentId;
long parentId; std::vector<long> childIds;
std::vector<long> childIds; Vec3f translation;
Vec3f translation; Quatf rotation;
Quatf rotation; Vec3f scale;
Vec3f scale; long surfaceId;
long surfaceId; long lightIx;
long lightIx; 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,
int AddMaterial(const RawMaterial &material); const int v1,
int AddMaterial( const int v2,
const char *name, const RawMaterialType materialType, const int textures[RAW_TEXTURE_USAGE_MAX], const int materialIndex,
std::shared_ptr<RawMatProps> materialInfo, const std::vector<std::string>& userProperties); const int surfaceIndex);
int AddLight(const char *name, RawLightType lightType, Vec3f color, float intensity, int AddTexture(
float innerConeAngle, float outerConeAngle); const std::string& name,
int AddSurface(const RawSurface &suface); const std::string& fileName,
int AddSurface(const char *name, long surfaceId); const std::string& fileLocation,
int AddAnimation(const RawAnimation &animation); RawTextureUsage usage);
int AddCameraPerspective( int AddMaterial(const RawMaterial& material);
const char *name, const long nodeId, const float aspectRatio, const float fovDegreesX, const float fovDegreesY, int AddMaterial(
const float nearZ, const float farZ); const char* name,
int const RawMaterialType materialType,
AddCameraOrthographic(const char *name, const long nodeId, const float magX, const float magY, const float nearZ, const float farZ); const int textures[RAW_TEXTURE_USAGE_MAX],
int AddNode(const RawNode &node); std::shared_ptr<RawMatProps> materialInfo,
int AddNode(const long id, const char *name, const long parentId); const std::vector<std::string>& userProperties);
void SetRootNode(const long nodeId) { rootNodeId = nodeId; } int AddLight(
const long GetRootNode() const { return rootNodeId; } const char* name,
RawLightType lightType,
Vec3f color,
float intensity,
float innerConeAngle,
float outerConeAngle);
int AddSurface(const RawSurface& suface);
int AddSurface(const char* name, long surfaceId);
int AddAnimation(const RawAnimation& animation);
int AddCameraPerspective(
const char* name,
const long nodeId,
const float aspectRatio,
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 long id, const char* name, const long parentId);
void SetRootNode(const long nodeId) {
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,
void Condense(); // materials or surfaces.
void Condense();
void TransformGeometry(ComputeNormalsOption); void TransformGeometry(ComputeNormalsOption);
void TransformTextures(const std::vector<std::function<Vec2f(Vec2f)>> &transforms); void TransformTextures(const std::vector<std::function<Vec2f(Vec2f)>>& transforms);
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]; } }
int GetSurfaceById(const long id) const; const RawSurface& GetSurface(const int index) const {
return surfaces[index];
}
RawSurface& GetSurface(const int index) {
return surfaces[index];
}
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]; } }
int GetNodeById(const long nodeId) const; const RawNode& GetNode(const int index) const {
return nodes[index];
}
RawNode& GetNode(const int index) {
return nodes[index];
}
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;
long rootNodeId; long rootNodeId;
int vertexAttributes; int vertexAttributes;
std::unordered_map<RawVertex, int, VertexHasher> vertexHash; std::unordered_map<RawVertex, int, VertexHasher> vertexHash;
std::vector<RawVertex> vertices; std::vector<RawVertex> vertices;
std::vector<RawTriangle> triangles; std::vector<RawTriangle> triangles;
std::vector<RawTexture> textures; std::vector<RawTexture> textures;
std::vector<RawMaterial> materials; std::vector<RawMaterial> materials;
std::vector<RawLight> lights; std::vector<RawLight> lights;
std::vector<RawSurface> surfaces; std::vector<RawSurface> surfaces;
std::vector<RawAnimation> animations; std::vector<RawAnimation> animations;
std::vector<RawCamera> cameras; std::vector<RawCamera> cameras;
std::vector<RawNode> nodes; std::vector<RawNode> nodes;
}; };
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,
out.resize(vertices.size()); const _attrib_type_ RawVertex::*ptr) const {
for (size_t i = 0; i < vertices.size(); i++) { out.resize(vertices.size());
out[i] = vertices[i].*ptr; for (size_t i = 0; i < vertices.size(); i++) {
} out[i] = vertices[i].*ptr;
}
} }

354
src/utils/File_Utils.cpp
View File

@ -9,24 +9,24 @@
#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)
#elif defined( _WIN32 ) #elif defined(_WIN32)
#include <direct.h> #include <direct.h>
#include <process.h> #include <process.h>
#else #else
@ -41,176 +41,174 @@
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(); }
} cwd[sizeof(cwd) - 1] = '\0';
cwd[sizeof(cwd) - 1] = '\0'; StringUtils::GetCleanPath(cwd, cwd, StringUtils::PATH_UNIX);
StringUtils::GetCleanPath(cwd, cwd, StringUtils::PATH_UNIX); const size_t length = strlen(cwd);
const size_t length = strlen(cwd); if (cwd[length - 1] != '/' && length < StringUtils::MAX_PATH_LENGTH - 1) {
if (cwd[length - 1] != '/' && length < StringUtils::MAX_PATH_LENGTH - 1) { cwd[length + 0] = '/';
cwd[length + 0] = '/'; cwd[length + 1] = '\0';
cwd[length + 1] = '\0'; }
} return std::string(cwd);
return std::string(cwd);
}
bool FileExists(const std::string &filePath)
{
std::ifstream stream(filePath);
return stream.good();
}
bool FolderExists(const std::string &folderPath)
{
#if defined( __unix__ ) || defined( __APPLE__ )
DIR *dir = opendir(folderPath.c_str());
if (dir) {
closedir(dir);
return true;
}
return false;
#else
const DWORD ftyp = GetFileAttributesA( folderPath.c_str() );
if ( ftyp == INVALID_FILE_ATTRIBUTES )
{
return false; // bad path
}
return ( ftyp & FILE_ATTRIBUTE_DIRECTORY ) != 0;
#endif
}
bool MatchExtension(const char *fileExtension, const char *matchExtensions)
{
if (matchExtensions[0] == '\0') {
return true;
}
if (fileExtension[0] == '.') {
fileExtension++;
}
for (const char *end = matchExtensions; end[0] != '\0';) {
for (; end[0] == ';'; end++) {}
const char *ext = end;
for (; end[0] != ';' && end[0] != '\0'; end++) {}
#if defined( __unix__ ) || defined( __APPLE__ )
if (strncasecmp(fileExtension, ext, end - ext) == 0)
#else
if ( _strnicmp( fileExtension, ext, end - ext ) == 0 )
#endif
{
return true;
}
}
return false;
}
std::vector<std::string> ListFolderFiles(const char *folder, const char *matchExtensions)
{
std::vector<std::string> fileList;
#if defined( __unix__ ) || defined( __APPLE__ )
DIR *dir = opendir(strlen(folder) > 0 ? folder : ".");
if (dir != nullptr) {
for (;;) {
struct dirent *dp = readdir(dir);
if (dp == nullptr) {
break;
}
if (dp->d_type == DT_DIR) {
continue;
}
const char *fileName = dp->d_name;
const char *fileExt = strrchr(fileName, '.');
if (!fileExt || !MatchExtension(fileExt, matchExtensions)) {
continue;
}
fileList.emplace_back(fileName);
}
closedir(dir);
}
#else
std::string pathStr = folder;
pathStr += "*";
WIN32_FIND_DATA FindFileData;
HANDLE hFind = FindFirstFile( pathStr.c_str(), &FindFileData );
if ( hFind != INVALID_HANDLE_VALUE )
{
do
{
if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
std::string fileName = FindFileData.cFileName;
std::string::size_type extPos = fileName.rfind('.');
if (extPos != std::string::npos &&
MatchExtension(fileName.substr(extPos + 1).c_str(), matchExtensions)) {
fileList.push_back(fileName);
}
}
} while ( FindNextFile( hFind, &FindFileData ) );
FindClose( hFind );
}
#endif
return fileList;
}
bool CreatePath(const char *path)
{
#if defined( __unix__ ) || defined( __APPLE__ )
StringUtils::PathSeparator separator = StringUtils::PATH_UNIX;
#else
StringUtils::PathSeparator separator = StringUtils::PATH_WIN;
#endif
std::string folder = StringUtils::GetFolderString(path);
std::string clean = StringUtils::GetCleanPathString(folder, separator);
std::string build = clean;
for (int i = 0; i < clean.length(); i ++) {
if (clean[i] == separator && i > 0) {
build[i] = '\0';
if (i > 1 || build[1] != ':') {
if (_mkdir(build.c_str()) != 0 && errno != EEXIST) {
return false;
}
}
}
build[i] = clean[i];
}
return true;
}
bool CopyFile(const std::string &srcFilename, const std::string &dstFilename, bool createPath) {
std::ifstream srcFile(srcFilename, std::ios::binary);
if (!srcFile) {
fmt::printf("Warning: Couldn't open file %s for reading.\n", srcFilename);
return false;
}
// find source file length
srcFile.seekg(0, std::ios::end);
std::streamsize srcSize = srcFile.tellg();
srcFile.seekg(0, std::ios::beg);
if (createPath && !CreatePath(dstFilename.c_str())) {
fmt::printf("Warning: Couldn't create directory %s.\n", dstFilename);
return false;
}
std::ofstream dstFile(dstFilename, std::ios::binary | std::ios::trunc);
if (!dstFile) {
fmt::printf("Warning: Couldn't open file %s for writing.\n", dstFilename);
return false;
}
dstFile << srcFile.rdbuf();
std::streamsize dstSize = dstFile.tellp();
if (srcSize == dstSize) {
return true;
}
fmt::printf("Warning: Only copied %lu bytes to %s, when %s is %lu bytes long.\n", dstSize, dstFilename, srcFilename, srcSize);
return false;
}
} }
bool FileExists(const std::string& filePath) {
std::ifstream stream(filePath);
return stream.good();
}
bool FolderExists(const std::string& folderPath) {
#if defined(__unix__) || defined(__APPLE__)
DIR* dir = opendir(folderPath.c_str());
if (dir) {
closedir(dir);
return true;
}
return false;
#else
const DWORD ftyp = GetFileAttributesA(folderPath.c_str());
if (ftyp == INVALID_FILE_ATTRIBUTES) {
return false; // bad path
}
return (ftyp & FILE_ATTRIBUTE_DIRECTORY) != 0;
#endif
}
bool MatchExtension(const char* fileExtension, const char* matchExtensions) {
if (matchExtensions[0] == '\0') {
return true;
}
if (fileExtension[0] == '.') {
fileExtension++;
}
for (const char* end = matchExtensions; end[0] != '\0';) {
for (; end[0] == ';'; end++) {
}
const char* ext = end;
for (; end[0] != ';' && end[0] != '\0'; end++) {
}
#if defined(__unix__) || defined(__APPLE__)
if (strncasecmp(fileExtension, ext, end - ext) == 0)
#else
if (_strnicmp(fileExtension, ext, end - ext) == 0)
#endif
{
return true;
}
}
return false;
}
std::vector<std::string> ListFolderFiles(const char* folder, const char* matchExtensions) {
std::vector<std::string> fileList;
#if defined(__unix__) || defined(__APPLE__)
DIR* dir = opendir(strlen(folder) > 0 ? folder : ".");
if (dir != nullptr) {
for (;;) {
struct dirent* dp = readdir(dir);
if (dp == nullptr) {
break;
}
if (dp->d_type == DT_DIR) {
continue;
}
const char* fileName = dp->d_name;
const char* fileExt = strrchr(fileName, '.');
if (!fileExt || !MatchExtension(fileExt, matchExtensions)) {
continue;
}
fileList.emplace_back(fileName);
}
closedir(dir);
}
#else
std::string pathStr = folder;
pathStr += "*";
WIN32_FIND_DATA FindFileData;
HANDLE hFind = FindFirstFile(pathStr.c_str(), &FindFileData);
if (hFind != INVALID_HANDLE_VALUE) {
do {
if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) {
std::string fileName = FindFileData.cFileName;
std::string::size_type extPos = fileName.rfind('.');
if (extPos != std::string::npos &&
MatchExtension(fileName.substr(extPos + 1).c_str(), matchExtensions)) {
fileList.push_back(fileName);
}
}
} while (FindNextFile(hFind, &FindFileData));
FindClose(hFind);
}
#endif
return fileList;
}
bool CreatePath(const char* path) {
#if defined(__unix__) || defined(__APPLE__)
StringUtils::PathSeparator separator = StringUtils::PATH_UNIX;
#else
StringUtils::PathSeparator separator = StringUtils::PATH_WIN;
#endif
std::string folder = StringUtils::GetFolderString(path);
std::string clean = StringUtils::GetCleanPathString(folder, separator);
std::string build = clean;
for (int i = 0; i < clean.length(); i++) {
if (clean[i] == separator && i > 0) {
build[i] = '\0';
if (i > 1 || build[1] != ':') {
if (_mkdir(build.c_str()) != 0 && errno != EEXIST) {
return false;
}
}
}
build[i] = clean[i];
}
return true;
}
bool CopyFile(const std::string& srcFilename, const std::string& dstFilename, bool createPath) {
std::ifstream srcFile(srcFilename, std::ios::binary);
if (!srcFile) {
fmt::printf("Warning: Couldn't open file %s for reading.\n", srcFilename);
return false;
}
// find source file length
srcFile.seekg(0, std::ios::end);
std::streamsize srcSize = srcFile.tellg();
srcFile.seekg(0, std::ios::beg);
if (createPath && !CreatePath(dstFilename.c_str())) {
fmt::printf("Warning: Couldn't create directory %s.\n", dstFilename);
return false;
}
std::ofstream dstFile(dstFilename, std::ios::binary | std::ios::trunc);
if (!dstFile) {
fmt::printf("Warning: Couldn't open file %s for writing.\n", dstFilename);
return false;
}
dstFile << srcFile.rdbuf();
std::streamsize dstSize = dstFile.tellp();
if (srcSize == dstSize) {
return true;
}
fmt::printf(
"Warning: Only copied %lu bytes to %s, when %s is %lu bytes long.\n",
dstSize,
dstFilename,
srcFilename,
srcSize);
return false;
}
} // namespace FileUtils

19
src/utils/File_Utils.hpp
View File

@ -14,15 +14,18 @@
namespace FileUtils { namespace FileUtils {
std::string GetCurrentFolder(); std::string GetCurrentFolder();
bool FileExists(const std::string &folderPath); bool FileExists(const std::string& folderPath);
bool FolderExists(const std::string &folderPath); bool FolderExists(const std::string& folderPath);
bool MatchExtension(const char *fileExtension, const char *matchExtensions); bool MatchExtension(const char* fileExtension, const char* matchExtensions);
std::vector<std::string> ListFolderFiles(const char *folder, const char *matchExtensions); std::vector<std::string> ListFolderFiles(const char* folder, const char* matchExtensions);
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

101
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,56 +22,53 @@
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); if (pixels != nullptr) {
if (pixels != nullptr) { int pixelCount = width * height;
int pixelCount = width * height; for (int ix = 0; ix < pixelCount; ix++) {
for (int ix = 0; ix < pixelCount; ix++) { // test fourth byte (alpha); 255 is 1.0
// test fourth byte (alpha); 255 is 1.0 if (pixels[4 * ix + 3] != 255) {
if (pixels[4 * ix + 3] != 255) { return true;
return true; }
}
}
}
return false;
} }
}
ImageProperties GetImageProperties(char const *filePath) return false;
{
ImageProperties result = {
1,
1,
IMAGE_OPAQUE,
};
FILE *f = fopen(filePath, "rb");
if (f == nullptr) {
return result;
}
int channels;
int success = stbi_info_from_file(f, &result.width, &result.height, &channels);
if (success && channels == 4 && imageHasTransparentPixels(f)) {
result.occlusion = IMAGE_TRANSPARENT;
}
return result;
}
std::string suffixToMimeType(std::string suffix)
{
std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
if (suffix == "jpg" || suffix == "jpeg") {
return "image/jpeg";
}
if (suffix == "png") {
return "image/png";
}
return "image/unknown";
}
} }
ImageProperties GetImageProperties(char const* filePath) {
ImageProperties result = {
1,
1,
IMAGE_OPAQUE,
};
FILE* f = fopen(filePath, "rb");
if (f == nullptr) {
return result;
}
int channels;
int success = stbi_info_from_file(f, &result.width, &result.height, &channels);
if (success && channels == 4 && imageHasTransparentPixels(f)) {
result.occlusion = IMAGE_TRANSPARENT;
}
return result;
}
std::string suffixToMimeType(std::string suffix) {
std::transform(suffix.begin(), suffix.end(), suffix.begin(), ::tolower);
if (suffix == "jpg" || suffix == "jpeg") {
return "image/jpeg";
}
if (suffix == "png") {
return "image/png";
}
return "image/unknown";
}
} // namespace ImageUtils

31
src/utils/Image_Utils.hpp
View File

@ -13,25 +13,20 @@
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; };
};
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

139
src/utils/String_Utils.cpp
View File

@ -11,77 +11,70 @@
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;
}
PathSeparator GetPathSeparator() {
#if defined( __unix__ ) || defined( __APPLE__ )
return PATH_UNIX;
#else
return PATH_WIN;
#endif
}
const std::string NormalizePath(const std::string &path)
{
PathSeparator separator = GetPathSeparator();
char replace;
if (separator == PATH_WIN) {
replace = PATH_UNIX;
}
else {
replace = PATH_WIN;
}
std::string normalizedPath = path;
for (size_t s = normalizedPath.find(replace, 0); s != std::string::npos; s = normalizedPath.find(replace, s)) {
normalizedPath[s] = separator;
}
return normalizedPath;
}
const std::string GetFolderString(const std::string &path)
{
size_t s = path.rfind(PATH_WIN);
s = (s != std::string::npos) ? s : path.rfind(PATH_UNIX);
return path.substr(0, s + 1);
}
const std::string GetCleanPathString(const std::string &path, const PathSeparator separator)
{
std::string cleanPath = path;
for (size_t s = cleanPath.find(!separator, 0); s != std::string::npos; s = cleanPath.find(!separator, s)) {
cleanPath[s] = separator;
}
return cleanPath;
}
const std::string GetFileNameString(const std::string &path)
{
size_t s = path.rfind(PATH_WIN);
s = (s != std::string::npos) ? s : path.rfind(PATH_UNIX);
return path.substr(s + 1, std::string::npos);
}
const std::string GetFileBaseString(const std::string &path)
{
const std::string fileName = GetFileNameString(path);
return fileName.substr(0, fileName.rfind('.')).c_str();
}
const std::string GetFileSuffixString(const std::string &path)
{
const std::string fileName = GetFileNameString(path);
size_t pos = fileName.rfind('.');
if (pos == std::string::npos) {
return "";
}
return fileName.substr(++pos);
}
int CompareNoCase(const std::string &s1, const std::string &s2)
{
return strncasecmp(s1.c_str(), s2.c_str(), MAX_PATH_LENGTH);
}
} }
PathSeparator GetPathSeparator() {
#if defined(__unix__) || defined(__APPLE__)
return PATH_UNIX;
#else
return PATH_WIN;
#endif
}
const std::string NormalizePath(const std::string& path) {
PathSeparator separator = GetPathSeparator();
char replace;
if (separator == PATH_WIN) {
replace = PATH_UNIX;
} else {
replace = PATH_WIN;
}
std::string normalizedPath = path;
for (size_t s = normalizedPath.find(replace, 0); s != std::string::npos;
s = normalizedPath.find(replace, s)) {
normalizedPath[s] = separator;
}
return normalizedPath;
}
const std::string GetFolderString(const std::string& path) {
size_t s = path.rfind(PATH_WIN);
s = (s != std::string::npos) ? s : path.rfind(PATH_UNIX);
return path.substr(0, s + 1);
}
const std::string GetCleanPathString(const std::string& path, const PathSeparator separator) {
std::string cleanPath = path;
for (size_t s = cleanPath.find(!separator, 0); s != std::string::npos;
s = cleanPath.find(!separator, s)) {
cleanPath[s] = separator;
}
return cleanPath;
}
const std::string GetFileNameString(const std::string& path) {
size_t s = path.rfind(PATH_WIN);
s = (s != std::string::npos) ? s : path.rfind(PATH_UNIX);
return path.substr(s + 1, std::string::npos);
}
const std::string GetFileBaseString(const std::string& path) {
const std::string fileName = GetFileNameString(path);
return fileName.substr(0, fileName.rfind('.')).c_str();
}
const std::string GetFileSuffixString(const std::string& path) {
const std::string fileName = GetFileNameString(path);
size_t pos = fileName.rfind('.');
if (pos == std::string::npos) {
return "";
}
return fileName.substr(++pos);
}
int CompareNoCase(const std::string& s1, const std::string& s2) {
return strncasecmp(s1.c_str(), s2.c_str(), MAX_PATH_LENGTH);
}
} // namespace StringUtils

59
src/utils/String_Utils.hpp
View File

@ -9,49 +9,46 @@
#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
#define strcasecmp _stricmp #define strcasecmp _stricmp
#endif #endif
namespace StringUtils { 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,
template<size_t size> const PathSeparator separator = PATH_WIN);
void GetCleanPath(char (&dest)[size], const char *path, const PathSeparator separator = PATH_WIN)
{
size_t len = size - 1;
strncpy(dest, path, len);
char *destPtr = dest;
while ((destPtr = strchr(destPtr, !separator)) != nullptr) {
*destPtr = separator;
}
}
const std::string GetFolderString(const std::string &path);
const std::string GetFileNameString(const std::string &path);
const std::string GetFileBaseString(const std::string &path);
const std::string GetFileSuffixString(const std::string &path);
int CompareNoCase(const std::string &s1, const std::string &s2);
template <size_t size>
void GetCleanPath(char (&dest)[size], const char* path, const PathSeparator separator = PATH_WIN) {
size_t len = size - 1;
strncpy(dest, path, len);
char* destPtr = dest;
while ((destPtr = strchr(destPtr, !separator)) != nullptr) {
*destPtr = separator;
}
} }
const std::string GetFolderString(const std::string& path);
const std::string GetFileNameString(const std::string& path);
const std::string GetFileBaseString(const std::string& path);
const std::string GetFileSuffixString(const std::string& path);
int CompareNoCase(const std::string& s1, const std::string& s2);
} // namespace StringUtils