| /* |
| Open Asset Import Library (assimp) |
| ---------------------------------------------------------------------- |
| |
| Copyright (c) 2006-2017, assimp team |
| |
| All rights reserved. |
| |
| Redistribution and use of this software in source and binary forms, |
| with or without modification, are permitted provided that the |
| following conditions are met: |
| |
| * Redistributions of source code must retain the above |
| copyright notice, this list of conditions and the |
| following disclaimer. |
| |
| * Redistributions in binary form must reproduce the above |
| copyright notice, this list of conditions and the |
| following disclaimer in the documentation and/or other |
| materials provided with the distribution. |
| |
| * Neither the name of the assimp team, nor the names of its |
| contributors may be used to endorse or promote products |
| derived from this software without specific prior |
| written permission of the assimp team. |
| |
| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| ---------------------------------------------------------------------- |
| */ |
| #ifndef ASSIMP_BUILD_NO_EXPORT |
| #ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER |
| |
| #include "glTFExporter.h" |
| |
| #include "Exceptional.h" |
| #include "StringComparison.h" |
| #include "ByteSwapper.h" |
| |
| #include "SplitLargeMeshes.h" |
| |
| #include <assimp/SceneCombiner.h> |
| #include <assimp/version.h> |
| #include <assimp/IOSystem.hpp> |
| #include <assimp/Exporter.hpp> |
| #include <assimp/material.h> |
| #include <assimp/scene.h> |
| |
| // Header files, standard library. |
| #include <memory> |
| #include <inttypes.h> |
| |
| #include "glTFAssetWriter.h" |
| |
| #ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC |
| // Header files, Open3DGC. |
| # include <Open3DGC/o3dgcSC3DMCEncoder.h> |
| #endif |
| |
| using namespace rapidjson; |
| |
| using namespace Assimp; |
| using namespace glTF; |
| |
| namespace Assimp { |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Worker function for exporting a scene to GLTF. Prototyped and registered in Exporter.cpp |
| void ExportSceneGLTF(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties) |
| { |
| // invoke the exporter |
| glTFExporter exporter(pFile, pIOSystem, pScene, pProperties, false); |
| } |
| |
| // ------------------------------------------------------------------------------------------------ |
| // Worker function for exporting a scene to GLB. Prototyped and registered in Exporter.cpp |
| void ExportSceneGLB(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties) |
| { |
| // invoke the exporter |
| glTFExporter exporter(pFile, pIOSystem, pScene, pProperties, true); |
| } |
| |
| } // end of namespace Assimp |
| |
| glTFExporter::glTFExporter(const char* filename, IOSystem* pIOSystem, const aiScene* pScene, |
| const ExportProperties* pProperties, bool isBinary) |
| : mFilename(filename) |
| , mIOSystem(pIOSystem) |
| , mProperties(pProperties) |
| { |
| aiScene* sceneCopy_tmp; |
| SceneCombiner::CopyScene(&sceneCopy_tmp, pScene); |
| std::unique_ptr<aiScene> sceneCopy(sceneCopy_tmp); |
| |
| SplitLargeMeshesProcess_Triangle tri_splitter; |
| tri_splitter.SetLimit(0xffff); |
| tri_splitter.Execute(sceneCopy.get()); |
| |
| SplitLargeMeshesProcess_Vertex vert_splitter; |
| vert_splitter.SetLimit(0xffff); |
| vert_splitter.Execute(sceneCopy.get()); |
| |
| mScene = sceneCopy.get(); |
| |
| mAsset.reset( new glTF::Asset( pIOSystem ) ); |
| |
| if (isBinary) { |
| mAsset->SetAsBinary(); |
| } |
| |
| ExportMetadata(); |
| |
| //for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {} |
| |
| //for (unsigned int i = 0; i < pScene->mNumLights; ++i) {} |
| |
| ExportMaterials(); |
| |
| if (mScene->mRootNode) { |
| ExportNodeHierarchy(mScene->mRootNode); |
| } |
| |
| ExportMeshes(); |
| |
| //for (unsigned int i = 0; i < pScene->mNumTextures; ++i) {} |
| |
| ExportScene(); |
| |
| ExportAnimations(); |
| |
| glTF::AssetWriter writer(*mAsset); |
| |
| if (isBinary) { |
| writer.WriteGLBFile(filename); |
| } else { |
| writer.WriteFile(filename); |
| } |
| } |
| |
| /* |
| * Copy a 4x4 matrix from struct aiMatrix to typedef mat4. |
| * Also converts from row-major to column-major storage. |
| */ |
| static void CopyValue(const aiMatrix4x4& v, glTF::mat4& o) |
| { |
| o[ 0] = v.a1; o[ 1] = v.b1; o[ 2] = v.c1; o[ 3] = v.d1; |
| o[ 4] = v.a2; o[ 5] = v.b2; o[ 6] = v.c2; o[ 7] = v.d2; |
| o[ 8] = v.a3; o[ 9] = v.b3; o[10] = v.c3; o[11] = v.d3; |
| o[12] = v.a4; o[13] = v.b4; o[14] = v.c4; o[15] = v.d4; |
| } |
| |
| static void CopyValue(const aiMatrix4x4& v, aiMatrix4x4& o) |
| { |
| o.a1 = v.a1; o.a2 = v.a2; o.a3 = v.a3; o.a4 = v.a4; |
| o.b1 = v.b1; o.b2 = v.b2; o.b3 = v.b3; o.b4 = v.b4; |
| o.c1 = v.c1; o.c2 = v.c2; o.c3 = v.c3; o.c4 = v.c4; |
| o.d1 = v.d1; o.d2 = v.d2; o.d3 = v.d3; o.d4 = v.d4; |
| } |
| |
| static void IdentityMatrix4(glTF::mat4& o) |
| { |
| o[ 0] = 1; o[ 1] = 0; o[ 2] = 0; o[ 3] = 0; |
| o[ 4] = 0; o[ 5] = 1; o[ 6] = 0; o[ 7] = 0; |
| o[ 8] = 0; o[ 9] = 0; o[10] = 1; o[11] = 0; |
| o[12] = 0; o[13] = 0; o[14] = 0; o[15] = 1; |
| } |
| |
| inline Ref<Accessor> ExportData(Asset& a, std::string& meshName, Ref<Buffer>& buffer, |
| unsigned int count, void* data, AttribType::Value typeIn, AttribType::Value typeOut, ComponentType compType, bool isIndices = false) |
| { |
| if (!count || !data) return Ref<Accessor>(); |
| |
| unsigned int numCompsIn = AttribType::GetNumComponents(typeIn); |
| unsigned int numCompsOut = AttribType::GetNumComponents(typeOut); |
| unsigned int bytesPerComp = ComponentTypeSize(compType); |
| |
| size_t offset = buffer->byteLength; |
| // make sure offset is correctly byte-aligned, as required by spec |
| size_t padding = offset % bytesPerComp; |
| offset += padding; |
| size_t length = count * numCompsOut * bytesPerComp; |
| buffer->Grow(length + padding); |
| |
| // bufferView |
| Ref<BufferView> bv = a.bufferViews.Create(a.FindUniqueID(meshName, "view")); |
| bv->buffer = buffer; |
| bv->byteOffset = unsigned(offset); |
| bv->byteLength = length; //! The target that the WebGL buffer should be bound to. |
| bv->target = isIndices ? BufferViewTarget_ELEMENT_ARRAY_BUFFER : BufferViewTarget_ARRAY_BUFFER; |
| |
| // accessor |
| Ref<Accessor> acc = a.accessors.Create(a.FindUniqueID(meshName, "accessor")); |
| acc->bufferView = bv; |
| acc->byteOffset = 0; |
| acc->byteStride = 0; |
| acc->componentType = compType; |
| acc->count = count; |
| acc->type = typeOut; |
| |
| // calculate min and max values |
| { |
| // Allocate and initialize with large values. |
| float float_MAX = 10000000000000.0f; |
| for (unsigned int i = 0 ; i < numCompsOut ; i++) { |
| acc->min.push_back( float_MAX); |
| acc->max.push_back(-float_MAX); |
| } |
| |
| // Search and set extreme values. |
| float valueTmp; |
| for (unsigned int i = 0 ; i < count ; i++) { |
| for (unsigned int j = 0 ; j < numCompsOut ; j++) { |
| if (numCompsOut == 1) { |
| valueTmp = static_cast<unsigned short*>(data)[i]; |
| } else { |
| valueTmp = static_cast<aiVector3D*>(data)[i][j]; |
| } |
| |
| if (valueTmp < acc->min[j]) { |
| acc->min[j] = valueTmp; |
| } |
| if (valueTmp > acc->max[j]) { |
| acc->max[j] = valueTmp; |
| } |
| } |
| } |
| } |
| |
| // copy the data |
| acc->WriteData(count, data, numCompsIn*bytesPerComp); |
| |
| return acc; |
| } |
| |
| namespace { |
| void GetMatScalar(const aiMaterial* mat, float& val, const char* propName, int type, int idx) { |
| if (mat->Get(propName, type, idx, val) == AI_SUCCESS) {} |
| } |
| } |
| |
| void glTFExporter::GetTexSampler(const aiMaterial* mat, glTF::TexProperty& prop) |
| { |
| std::string samplerId = mAsset->FindUniqueID("", "sampler"); |
| prop.texture->sampler = mAsset->samplers.Create(samplerId); |
| |
| aiTextureMapMode mapU, mapV; |
| aiGetMaterialInteger(mat,AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0),(int*)&mapU); |
| aiGetMaterialInteger(mat,AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0),(int*)&mapV); |
| |
| switch (mapU) { |
| case aiTextureMapMode_Wrap: |
| prop.texture->sampler->wrapS = SamplerWrap_Repeat; |
| break; |
| case aiTextureMapMode_Clamp: |
| prop.texture->sampler->wrapS = SamplerWrap_Clamp_To_Edge; |
| break; |
| case aiTextureMapMode_Mirror: |
| prop.texture->sampler->wrapS = SamplerWrap_Mirrored_Repeat; |
| break; |
| case aiTextureMapMode_Decal: |
| default: |
| prop.texture->sampler->wrapS = SamplerWrap_Repeat; |
| break; |
| }; |
| |
| switch (mapV) { |
| case aiTextureMapMode_Wrap: |
| prop.texture->sampler->wrapT = SamplerWrap_Repeat; |
| break; |
| case aiTextureMapMode_Clamp: |
| prop.texture->sampler->wrapT = SamplerWrap_Clamp_To_Edge; |
| break; |
| case aiTextureMapMode_Mirror: |
| prop.texture->sampler->wrapT = SamplerWrap_Mirrored_Repeat; |
| break; |
| case aiTextureMapMode_Decal: |
| default: |
| prop.texture->sampler->wrapT = SamplerWrap_Repeat; |
| break; |
| }; |
| |
| // Hard coded Texture filtering options because I do not know where to find them in the aiMaterial. |
| prop.texture->sampler->magFilter = SamplerMagFilter_Linear; |
| prop.texture->sampler->minFilter = SamplerMinFilter_Linear; |
| } |
| |
| void glTFExporter::GetMatColorOrTex(const aiMaterial* mat, glTF::TexProperty& prop, const char* propName, int type, int idx, aiTextureType tt) |
| { |
| aiString tex; |
| aiColor4D col; |
| if (mat->GetTextureCount(tt) > 0) { |
| if (mat->Get(AI_MATKEY_TEXTURE(tt, 0), tex) == AI_SUCCESS) { |
| std::string path = tex.C_Str(); |
| |
| if (path.size() > 0) { |
| if (path[0] != '*') { |
| std::map<std::string, unsigned int>::iterator it = mTexturesByPath.find(path); |
| if (it != mTexturesByPath.end()) { |
| prop.texture = mAsset->textures.Get(it->second); |
| } |
| } |
| |
| if (!prop.texture) { |
| std::string texId = mAsset->FindUniqueID("", "texture"); |
| prop.texture = mAsset->textures.Create(texId); |
| mTexturesByPath[path] = prop.texture.GetIndex(); |
| |
| std::string imgId = mAsset->FindUniqueID("", "image"); |
| prop.texture->source = mAsset->images.Create(imgId); |
| |
| if (path[0] == '*') { // embedded |
| aiTexture* tex = mScene->mTextures[atoi(&path[1])]; |
| |
| uint8_t* data = reinterpret_cast<uint8_t*>(tex->pcData); |
| prop.texture->source->SetData(data, tex->mWidth, *mAsset); |
| |
| if (tex->achFormatHint[0]) { |
| std::string mimeType = "image/"; |
| mimeType += (memcmp(tex->achFormatHint, "jpg", 3) == 0) ? "jpeg" : tex->achFormatHint; |
| prop.texture->source->mimeType = mimeType; |
| } |
| } |
| else { |
| prop.texture->source->uri = path; |
| } |
| |
| GetTexSampler(mat, prop); |
| } |
| } |
| } |
| } |
| |
| if (mat->Get(propName, type, idx, col) == AI_SUCCESS) { |
| prop.color[0] = col.r; prop.color[1] = col.g; prop.color[2] = col.b; prop.color[3] = col.a; |
| } |
| } |
| |
| |
| void glTFExporter::ExportMaterials() |
| { |
| aiString aiName; |
| for (unsigned int i = 0; i < mScene->mNumMaterials; ++i) { |
| const aiMaterial* mat = mScene->mMaterials[i]; |
| |
| |
| std::string name; |
| if (mat->Get(AI_MATKEY_NAME, aiName) == AI_SUCCESS) { |
| name = aiName.C_Str(); |
| } |
| name = mAsset->FindUniqueID(name, "material"); |
| |
| Ref<Material> m = mAsset->materials.Create(name); |
| |
| GetMatColorOrTex(mat, m->ambient, AI_MATKEY_COLOR_AMBIENT, aiTextureType_AMBIENT); |
| GetMatColorOrTex(mat, m->diffuse, AI_MATKEY_COLOR_DIFFUSE, aiTextureType_DIFFUSE); |
| GetMatColorOrTex(mat, m->specular, AI_MATKEY_COLOR_SPECULAR, aiTextureType_SPECULAR); |
| GetMatColorOrTex(mat, m->emission, AI_MATKEY_COLOR_EMISSIVE, aiTextureType_EMISSIVE); |
| |
| m->transparent = mat->Get(AI_MATKEY_OPACITY, m->transparency) == aiReturn_SUCCESS && m->transparency != 1.0; |
| |
| GetMatScalar(mat, m->shininess, AI_MATKEY_SHININESS); |
| } |
| } |
| |
| /* |
| * Search through node hierarchy and find the node containing the given meshID. |
| * Returns true on success, and false otherwise. |
| */ |
| bool FindMeshNode(Ref<Node>& nodeIn, Ref<Node>& meshNode, std::string meshID) |
| { |
| for (unsigned int i = 0; i < nodeIn->meshes.size(); ++i) { |
| if (meshID.compare(nodeIn->meshes[i]->id) == 0) { |
| meshNode = nodeIn; |
| return true; |
| } |
| } |
| |
| for (unsigned int i = 0; i < nodeIn->children.size(); ++i) { |
| if(FindMeshNode(nodeIn->children[i], meshNode, meshID)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /* |
| * Find the root joint of the skeleton. |
| * Starts will any joint node and traces up the tree, |
| * until a parent is found that does not have a jointName. |
| * Returns the first parent Ref<Node> found that does not have a jointName. |
| */ |
| Ref<Node> FindSkeletonRootJoint(Ref<Skin>& skinRef) |
| { |
| Ref<Node> startNodeRef; |
| Ref<Node> parentNodeRef; |
| |
| // Arbitrarily use the first joint to start the search. |
| startNodeRef = skinRef->jointNames[0]; |
| parentNodeRef = skinRef->jointNames[0]; |
| |
| do { |
| startNodeRef = parentNodeRef; |
| parentNodeRef = startNodeRef->parent; |
| } while (!parentNodeRef->jointName.empty()); |
| |
| return parentNodeRef; |
| } |
| |
| void ExportSkin(Asset& mAsset, const aiMesh* aimesh, Ref<Mesh>& meshRef, Ref<Buffer>& bufferRef, Ref<Skin>& skinRef, std::vector<aiMatrix4x4>& inverseBindMatricesData) |
| { |
| if (aimesh->mNumBones < 1) { |
| return; |
| } |
| |
| // Store the vertex joint and weight data. |
| const size_t NumVerts( aimesh->mNumVertices ); |
| vec4* vertexJointData = new vec4[ NumVerts ]; |
| vec4* vertexWeightData = new vec4[ NumVerts ]; |
| int* jointsPerVertex = new int[ NumVerts ]; |
| for (size_t i = 0; i < NumVerts; ++i) { |
| jointsPerVertex[i] = 0; |
| for (size_t j = 0; j < 4; ++j) { |
| vertexJointData[i][j] = 0; |
| vertexWeightData[i][j] = 0; |
| } |
| } |
| |
| for (unsigned int idx_bone = 0; idx_bone < aimesh->mNumBones; ++idx_bone) { |
| const aiBone* aib = aimesh->mBones[idx_bone]; |
| |
| // aib->mName =====> skinRef->jointNames |
| // Find the node with id = mName. |
| Ref<Node> nodeRef = mAsset.nodes.Get(aib->mName.C_Str()); |
| nodeRef->jointName = nodeRef->id; |
| |
| unsigned int jointNamesIndex = 0; |
| bool addJointToJointNames = true; |
| for ( unsigned int idx_joint = 0; idx_joint < skinRef->jointNames.size(); ++idx_joint) { |
| if (skinRef->jointNames[idx_joint]->jointName.compare(nodeRef->jointName) == 0) { |
| addJointToJointNames = false; |
| jointNamesIndex = idx_joint; |
| } |
| } |
| |
| if (addJointToJointNames) { |
| skinRef->jointNames.push_back(nodeRef); |
| |
| // aib->mOffsetMatrix =====> skinRef->inverseBindMatrices |
| aiMatrix4x4 tmpMatrix4; |
| CopyValue(aib->mOffsetMatrix, tmpMatrix4); |
| inverseBindMatricesData.push_back(tmpMatrix4); |
| jointNamesIndex = static_cast<unsigned int>(inverseBindMatricesData.size() - 1); |
| } |
| |
| // aib->mWeights =====> vertexWeightData |
| for (unsigned int idx_weights = 0; idx_weights < aib->mNumWeights; ++idx_weights) { |
| unsigned int vertexId = aib->mWeights[idx_weights].mVertexId; |
| float vertWeight = aib->mWeights[idx_weights].mWeight; |
| |
| // A vertex can only have at most four joint weights. Ignore all others. |
| if (jointsPerVertex[vertexId] > 3) { |
| continue; |
| } |
| |
| vertexJointData[vertexId][jointsPerVertex[vertexId]] = static_cast<float>(jointNamesIndex); |
| vertexWeightData[vertexId][jointsPerVertex[vertexId]] = vertWeight; |
| |
| jointsPerVertex[vertexId] += 1; |
| } |
| |
| } // End: for-loop mNumMeshes |
| |
| Mesh::Primitive& p = meshRef->primitives.back(); |
| Ref<Accessor> vertexJointAccessor = ExportData(mAsset, skinRef->id, bufferRef, aimesh->mNumVertices, vertexJointData, AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT); |
| if ( vertexJointAccessor ) { |
| p.attributes.joint.push_back( vertexJointAccessor ); |
| } |
| |
| Ref<Accessor> vertexWeightAccessor = ExportData(mAsset, skinRef->id, bufferRef, aimesh->mNumVertices, vertexWeightData, AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT); |
| if ( vertexWeightAccessor ) { |
| p.attributes.weight.push_back( vertexWeightAccessor ); |
| } |
| delete[] jointsPerVertex; |
| delete[] vertexWeightData; |
| delete[] vertexJointData; |
| } |
| |
| void glTFExporter::ExportMeshes() |
| { |
| // Not for |
| // using IndicesType = decltype(aiFace::mNumIndices); |
| // But yes for |
| // using IndicesType = unsigned short; |
| // because "ComponentType_UNSIGNED_SHORT" used for indices. And it's a maximal type according to glTF specification. |
| typedef unsigned short IndicesType; |
| |
| // Variables needed for compression. BEGIN. |
| // Indices, not pointers - because pointer to buffer is changing while writing to it. |
| size_t idx_srcdata_begin = 0; // Index of buffer before writing mesh data. Also, index of begin of coordinates array in buffer. |
| size_t idx_srcdata_normal = SIZE_MAX;// Index of begin of normals array in buffer. SIZE_MAX - mean that mesh has no normals. |
| std::vector<size_t> idx_srcdata_tc;// Array of indices. Every index point to begin of texture coordinates array in buffer. |
| size_t idx_srcdata_ind;// Index of begin of coordinates indices array in buffer. |
| bool comp_allow;// Point that data of current mesh can be compressed. |
| // Variables needed for compression. END. |
| |
| std::string fname = std::string(mFilename); |
| std::string bufferIdPrefix = fname.substr(0, fname.rfind(".gltf")); |
| std::string bufferId = mAsset->FindUniqueID("", bufferIdPrefix.c_str()); |
| |
| Ref<Buffer> b = mAsset->GetBodyBuffer(); |
| if (!b) { |
| b = mAsset->buffers.Create(bufferId); |
| } |
| |
| //---------------------------------------- |
| // Initialize variables for the skin |
| bool createSkin = false; |
| for (unsigned int idx_mesh = 0; idx_mesh < mScene->mNumMeshes; ++idx_mesh) { |
| const aiMesh* aim = mScene->mMeshes[idx_mesh]; |
| if(aim->HasBones()) { |
| createSkin = true; |
| break; |
| } |
| } |
| |
| Ref<Skin> skinRef; |
| std::string skinName = mAsset->FindUniqueID("skin", "skin"); |
| std::vector<aiMatrix4x4> inverseBindMatricesData; |
| if(createSkin) { |
| skinRef = mAsset->skins.Create(skinName); |
| skinRef->name = skinName; |
| } |
| //---------------------------------------- |
| |
| for (unsigned int idx_mesh = 0; idx_mesh < mScene->mNumMeshes; ++idx_mesh) { |
| const aiMesh* aim = mScene->mMeshes[idx_mesh]; |
| |
| // Check if compressing requested and mesh can be encoded. |
| #ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC |
| comp_allow = mProperties->GetPropertyBool("extensions.Open3DGC.use", false); |
| #else |
| comp_allow = false; |
| #endif |
| |
| if(comp_allow && (aim->mPrimitiveTypes == aiPrimitiveType_TRIANGLE) && (aim->mNumVertices > 0) && (aim->mNumFaces > 0)) |
| { |
| idx_srcdata_tc.clear(); |
| idx_srcdata_tc.reserve(AI_MAX_NUMBER_OF_TEXTURECOORDS); |
| } |
| else |
| { |
| std::string msg; |
| |
| if(aim->mPrimitiveTypes != aiPrimitiveType_TRIANGLE) |
| msg = "all primitives of the mesh must be a triangles."; |
| else |
| msg = "mesh must has vertices and faces."; |
| |
| DefaultLogger::get()->warn("GLTF: can not use Open3DGC-compression: " + msg); |
| comp_allow = false; |
| } |
| |
| std::string meshId = mAsset->FindUniqueID(aim->mName.C_Str(), "mesh"); |
| Ref<Mesh> m = mAsset->meshes.Create(meshId); |
| m->primitives.resize(1); |
| Mesh::Primitive& p = m->primitives.back(); |
| |
| p.material = mAsset->materials.Get(aim->mMaterialIndex); |
| |
| /******************* Vertices ********************/ |
| // If compression is used then you need parameters of uncompressed region: begin and size. At this step "begin" is stored. |
| if(comp_allow) idx_srcdata_begin = b->byteLength; |
| |
| Ref<Accessor> v = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mVertices, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT); |
| if (v) p.attributes.position.push_back(v); |
| |
| /******************** Normals ********************/ |
| if(comp_allow && (aim->mNormals != 0)) idx_srcdata_normal = b->byteLength;// Store index of normals array. |
| |
| Ref<Accessor> n = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mNormals, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT); |
| if (n) p.attributes.normal.push_back(n); |
| |
| /************** Texture coordinates **************/ |
| for (int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) { |
| // Flip UV y coords |
| if (aim -> mNumUVComponents[i] > 1) { |
| for (unsigned int j = 0; j < aim->mNumVertices; ++j) { |
| aim->mTextureCoords[i][j].y = 1 - aim->mTextureCoords[i][j].y; |
| } |
| } |
| |
| if (aim->mNumUVComponents[i] > 0) { |
| AttribType::Value type = (aim->mNumUVComponents[i] == 2) ? AttribType::VEC2 : AttribType::VEC3; |
| |
| if(comp_allow) idx_srcdata_tc.push_back(b->byteLength);// Store index of texture coordinates array. |
| |
| Ref<Accessor> tc = ExportData(*mAsset, meshId, b, aim->mNumVertices, aim->mTextureCoords[i], AttribType::VEC3, type, ComponentType_FLOAT, false); |
| if (tc) p.attributes.texcoord.push_back(tc); |
| } |
| } |
| |
| /*************** Vertices indices ****************/ |
| idx_srcdata_ind = b->byteLength;// Store index of indices array. |
| |
| if (aim->mNumFaces > 0) { |
| std::vector<IndicesType> indices; |
| unsigned int nIndicesPerFace = aim->mFaces[0].mNumIndices; |
| indices.resize(aim->mNumFaces * nIndicesPerFace); |
| for (size_t i = 0; i < aim->mNumFaces; ++i) { |
| for (size_t j = 0; j < nIndicesPerFace; ++j) { |
| indices[i*nIndicesPerFace + j] = uint16_t(aim->mFaces[i].mIndices[j]); |
| } |
| } |
| |
| p.indices = ExportData(*mAsset, meshId, b, unsigned(indices.size()), &indices[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_UNSIGNED_SHORT, true); |
| } |
| |
| switch (aim->mPrimitiveTypes) { |
| case aiPrimitiveType_POLYGON: |
| p.mode = PrimitiveMode_TRIANGLES; break; // TODO implement this |
| case aiPrimitiveType_LINE: |
| p.mode = PrimitiveMode_LINES; break; |
| case aiPrimitiveType_POINT: |
| p.mode = PrimitiveMode_POINTS; break; |
| default: // aiPrimitiveType_TRIANGLE |
| p.mode = PrimitiveMode_TRIANGLES; |
| } |
| |
| /*************** Skins ****************/ |
| if(aim->HasBones()) { |
| ExportSkin(*mAsset, aim, m, b, skinRef, inverseBindMatricesData); |
| } |
| |
| /****************** Compression ******************/ |
| ///TODO: animation: weights, joints. |
| if(comp_allow) |
| { |
| #ifdef ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC |
| // Only one type of compression supported at now - Open3DGC. |
| // |
| o3dgc::BinaryStream bs; |
| o3dgc::SC3DMCEncoder<IndicesType> encoder; |
| o3dgc::IndexedFaceSet<IndicesType> comp_o3dgc_ifs; |
| o3dgc::SC3DMCEncodeParams comp_o3dgc_params; |
| |
| // |
| // Fill data for encoder. |
| // |
| // Quantization |
| unsigned quant_coord = mProperties->GetPropertyInteger("extensions.Open3DGC.quantization.POSITION", 12); |
| unsigned quant_normal = mProperties->GetPropertyInteger("extensions.Open3DGC.quantization.NORMAL", 10); |
| unsigned quant_texcoord = mProperties->GetPropertyInteger("extensions.Open3DGC.quantization.TEXCOORD", 10); |
| |
| // Prediction |
| o3dgc::O3DGCSC3DMCPredictionMode prediction_position = o3dgc::O3DGC_SC3DMC_PARALLELOGRAM_PREDICTION; |
| o3dgc::O3DGCSC3DMCPredictionMode prediction_normal = o3dgc::O3DGC_SC3DMC_SURF_NORMALS_PREDICTION; |
| o3dgc::O3DGCSC3DMCPredictionMode prediction_texcoord = o3dgc::O3DGC_SC3DMC_PARALLELOGRAM_PREDICTION; |
| |
| // IndexedFacesSet: "Crease angle", "solid", "convex" are set to default. |
| comp_o3dgc_ifs.SetCCW(true); |
| comp_o3dgc_ifs.SetIsTriangularMesh(true); |
| comp_o3dgc_ifs.SetNumFloatAttributes(0); |
| // Coordinates |
| comp_o3dgc_params.SetCoordQuantBits(quant_coord); |
| comp_o3dgc_params.SetCoordPredMode(prediction_position); |
| comp_o3dgc_ifs.SetNCoord(aim->mNumVertices); |
| comp_o3dgc_ifs.SetCoord((o3dgc::Real* const)&b->GetPointer()[idx_srcdata_begin]); |
| // Normals |
| if(idx_srcdata_normal != SIZE_MAX) |
| { |
| comp_o3dgc_params.SetNormalQuantBits(quant_normal); |
| comp_o3dgc_params.SetNormalPredMode(prediction_normal); |
| comp_o3dgc_ifs.SetNNormal(aim->mNumVertices); |
| comp_o3dgc_ifs.SetNormal((o3dgc::Real* const)&b->GetPointer()[idx_srcdata_normal]); |
| } |
| |
| // Texture coordinates |
| for(size_t num_tc = 0; num_tc < idx_srcdata_tc.size(); num_tc++) |
| { |
| size_t num = comp_o3dgc_ifs.GetNumFloatAttributes(); |
| |
| comp_o3dgc_params.SetFloatAttributeQuantBits(static_cast<unsigned long>(num), quant_texcoord); |
| comp_o3dgc_params.SetFloatAttributePredMode(static_cast<unsigned long>(num), prediction_texcoord); |
| comp_o3dgc_ifs.SetNFloatAttribute(static_cast<unsigned long>(num), aim->mNumVertices);// number of elements. |
| comp_o3dgc_ifs.SetFloatAttributeDim(static_cast<unsigned long>(num), aim->mNumUVComponents[num_tc]);// components per element: aiVector3D => x * float |
| comp_o3dgc_ifs.SetFloatAttributeType(static_cast<unsigned long>(num), o3dgc::O3DGC_IFS_FLOAT_ATTRIBUTE_TYPE_TEXCOORD); |
| comp_o3dgc_ifs.SetFloatAttribute(static_cast<unsigned long>(num), (o3dgc::Real* const)&b->GetPointer()[idx_srcdata_tc[num_tc]]); |
| comp_o3dgc_ifs.SetNumFloatAttributes(static_cast<unsigned long>(num + 1)); |
| } |
| |
| // Coordinates indices |
| comp_o3dgc_ifs.SetNCoordIndex(aim->mNumFaces); |
| comp_o3dgc_ifs.SetCoordIndex((IndicesType* const)&b->GetPointer()[idx_srcdata_ind]); |
| // Prepare to enconding |
| comp_o3dgc_params.SetNumFloatAttributes(comp_o3dgc_ifs.GetNumFloatAttributes()); |
| if(mProperties->GetPropertyBool("extensions.Open3DGC.binary", true)) |
| comp_o3dgc_params.SetStreamType(o3dgc::O3DGC_STREAM_TYPE_BINARY); |
| else |
| comp_o3dgc_params.SetStreamType(o3dgc::O3DGC_STREAM_TYPE_ASCII); |
| |
| comp_o3dgc_ifs.ComputeMinMax(o3dgc::O3DGC_SC3DMC_MAX_ALL_DIMS); |
| // |
| // Encoding |
| // |
| encoder.Encode(comp_o3dgc_params, comp_o3dgc_ifs, bs); |
| // Replace data in buffer. |
| b->ReplaceData(idx_srcdata_begin, b->byteLength - idx_srcdata_begin, bs.GetBuffer(), bs.GetSize()); |
| // |
| // Add information about extension to mesh. |
| // |
| // Create extension structure. |
| Mesh::SCompression_Open3DGC* ext = new Mesh::SCompression_Open3DGC; |
| |
| // Fill it. |
| ext->Buffer = b->id; |
| ext->Offset = idx_srcdata_begin; |
| ext->Count = b->byteLength - idx_srcdata_begin; |
| ext->Binary = mProperties->GetPropertyBool("extensions.Open3DGC.binary"); |
| ext->IndicesCount = comp_o3dgc_ifs.GetNCoordIndex() * 3; |
| ext->VerticesCount = comp_o3dgc_ifs.GetNCoord(); |
| // And assign to mesh. |
| m->Extension.push_back(ext); |
| #endif |
| }// if(comp_allow) |
| }// for (unsigned int i = 0; i < mScene->mNumMeshes; ++i) |
| |
| //---------------------------------------- |
| // Finish the skin |
| // Create the Accessor for skinRef->inverseBindMatrices |
| if (createSkin) { |
| mat4* invBindMatrixData = new mat4[inverseBindMatricesData.size()]; |
| for ( unsigned int idx_joint = 0; idx_joint < inverseBindMatricesData.size(); ++idx_joint) { |
| CopyValue(inverseBindMatricesData[idx_joint], invBindMatrixData[idx_joint]); |
| } |
| |
| Ref<Accessor> invBindMatrixAccessor = ExportData(*mAsset, skinName, b, static_cast<unsigned int>(inverseBindMatricesData.size()), invBindMatrixData, AttribType::MAT4, AttribType::MAT4, ComponentType_FLOAT); |
| if (invBindMatrixAccessor) skinRef->inverseBindMatrices = invBindMatrixAccessor; |
| |
| // Identity Matrix =====> skinRef->bindShapeMatrix |
| // Temporary. Hard-coded identity matrix here |
| skinRef->bindShapeMatrix.isPresent = true; |
| IdentityMatrix4(skinRef->bindShapeMatrix.value); |
| |
| // Find node that contains this mesh and add "skeletons" and "skin" attributes to that node. |
| Ref<Node> rootNode = mAsset->nodes.Get(unsigned(0)); |
| Ref<Node> meshNode; |
| std::string meshID = mAsset->meshes.Get(unsigned(0))->id; |
| FindMeshNode(rootNode, meshNode, meshID); |
| |
| Ref<Node> rootJoint = FindSkeletonRootJoint(skinRef); |
| meshNode->skeletons.push_back(rootJoint); |
| meshNode->skin = skinRef; |
| } |
| } |
| |
| /* |
| * Export the root node of the node hierarchy. |
| * Calls ExportNode for all children. |
| */ |
| unsigned int glTFExporter::ExportNodeHierarchy(const aiNode* n) |
| { |
| Ref<Node> node = mAsset->nodes.Create(mAsset->FindUniqueID(n->mName.C_Str(), "node")); |
| |
| if (!n->mTransformation.IsIdentity()) { |
| node->matrix.isPresent = true; |
| CopyValue(n->mTransformation, node->matrix.value); |
| } |
| |
| for (unsigned int i = 0; i < n->mNumMeshes; ++i) { |
| node->meshes.push_back(mAsset->meshes.Get(n->mMeshes[i])); |
| } |
| |
| for (unsigned int i = 0; i < n->mNumChildren; ++i) { |
| unsigned int idx = ExportNode(n->mChildren[i], node); |
| node->children.push_back(mAsset->nodes.Get(idx)); |
| } |
| |
| return node.GetIndex(); |
| } |
| |
| /* |
| * Export node and recursively calls ExportNode for all children. |
| * Since these nodes are not the root node, we also export the parent Ref<Node> |
| */ |
| unsigned int glTFExporter::ExportNode(const aiNode* n, Ref<Node>& parent) |
| { |
| Ref<Node> node = mAsset->nodes.Create(mAsset->FindUniqueID(n->mName.C_Str(), "node")); |
| |
| node->parent = parent; |
| |
| if (!n->mTransformation.IsIdentity()) { |
| node->matrix.isPresent = true; |
| CopyValue(n->mTransformation, node->matrix.value); |
| } |
| |
| for (unsigned int i = 0; i < n->mNumMeshes; ++i) { |
| node->meshes.push_back(mAsset->meshes.Get(n->mMeshes[i])); |
| } |
| |
| for (unsigned int i = 0; i < n->mNumChildren; ++i) { |
| unsigned int idx = ExportNode(n->mChildren[i], node); |
| node->children.push_back(mAsset->nodes.Get(idx)); |
| } |
| |
| return node.GetIndex(); |
| } |
| |
| |
| void glTFExporter::ExportScene() |
| { |
| const char* sceneName = "defaultScene"; |
| Ref<Scene> scene = mAsset->scenes.Create(sceneName); |
| |
| // root node will be the first one exported (idx 0) |
| if (mAsset->nodes.Size() > 0) { |
| scene->nodes.push_back(mAsset->nodes.Get(0u)); |
| } |
| |
| // set as the default scene |
| mAsset->scene = scene; |
| } |
| |
| void glTFExporter::ExportMetadata() |
| { |
| glTF::AssetMetadata& asset = mAsset->asset; |
| asset.version = "1.0"; |
| |
| char buffer[256]; |
| ai_snprintf(buffer, 256, "Open Asset Import Library (assimp v%d.%d.%d)", |
| aiGetVersionMajor(), aiGetVersionMinor(), aiGetVersionRevision()); |
| |
| asset.generator = buffer; |
| } |
| |
| inline void ExtractAnimationData(Asset& mAsset, std::string& animId, Ref<Animation>& animRef, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond) |
| { |
| // Loop over the data and check to see if it exactly matches an existing buffer. |
| // If yes, then reference the existing corresponding accessor. |
| // Otherwise, add to the buffer and create a new accessor. |
| |
| size_t counts[3] = { |
| nodeChannel->mNumPositionKeys, |
| nodeChannel->mNumScalingKeys, |
| nodeChannel->mNumRotationKeys, |
| }; |
| size_t numKeyframes = 1; |
| for (int i = 0; i < 3; ++i) { |
| if (counts[i] > numKeyframes) { |
| numKeyframes = counts[i]; |
| } |
| } |
| |
| //------------------------------------------------------- |
| // Extract TIME parameter data. |
| // Check if the timeStamps are the same for mPositionKeys, mRotationKeys, and mScalingKeys. |
| if(nodeChannel->mNumPositionKeys > 0) { |
| typedef float TimeType; |
| std::vector<TimeType> timeData; |
| timeData.resize(numKeyframes); |
| for (size_t i = 0; i < numKeyframes; ++i) { |
| size_t frameIndex = i * nodeChannel->mNumPositionKeys / numKeyframes; |
| // mTime is measured in ticks, but GLTF time is measured in seconds, so convert. |
| // Check if we have to cast type here. e.g. uint16_t() |
| timeData[i] = static_cast<float>(nodeChannel->mPositionKeys[frameIndex].mTime / ticksPerSecond); |
| } |
| |
| Ref<Accessor> timeAccessor = ExportData(mAsset, animId, buffer, static_cast<unsigned int>(numKeyframes), &timeData[0], AttribType::SCALAR, AttribType::SCALAR, ComponentType_FLOAT); |
| if (timeAccessor) animRef->Parameters.TIME = timeAccessor; |
| } |
| |
| //------------------------------------------------------- |
| // Extract translation parameter data |
| if(nodeChannel->mNumPositionKeys > 0) { |
| C_STRUCT aiVector3D* translationData = new aiVector3D[numKeyframes]; |
| for (size_t i = 0; i < numKeyframes; ++i) { |
| size_t frameIndex = i * nodeChannel->mNumPositionKeys / numKeyframes; |
| translationData[i] = nodeChannel->mPositionKeys[frameIndex].mValue; |
| } |
| |
| Ref<Accessor> tranAccessor = ExportData(mAsset, animId, buffer, static_cast<unsigned int>(numKeyframes), translationData, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT); |
| if ( tranAccessor ) { |
| animRef->Parameters.translation = tranAccessor; |
| } |
| delete[] translationData; |
| } |
| |
| //------------------------------------------------------- |
| // Extract scale parameter data |
| if(nodeChannel->mNumScalingKeys > 0) { |
| C_STRUCT aiVector3D* scaleData = new aiVector3D[numKeyframes]; |
| for (size_t i = 0; i < numKeyframes; ++i) { |
| size_t frameIndex = i * nodeChannel->mNumScalingKeys / numKeyframes; |
| scaleData[i] = nodeChannel->mScalingKeys[frameIndex].mValue; |
| } |
| |
| Ref<Accessor> scaleAccessor = ExportData(mAsset, animId, buffer, static_cast<unsigned int>(numKeyframes), scaleData, AttribType::VEC3, AttribType::VEC3, ComponentType_FLOAT); |
| if ( scaleAccessor ) { |
| animRef->Parameters.scale = scaleAccessor; |
| } |
| delete[] scaleData; |
| } |
| |
| //------------------------------------------------------- |
| // Extract rotation parameter data |
| if(nodeChannel->mNumRotationKeys > 0) { |
| vec4* rotationData = new vec4[numKeyframes]; |
| for (size_t i = 0; i < numKeyframes; ++i) { |
| size_t frameIndex = i * nodeChannel->mNumRotationKeys / numKeyframes; |
| rotationData[i][0] = nodeChannel->mRotationKeys[frameIndex].mValue.x; |
| rotationData[i][1] = nodeChannel->mRotationKeys[frameIndex].mValue.y; |
| rotationData[i][2] = nodeChannel->mRotationKeys[frameIndex].mValue.z; |
| rotationData[i][3] = nodeChannel->mRotationKeys[frameIndex].mValue.w; |
| } |
| |
| Ref<Accessor> rotAccessor = ExportData(mAsset, animId, buffer, static_cast<unsigned int>(numKeyframes), rotationData, AttribType::VEC4, AttribType::VEC4, ComponentType_FLOAT); |
| if ( rotAccessor ) { |
| animRef->Parameters.rotation = rotAccessor; |
| } |
| delete[] rotationData; |
| } |
| } |
| |
| void glTFExporter::ExportAnimations() |
| { |
| Ref<Buffer> bufferRef = mAsset->buffers.Get(unsigned (0)); |
| |
| for (unsigned int i = 0; i < mScene->mNumAnimations; ++i) { |
| const aiAnimation* anim = mScene->mAnimations[i]; |
| |
| std::string nameAnim = "anim"; |
| if (anim->mName.length > 0) { |
| nameAnim = anim->mName.C_Str(); |
| } |
| |
| for (unsigned int channelIndex = 0; channelIndex < anim->mNumChannels; ++channelIndex) { |
| const aiNodeAnim* nodeChannel = anim->mChannels[channelIndex]; |
| |
| // It appears that assimp stores this type of animation as multiple animations. |
| // where each aiNodeAnim in mChannels animates a specific node. |
| std::string name = nameAnim + "_" + to_string(channelIndex); |
| name = mAsset->FindUniqueID(name, "animation"); |
| Ref<Animation> animRef = mAsset->animations.Create(name); |
| |
| /******************* Parameters ********************/ |
| ExtractAnimationData(*mAsset, name, animRef, bufferRef, nodeChannel, static_cast<float>(anim->mTicksPerSecond)); |
| |
| for (unsigned int j = 0; j < 3; ++j) { |
| std::string channelType; |
| int channelSize; |
| switch (j) { |
| case 0: |
| channelType = "rotation"; |
| channelSize = nodeChannel->mNumRotationKeys; |
| break; |
| case 1: |
| channelType = "scale"; |
| channelSize = nodeChannel->mNumScalingKeys; |
| break; |
| case 2: |
| channelType = "translation"; |
| channelSize = nodeChannel->mNumPositionKeys; |
| break; |
| } |
| |
| if (channelSize < 1) { continue; } |
| |
| Animation::AnimChannel tmpAnimChannel; |
| Animation::AnimSampler tmpAnimSampler; |
| |
| tmpAnimChannel.sampler = name + "_" + channelType; |
| tmpAnimChannel.target.path = channelType; |
| tmpAnimSampler.output = channelType; |
| tmpAnimSampler.id = name + "_" + channelType; |
| |
| tmpAnimChannel.target.id = mAsset->nodes.Get(nodeChannel->mNodeName.C_Str()); |
| |
| tmpAnimSampler.input = "TIME"; |
| tmpAnimSampler.interpolation = "LINEAR"; |
| |
| animRef->Channels.push_back(tmpAnimChannel); |
| animRef->Samplers.push_back(tmpAnimSampler); |
| } |
| |
| } |
| |
| // Assimp documentation staes this is not used (not implemented) |
| // for (unsigned int channelIndex = 0; channelIndex < anim->mNumMeshChannels; ++channelIndex) { |
| // const aiMeshAnim* meshChannel = anim->mMeshChannels[channelIndex]; |
| // } |
| |
| } // End: for-loop mNumAnimations |
| } |
| |
| |
| #endif // ASSIMP_BUILD_NO_GLTF_EXPORTER |
| #endif // ASSIMP_BUILD_NO_EXPORT |