|
|
@@ -0,0 +1,751 @@
|
|
|
+/*
|
|
|
+---------------------------------------------------------------------------
|
|
|
+Open Asset Import Library (assimp)
|
|
|
+---------------------------------------------------------------------------
|
|
|
+
|
|
|
+Copyright (c) 2006-2024, 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.
|
|
|
+ ---------------------------------------------------------------------------
|
|
|
+ */
|
|
|
+
|
|
|
+/** @file USDLoader.cpp
|
|
|
+ * @brief Implementation of the USD importer class
|
|
|
+ */
|
|
|
+
|
|
|
+#ifndef ASSIMP_BUILD_NO_USD_IMPORTER
|
|
|
+#include <memory>
|
|
|
+#include <sstream>
|
|
|
+
|
|
|
+// internal headers
|
|
|
+#include <assimp/ai_assert.h>
|
|
|
+#include <assimp/anim.h>
|
|
|
+#include <assimp/CreateAnimMesh.h>
|
|
|
+#include <assimp/DefaultIOSystem.h>
|
|
|
+#include <assimp/DefaultLogger.hpp>
|
|
|
+#include <assimp/fast_atof.h>
|
|
|
+#include <assimp/Importer.hpp>
|
|
|
+#include <assimp/importerdesc.h>
|
|
|
+#include <assimp/IOStreamBuffer.h>
|
|
|
+#include <assimp/IOSystem.hpp>
|
|
|
+#include <assimp/StringUtils.h>
|
|
|
+#include <assimp/StreamReader.h>
|
|
|
+
|
|
|
+#include "io-util.hh" // namespace tinyusdz::io
|
|
|
+#include "tydra/scene-access.hh"
|
|
|
+#include "tydra/shader-network.hh"
|
|
|
+#include "USDLoaderImplTinyusdzHelper.h"
|
|
|
+#include "USDLoaderImplTinyusdz.h"
|
|
|
+#include "USDLoaderUtil.h"
|
|
|
+#include "USDPreprocessor.h"
|
|
|
+
|
|
|
+#include "../../../contrib/tinyusdz/assimp_tinyusdz_logging.inc"
|
|
|
+
|
|
|
+namespace {
|
|
|
+ const char *const TAG = "tinyusdz loader";
|
|
|
+}
|
|
|
+
|
|
|
+namespace Assimp {
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::InternReadFile(
|
|
|
+ const std::string &pFile,
|
|
|
+ aiScene *pScene,
|
|
|
+ IOSystem *pIOHandler) {
|
|
|
+ UNUSED(pIOHandler);
|
|
|
+ UNUSED(TAG); // Ignore unused variable when -Werror enabled
|
|
|
+ // Grab filename for logging purposes
|
|
|
+ size_t pos = pFile.find_last_of('/');
|
|
|
+ string basePath = pFile.substr(0, pos);
|
|
|
+ string nameWExt = pFile.substr(pos + 1);
|
|
|
+ stringstream ss;
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): model" << nameWExt;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+
|
|
|
+ bool ret{ false };
|
|
|
+ tinyusdz::USDLoadOptions options;
|
|
|
+ tinyusdz::Stage stage;
|
|
|
+ std::string warn, err;
|
|
|
+ bool is_usdz{ false };
|
|
|
+ if (isUsdc(pFile)) {
|
|
|
+ ret = LoadUSDCFromFile(pFile, &stage, &warn, &err, options);
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): LoadUSDCFromFile() result: " << ret;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ } else if (isUsda(pFile)) {
|
|
|
+ ret = LoadUSDAFromFile(pFile, &stage, &warn, &err, options);
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): LoadUSDAFromFile() result: " << ret;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ } else if (isUsdz(pFile)) {
|
|
|
+ ret = LoadUSDZFromFile(pFile, &stage, &warn, &err, options);
|
|
|
+ is_usdz = true;
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): LoadUSDZFromFile() result: " << ret;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ } else if (isUsd(pFile)) {
|
|
|
+ ret = LoadUSDFromFile(pFile, &stage, &warn, &err, options);
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): LoadUSDFromFile() result: " << ret;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ }
|
|
|
+ if (warn.empty() && err.empty()) {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): load free of warnings/errors";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ } else {
|
|
|
+ if (!warn.empty()) {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): WARNING reported: " << warn;
|
|
|
+ TINYUSDZLOGW(TAG, "%s", ss.str().c_str());
|
|
|
+ }
|
|
|
+ if (!err.empty()) {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): ERROR reported: " << err;
|
|
|
+ TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!ret) {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): ERROR: load failed! ret: " << ret;
|
|
|
+ TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ tinyusdz::tydra::RenderScene render_scene;
|
|
|
+ tinyusdz::tydra::RenderSceneConverter converter;
|
|
|
+ tinyusdz::tydra::RenderSceneConverterEnv env(stage);
|
|
|
+ std::string usd_basedir = tinyusdz::io::GetBaseDir(pFile);
|
|
|
+ env.set_search_paths({ usd_basedir }); // {} needed to convert to vector of char
|
|
|
+
|
|
|
+ // NOTE: Pointer address of usdz_asset must be valid until the call of RenderSceneConverter::ConvertToRenderScene.
|
|
|
+ tinyusdz::USDZAsset usdz_asset;
|
|
|
+ if (is_usdz) {
|
|
|
+ if (!tinyusdz::ReadUSDZAssetInfoFromFile(pFile, &usdz_asset, &warn, &err)) {
|
|
|
+ if (!warn.empty()) {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): ReadUSDZAssetInfoFromFile: WARNING reported: " << warn;
|
|
|
+ TINYUSDZLOGW(TAG, "%s", ss.str().c_str());
|
|
|
+ }
|
|
|
+ if (!err.empty()) {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): ReadUSDZAssetInfoFromFile: ERROR reported: " << err;
|
|
|
+ TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
|
|
+ }
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): ReadUSDZAssetInfoFromFile: ERROR!";
|
|
|
+ TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
|
|
+ } else {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): ReadUSDZAssetInfoFromFile: OK";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ }
|
|
|
+
|
|
|
+ tinyusdz::AssetResolutionResolver arr;
|
|
|
+ if (!tinyusdz::SetupUSDZAssetResolution(arr, &usdz_asset)) {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): SetupUSDZAssetResolution: ERROR: load failed! ret: " << ret;
|
|
|
+ TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
|
|
+ } else {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): SetupUSDZAssetResolution: OK";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ env.asset_resolver = arr;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ret = converter.ConvertToRenderScene(env, &render_scene);
|
|
|
+ if (!ret) {
|
|
|
+ ss.str("");
|
|
|
+ ss << "InternReadFile(): ConvertToRenderScene() failed!";
|
|
|
+ TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+// sanityCheckNodesRecursive(pScene->mRootNode);
|
|
|
+ meshes(render_scene, pScene, nameWExt);
|
|
|
+ materials(render_scene, pScene, nameWExt);
|
|
|
+ textures(render_scene, pScene, nameWExt);
|
|
|
+ textureImages(render_scene, pScene, nameWExt);
|
|
|
+ buffers(render_scene, pScene, nameWExt);
|
|
|
+
|
|
|
+ std::map<size_t, tinyusdz::tydra::Node> meshNodes;
|
|
|
+ setupNodes(render_scene, pScene, meshNodes, nameWExt);
|
|
|
+
|
|
|
+ setupBlendShapes(render_scene, pScene, nameWExt);
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::meshes(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ stringstream ss;
|
|
|
+ pScene->mNumMeshes = static_cast<unsigned int>(render_scene.meshes.size());
|
|
|
+ pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]();
|
|
|
+ ss.str("");
|
|
|
+ ss << "meshes(): pScene->mNumMeshes: " << pScene->mNumMeshes;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+
|
|
|
+ // Export meshes
|
|
|
+ for (size_t meshIdx = 0; meshIdx < pScene->mNumMeshes; meshIdx++) {
|
|
|
+ pScene->mMeshes[meshIdx] = new aiMesh();
|
|
|
+ pScene->mMeshes[meshIdx]->mName.Set(render_scene.meshes[meshIdx].prim_name);
|
|
|
+ ss.str("");
|
|
|
+ ss << " mesh[" << meshIdx << "]: " <<
|
|
|
+ render_scene.meshes[meshIdx].joint_and_weights.jointIndices.size() << " jointIndices, " <<
|
|
|
+ render_scene.meshes[meshIdx].joint_and_weights.jointWeights.size() << " jointWeights, elementSize: " <<
|
|
|
+ render_scene.meshes[meshIdx].joint_and_weights.elementSize;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ ss.str("");
|
|
|
+ ss << " skel_id: " << render_scene.meshes[meshIdx].skel_id;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ if (render_scene.meshes[meshIdx].material_id > -1) {
|
|
|
+ pScene->mMeshes[meshIdx]->mMaterialIndex = render_scene.meshes[meshIdx].material_id;
|
|
|
+ }
|
|
|
+ verticesForMesh(render_scene, pScene, meshIdx, nameWExt);
|
|
|
+ facesForMesh(render_scene, pScene, meshIdx, nameWExt);
|
|
|
+ // Some models infer normals from faces, but others need them e.g.
|
|
|
+ // - apple "toy car" canopy normals will be wrong
|
|
|
+ // - human "untitled" model (tinyusdz issue #115) will be "splotchy"
|
|
|
+ normalsForMesh(render_scene, pScene, meshIdx, nameWExt);
|
|
|
+ materialsForMesh(render_scene, pScene, meshIdx, nameWExt);
|
|
|
+ uvsForMesh(render_scene, pScene, meshIdx, nameWExt);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::verticesForMesh(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ size_t meshIdx,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ UNUSED(nameWExt);
|
|
|
+ pScene->mMeshes[meshIdx]->mNumVertices = static_cast<unsigned int>(render_scene.meshes[meshIdx].points.size());
|
|
|
+ pScene->mMeshes[meshIdx]->mVertices = new aiVector3D[pScene->mMeshes[meshIdx]->mNumVertices];
|
|
|
+ for (size_t j = 0; j < pScene->mMeshes[meshIdx]->mNumVertices; ++j) {
|
|
|
+ pScene->mMeshes[meshIdx]->mVertices[j].x = render_scene.meshes[meshIdx].points[j][0];
|
|
|
+ pScene->mMeshes[meshIdx]->mVertices[j].y = render_scene.meshes[meshIdx].points[j][1];
|
|
|
+ pScene->mMeshes[meshIdx]->mVertices[j].z = render_scene.meshes[meshIdx].points[j][2];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::facesForMesh(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ size_t meshIdx,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ UNUSED(nameWExt);
|
|
|
+ pScene->mMeshes[meshIdx]->mNumFaces = static_cast<unsigned int>(render_scene.meshes[meshIdx].faceVertexCounts().size());
|
|
|
+ pScene->mMeshes[meshIdx]->mFaces = new aiFace[pScene->mMeshes[meshIdx]->mNumFaces]();
|
|
|
+ size_t faceVertIdxOffset = 0;
|
|
|
+ for (size_t faceIdx = 0; faceIdx < pScene->mMeshes[meshIdx]->mNumFaces; ++faceIdx) {
|
|
|
+ pScene->mMeshes[meshIdx]->mFaces[faceIdx].mNumIndices = render_scene.meshes[meshIdx].faceVertexCounts()[faceIdx];
|
|
|
+ pScene->mMeshes[meshIdx]->mFaces[faceIdx].mIndices = new unsigned int[pScene->mMeshes[meshIdx]->mFaces[faceIdx].mNumIndices];
|
|
|
+ for (size_t j = 0; j < pScene->mMeshes[meshIdx]->mFaces[faceIdx].mNumIndices; ++j) {
|
|
|
+ pScene->mMeshes[meshIdx]->mFaces[faceIdx].mIndices[j] =
|
|
|
+ render_scene.meshes[meshIdx].faceVertexIndices()[j + faceVertIdxOffset];
|
|
|
+ }
|
|
|
+ faceVertIdxOffset += pScene->mMeshes[meshIdx]->mFaces[faceIdx].mNumIndices;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::normalsForMesh(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ size_t meshIdx,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ UNUSED(nameWExt);
|
|
|
+ pScene->mMeshes[meshIdx]->mNormals = new aiVector3D[pScene->mMeshes[meshIdx]->mNumVertices];
|
|
|
+ const float *floatPtr = reinterpret_cast<const float *>(render_scene.meshes[meshIdx].normals.get_data().data());
|
|
|
+ for (size_t vertIdx = 0, fpj = 0; vertIdx < pScene->mMeshes[meshIdx]->mNumVertices; ++vertIdx, fpj += 3) {
|
|
|
+ pScene->mMeshes[meshIdx]->mNormals[vertIdx].x = floatPtr[fpj];
|
|
|
+ pScene->mMeshes[meshIdx]->mNormals[vertIdx].y = floatPtr[fpj + 1];
|
|
|
+ pScene->mMeshes[meshIdx]->mNormals[vertIdx].z = floatPtr[fpj + 2];
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::materialsForMesh(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ size_t meshIdx,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ UNUSED(render_scene); UNUSED(pScene); UNUSED(meshIdx); UNUSED(nameWExt);
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::uvsForMesh(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ size_t meshIdx,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ UNUSED(nameWExt);
|
|
|
+ const size_t uvSlotsCount = render_scene.meshes[meshIdx].texcoords.size();
|
|
|
+ if (uvSlotsCount < 1) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ pScene->mMeshes[meshIdx]->mTextureCoords[0] = new aiVector3D[pScene->mMeshes[meshIdx]->mNumVertices];
|
|
|
+ pScene->mMeshes[meshIdx]->mNumUVComponents[0] = 2; // U and V stored in "x", "y" of aiVector3D.
|
|
|
+ for (unsigned int uvSlotIdx = 0; uvSlotIdx < uvSlotsCount; ++uvSlotIdx) {
|
|
|
+ const auto uvsForSlot = render_scene.meshes[meshIdx].texcoords.at(uvSlotIdx);
|
|
|
+ if (uvsForSlot.get_data().size() == 0) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ const float *floatPtr = reinterpret_cast<const float *>(uvsForSlot.get_data().data());
|
|
|
+ for (size_t vertIdx = 0, fpj = 0; vertIdx < pScene->mMeshes[meshIdx]->mNumVertices; ++vertIdx, fpj += 2) {
|
|
|
+ pScene->mMeshes[meshIdx]->mTextureCoords[uvSlotIdx][vertIdx].x = floatPtr[fpj];
|
|
|
+ pScene->mMeshes[meshIdx]->mTextureCoords[uvSlotIdx][vertIdx].y = floatPtr[fpj + 1];
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+static aiColor3D *ownedColorPtrFor(const std::array<float, 3> &color) {
|
|
|
+ aiColor3D *colorPtr = new aiColor3D();
|
|
|
+ colorPtr->r = color[0];
|
|
|
+ colorPtr->g = color[1];
|
|
|
+ colorPtr->b = color[2];
|
|
|
+ return colorPtr;
|
|
|
+}
|
|
|
+
|
|
|
+static std::string nameForTextureWithId(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ const int targetId) {
|
|
|
+ stringstream ss;
|
|
|
+ std::string texName;
|
|
|
+ for (const auto &image : render_scene.images) {
|
|
|
+ if (image.buffer_id == targetId) {
|
|
|
+ texName = image.asset_identifier;
|
|
|
+ ss.str("");
|
|
|
+ ss << "nameForTextureWithId(): found texture " << texName << " with target id " << targetId;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ ss.str("");
|
|
|
+ ss << "nameForTextureWithId(): ERROR! Failed to find texture with target id " << targetId;
|
|
|
+ TINYUSDZLOGE(TAG, "%s", ss.str().c_str());
|
|
|
+ return texName;
|
|
|
+}
|
|
|
+
|
|
|
+static void assignTexture(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ const tinyusdz::tydra::RenderMaterial &material,
|
|
|
+ aiMaterial *mat,
|
|
|
+ const int textureId,
|
|
|
+ const int aiTextureType) {
|
|
|
+ UNUSED(material);
|
|
|
+ std::string name = nameForTextureWithId(render_scene, textureId);
|
|
|
+ aiString *texName = new aiString();
|
|
|
+ texName->Set(name);
|
|
|
+ stringstream ss;
|
|
|
+ ss.str("");
|
|
|
+ ss << "assignTexture(): name: " << name;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ // TODO: verify hard-coded '0' index is correct
|
|
|
+ mat->AddProperty(texName, _AI_MATKEY_TEXTURE_BASE, aiTextureType, 0);
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::materials(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ const size_t numMaterials{render_scene.materials.size()};
|
|
|
+ (void) numMaterials; // Ignore unused variable when -Werror enabled
|
|
|
+ stringstream ss;
|
|
|
+ ss.str("");
|
|
|
+ ss << "materials(): model" << nameWExt << ", numMaterials: " << numMaterials;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ pScene->mNumMaterials = 0;
|
|
|
+ if (render_scene.materials.empty()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ pScene->mMaterials = new aiMaterial *[render_scene.materials.size()];
|
|
|
+ for (const auto &material : render_scene.materials) {
|
|
|
+ ss.str("");
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: name: |" << material.name << "|, disp name: |" << material.display_name << "|";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ aiMaterial *mat = new aiMaterial;
|
|
|
+
|
|
|
+ aiString *materialName = new aiString();
|
|
|
+ materialName->Set(material.name);
|
|
|
+ mat->AddProperty(materialName, AI_MATKEY_NAME);
|
|
|
+
|
|
|
+ mat->AddProperty(
|
|
|
+ ownedColorPtrFor(material.surfaceShader.diffuseColor.value),
|
|
|
+ 1, AI_MATKEY_COLOR_DIFFUSE);
|
|
|
+ mat->AddProperty(
|
|
|
+ ownedColorPtrFor(material.surfaceShader.specularColor.value),
|
|
|
+ 1, AI_MATKEY_COLOR_SPECULAR);
|
|
|
+ mat->AddProperty(
|
|
|
+ ownedColorPtrFor(material.surfaceShader.emissiveColor.value),
|
|
|
+ 1, AI_MATKEY_COLOR_EMISSIVE);
|
|
|
+
|
|
|
+ ss.str("");
|
|
|
+ if (material.surfaceShader.diffuseColor.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.diffuseColor.texture_id, aiTextureType_DIFFUSE);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: diff tex id " << material.surfaceShader.diffuseColor.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.specularColor.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.specularColor.texture_id, aiTextureType_SPECULAR);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: spec tex id " << material.surfaceShader.specularColor.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.normal.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.normal.texture_id, aiTextureType_NORMALS);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: normal tex id " << material.surfaceShader.normal.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.emissiveColor.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.emissiveColor.texture_id, aiTextureType_EMISSIVE);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: emissive tex id " << material.surfaceShader.emissiveColor.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.occlusion.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.occlusion.texture_id, aiTextureType_LIGHTMAP);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: lightmap (occlusion) tex id " << material.surfaceShader.occlusion.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.metallic.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.metallic.texture_id, aiTextureType_METALNESS);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: metallic tex id " << material.surfaceShader.metallic.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.roughness.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.roughness.texture_id, aiTextureType_DIFFUSE_ROUGHNESS);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: roughness tex id " << material.surfaceShader.roughness.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.clearcoat.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.clearcoat.texture_id, aiTextureType_CLEARCOAT);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: clearcoat tex id " << material.surfaceShader.clearcoat.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.opacity.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.opacity.texture_id, aiTextureType_OPACITY);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: opacity tex id " << material.surfaceShader.opacity.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.displacement.is_texture()) {
|
|
|
+ assignTexture(render_scene, material, mat, material.surfaceShader.displacement.texture_id, aiTextureType_DISPLACEMENT);
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: displacement tex id " << material.surfaceShader.displacement.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.clearcoatRoughness.is_texture()) {
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: clearcoatRoughness tex id " << material.surfaceShader.clearcoatRoughness.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.opacityThreshold.is_texture()) {
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: opacityThreshold tex id " << material.surfaceShader.opacityThreshold.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (material.surfaceShader.ior.is_texture()) {
|
|
|
+ ss << " material[" << pScene->mNumMaterials << "]: ior tex id " << material.surfaceShader.ior.texture_id << "\n";
|
|
|
+ }
|
|
|
+ if (!ss.str().empty()) {
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ }
|
|
|
+
|
|
|
+ pScene->mMaterials[pScene->mNumMaterials] = mat;
|
|
|
+ ++pScene->mNumMaterials;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::textures(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ UNUSED(pScene);
|
|
|
+ const size_t numTextures{render_scene.textures.size()};
|
|
|
+ UNUSED(numTextures); // Ignore unused variable when -Werror enabled
|
|
|
+ stringstream ss;
|
|
|
+ ss.str("");
|
|
|
+ ss << "textures(): model" << nameWExt << ", numTextures: " << numTextures;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ size_t i{0};
|
|
|
+ UNUSED(i);
|
|
|
+ for (const auto &texture : render_scene.textures) {
|
|
|
+ UNUSED(texture);
|
|
|
+ ss.str("");
|
|
|
+ ss << " texture[" << i << "]: id: " << texture.texture_image_id << ", disp name: |" << texture.display_name << "|, varname_uv: " <<
|
|
|
+ texture.varname_uv << ", prim_name: |" << texture.prim_name << "|, abs_path: |" << texture.abs_path << "|";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+/**
|
|
|
+ * "owned" as in, used "new" to allocate and aiScene now responsible for "delete"
|
|
|
+ *
|
|
|
+ * @param render_scene renderScene object
|
|
|
+ * @param image textureImage object
|
|
|
+ * @param nameWExt filename w/ext (use to extract file type hint)
|
|
|
+ * @return aiTexture ptr
|
|
|
+ */
|
|
|
+static aiTexture *ownedEmbeddedTextureFor(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ const tinyusdz::tydra::TextureImage &image,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ UNUSED(nameWExt);
|
|
|
+ stringstream ss;
|
|
|
+ aiTexture *tex = new aiTexture();
|
|
|
+ size_t pos = image.asset_identifier.find_last_of('/');
|
|
|
+ string embTexName{image.asset_identifier.substr(pos + 1)};
|
|
|
+ tex->mFilename.Set(image.asset_identifier.c_str());
|
|
|
+ tex->mHeight = image.height;
|
|
|
+// const size_t imageBytesCount{render_scene.buffers[image.buffer_id].data.size() / image.channels};
|
|
|
+ tex->mWidth = image.width;
|
|
|
+ if (tex->mHeight == 0) {
|
|
|
+ pos = embTexName.find_last_of('.');
|
|
|
+ strncpy(tex->achFormatHint, embTexName.substr(pos + 1).c_str(), 3);
|
|
|
+ const size_t imageBytesCount{render_scene.buffers[image.buffer_id].data.size()};
|
|
|
+ tex->pcData = (aiTexel *) new char[imageBytesCount];
|
|
|
+ memcpy(tex->pcData, &render_scene.buffers[image.buffer_id].data[0], imageBytesCount);
|
|
|
+ } else {
|
|
|
+ string formatHint{"rgba8888"};
|
|
|
+ strncpy(tex->achFormatHint, formatHint.c_str(), 8);
|
|
|
+ const size_t imageTexelsCount{tex->mWidth * tex->mHeight};
|
|
|
+ tex->pcData = (aiTexel *) new char[imageTexelsCount * image.channels];
|
|
|
+ const float *floatPtr = reinterpret_cast<const float *>(&render_scene.buffers[image.buffer_id].data[0]);
|
|
|
+ ss.str("");
|
|
|
+ ss << "ownedEmbeddedTextureFor(): manual fill...";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ for (size_t i = 0, fpi = 0; i < imageTexelsCount; ++i, fpi += 4) {
|
|
|
+ tex->pcData[i].b = static_cast<uint8_t>(floatPtr[fpi] * 255);
|
|
|
+ tex->pcData[i].g = static_cast<uint8_t>(floatPtr[fpi + 1] * 255);
|
|
|
+ tex->pcData[i].r = static_cast<uint8_t>(floatPtr[fpi + 2] * 255);
|
|
|
+ tex->pcData[i].a = static_cast<uint8_t>(floatPtr[fpi + 3] * 255);
|
|
|
+ }
|
|
|
+ ss.str("");
|
|
|
+ ss << "ownedEmbeddedTextureFor(): imageTexelsCount: " << imageTexelsCount << ", channels: " << image.channels;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ }
|
|
|
+ return tex;
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::textureImages(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ stringstream ss;
|
|
|
+ const size_t numTextureImages{render_scene.images.size()};
|
|
|
+ UNUSED(numTextureImages); // Ignore unused variable when -Werror enabled
|
|
|
+ ss.str("");
|
|
|
+ ss << "textureImages(): model" << nameWExt << ", numTextureImages: " << numTextureImages;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ pScene->mTextures = nullptr; // Need to iterate over images before knowing if valid textures available
|
|
|
+ pScene->mNumTextures = 0;
|
|
|
+ for (const auto &image : render_scene.images) {
|
|
|
+ ss.str("");
|
|
|
+ ss << " image[" << pScene->mNumTextures << "]: |" << image.asset_identifier << "| w: " << image.width << ", h: " << image.height <<
|
|
|
+ ", channels: " << image.channels << ", miplevel: " << image.miplevel << ", buffer id: " << image.buffer_id << "\n" <<
|
|
|
+ " buffers.size(): " << render_scene.buffers.size() << ", data empty? " << render_scene.buffers[image.buffer_id].data.empty();
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ if (image.buffer_id > -1 &&
|
|
|
+ image.buffer_id < static_cast<long int>(render_scene.buffers.size()) &&
|
|
|
+ !render_scene.buffers[image.buffer_id].data.empty()) {
|
|
|
+ aiTexture *tex = ownedEmbeddedTextureFor(
|
|
|
+ render_scene,
|
|
|
+ image,
|
|
|
+ nameWExt);
|
|
|
+ if (pScene->mTextures == nullptr) {
|
|
|
+ ss.str("");
|
|
|
+ ss << " Init pScene->mTextures[" << render_scene.images.size() << "]";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ pScene->mTextures = new aiTexture *[render_scene.images.size()];
|
|
|
+ }
|
|
|
+ ss.str("");
|
|
|
+ ss << " pScene->mTextures[" << pScene->mNumTextures << "] name: |" << tex->mFilename.C_Str() <<
|
|
|
+ "|, w: " << tex->mWidth << ", h: " << tex->mHeight << ", hint: " << tex->achFormatHint;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ pScene->mTextures[pScene->mNumTextures++] = tex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::buffers(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ const size_t numBuffers{render_scene.buffers.size()};
|
|
|
+ UNUSED(pScene); UNUSED(numBuffers); // Ignore unused variable when -Werror enabled
|
|
|
+ stringstream ss;
|
|
|
+ ss.str("");
|
|
|
+ ss << "buffers(): model" << nameWExt << ", numBuffers: " << numBuffers;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ size_t i = 0;
|
|
|
+ for (const auto &buffer : render_scene.buffers) {
|
|
|
+ ss.str("");
|
|
|
+ ss << " buffer[" << i << "]: count: " << buffer.data.size() << ", type: " << to_string(buffer.componentType);
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::setupNodes(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ std::map<size_t, tinyusdz::tydra::Node> &meshNodes,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ stringstream ss;
|
|
|
+
|
|
|
+ pScene->mRootNode = nodes(render_scene, meshNodes, nameWExt);
|
|
|
+ pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
|
|
|
+ pScene->mRootNode->mMeshes = new unsigned int[pScene->mRootNode->mNumMeshes];
|
|
|
+ ss.str("");
|
|
|
+ ss << "setupNodes(): pScene->mNumMeshes: " << pScene->mNumMeshes;
|
|
|
+ if (pScene->mRootNode != nullptr) {
|
|
|
+ ss << ", mRootNode->mNumMeshes: " << pScene->mRootNode->mNumMeshes;
|
|
|
+ }
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+
|
|
|
+ for (unsigned int meshIdx = 0; meshIdx < pScene->mNumMeshes; meshIdx++) {
|
|
|
+ pScene->mRootNode->mMeshes[meshIdx] = meshIdx;
|
|
|
+ }
|
|
|
+
|
|
|
+}
|
|
|
+
|
|
|
+aiNode *USDImporterImplTinyusdz::nodes(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ std::map<size_t, tinyusdz::tydra::Node> &meshNodes,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ const size_t numNodes{render_scene.nodes.size()};
|
|
|
+ (void) numNodes; // Ignore unused variable when -Werror enabled
|
|
|
+ stringstream ss;
|
|
|
+ ss.str("");
|
|
|
+ ss << "nodes(): model" << nameWExt << ", numNodes: " << numNodes;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ return nodesRecursive(nullptr, render_scene.nodes[0], meshNodes);
|
|
|
+}
|
|
|
+
|
|
|
+using Assimp::tinyusdzNodeTypeFor;
|
|
|
+using Assimp::tinyUsdzMat4ToAiMat4;
|
|
|
+using tinyusdz::tydra::NodeType;
|
|
|
+aiNode *USDImporterImplTinyusdz::nodesRecursive(
|
|
|
+ aiNode *pNodeParent,
|
|
|
+ const tinyusdz::tydra::Node &node,
|
|
|
+ std::map<size_t, tinyusdz::tydra::Node> &meshNodes) {
|
|
|
+ stringstream ss;
|
|
|
+ aiNode *cNode = new aiNode();
|
|
|
+ cNode->mParent = pNodeParent;
|
|
|
+ cNode->mName.Set(node.prim_name);
|
|
|
+ cNode->mTransformation = tinyUsdzMat4ToAiMat4(node.local_matrix.m);
|
|
|
+ ss.str("");
|
|
|
+ ss << "nodesRecursive(): node " << cNode->mName.C_Str() <<
|
|
|
+ " type: |" << tinyusdzNodeTypeFor(node.nodeType) <<
|
|
|
+ "|, disp " << node.display_name << ", abs " << node.abs_path;
|
|
|
+ if (cNode->mParent != nullptr) {
|
|
|
+ ss << " (parent " << cNode->mParent->mName.C_Str() << ")";
|
|
|
+ }
|
|
|
+ ss << " has " << node.children.size() << " children";
|
|
|
+ if (node.id > -1) {
|
|
|
+ ss << "\n node mesh id: " << node.id << " (node type: " << tinyusdzNodeTypeFor(node.nodeType) << ")";
|
|
|
+ meshNodes[node.id] = node;
|
|
|
+ }
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ if (!node.children.empty()) {
|
|
|
+ cNode->mNumChildren = static_cast<unsigned int>(node.children.size());
|
|
|
+ cNode->mChildren = new aiNode *[cNode->mNumChildren];
|
|
|
+ }
|
|
|
+
|
|
|
+ size_t i{0};
|
|
|
+ for (const auto &childNode: node.children) {
|
|
|
+ cNode->mChildren[i] = nodesRecursive(cNode, childNode, meshNodes);
|
|
|
+ ++i;
|
|
|
+ }
|
|
|
+ return cNode;
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::sanityCheckNodesRecursive(
|
|
|
+ aiNode *cNode) {
|
|
|
+ stringstream ss;
|
|
|
+ ss.str("");
|
|
|
+ ss << "sanityCheckNodesRecursive(): node " << cNode->mName.C_Str();
|
|
|
+ if (cNode->mParent != nullptr) {
|
|
|
+ ss << " (parent " << cNode->mParent->mName.C_Str() << ")";
|
|
|
+ }
|
|
|
+ ss << " has " << cNode->mNumChildren << " children";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ for (size_t i = 0; i < cNode->mNumChildren; ++i) {
|
|
|
+ sanityCheckNodesRecursive(cNode->mChildren[i]);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::setupBlendShapes(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ stringstream ss;
|
|
|
+ ss.str("");
|
|
|
+ ss << "setupBlendShapes(): iterating over " << pScene->mNumMeshes << " meshes for model" << nameWExt;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ for (size_t meshIdx = 0; meshIdx < pScene->mNumMeshes; meshIdx++) {
|
|
|
+ blendShapesForMesh(render_scene, pScene, meshIdx, nameWExt);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void USDImporterImplTinyusdz::blendShapesForMesh(
|
|
|
+ const tinyusdz::tydra::RenderScene &render_scene,
|
|
|
+ aiScene *pScene,
|
|
|
+ size_t meshIdx,
|
|
|
+ const std::string &nameWExt) {
|
|
|
+ UNUSED(nameWExt);
|
|
|
+ stringstream ss;
|
|
|
+ const unsigned int numBlendShapeTargets{static_cast<unsigned int>(render_scene.meshes[meshIdx].targets.size())};
|
|
|
+ UNUSED(numBlendShapeTargets); // Ignore unused variable when -Werror enabled
|
|
|
+ ss.str("");
|
|
|
+ ss << " blendShapesForMesh(): mesh[" << meshIdx << "], numBlendShapeTargets: " << numBlendShapeTargets;
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ if (numBlendShapeTargets > 0) {
|
|
|
+ pScene->mMeshes[meshIdx]->mNumAnimMeshes = numBlendShapeTargets;
|
|
|
+ pScene->mMeshes[meshIdx]->mAnimMeshes = new aiAnimMesh *[pScene->mMeshes[meshIdx]->mNumAnimMeshes];
|
|
|
+ }
|
|
|
+ auto mapIter = render_scene.meshes[meshIdx].targets.begin();
|
|
|
+ size_t animMeshIdx{0};
|
|
|
+ for (; mapIter != render_scene.meshes[meshIdx].targets.end(); ++mapIter) {
|
|
|
+ const std::string name{mapIter->first};
|
|
|
+ const tinyusdz::tydra::ShapeTarget shapeTarget{mapIter->second};
|
|
|
+ pScene->mMeshes[meshIdx]->mAnimMeshes[animMeshIdx] = aiCreateAnimMesh(pScene->mMeshes[meshIdx]);
|
|
|
+ ss.str("");
|
|
|
+ ss << " mAnimMeshes[" << animMeshIdx << "]: mNumVertices: " << pScene->mMeshes[meshIdx]->mAnimMeshes[animMeshIdx]->mNumVertices <<
|
|
|
+ ", target: " << shapeTarget.pointIndices.size() << " pointIndices, " << shapeTarget.pointOffsets.size() <<
|
|
|
+ " pointOffsets, " << shapeTarget.normalOffsets.size() << " normalOffsets";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ for (size_t iVert = 0; iVert < shapeTarget.pointOffsets.size(); ++iVert) {
|
|
|
+ pScene->mMeshes[meshIdx]->mAnimMeshes[animMeshIdx]->mVertices[shapeTarget.pointIndices[iVert]] +=
|
|
|
+ tinyUsdzScaleOrPosToAssimp(shapeTarget.pointOffsets[iVert]);
|
|
|
+ }
|
|
|
+ for (size_t iVert = 0; iVert < shapeTarget.normalOffsets.size(); ++iVert) {
|
|
|
+ pScene->mMeshes[meshIdx]->mAnimMeshes[animMeshIdx]->mNormals[shapeTarget.pointIndices[iVert]] +=
|
|
|
+ tinyUsdzScaleOrPosToAssimp(shapeTarget.normalOffsets[iVert]);
|
|
|
+ }
|
|
|
+ ss.str("");
|
|
|
+ ss << " target[" << animMeshIdx << "]: name: " << name << ", prim_name: " <<
|
|
|
+ shapeTarget.prim_name << ", abs_path: " << shapeTarget.abs_path <<
|
|
|
+ ", display_name: " << shapeTarget.display_name << ", " << shapeTarget.pointIndices.size() <<
|
|
|
+ " pointIndices, " << shapeTarget.pointOffsets.size() << " pointOffsets, " <<
|
|
|
+ shapeTarget.normalOffsets.size() << " normalOffsets, " << shapeTarget.inbetweens.size() <<
|
|
|
+ " inbetweens";
|
|
|
+ TINYUSDZLOGD(TAG, "%s", ss.str().c_str());
|
|
|
+ ++animMeshIdx;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+} // namespace Assimp
|
|
|
+
|
|
|
+#endif // !! ASSIMP_BUILD_NO_USD_IMPORTER
|
Steve M
