Blast 1.1 release (windows / linux)

see docs/release_notes.txt for details

1 files changed, 83 insertions, 48 deletions

diff --git a/tools/common/BlastDataExporter.cpp b/tools/common/BlastDataExporter.cpp
index 622901a..870bdcf 100644
--- a/tools/common/BlastDataExporter.cpp
+++ b/tools/common/BlastDataExporter.cpp
@@ -1,15 +1,69 @@
-#include <BlastDataExporter.h>
+// 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) 2017 NVIDIA Corporation. All rights reserved.
+
+
+#include "BlastDataExporter.h"
 #include "NvBlastExtPxManager.h"
 #include <NvBlastExtAuthoringCollisionBuilder.h>
+#include "NvBlastExtSerialization.h"
+#include "NvBlastExtLlSerialization.h"
+#include "NvBlastExtTkSerialization.h"
+#include "NvBlastExtPxSerialization.h"
 #include <Log.h>
 #include "PsFileBuffer.h"
 #include "NvBlastExtPxAsset.h"
 #include "NvBlast.h"
+#include "NvBlastGlobals.h"
 #include <NvBlastTkAsset.h>
-
+#include <fstream>
 using namespace Nv::Blast;
 
 
+BlastDataExporter::BlastDataExporter(TkFramework* framework, physx::PxPhysics* physics, physx::PxCooking* cooking) : mFramework(framework)
+{
+	mSerialization = NvBlastExtSerializationCreate();
+	if (mSerialization != nullptr && physics != nullptr && cooking != nullptr && framework != nullptr)
+	{
+		NvBlastExtTkSerializerLoadSet(*framework, *mSerialization);
+		NvBlastExtPxSerializerLoadSet(*framework, *physics, *cooking, *mSerialization);
+		mSerialization->setSerializationEncoding(NVBLAST_FOURCC('C', 'P', 'N', 'B'));
+	}
+}
+
+
+BlastDataExporter::~BlastDataExporter()
+{
+	if (mSerialization != nullptr)
+	{
+		mSerialization->release();
+	}
+}
+
+
 ExtPxAsset* BlastDataExporter::createExtBlastAsset(std::vector<NvBlastBondDesc>& bondDescs, const std::vector<NvBlastChunkDesc>& chunkDescs,
 	std::vector<ExtPxAssetDesc::ChunkDesc>& physicsChunks)
 {
@@ -25,24 +79,22 @@ ExtPxAsset* BlastDataExporter::createExtBlastAsset(std::vector<NvBlastBondDesc>&
 }
 
 
-
 NvBlastAsset* BlastDataExporter::createLlBlastAsset(std::vector<NvBlastBondDesc>& bondDescs, const std::vector<NvBlastChunkDesc>& chunkDescs)
 {
-
 	NvBlastAssetDesc assetDesc;
 	assetDesc.bondCount = static_cast<uint32_t>(bondDescs.size());
-	assetDesc.bondDescs = &bondDescs[0];
+	assetDesc.bondDescs = bondDescs.data();
 
 	assetDesc.chunkCount = static_cast<uint32_t>(chunkDescs.size());
-	assetDesc.chunkDescs = &chunkDescs[0];
+	assetDesc.chunkDescs = chunkDescs.data();
 
-
-	std::vector<uint8_t> scratch(static_cast<unsigned int>(NvBlastGetRequiredScratchForCreateAsset(&assetDesc, m_log)));
-	void* mem = _aligned_malloc(NvBlastGetAssetMemorySize(&assetDesc, m_log), 16);
-	NvBlastAsset* asset = NvBlastCreateAsset(mem, &assetDesc, &scratch[0], m_log);
+	std::vector<uint8_t> scratch(static_cast<unsigned int>(NvBlastGetRequiredScratchForCreateAsset(&assetDesc, logLL)));
+	void* mem = NVBLAST_ALLOC(NvBlastGetAssetMemorySize(&assetDesc, logLL));
+	NvBlastAsset* asset = NvBlastCreateAsset(mem, &assetDesc, scratch.data(), logLL);
 	return asset;
 }
 
+
 TkAsset* BlastDataExporter::createTkBlastAsset(const std::vector<NvBlastBondDesc>& bondDescs, const std::vector<NvBlastChunkDesc>& chunkDescs)
 {
 	TkAssetDesc desc;
@@ -56,51 +108,34 @@ TkAsset* BlastDataExporter::createTkBlastAsset(const std::vector<NvBlastBondDesc
 };
 
 
-bool BlastDataExporter::saveBlastLLAsset(const std::string& outputFilePath, const NvBlastAsset* asset)
+bool BlastDataExporter::saveBlastObject(const std::string& outputDir, const std::string& objectName, const void* object, uint32_t objectTypeID)
 {
-	uint32_t assetSize = NvBlastAssetGetSize(asset, m_log);
-
-	physx::PsFileBuffer fileBuf(outputFilePath.c_str(), physx::PxFileBuf::OPEN_WRITE_ONLY);
-	if (!fileBuf.isOpen())
+	void* buffer;
+	const uint64_t bufferSize = mSerialization->serializeIntoBuffer(buffer, object, objectTypeID);
+	if (bufferSize == 0)
 	{
-		NVBLAST_LOG_ERROR(m_log, "Can't open output buffer. \n");
+		std::cerr << "saveBlastObject: Serialization failed.\n";
 		return false;
 	}
-	fileBuf.write(asset, sizeof(char) * assetSize);
-	fileBuf.close();
-	return true;
-}
 
-bool BlastDataExporter::saveBlastTkAsset(const std::string& outputFilePath, const TkAsset* asset)
-{
-	physx::PsFileBuffer fileBuf(outputFilePath.c_str(), physx::PxFileBuf::OPEN_WRITE_ONLY);
-	if (!fileBuf.isOpen())
-	{
-		NVBLAST_LOG_ERROR(m_log, "Can't open output buffer. \n");
-		return false;
-	}
-	if (!asset->serialize(fileBuf))
-	{
-		NVBLAST_LOG_ERROR(m_log, "Serialization failed. \n");
-		return false;
-	}
-	fileBuf.close();
-	return true;
-}
+	physx::PsFileBuffer fileBuf((outputDir + "/" + objectName + ".blast").c_str(), physx::PxFileBuf::OPEN_WRITE_ONLY);
+	bool result = fileBuf.isOpen();
 
-bool BlastDataExporter::saveBlastExtAsset(const std::string& outputFilePath, const ExtPxAsset* asset)
-{
-	physx::PsFileBuffer fileBuf(outputFilePath.c_str(), physx::PxFileBuf::OPEN_WRITE_ONLY);
-	if (!fileBuf.isOpen())
+	if (!result)
 	{
-		NVBLAST_LOG_ERROR(m_log, "Can't open output buffer. \n");
-		return false;
+		std::cerr << "Can't open output buffer.\n";
 	}
-	if (!asset->serialize(fileBuf, *mCooking))
+	else
 	{
-		NVBLAST_LOG_ERROR(m_log, "ExtPhysicsAsset serialization failed.\n");
-		return false;
+		result = (bufferSize == (size_t)fileBuf.write(buffer, (uint32_t)bufferSize));
+		if (!result)
+		{
+			std::cerr << "Buffer write failed.\n";
+		}
+		fileBuf.close();
 	}
-	fileBuf.close();
-	return true;
-}
\ No newline at end of file
+
+	NVBLAST_FREE(buffer);
+
+	return result;
+};