948 lines
33 KiB
C++
948 lines
33 KiB
C++
/*
|
|
Nazara Engine - Assimp Plugin
|
|
|
|
Copyright (C) 2015 Jérôme "Lynix" Leclercq (lynix680@gmail.com)
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
|
this software and associated documentation files (the "Software"), to deal in
|
|
the Software without restriction, including without limitation the rights to
|
|
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
of the Software, and to permit persons to whom the Software is furnished to do
|
|
so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
SOFTWARE.
|
|
*/
|
|
|
|
#include <CustomStream.hpp>
|
|
#include <Nazara/Utils/CallOnExit.hpp>
|
|
#include <Nazara/Core/Error.hpp>
|
|
#include <Nazara/Utility/Animation.hpp>
|
|
#include <Nazara/Utility/Mesh.hpp>
|
|
#include <Nazara/Utility/IndexIterator.hpp>
|
|
#include <Nazara/Utility/IndexMapper.hpp>
|
|
#include <Nazara/Utility/Joint.hpp>
|
|
#include <Nazara/Utility/MaterialData.hpp>
|
|
#include <Nazara/Utility/Sequence.hpp>
|
|
#include <Nazara/Utility/SkeletalMesh.hpp>
|
|
#include <Nazara/Utility/Skeleton.hpp>
|
|
#include <Nazara/Utility/StaticMesh.hpp>
|
|
#include <Nazara/Utility/VertexMapper.hpp>
|
|
#include <Nazara/Utility/Utility.hpp>
|
|
#include <assimp/cfileio.h>
|
|
#include <assimp/cimport.h>
|
|
#include <assimp/config.h>
|
|
#include <assimp/mesh.h>
|
|
#include <assimp/postprocess.h>
|
|
#include <assimp/scene.h>
|
|
#include <limits>
|
|
#include <unordered_map>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
|
|
struct SceneInfo
|
|
{
|
|
struct Node
|
|
{
|
|
const aiNode* node;
|
|
std::size_t totalChildrenCount;
|
|
};
|
|
|
|
struct SkeletalMesh
|
|
{
|
|
const aiMesh* mesh;
|
|
std::size_t nodeIndex;
|
|
std::size_t skeletonRootIndex;
|
|
std::unordered_map<std::string, unsigned int> bones;
|
|
};
|
|
|
|
struct StaticMesh
|
|
{
|
|
const aiMesh* mesh;
|
|
std::size_t nodeIndex;
|
|
};
|
|
|
|
std::unordered_multimap<std::string, std::size_t> nodeByName;
|
|
std::vector<Node> nodes;
|
|
std::vector<SkeletalMesh> skeletalMeshes;
|
|
std::vector<StaticMesh> staticMeshes;
|
|
};
|
|
|
|
void VisitNodes(SceneInfo& sceneInfo, const aiScene* scene, const aiNode* node)
|
|
{
|
|
std::size_t nodeIndex = sceneInfo.nodes.size();
|
|
sceneInfo.nodeByName.emplace(node->mName.C_Str(), nodeIndex);
|
|
auto& sceneNode = sceneInfo.nodes.emplace_back();
|
|
sceneNode.node = node;
|
|
|
|
for (unsigned int i = 0; i < node->mNumMeshes; ++i)
|
|
{
|
|
const aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
|
|
if (mesh->HasBones())
|
|
{
|
|
auto& skeletalMesh = sceneInfo.skeletalMeshes.emplace_back();
|
|
skeletalMesh.mesh = mesh;
|
|
skeletalMesh.nodeIndex = nodeIndex;
|
|
|
|
for (unsigned int boneIndex = 0; boneIndex < mesh->mNumBones; ++boneIndex)
|
|
skeletalMesh.bones.emplace(mesh->mBones[boneIndex]->mName.C_Str(), boneIndex);
|
|
}
|
|
else
|
|
{
|
|
auto& staticMesh = sceneInfo.staticMeshes.emplace_back();
|
|
staticMesh.mesh = mesh;
|
|
staticMesh.nodeIndex = nodeIndex;
|
|
}
|
|
}
|
|
|
|
std::size_t prevNodeCount = sceneInfo.nodes.size();
|
|
|
|
for (unsigned int i = 0; i < node->mNumChildren; ++i)
|
|
VisitNodes(sceneInfo, scene, node->mChildren[i]);
|
|
|
|
// Can't use sceneNode from there
|
|
|
|
sceneInfo.nodes[nodeIndex].totalChildrenCount = sceneInfo.nodes.size() - prevNodeCount;
|
|
}
|
|
|
|
bool FindSkeletonRoot(SceneInfo& sceneInfo, SceneInfo::SkeletalMesh& skeletalMesh, const aiNode* node)
|
|
{
|
|
if (skeletalMesh.bones.find(node->mName.C_Str()) != skeletalMesh.bones.end())
|
|
{
|
|
// Get to parents until there's only one child
|
|
while (node->mParent && node->mParent->mNumChildren != 1)
|
|
node = node->mParent;
|
|
|
|
/*if (!node->mParent && node->mNumChildren > 1)
|
|
{
|
|
NazaraError("failed to identify skeleton root node");
|
|
return false;
|
|
}*/
|
|
|
|
auto range = sceneInfo.nodeByName.equal_range(node->mName.C_Str());
|
|
if (std::distance(range.first, range.second) != 1)
|
|
{
|
|
NazaraError("failed to identify skeleton root node: " + std::to_string(std::distance(range.first, range.second)) + " node(s) matched");
|
|
return false;
|
|
}
|
|
|
|
skeletalMesh.skeletonRootIndex = range.first->second;
|
|
return true;
|
|
}
|
|
|
|
for (unsigned int i = 0; i < node->mNumChildren; ++i)
|
|
{
|
|
if (FindSkeletonRoot(sceneInfo, skeletalMesh, node->mChildren[i]))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ProcessJoints(const SceneInfo::SkeletalMesh& skeletalMesh, Nz::Skeleton* skeleton, const aiNode* node, std::size_t& jointIndex)
|
|
{
|
|
Nz::Joint* joint = skeleton->GetJoint(jointIndex);
|
|
joint->SetName(node->mName.C_Str());
|
|
|
|
if (jointIndex != 0)
|
|
joint->SetParent(skeleton->GetJoint(node->mParent->mName.C_Str()));
|
|
|
|
jointIndex++;
|
|
|
|
if (auto it = skeletalMesh.bones.find(node->mName.C_Str()); it != skeletalMesh.bones.end())
|
|
{
|
|
const aiBone* bone = skeletalMesh.mesh->mBones[it->second];
|
|
|
|
Nz::Matrix4f offsetMatrix(bone->mOffsetMatrix.a1, bone->mOffsetMatrix.b1, bone->mOffsetMatrix.c1, bone->mOffsetMatrix.d1,
|
|
bone->mOffsetMatrix.a2, bone->mOffsetMatrix.b2, bone->mOffsetMatrix.c2, bone->mOffsetMatrix.d2,
|
|
bone->mOffsetMatrix.a3, bone->mOffsetMatrix.b3, bone->mOffsetMatrix.c3, bone->mOffsetMatrix.d3,
|
|
bone->mOffsetMatrix.a4, bone->mOffsetMatrix.b4, bone->mOffsetMatrix.c4, bone->mOffsetMatrix.d4);
|
|
|
|
joint->SetInverseBindMatrix(offsetMatrix);
|
|
}
|
|
else
|
|
joint->SetInverseBindMatrix(Nz::Matrix4f::Identity());
|
|
|
|
for (unsigned int i = 0; i < node->mNumChildren; ++i)
|
|
ProcessJoints(skeletalMesh, skeleton, node->mChildren[i], jointIndex);
|
|
}
|
|
|
|
bool IsSupported(const std::string_view& extension)
|
|
{
|
|
std::string dotExt;
|
|
dotExt.reserve(extension.size() + 1);
|
|
dotExt += '.';
|
|
dotExt += extension;
|
|
|
|
return (aiIsExtensionSupported(dotExt.data()) == AI_TRUE);
|
|
}
|
|
|
|
Nz::Ternary CheckAnimation(Nz::Stream& /*stream*/, const Nz::AnimationParams& parameters)
|
|
{
|
|
bool skip;
|
|
if (parameters.custom.GetBooleanParameter("SkipAssimpLoader", &skip) && skip)
|
|
return Nz::Ternary::False;
|
|
|
|
return Nz::Ternary::Unknown;
|
|
}
|
|
|
|
std::shared_ptr<Nz::Animation> LoadAnimation(Nz::Stream& stream, const Nz::AnimationParams& parameters)
|
|
{
|
|
NazaraAssert(parameters.IsValid(), "invalid animation parameters");
|
|
|
|
std::string streamPath = Nz::PathToString(stream.GetPath());
|
|
|
|
FileIOUserdata userdata;
|
|
userdata.originalFilePath = (!streamPath.empty()) ? streamPath.data() : StreamPath;
|
|
userdata.originalStream = &stream;
|
|
|
|
aiFileIO fileIO;
|
|
fileIO.CloseProc = StreamCloser;
|
|
fileIO.OpenProc = StreamOpener;
|
|
fileIO.UserData = reinterpret_cast<char*>(&userdata);
|
|
|
|
unsigned int postProcess = aiProcess_CalcTangentSpace /*| aiProcess_Debone*/
|
|
| aiProcess_FindInvalidData | aiProcess_FixInfacingNormals
|
|
| aiProcess_FlipWindingOrder | aiProcess_GenSmoothNormals
|
|
| aiProcess_GenUVCoords | aiProcess_JoinIdenticalVertices
|
|
| aiProcess_LimitBoneWeights | aiProcess_MakeLeftHanded
|
|
/*| aiProcess_OptimizeGraph | aiProcess_OptimizeMeshes*/
|
|
| aiProcess_RemoveComponent | aiProcess_RemoveRedundantMaterials
|
|
| aiProcess_SortByPType | aiProcess_SplitLargeMeshes
|
|
| aiProcess_TransformUVCoords | aiProcess_Triangulate;
|
|
|
|
aiPropertyStore* properties = aiCreatePropertyStore();
|
|
aiSetImportPropertyInteger(properties, AI_CONFIG_PP_LBW_MAX_WEIGHTS, 4);
|
|
aiSetImportPropertyInteger(properties, AI_CONFIG_PP_SBP_REMOVE, ~aiPrimitiveType_TRIANGLE); //< We only want triangles
|
|
Nz::CallOnExit releaseProperties([&] { aiReleasePropertyStore(properties); });
|
|
|
|
const aiScene* scene = aiImportFileExWithProperties(userdata.originalFilePath, postProcess, &fileIO, properties);
|
|
Nz::CallOnExit releaseScene([&] { aiReleaseImport(scene); });
|
|
|
|
releaseProperties.CallAndReset();
|
|
|
|
if (!scene)
|
|
{
|
|
NazaraError("Assimp failed to import file: " + std::string(aiGetErrorString()));
|
|
return nullptr;
|
|
}
|
|
|
|
if (!scene->HasAnimations())
|
|
{
|
|
NazaraError("File has no animation");
|
|
return nullptr;
|
|
}
|
|
|
|
SceneInfo sceneInfo;
|
|
VisitNodes(sceneInfo, scene, scene->mRootNode);
|
|
|
|
const aiAnimation* animation = scene->mAnimations[0];
|
|
|
|
unsigned int maxFrameCount = 0;
|
|
for (unsigned int i = 0; i < animation->mNumChannels; ++i)
|
|
{
|
|
const aiNodeAnim* nodeAnim = animation->mChannels[i];
|
|
|
|
maxFrameCount = std::max({ maxFrameCount, nodeAnim->mNumPositionKeys, nodeAnim->mNumRotationKeys, nodeAnim->mNumScalingKeys });
|
|
}
|
|
|
|
std::shared_ptr<Nz::Animation> anim = std::make_shared<Nz::Animation>();
|
|
|
|
anim->CreateSkeletal(maxFrameCount, parameters.skeleton->GetJointCount());
|
|
|
|
Nz::Sequence sequence;
|
|
sequence.firstFrame = 0;
|
|
sequence.frameCount = maxFrameCount;
|
|
sequence.frameRate = (animation->mTicksPerSecond != 0.0) ? animation->mTicksPerSecond : 24.0;
|
|
|
|
anim->AddSequence(sequence);
|
|
|
|
for (unsigned int i = 0; i < animation->mNumChannels; ++i)
|
|
{
|
|
const aiNodeAnim* nodeAnim = animation->mChannels[i];
|
|
|
|
std::size_t jointIndex = parameters.skeleton->GetJointIndex(nodeAnim->mNodeName.C_Str());
|
|
if (jointIndex == Nz::Skeleton::InvalidJointIndex)
|
|
continue;
|
|
|
|
Nz::Vector3f currentPosition = Nz::Vector3f::Zero();
|
|
Nz::Vector3f currentScale = Nz::Vector3f::Unit();
|
|
Nz::Quaternionf currentRotation = Nz::Quaternionf::Identity();
|
|
|
|
unsigned int positionKeyIndex = std::numeric_limits<unsigned int>::max();
|
|
unsigned int rotationKeyIndex = std::numeric_limits<unsigned int>::max();
|
|
unsigned int scaleKeyIndex = std::numeric_limits<unsigned int>::max();
|
|
|
|
for (unsigned int frameIndex = 0; frameIndex < maxFrameCount; ++frameIndex)
|
|
{
|
|
double frameTime = frameIndex;
|
|
|
|
for (unsigned int nextPos = positionKeyIndex + 1; nextPos < nodeAnim->mNumPositionKeys; ++nextPos)
|
|
{
|
|
if (nodeAnim->mPositionKeys[nextPos].mTime > frameTime)
|
|
{
|
|
if (--nextPos != positionKeyIndex)
|
|
{
|
|
const aiVector3D& vec = nodeAnim->mPositionKeys[nextPos].mValue;
|
|
currentPosition = Nz::Vector3f(vec.x, vec.y, vec.z);
|
|
positionKeyIndex = nextPos;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (unsigned int nextRot = rotationKeyIndex + 1; nextRot < nodeAnim->mNumRotationKeys; ++nextRot)
|
|
{
|
|
if (nodeAnim->mRotationKeys[nextRot].mTime > frameTime)
|
|
{
|
|
if (--nextRot != rotationKeyIndex)
|
|
{
|
|
const aiQuaternion& rot = nodeAnim->mRotationKeys[nextRot].mValue;
|
|
currentRotation = Nz::Quaternionf(rot.w, rot.x, rot.y, rot.z);
|
|
rotationKeyIndex = nextRot;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// TODO: Scale
|
|
|
|
Nz::SequenceJoint* sequenceJoints = anim->GetSequenceJoints(frameIndex);
|
|
sequenceJoints[jointIndex].position = currentPosition;
|
|
sequenceJoints[jointIndex].rotation = currentRotation;
|
|
sequenceJoints[jointIndex].scale = currentScale;
|
|
}
|
|
}
|
|
|
|
Nz::Quaternionf rotationQuat = Nz::Quaternionf::Identity();
|
|
|
|
/*for (unsigned int i = 0; i < animation->mNumChannels; ++i)
|
|
{
|
|
const aiNodeAnim* nodeAnim = animation->mChannels[i];
|
|
|
|
unsigned int keyCount = std::max({ nodeAnim->mNumPositionKeys, nodeAnim->mNumRotationKeys, nodeAnim->mNumScalingKeys });
|
|
if (nodeAnim->mNumPositionKeys != keyCount && nodeAnim->mNumPositionKeys != 0)
|
|
NazaraWarning("expected at least one position key, got 0");
|
|
|
|
if (nodeAnim->mNumRotationKeys != keyCount && nodeAnim->mNumRotationKeys != 0)
|
|
NazaraWarning("expected at least one rotation key, got 0");
|
|
|
|
if (nodeAnim->mNumScalingKeys != keyCount && nodeAnim->mNumScalingKeys != 0)
|
|
NazaraWarning("expected at least one scaling key, got 0");
|
|
|
|
for (unsigned int j = 0; j < keyCount; ++j)
|
|
{
|
|
unsigned int posKey = std::min(j, nodeAnim->mNumPositionKeys - 1);
|
|
unsigned int rotKey = std::min(j, nodeAnim->mNumRotationKeys - 1);
|
|
unsigned int scaleKey = std::min(j, nodeAnim->mNumScalingKeys - 1);
|
|
|
|
aiQuaternion rotation = nodeAnim->mRotationKeys[posKey].mValue;
|
|
aiVector3D position = nodeAnim->mPositionKeys[rotKey].mValue;
|
|
aiVector3D scaling = nodeAnim->mScalingKeys[scaleKey].mValue;
|
|
|
|
Nz::SequenceJoint& sequenceJoint = sequenceJoints[i*animation->mNumChannels + j];
|
|
|
|
sequenceJoint.position = Nz::Vector3f(position.x, position.y, position.z);
|
|
sequenceJoint.rotation = Nz::Quaternionf(rotation.w, rotation.x, rotation.y, rotation.z);
|
|
sequenceJoint.scale = Nz::Vector3f(scaling.x, scaling.y, scaling.z);
|
|
}
|
|
}*/
|
|
|
|
return anim;
|
|
}
|
|
|
|
Nz::Ternary CheckMesh(Nz::Stream& /*stream*/, const Nz::MeshParams& parameters)
|
|
{
|
|
bool skip;
|
|
if (parameters.custom.GetBooleanParameter("SkipAssimpLoader", &skip) && skip)
|
|
return Nz::Ternary::False;
|
|
|
|
return Nz::Ternary::Unknown;
|
|
}
|
|
|
|
std::shared_ptr<Nz::Mesh> LoadMesh(Nz::Stream& stream, const Nz::MeshParams& parameters)
|
|
{
|
|
std::string streamPath = Nz::PathToString(stream.GetPath());
|
|
|
|
FileIOUserdata userdata;
|
|
userdata.originalFilePath = (!streamPath.empty()) ? streamPath.data() : StreamPath;
|
|
userdata.originalStream = &stream;
|
|
|
|
aiFileIO fileIO;
|
|
fileIO.CloseProc = StreamCloser;
|
|
fileIO.OpenProc = StreamOpener;
|
|
fileIO.UserData = reinterpret_cast<char*>(&userdata);
|
|
|
|
unsigned int postProcess = aiProcess_CalcTangentSpace /*| aiProcess_Debone*/
|
|
| aiProcess_FindInvalidData | aiProcess_FixInfacingNormals
|
|
| aiProcess_FlipWindingOrder | aiProcess_GenSmoothNormals
|
|
| aiProcess_GenUVCoords | aiProcess_JoinIdenticalVertices
|
|
| aiProcess_LimitBoneWeights | aiProcess_MakeLeftHanded
|
|
/*| aiProcess_OptimizeGraph | aiProcess_OptimizeMeshes*/
|
|
| aiProcess_RemoveComponent | aiProcess_RemoveRedundantMaterials
|
|
| aiProcess_SortByPType | aiProcess_SplitLargeMeshes
|
|
| aiProcess_TransformUVCoords | aiProcess_Triangulate;
|
|
|
|
if (parameters.optimizeIndexBuffers)
|
|
postProcess |= aiProcess_ImproveCacheLocality;
|
|
|
|
double smoothingAngle = 80.f;
|
|
parameters.custom.GetDoubleParameter("AssimpLoader_SmoothingAngle", &smoothingAngle);
|
|
|
|
long long triangleLimit = 1'000'000;
|
|
parameters.custom.GetIntegerParameter("AssimpLoader_TriangleLimit", &triangleLimit);
|
|
|
|
long long vertexLimit = 1'000'000;
|
|
parameters.custom.GetIntegerParameter("AssimpLoader_VertexLimit", &vertexLimit);
|
|
|
|
int excludedComponents = 0;
|
|
|
|
if (!parameters.vertexDeclaration->HasComponent(Nz::VertexComponent::Color))
|
|
excludedComponents |= aiComponent_COLORS;
|
|
|
|
if (!parameters.vertexDeclaration->HasComponent(Nz::VertexComponent::Normal))
|
|
excludedComponents |= aiComponent_NORMALS;
|
|
|
|
if (!parameters.vertexDeclaration->HasComponent(Nz::VertexComponent::Tangent))
|
|
excludedComponents |= aiComponent_TANGENTS_AND_BITANGENTS;
|
|
|
|
if (!parameters.vertexDeclaration->HasComponent(Nz::VertexComponent::TexCoord))
|
|
excludedComponents |= aiComponent_TEXCOORDS;
|
|
|
|
aiPropertyStore* properties = aiCreatePropertyStore();
|
|
Nz::CallOnExit releaseProperties([&] { aiReleasePropertyStore(properties); });
|
|
|
|
aiSetImportPropertyFloat(properties, AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE, float(smoothingAngle));
|
|
aiSetImportPropertyInteger(properties, AI_CONFIG_PP_LBW_MAX_WEIGHTS, 4);
|
|
aiSetImportPropertyInteger(properties, AI_CONFIG_PP_SBP_REMOVE, ~aiPrimitiveType_TRIANGLE); //< We only want triangles
|
|
aiSetImportPropertyInteger(properties, AI_CONFIG_PP_SLM_TRIANGLE_LIMIT, int(triangleLimit));
|
|
aiSetImportPropertyInteger(properties, AI_CONFIG_PP_SLM_VERTEX_LIMIT, int(vertexLimit));
|
|
aiSetImportPropertyInteger(properties, AI_CONFIG_PP_RVC_FLAGS, excludedComponents);
|
|
|
|
const aiScene* scene = aiImportFileExWithProperties(userdata.originalFilePath, postProcess, &fileIO, properties);
|
|
Nz::CallOnExit releaseScene([&] { aiReleaseImport(scene); });
|
|
|
|
releaseProperties.CallAndReset();
|
|
|
|
if (!scene)
|
|
{
|
|
NazaraError("Assimp failed to import file: " + std::string(aiGetErrorString()));
|
|
return nullptr;
|
|
}
|
|
|
|
SceneInfo sceneInfo;
|
|
VisitNodes(sceneInfo, scene, scene->mRootNode);
|
|
|
|
for (auto& skeletalMesh : sceneInfo.skeletalMeshes)
|
|
{
|
|
if (!FindSkeletonRoot(sceneInfo, skeletalMesh, scene->mRootNode))
|
|
return nullptr;
|
|
}
|
|
|
|
std::shared_ptr<Nz::Mesh> mesh = std::make_shared<Nz::Mesh>();
|
|
if (parameters.animated && !sceneInfo.skeletalMeshes.empty())
|
|
{
|
|
auto& skeletalMesh = sceneInfo.skeletalMeshes.front();
|
|
auto& skeletalRoot = sceneInfo.nodes[skeletalMesh.skeletonRootIndex];
|
|
|
|
mesh->CreateSkeletal(Nz::SafeCast<Nz::UInt32>(skeletalRoot.totalChildrenCount + 1));
|
|
|
|
Nz::Skeleton* skeleton = mesh->GetSkeleton();
|
|
|
|
std::size_t jointIndex = 0;
|
|
ProcessJoints(skeletalMesh, skeleton, skeletalRoot.node, jointIndex);
|
|
|
|
// aiMaterial index in scene => Material index and data in Mesh
|
|
std::unordered_map<unsigned int, std::pair<Nz::UInt32, Nz::ParameterList>> materials;
|
|
|
|
const aiMesh* iMesh = skeletalMesh.mesh;
|
|
|
|
unsigned int indexCount = iMesh->mNumFaces * 3;
|
|
unsigned int vertexCount = iMesh->mNumVertices;
|
|
|
|
// Index buffer
|
|
bool largeIndices = (vertexCount > std::numeric_limits<Nz::UInt16>::max());
|
|
|
|
std::shared_ptr<Nz::IndexBuffer> indexBuffer = std::make_shared<Nz::IndexBuffer>((largeIndices) ? Nz::IndexType::U32 : Nz::IndexType::U16, indexCount, parameters.indexBufferFlags, parameters.bufferFactory);
|
|
|
|
Nz::IndexMapper indexMapper(*indexBuffer);
|
|
Nz::IndexIterator index = indexMapper.begin();
|
|
|
|
for (unsigned int faceIndex = 0; faceIndex < iMesh->mNumFaces; ++faceIndex)
|
|
{
|
|
const aiFace& face = iMesh->mFaces[faceIndex];
|
|
if (face.mNumIndices != 3)
|
|
NazaraWarning("Assimp plugin: This face is not a triangle!");
|
|
|
|
*index++ = face.mIndices[0];
|
|
*index++ = face.mIndices[1];
|
|
*index++ = face.mIndices[2];
|
|
}
|
|
indexMapper.Unmap();
|
|
|
|
// Make sure the normal/tangent matrix won't rescale our vectors
|
|
Nz::Matrix4f normalTangentMatrix = parameters.matrix;
|
|
if (normalTangentMatrix.HasScale())
|
|
normalTangentMatrix.ApplyScale(1.f / normalTangentMatrix.GetScale());
|
|
|
|
std::shared_ptr<Nz::VertexBuffer> vertexBuffer = std::make_shared<Nz::VertexBuffer>(Nz::VertexDeclaration::Get(Nz::VertexLayout::XYZ_Normal_UV_Tangent_Skinning), vertexCount, parameters.vertexBufferFlags, parameters.bufferFactory);
|
|
|
|
Nz::VertexMapper vertexMapper(*vertexBuffer);
|
|
|
|
// Vertex positions
|
|
if (auto posPtr = vertexMapper.GetComponentPtr<Nz::Vector3f>(Nz::VertexComponent::Position))
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiVector3D position = iMesh->mVertices[vertexIdx];
|
|
*posPtr++ = parameters.matrix * Nz::Vector3f(position.x, position.y, position.z);
|
|
}
|
|
}
|
|
|
|
// Vertex normals
|
|
if (auto normalPtr = vertexMapper.GetComponentPtr<Nz::Vector3f>(Nz::VertexComponent::Normal))
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiVector3D normal = iMesh->mNormals[vertexIdx];
|
|
*normalPtr++ = normalTangentMatrix.Transform({ normal.x, normal.y, normal.z }, 0.f);
|
|
}
|
|
}
|
|
|
|
// Vertex tangents
|
|
bool generateTangents = false;
|
|
if (auto tangentPtr = vertexMapper.GetComponentPtr<Nz::Vector3f>(Nz::VertexComponent::Tangent))
|
|
{
|
|
if (iMesh->HasTangentsAndBitangents())
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiVector3D tangent = iMesh->mTangents[vertexIdx];
|
|
*tangentPtr++ = normalTangentMatrix.Transform({ tangent.x, tangent.y, tangent.z }, 0.f);
|
|
}
|
|
}
|
|
else
|
|
generateTangents = true;
|
|
}
|
|
|
|
// Vertex UVs
|
|
if (auto uvPtr = vertexMapper.GetComponentPtr<Nz::Vector2f>(Nz::VertexComponent::TexCoord))
|
|
{
|
|
if (iMesh->HasTextureCoords(0))
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiVector3D uv = iMesh->mTextureCoords[0][vertexIdx];
|
|
*uvPtr++ = parameters.texCoordOffset + Nz::Vector2f(uv.x, uv.y) * parameters.texCoordScale;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
*uvPtr++ = Nz::Vector2f::Zero();
|
|
}
|
|
}
|
|
|
|
// Vertex colors
|
|
if (auto colorPtr = vertexMapper.GetComponentPtr<Nz::Color>(Nz::VertexComponent::Color))
|
|
{
|
|
if (iMesh->HasVertexColors(0))
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiColor4D color = iMesh->mColors[0][vertexIdx];
|
|
*colorPtr++ = Nz::Color(color.r, color.g, color.b, color.a);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
*colorPtr++ = Nz::Color::White;
|
|
}
|
|
}
|
|
|
|
auto jointIndicesPtr = vertexMapper.GetComponentPtr<Vector4i32>(VertexComponent::JointIndices);
|
|
auto jointWeightPtr = vertexMapper.GetComponentPtr<Vector4f>(VertexComponent::JointWeights);
|
|
|
|
if (jointIndicesPtr || jointWeightPtr)
|
|
{
|
|
std::vector<std::size_t> weightIndices(iMesh->mNumVertices, 0);
|
|
|
|
for (unsigned int boneIndex = 0; boneIndex < iMesh->mNumBones; ++boneIndex)
|
|
{
|
|
aiBone* bone = iMesh->mBones[boneIndex];
|
|
for (unsigned int weightIndex = 0; weightIndex < bone->mNumWeights; ++weightIndex)
|
|
{
|
|
aiVertexWeight& vertexWeight = bone->mWeights[weightIndex];
|
|
|
|
std::size_t vertexWeightIndex = weightIndices[vertexWeight.mVertexId]++;
|
|
|
|
if (jointIndicesPtr)
|
|
jointIndicesPtr[vertexWeight.mVertexId][vertexWeightIndex] = boneIndex;
|
|
|
|
if (jointWeightPtr)
|
|
jointWeightPtr[vertexWeight.mVertexId][vertexWeightIndex] = vertexWeight.mWeight;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Submesh
|
|
std::shared_ptr<Nz::SkeletalMesh> subMesh = std::make_shared<Nz::SkeletalMesh>(vertexBuffer, indexBuffer);
|
|
subMesh->SetMaterialIndex(iMesh->mMaterialIndex);
|
|
|
|
auto matIt = materials.find(iMesh->mMaterialIndex);
|
|
if (matIt == materials.end())
|
|
{
|
|
Nz::ParameterList matData;
|
|
aiMaterial* aiMat = scene->mMaterials[iMesh->mMaterialIndex];
|
|
|
|
auto ConvertColor = [&](const char* aiKey, unsigned int aiType, unsigned int aiIndex, const char* colorKey)
|
|
{
|
|
aiColor4D color;
|
|
if (aiGetMaterialColor(aiMat, aiKey, aiType, aiIndex, &color) == aiReturn_SUCCESS)
|
|
{
|
|
matData.SetParameter(colorKey, Nz::Color(color.r, color.g, color.b, color.a));
|
|
}
|
|
};
|
|
|
|
auto ConvertTexture = [&](aiTextureType aiType, const char* textureKey, const char* wrapKey = nullptr)
|
|
{
|
|
aiString path;
|
|
aiTextureMapMode mapMode[3];
|
|
if (aiGetMaterialTexture(aiMat, aiType, 0, &path, nullptr, nullptr, nullptr, nullptr, &mapMode[0], nullptr) == aiReturn_SUCCESS)
|
|
{
|
|
matData.SetParameter(textureKey, (stream.GetDirectory() / std::string_view(path.data, path.length)).generic_u8string());
|
|
|
|
if (wrapKey)
|
|
{
|
|
Nz::SamplerWrap wrap = Nz::SamplerWrap::Clamp;
|
|
switch (mapMode[0])
|
|
{
|
|
case aiTextureMapMode_Clamp:
|
|
case aiTextureMapMode_Decal:
|
|
wrap = Nz::SamplerWrap::Clamp;
|
|
break;
|
|
|
|
case aiTextureMapMode_Mirror:
|
|
wrap = Nz::SamplerWrap::MirroredRepeat;
|
|
break;
|
|
|
|
case aiTextureMapMode_Wrap:
|
|
wrap = Nz::SamplerWrap::Repeat;
|
|
break;
|
|
|
|
default:
|
|
NazaraWarning("Assimp texture map mode 0x" + Nz::NumberToString(mapMode[0], 16) + " not handled");
|
|
break;
|
|
}
|
|
|
|
matData.SetParameter(wrapKey, static_cast<long long>(wrap));
|
|
}
|
|
}
|
|
};
|
|
|
|
ConvertColor(AI_MATKEY_COLOR_AMBIENT, Nz::MaterialData::AmbientColor);
|
|
ConvertColor(AI_MATKEY_COLOR_DIFFUSE, Nz::MaterialData::DiffuseColor);
|
|
ConvertColor(AI_MATKEY_COLOR_SPECULAR, Nz::MaterialData::SpecularColor);
|
|
|
|
ConvertTexture(aiTextureType_DIFFUSE, Nz::MaterialData::DiffuseTexturePath, Nz::MaterialData::DiffuseWrap);
|
|
ConvertTexture(aiTextureType_EMISSIVE, Nz::MaterialData::EmissiveTexturePath);
|
|
ConvertTexture(aiTextureType_HEIGHT, Nz::MaterialData::HeightTexturePath);
|
|
ConvertTexture(aiTextureType_NORMALS, Nz::MaterialData::NormalTexturePath);
|
|
ConvertTexture(aiTextureType_OPACITY, Nz::MaterialData::AlphaTexturePath);
|
|
ConvertTexture(aiTextureType_SPECULAR, Nz::MaterialData::SpecularTexturePath, Nz::MaterialData::SpecularWrap);
|
|
|
|
aiString name;
|
|
if (aiGetMaterialString(aiMat, AI_MATKEY_NAME, &name) == aiReturn_SUCCESS)
|
|
matData.SetParameter(Nz::MaterialData::Name, std::string(name.data, name.length));
|
|
|
|
int iValue;
|
|
if (aiGetMaterialInteger(aiMat, AI_MATKEY_TWOSIDED, &iValue) == aiReturn_SUCCESS)
|
|
matData.SetParameter(Nz::MaterialData::FaceCulling, !iValue);
|
|
|
|
matIt = materials.insert(std::make_pair(iMesh->mMaterialIndex, std::make_pair(Nz::UInt32(materials.size()), std::move(matData)))).first;
|
|
}
|
|
|
|
subMesh->SetMaterialIndex(matIt->first);
|
|
|
|
mesh->AddSubMesh(subMesh);
|
|
|
|
mesh->SetMaterialCount(std::max<Nz::UInt32>(Nz::SafeCast<Nz::UInt32>(materials.size()), 1));
|
|
for (const auto& pair : materials)
|
|
mesh->SetMaterialData(pair.second.first, pair.second.second);
|
|
}
|
|
else
|
|
{
|
|
mesh->CreateStatic();
|
|
|
|
// aiMaterial index in scene => Material index and data in Mesh
|
|
std::unordered_map<unsigned int, std::pair<Nz::UInt32, Nz::ParameterList>> materials;
|
|
|
|
for (unsigned int meshIndex = 0; meshIndex < scene->mNumMeshes; ++meshIndex)
|
|
{
|
|
aiMesh* iMesh = scene->mMeshes[meshIndex];
|
|
|
|
unsigned int indexCount = iMesh->mNumFaces * 3;
|
|
unsigned int vertexCount = iMesh->mNumVertices;
|
|
|
|
// Index buffer
|
|
bool largeIndices = (vertexCount > std::numeric_limits<Nz::UInt16>::max());
|
|
|
|
std::shared_ptr<Nz::IndexBuffer> indexBuffer = std::make_shared<Nz::IndexBuffer>((largeIndices) ? Nz::IndexType::U32 : Nz::IndexType::U16, indexCount, parameters.indexBufferFlags, parameters.bufferFactory);
|
|
|
|
Nz::IndexMapper indexMapper(*indexBuffer);
|
|
Nz::IndexIterator index = indexMapper.begin();
|
|
|
|
for (unsigned int faceIndex = 0; faceIndex < iMesh->mNumFaces; ++faceIndex)
|
|
{
|
|
const aiFace& face = iMesh->mFaces[faceIndex];
|
|
if (face.mNumIndices != 3)
|
|
NazaraWarning("Assimp plugin: This face is not a triangle!");
|
|
|
|
// Index buffer
|
|
*index++ = face.mIndices[0];
|
|
*index++ = face.mIndices[1];
|
|
*index++ = face.mIndices[2];
|
|
|
|
indexMapper.Unmap();
|
|
}
|
|
|
|
// Vertex buffer
|
|
|
|
// Make sure the normal/tangent matrix won't rescale our vectors
|
|
Nz::Matrix4f normalTangentMatrix = parameters.matrix;
|
|
if (normalTangentMatrix.HasScale())
|
|
normalTangentMatrix.ApplyScale(1.f / normalTangentMatrix.GetScale());
|
|
|
|
std::shared_ptr<Nz::VertexBuffer> vertexBuffer = std::make_shared<Nz::VertexBuffer>(parameters.vertexDeclaration, vertexCount, parameters.vertexBufferFlags, parameters.bufferFactory);
|
|
|
|
Nz::VertexMapper vertexMapper(*vertexBuffer);
|
|
|
|
// Vertex positions
|
|
if (auto posPtr = vertexMapper.GetComponentPtr<Nz::Vector3f>(Nz::VertexComponent::Position))
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiVector3D position = iMesh->mVertices[vertexIdx];
|
|
*posPtr++ = parameters.matrix * Nz::Vector3f(position.x, position.y, position.z);
|
|
}
|
|
}
|
|
|
|
// Vertex normals
|
|
if (auto normalPtr = vertexMapper.GetComponentPtr<Nz::Vector3f>(Nz::VertexComponent::Normal))
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiVector3D normal = iMesh->mNormals[vertexIdx];
|
|
*normalPtr++ = normalTangentMatrix.Transform({normal.x, normal.y, normal.z}, 0.f);
|
|
}
|
|
}
|
|
|
|
// Vertex tangents
|
|
bool generateTangents = false;
|
|
if (auto tangentPtr = vertexMapper.GetComponentPtr<Nz::Vector3f>(Nz::VertexComponent::Tangent))
|
|
{
|
|
if (iMesh->HasTangentsAndBitangents())
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiVector3D tangent = iMesh->mTangents[vertexIdx];
|
|
*tangentPtr++ = normalTangentMatrix.Transform({tangent.x, tangent.y, tangent.z}, 0.f);
|
|
}
|
|
}
|
|
else
|
|
generateTangents = true;
|
|
}
|
|
|
|
// Vertex UVs
|
|
if (auto uvPtr = vertexMapper.GetComponentPtr<Nz::Vector2f>(Nz::VertexComponent::TexCoord))
|
|
{
|
|
if (iMesh->HasTextureCoords(0))
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiVector3D uv = iMesh->mTextureCoords[0][vertexIdx];
|
|
*uvPtr++ = parameters.texCoordOffset + Nz::Vector2f(uv.x, uv.y) * parameters.texCoordScale;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
*uvPtr++ = Nz::Vector2f::Zero();
|
|
}
|
|
}
|
|
|
|
// Vertex colors
|
|
if (auto colorPtr = vertexMapper.GetComponentPtr<Nz::Color>(Nz::VertexComponent::Color))
|
|
{
|
|
if (iMesh->HasVertexColors(0))
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
{
|
|
aiColor4D color = iMesh->mColors[0][vertexIdx];
|
|
*colorPtr++ = Nz::Color(color.r, color.g, color.b, color.a);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (unsigned int vertexIdx = 0; vertexIdx < vertexCount; ++vertexIdx)
|
|
*colorPtr++ = Nz::Color::White;
|
|
}
|
|
}
|
|
|
|
vertexMapper.Unmap();
|
|
|
|
// Submesh
|
|
std::shared_ptr<Nz::StaticMesh> subMesh = std::make_shared<Nz::StaticMesh>(vertexBuffer, indexBuffer);
|
|
subMesh->GenerateAABB();
|
|
subMesh->SetMaterialIndex(iMesh->mMaterialIndex);
|
|
|
|
if (generateTangents)
|
|
subMesh->GenerateTangents();
|
|
|
|
auto matIt = materials.find(iMesh->mMaterialIndex);
|
|
if (matIt == materials.end())
|
|
{
|
|
Nz::ParameterList matData;
|
|
aiMaterial* aiMat = scene->mMaterials[iMesh->mMaterialIndex];
|
|
|
|
auto ConvertColor = [&] (const char* aiKey, unsigned int aiType, unsigned int aiIndex, const char* colorKey)
|
|
{
|
|
aiColor4D color;
|
|
if (aiGetMaterialColor(aiMat, aiKey, aiType, aiIndex, &color) == aiReturn_SUCCESS)
|
|
{
|
|
matData.SetParameter(colorKey, Nz::Color(color.r, color.g, color.b, color.a));
|
|
}
|
|
};
|
|
|
|
auto ConvertTexture = [&] (aiTextureType aiType, const char* textureKey, const char* wrapKey = nullptr)
|
|
{
|
|
aiString path;
|
|
aiTextureMapMode mapMode[3];
|
|
if (aiGetMaterialTexture(aiMat, aiType, 0, &path, nullptr, nullptr, nullptr, nullptr, &mapMode[0], nullptr) == aiReturn_SUCCESS)
|
|
{
|
|
matData.SetParameter(textureKey, (stream.GetDirectory() / std::string_view(path.data, path.length)).generic_u8string());
|
|
|
|
if (wrapKey)
|
|
{
|
|
Nz::SamplerWrap wrap = Nz::SamplerWrap::Clamp;
|
|
switch (mapMode[0])
|
|
{
|
|
case aiTextureMapMode_Clamp:
|
|
case aiTextureMapMode_Decal:
|
|
wrap = Nz::SamplerWrap::Clamp;
|
|
break;
|
|
|
|
case aiTextureMapMode_Mirror:
|
|
wrap = Nz::SamplerWrap::MirroredRepeat;
|
|
break;
|
|
|
|
case aiTextureMapMode_Wrap:
|
|
wrap = Nz::SamplerWrap::Repeat;
|
|
break;
|
|
|
|
default:
|
|
NazaraWarning("Assimp texture map mode 0x" + Nz::NumberToString(mapMode[0], 16) + " not handled");
|
|
break;
|
|
}
|
|
|
|
matData.SetParameter(wrapKey, static_cast<long long>(wrap));
|
|
}
|
|
}
|
|
};
|
|
|
|
ConvertColor(AI_MATKEY_COLOR_AMBIENT, Nz::MaterialData::AmbientColor);
|
|
ConvertColor(AI_MATKEY_COLOR_DIFFUSE, Nz::MaterialData::DiffuseColor);
|
|
ConvertColor(AI_MATKEY_COLOR_SPECULAR, Nz::MaterialData::SpecularColor);
|
|
|
|
ConvertTexture(aiTextureType_DIFFUSE, Nz::MaterialData::DiffuseTexturePath, Nz::MaterialData::DiffuseWrap);
|
|
ConvertTexture(aiTextureType_EMISSIVE, Nz::MaterialData::EmissiveTexturePath);
|
|
ConvertTexture(aiTextureType_HEIGHT, Nz::MaterialData::HeightTexturePath);
|
|
ConvertTexture(aiTextureType_NORMALS, Nz::MaterialData::NormalTexturePath);
|
|
ConvertTexture(aiTextureType_OPACITY, Nz::MaterialData::AlphaTexturePath);
|
|
ConvertTexture(aiTextureType_SPECULAR, Nz::MaterialData::SpecularTexturePath, Nz::MaterialData::SpecularWrap);
|
|
|
|
aiString name;
|
|
if (aiGetMaterialString(aiMat, AI_MATKEY_NAME, &name) == aiReturn_SUCCESS)
|
|
matData.SetParameter(Nz::MaterialData::Name, std::string(name.data, name.length));
|
|
|
|
int iValue;
|
|
if (aiGetMaterialInteger(aiMat, AI_MATKEY_TWOSIDED, &iValue) == aiReturn_SUCCESS)
|
|
matData.SetParameter(Nz::MaterialData::FaceCulling, !iValue);
|
|
|
|
matIt = materials.insert(std::make_pair(iMesh->mMaterialIndex, std::make_pair(Nz::UInt32(materials.size()), std::move(matData)))).first;
|
|
}
|
|
|
|
subMesh->SetMaterialIndex(matIt->first);
|
|
|
|
mesh->AddSubMesh(subMesh);
|
|
|
|
mesh->SetMaterialCount(std::max<Nz::UInt32>(Nz::UInt32(materials.size()), 1));
|
|
for (const auto& pair : materials)
|
|
mesh->SetMaterialData(pair.second.first, pair.second.second);
|
|
}
|
|
|
|
if (parameters.center)
|
|
mesh->Recenter();
|
|
}
|
|
|
|
return mesh;
|
|
}
|
|
|
|
namespace
|
|
{
|
|
const Nz::AnimationLoader::Entry* animationLoaderEntry = nullptr;
|
|
const Nz::MeshLoader::Entry* meshLoaderEntry = nullptr;
|
|
}
|
|
|
|
extern "C"
|
|
{
|
|
NAZARA_EXPORT int PluginLoad()
|
|
{
|
|
Nz::Utility* utility = Nz::Utility::Instance();
|
|
NazaraAssert(utility, "utility module is not instancied");
|
|
|
|
Nz::AnimationLoader& animationLoader = utility->GetAnimationLoader();
|
|
animationLoaderEntry = animationLoader.RegisterLoader({
|
|
IsSupported,
|
|
nullptr,
|
|
nullptr,
|
|
CheckAnimation,
|
|
LoadAnimation
|
|
});
|
|
|
|
Nz::MeshLoader& meshLoader = utility->GetMeshLoader();
|
|
meshLoaderEntry = meshLoader.RegisterLoader({
|
|
IsSupported,
|
|
nullptr,
|
|
nullptr,
|
|
CheckMesh,
|
|
LoadMesh
|
|
});
|
|
|
|
return 1;
|
|
}
|
|
|
|
NAZARA_EXPORT void PluginUnload()
|
|
{
|
|
Nz::Utility* utility = Nz::Utility::Instance();
|
|
NazaraAssert(utility, "utility module is not instancied");
|
|
|
|
Nz::AnimationLoader& animationLoader = utility->GetAnimationLoader();
|
|
animationLoader.UnregisterLoader(animationLoaderEntry);
|
|
animationLoaderEntry = nullptr;
|
|
|
|
Nz::MeshLoader& meshLoader = utility->GetMeshLoader();
|
|
meshLoader.UnregisterLoader(meshLoaderEntry);
|
|
meshLoaderEntry = nullptr;
|
|
}
|
|
}
|