Blast 1.1 release (windows / linux)

see docs/release_notes.txt for details

1 files changed, 133 insertions, 29 deletions

diff --git a/tools/ApexImporter/src/ApexDestructibleObjExporter.cpp b/tools/ApexImporter/src/ApexDestructibleObjExporter.cpp
index 0c90ac1..2a2e21e 100644
--- a/tools/ApexImporter/src/ApexDestructibleObjExporter.cpp
+++ b/tools/ApexImporter/src/ApexDestructibleObjExporter.cpp
@@ -1,3 +1,31 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2016-2017 NVIDIA Corporation. All rights reserved.
+
+
 #include "ApexDestructibleObjExporter.h"
 
 #include "Log.h"
@@ -8,8 +36,8 @@
 #include <PxVec2.h>
 #include <PxVec3.h>
 #include <map>
-#include <FbxFileWriter.h>
-#include <ObjFileWriter.h>
+#include <NvBlastExtExporter.h>
+#include <NvBlastExtAuthoringTypes.h>
 
 
 using namespace nvidia;
@@ -84,20 +112,27 @@ std::string getTextureFromMaterial(const char* materialPath)
 }
 
 
-bool ApexDestructibleGeometryExporter::exportToFile(NvBlastAsset* asset, const DestructibleAsset& apexAsset, const std::string& name, const std::vector<uint32_t>& chunkReorderInvMap, bool toFbx, bool toObj, bool fbxascii, bool toUe4)
+bool ApexDestructibleGeometryExporter::exportToFile(NvBlastAsset* asset, const DestructibleAsset& apexAsset, const std::string& name, 
+	const std::vector<uint32_t>& chunkReorderInvMap, bool toFbx, bool toObj, bool fbxascii, bool nonSkinned, const std::vector<std::vector<CollisionHull*> >& hulls)
 {
 	const RenderMeshAsset* rAsset = apexAsset.getRenderMeshAsset();
-	uint32_t submeshCount = rAsset->getSubmeshCount();	
+
+	Nv::Blast::ExporterMeshData meshData;
+	meshData.asset = asset;
+	meshData.submeshCount = rAsset->getSubmeshCount();
+	meshData.submeshNames = new const char*[meshData.submeshCount];
 	std::vector<std::string> materialPathes;
+	materialPathes.reserve(meshData.submeshCount);
 	// gather materials
 	{
-		for (uint32_t submeshIndex = 0; submeshIndex < submeshCount; ++submeshIndex)
+		for (uint32_t submeshIndex = 0; submeshIndex < meshData.submeshCount; ++submeshIndex)
 		{
 			const char* materialName = rAsset->getMaterialName(submeshIndex);
 			std::ostringstream materialPath;
 			materialPath << m_materialsDir << "\\" << materialName;
 			std::string texturePath = getTextureFromMaterial(materialPath.str().c_str());
 			materialPathes.push_back(texturePath);
+			meshData.submeshNames[submeshIndex] = materialPathes[submeshIndex].c_str();
 		}
 	}
 	struct vc3Comp
@@ -138,7 +173,7 @@ bool ApexDestructibleGeometryExporter::exportToFile(NvBlastAsset* asset, const D
 
 	// gather data for export
 	{		
-		for (uint32_t submeshIndex = 0; submeshIndex < submeshCount; ++submeshIndex)
+		for (uint32_t submeshIndex = 0; submeshIndex < meshData.submeshCount; ++submeshIndex)
 		{
 			const RenderSubmesh& currentSubmesh = rAsset->getSubmesh(submeshIndex);
 			uint32_t indexCount = currentSubmesh.getVertexBuffer().getVertexCount();
@@ -178,7 +213,7 @@ bool ApexDestructibleGeometryExporter::exportToFile(NvBlastAsset* asset, const D
 				}			
 		}
 
-		for (uint32_t submeshIndex = 0; submeshIndex < submeshCount; ++submeshIndex)
+		for (uint32_t submeshIndex = 0; submeshIndex < meshData.submeshCount; ++submeshIndex)
 		{
 			const RenderSubmesh& currentSubmesh = rAsset->getSubmesh(submeshIndex);
 			uint32_t indexCount = currentSubmesh.getVertexBuffer().getVertexCount();
@@ -218,7 +253,7 @@ bool ApexDestructibleGeometryExporter::exportToFile(NvBlastAsset* asset, const D
 				}
 			
 		}
-		for (uint32_t submeshIndex = 0; submeshIndex < submeshCount; ++submeshIndex)
+		for (uint32_t submeshIndex = 0; submeshIndex < meshData.submeshCount; ++submeshIndex)
 		{
 			const RenderSubmesh& currentSubmesh = rAsset->getSubmesh(submeshIndex);
 			uint32_t indexCount = currentSubmesh.getVertexBuffer().getVertexCount();
@@ -257,57 +292,126 @@ bool ApexDestructibleGeometryExporter::exportToFile(NvBlastAsset* asset, const D
 						texturesMapping[oldSize + i] = it->second;
 					}
 				}
-			
+		}
+		for (uint32_t i = 0; i < compressedTextures.size(); ++i)
+		{
+			std::swap(compressedTextures[i].x, compressedTextures[i].y);
 		}
 
-		uint32_t apexChunkCount = apexAsset.getChunkCount();
-		uint32_t chunkCount = static_cast<uint32_t>(chunkReorderInvMap.size());
-
-		std::vector<std::vector<std::vector<int32_t> > > pInd(chunkCount);
-		std::vector<std::vector<std::vector<int32_t> > > tInd(chunkCount);
-		std::vector<std::vector<std::vector<int32_t> > > nInd(chunkCount);
 
+		meshData.positionsCount = (uint32_t)compressedPositions.size();
+		//meshData.positions = compressedPositions.data();
+		meshData.positions = new PxVec3[meshData.positionsCount];
+		memcpy(meshData.positions, compressedPositions.data(), sizeof(PxVec3) * meshData.positionsCount);
+		meshData.normalsCount = (uint32_t)compressedNormals.size();
+		//meshData.normals = compressedNormals.data();
+		meshData.normals = new PxVec3[meshData.normalsCount];
+		memcpy(meshData.normals, compressedNormals.data(), sizeof(PxVec3) * meshData.normalsCount);
+		meshData.uvsCount = (uint32_t)compressedTextures.size();
+		//meshData.uvs = compressedTextures.data();
+		meshData.uvs = new PxVec2[meshData.uvsCount];
+		memcpy(meshData.uvs, compressedTextures.data(), sizeof(PxVec2) * meshData.uvsCount);
 
-		for (uint32_t chunkIndex = 0; chunkIndex < chunkCount; ++chunkIndex)
+		uint32_t apexChunkCount = apexAsset.getChunkCount();
+		meshData.meshCount = (uint32_t)chunkReorderInvMap.size();
+		meshData.submeshOffsets = new uint32_t[meshData.meshCount * meshData.submeshCount + 1]{ 0 };
+	
+		//count total number of indices
+		for (uint32_t chunkIndex = 0; chunkIndex < meshData.meshCount; ++chunkIndex)
+		{
+			uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex];
+			if (apexChunkIndex >= apexChunkCount)
+			{
+				PX_ALWAYS_ASSERT();
+				continue;
+			}
+			uint32_t part = apexAsset.getPartIndex(apexChunkIndex);
+			for (uint32_t submeshIndex = 0; submeshIndex < meshData.submeshCount; ++submeshIndex)
+			{
+				uint32_t indexCount = rAsset->getSubmesh(submeshIndex).getIndexCount(part);
+				uint32_t* firstIdx = meshData.submeshOffsets + chunkIndex * meshData.submeshCount + submeshIndex;
+				*(firstIdx + 1) = *firstIdx + indexCount;
+			}
+		}
+		meshData.posIndex = new uint32_t[meshData.submeshOffsets[meshData.meshCount * meshData.submeshCount]];
+		meshData.normIndex = new uint32_t[meshData.submeshOffsets[meshData.meshCount * meshData.submeshCount]];
+		meshData.texIndex = new uint32_t[meshData.submeshOffsets[meshData.meshCount * meshData.submeshCount]];
+		//copy indices
+		for (uint32_t chunkIndex = 0; chunkIndex < meshData.meshCount; ++chunkIndex)
 		{
 			uint32_t apexChunkIndex = chunkReorderInvMap[chunkIndex];
 			if (apexChunkIndex >= apexChunkCount)
 			{
+				PX_ALWAYS_ASSERT();
 				continue;
 			}
 			uint32_t part = apexAsset.getPartIndex(apexChunkIndex);
 			uint32_t offset = 0;
-			for (uint32_t submeshIndex = 0; submeshIndex < submeshCount; ++submeshIndex)
+			for (uint32_t submeshIndex = 0; submeshIndex < meshData.submeshCount; ++submeshIndex)
 			{
 				const RenderSubmesh& currentSubmesh = rAsset->getSubmesh(submeshIndex);
 				const uint32_t* indexArray = currentSubmesh.getIndexBuffer(part);
 				uint32_t indexCount = currentSubmesh.getIndexCount(part);
-				pInd[chunkIndex].push_back(std::vector<int32_t>());
-				tInd[chunkIndex].push_back(std::vector<int32_t>());
-				nInd[chunkIndex].push_back(std::vector<int32_t>());
+				uint32_t firstIdx = meshData.submeshOffsets[chunkIndex * meshData.submeshCount + submeshIndex];
 
 				for (uint32_t i = 0; i < indexCount;++i)
 				{
-					pInd[chunkIndex].back().push_back(positionsMapping[indexArray[i] + offset]);
-					tInd[chunkIndex].back().push_back(texturesMapping[indexArray[i] + offset]);
-					nInd[chunkIndex].back().push_back(normalsMapping[indexArray[i] + offset]);
+					meshData.posIndex[firstIdx + i] = positionsMapping[indexArray[i] + offset];
+					meshData.normIndex[firstIdx + i] = normalsMapping[indexArray[i] + offset];
+					meshData.texIndex[firstIdx + i] = texturesMapping[indexArray[i] + offset];
 				}
 				offset += currentSubmesh.getVertexBuffer().getVertexCount();
 			}
 		}
+		
+		if (!hulls.empty())
+		{
+			meshData.hullsOffsets = new uint32_t[hulls.size() + 1]{ 0 };
+			for (uint32_t i = 0; i < hulls.size(); i++)
+			{
+				meshData.hullsOffsets[i + 1] = meshData.hullsOffsets[i] + (uint32_t)hulls[i].size();
+			}
+			meshData.hulls = new CollisionHull*[meshData.hullsOffsets[hulls.size()]];
+			for (uint32_t i = 0; i < hulls.size(); i++)
+			{
+				for (uint32_t j = 0; j < hulls[i].size(); j++)
+				{
+					meshData.hulls[meshData.hullsOffsets[i] + j] = hulls[i][j];
+				}
+			}
+		}
+		else
+		{
+			meshData.hulls = nullptr;
+			meshData.hullsOffsets = nullptr;
 
+		}
 		if (toObj)
 		{
-			ObjFileWriter writer;
-			writer.saveToFile(asset, name, m_exportDir, compressedPositions, compressedNormals, compressedTextures, pInd, nInd, tInd, materialPathes, submeshCount);
+			IMeshFileWriter* fileWriter = NvBlastExtExporterCreateObjFileWriter();
+			fileWriter->appendMesh(meshData, name.c_str());
+			fileWriter->saveToFile(name.c_str(), m_exportDir.c_str());
+			fileWriter->release();
+			//writer.saveToFile(asset, name, m_exportDir, compressedPositions, compressedNormals, compressedTextures, pInd, nInd, tInd, materialPathes, submeshCount);
 		}
 		if (toFbx)
 		{
-			FbxFileWriter writer;
-			writer.bOutputFBXAscii = fbxascii;
-			writer.setConvertToUE4(toUe4);
-			writer.saveToFile(asset, name, m_exportDir, compressedPositions, compressedNormals, compressedTextures, pInd, nInd, tInd, materialPathes, submeshCount);
+			IMeshFileWriter* fileWriter = NvBlastExtExporterCreateFbxFileWriter(fbxascii);
+			fileWriter->appendMesh(meshData, name.c_str(), nonSkinned);
+			fileWriter->saveToFile(name.c_str(), m_exportDir.c_str());
+			fileWriter->release();
 		}
+
+		delete[] meshData.hulls;
+		delete[] meshData.hullsOffsets;
+		delete[] meshData.normals;
+		delete[] meshData.normIndex;
+		delete[] meshData.posIndex;
+		delete[] meshData.positions;
+		delete[] meshData.submeshOffsets;
+		delete[] meshData.texIndex;
+		delete[] meshData.submeshNames;
+		delete[] meshData.uvs;
 	}
 
 	return true;