Blast 1.1.3. See docs/release_notes.txt.v1.1.3_rc1

6 files changed, 812 insertions, 812 deletions

diff --git a/tools/common/BlastDataExporter.cpp b/tools/common/BlastDataExporter.cpp
index 3ffffb1..2f88476 100644..100755
--- a/tools/common/BlastDataExporter.cpp
+++ b/tools/common/BlastDataExporter.cpp
@@ -1,141 +1,141 @@
-// 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) 2018 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)
-{
-	ExtPxAssetDesc	descriptor;
-	descriptor.bondCount = static_cast<uint32_t>(bondDescs.size());
-	descriptor.bondDescs = bondDescs.data();
-	descriptor.chunkCount = static_cast<uint32_t>(chunkDescs.size());
-	descriptor.chunkDescs = chunkDescs.data();
-	descriptor.bondFlags = nullptr;
-	descriptor.pxChunks = physicsChunks.data();
-	ExtPxAsset* asset = ExtPxAsset::create(descriptor, *mFramework);
-	return asset;
-}
-
-
-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.data();
-
-	assetDesc.chunkCount = static_cast<uint32_t>(chunkDescs.size());
-	assetDesc.chunkDescs = chunkDescs.data();
-
-	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;
-	desc.bondCount = static_cast<uint32_t>(bondDescs.size());
-	desc.bondDescs = bondDescs.data();
-	desc.chunkCount = static_cast<uint32_t>(chunkDescs.size());
-	desc.chunkDescs = chunkDescs.data();
-	desc.bondFlags = nullptr;
-	TkAsset* asset = mFramework->createAsset(desc);
-	return asset;
-};
-
-
-bool BlastDataExporter::saveBlastObject(const std::string& outputDir, const std::string& objectName, const void* object, uint32_t objectTypeID)
-{
-	void* buffer;
-	const uint64_t bufferSize = mSerialization->serializeIntoBuffer(buffer, object, objectTypeID);
-	if (bufferSize == 0)
-	{
-		std::cerr << "saveBlastObject: Serialization failed.\n";
-		return false;
-	}
-
-	physx::PsFileBuffer fileBuf((outputDir + "/" + objectName + ".blast").c_str(), physx::PxFileBuf::OPEN_WRITE_ONLY);
-	bool result = fileBuf.isOpen();
-
-	if (!result)
-	{
-		std::cerr << "Can't open output buffer.\n";
-	}
-	else
-	{
-		result = (bufferSize == (size_t)fileBuf.write(buffer, (uint32_t)bufferSize));
-		if (!result)
-		{
-			std::cerr << "Buffer write failed.\n";
-		}
-		fileBuf.close();
-	}
-
-	NVBLAST_FREE(buffer);
-
-	return result;
-};
+// 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) 2018 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)

+{

+	ExtPxAssetDesc	descriptor;

+	descriptor.bondCount = static_cast<uint32_t>(bondDescs.size());

+	descriptor.bondDescs = bondDescs.data();

+	descriptor.chunkCount = static_cast<uint32_t>(chunkDescs.size());

+	descriptor.chunkDescs = chunkDescs.data();

+	descriptor.bondFlags = nullptr;

+	descriptor.pxChunks = physicsChunks.data();

+	ExtPxAsset* asset = ExtPxAsset::create(descriptor, *mFramework);

+	return asset;

+}

+

+

+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.data();

+

+	assetDesc.chunkCount = static_cast<uint32_t>(chunkDescs.size());

+	assetDesc.chunkDescs = chunkDescs.data();

+

+	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;

+	desc.bondCount = static_cast<uint32_t>(bondDescs.size());

+	desc.bondDescs = bondDescs.data();

+	desc.chunkCount = static_cast<uint32_t>(chunkDescs.size());

+	desc.chunkDescs = chunkDescs.data();

+	desc.bondFlags = nullptr;

+	TkAsset* asset = mFramework->createAsset(desc);

+	return asset;

+};

+

+

+bool BlastDataExporter::saveBlastObject(const std::string& outputDir, const std::string& objectName, const void* object, uint32_t objectTypeID)

+{

+	void* buffer;

+	const uint64_t bufferSize = mSerialization->serializeIntoBuffer(buffer, object, objectTypeID);

+	if (bufferSize == 0)

+	{

+		std::cerr << "saveBlastObject: Serialization failed.\n";

+		return false;

+	}

+

+	physx::PsFileBuffer fileBuf((outputDir + "/" + objectName + ".blast").c_str(), physx::PxFileBuf::OPEN_WRITE_ONLY);

+	bool result = fileBuf.isOpen();

+

+	if (!result)

+	{

+		std::cerr << "Can't open output buffer.\n";

+	}

+	else

+	{

+		result = (bufferSize == (size_t)fileBuf.write(buffer, (uint32_t)bufferSize));

+		if (!result)

+		{

+			std::cerr << "Buffer write failed.\n";

+		}

+		fileBuf.close();

+	}

+

+	NVBLAST_FREE(buffer);

+

+	return result;

+};

diff --git a/tools/common/BlastDataExporter.h b/tools/common/BlastDataExporter.h
index f3cae31..54e2bbf 100644..100755
--- a/tools/common/BlastDataExporter.h
+++ b/tools/common/BlastDataExporter.h
@@ -1,100 +1,100 @@
-// 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) 2018 NVIDIA Corporation. All rights reserved.
-
-
-#ifndef BLAST_DATA_EXPORTER
-#define BLAST_DATA_EXPORTER
-
-
-#include <NvBlastIndexFns.h>
-#include <NvBlastExtAuthoringTypes.h>
-#include <NvBlastExtPxAsset.h>
-#include <vector>
-#include <string>
-
-using namespace Nv::Blast;
-
-namespace physx
-{
-class PxPhysics;
-class PxCooking;
-}
-
-
-struct NvBlastBondDesc;
-struct NvBlastChunkDesc;
-
-struct NvBlastAsset;
-namespace Nv
-{
-namespace Blast
-{
-class TkAsset;
-class ExtPxAsset;
-class ExtSerialization;
-}
-}
-
-
-/**
-	Tool for Blast asset creation and exporting
-*/
-class BlastDataExporter
-{
-public:
-	BlastDataExporter(TkFramework* framework, physx::PxPhysics* physics, physx::PxCooking* cooking);
-	~BlastDataExporter();
-
-	/**
-		Creates ExtPxAsset
-	*/
-	ExtPxAsset*		createExtBlastAsset(std::vector<NvBlastBondDesc>& bondDescs, const std::vector<NvBlastChunkDesc>& chunkDescs,
-		std::vector<ExtPxAssetDesc::ChunkDesc>& physicsChunks);
-	/**
-		Creates Low Level Blast asset 
-	*/
-	NvBlastAsset*	createLlBlastAsset(std::vector<NvBlastBondDesc>& bondDescs, const std::vector<NvBlastChunkDesc>& chunkDescs);
-
-	/**
-		Creates Blast Toolkit Asset asset 
-	*/
-	TkAsset*		createTkBlastAsset(const std::vector<NvBlastBondDesc>& bondDescs, const std::vector<NvBlastChunkDesc>& chunkDescs);
-
-	/*
-	Saves a Blast object to given path
-	*/
-	bool			saveBlastObject(const std::string& outputDir, const std::string& objectName, const void* object, uint32_t objectTypeID);
-
-private:
-	TkFramework*		mFramework;
-	ExtSerialization*	mSerialization;
-};
-
-
-
-
+// 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) 2018 NVIDIA Corporation. All rights reserved.

+

+

+#ifndef BLAST_DATA_EXPORTER

+#define BLAST_DATA_EXPORTER

+

+

+#include <NvBlastIndexFns.h>

+#include <NvBlastExtAuthoringTypes.h>

+#include <NvBlastExtPxAsset.h>

+#include <vector>

+#include <string>

+

+using namespace Nv::Blast;

+

+namespace physx

+{

+class PxPhysics;

+class PxCooking;

+}

+

+

+struct NvBlastBondDesc;

+struct NvBlastChunkDesc;

+

+struct NvBlastAsset;

+namespace Nv

+{

+namespace Blast

+{

+class TkAsset;

+class ExtPxAsset;

+class ExtSerialization;

+}

+}

+

+

+/**

+	Tool for Blast asset creation and exporting

+*/

+class BlastDataExporter

+{

+public:

+	BlastDataExporter(TkFramework* framework, physx::PxPhysics* physics, physx::PxCooking* cooking);

+	~BlastDataExporter();

+

+	/**

+		Creates ExtPxAsset

+	*/

+	ExtPxAsset*		createExtBlastAsset(std::vector<NvBlastBondDesc>& bondDescs, const std::vector<NvBlastChunkDesc>& chunkDescs,

+		std::vector<ExtPxAssetDesc::ChunkDesc>& physicsChunks);

+	/**

+		Creates Low Level Blast asset 

+	*/

+	NvBlastAsset*	createLlBlastAsset(std::vector<NvBlastBondDesc>& bondDescs, const std::vector<NvBlastChunkDesc>& chunkDescs);

+

+	/**

+		Creates Blast Toolkit Asset asset 

+	*/

+	TkAsset*		createTkBlastAsset(const std::vector<NvBlastBondDesc>& bondDescs, const std::vector<NvBlastChunkDesc>& chunkDescs);

+

+	/*

+	Saves a Blast object to given path

+	*/

+	bool			saveBlastObject(const std::string& outputDir, const std::string& objectName, const void* object, uint32_t objectTypeID);

+

+private:

+	TkFramework*		mFramework;

+	ExtSerialization*	mSerialization;

+};

+

+

+

+

 #endif
\ No newline at end of file
diff --git a/tools/common/Log.cpp b/tools/common/Log.cpp
index 0d4c8f7..57a25b4 100644..100755
--- a/tools/common/Log.cpp
+++ b/tools/common/Log.cpp
@@ -1,87 +1,87 @@
-// 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-2018 NVIDIA Corporation. All rights reserved.
-
-
-#include "Log.h"
-
-#include "PsString.h"
-
-#include <iomanip>
-#include <stdarg.h>
-#include <stdio.h>
-
-///////////////////////////////////////////////////////////////////////////
-
-namespace Nv
-{
-namespace Blast
-{
-
-void fLogf(const char* format, ...)
-{
-	char    buf[4096], *p = buf;
-	va_list args;
-	int     n;
-
-	va_start(args, format);
-	//n = _vsnprintf(p, sizeof buf - 3, format, args);
-	n = vsprintf_s(p, sizeof(buf)-3, format, args);
-	va_end(args);
-
-	p += (n < 0) ? sizeof buf - 3 : n;
-
-	while (p > buf  &&  isspace((unsigned char)p[-1]))
-	{
-		*--p = '\0';
-	}
-
-	*p++ = '\r';
-	*p++ = '\n';
-	*p   = '\0';
-
-	fLog(buf, Log::TYPE_INFO);
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-
-void Log::flushDeferredMessages()
-{
-	if (mDeferredMessages.size() == 0) return;
-
-	std::cout << std::endl;
-	for (std::vector<std::string>::iterator it = mDeferredMessages.begin(); it != mDeferredMessages.end(); ++it)
-	{
-		log(*it, mMinVerbosity);
-	}
-	mDeferredMessages.clear();
-}
-
-
-
-} // namespace Blast
-} // namespace Nv
+// 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-2018 NVIDIA Corporation. All rights reserved.

+

+

+#include "Log.h"

+

+#include "PsString.h"

+

+#include <iomanip>

+#include <stdarg.h>

+#include <stdio.h>

+

+///////////////////////////////////////////////////////////////////////////

+

+namespace Nv

+{

+namespace Blast

+{

+

+void fLogf(const char* format, ...)

+{

+	char    buf[4096], *p = buf;

+	va_list args;

+	int     n;

+

+	va_start(args, format);

+	//n = _vsnprintf(p, sizeof buf - 3, format, args);

+	n = vsprintf_s(p, sizeof(buf)-3, format, args);

+	va_end(args);

+

+	p += (n < 0) ? sizeof buf - 3 : n;

+

+	while (p > buf  &&  isspace((unsigned char)p[-1]))

+	{

+		*--p = '\0';

+	}

+

+	*p++ = '\r';

+	*p++ = '\n';

+	*p   = '\0';

+

+	fLog(buf, Log::TYPE_INFO);

+}

+

+

+//////////////////////////////////////////////////////////////////////////////

+

+void Log::flushDeferredMessages()

+{

+	if (mDeferredMessages.size() == 0) return;

+

+	std::cout << std::endl;

+	for (std::vector<std::string>::iterator it = mDeferredMessages.begin(); it != mDeferredMessages.end(); ++it)

+	{

+		log(*it, mMinVerbosity);

+	}

+	mDeferredMessages.clear();

+}

+

+

+

+} // namespace Blast

+} // namespace Nv

diff --git a/tools/common/Log.h b/tools/common/Log.h
index 8df9660..588c32b 100644..100755
--- a/tools/common/Log.h
+++ b/tools/common/Log.h
@@ -1,150 +1,150 @@
-// 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-2018 NVIDIA Corporation. All rights reserved.
-
-
-#ifndef LOG_H
-#define LOG_H
-
-#include "Utils.h"
-#include "PxVec3.h"
-
-#include <sstream>
-
-namespace Nv
-{
-namespace Blast
-{
-
-
-//////////////////////////////////////////////////////////////////////////////
-
-void fLogf(const char* format, ...);
-
-class Log : public Singleton<Log>
-{
-	friend class Singleton<Log>;
-
-public:
-
-	enum MessageType {
-		TYPE_INFO = 0,
-		TYPE_WARNING,
-		TYPE_ERROR,
-		TYPE_DEFERRED,
-
-		NUM_TYPES,
-		MOST_VERBOSE  = TYPE_INFO,
-		LEAST_VERBOSE = TYPE_ERROR
-#if defined(_DEBUG)
-		, DEFAULT_VERBOSITY = MOST_VERBOSE
-#else
-		, DEFAULT_VERBOSITY = LEAST_VERBOSE
-#endif
-	};
-	typedef MessageType Verbosity;
-
-	///////////////////////////////////////////////////////////////////////////
-
-	template<typename T>
-	Log& log(const T& value, MessageType messageType);
-
-	void flushDeferredMessages();
-
-	///////////////////////////////////////////////////////////////////////////
-
-	void setCurrentVerbosity(Verbosity verbosity) { mCurrentVerbosity = verbosity; }
-	Verbosity getCurrentVerbosity() const { return mCurrentVerbosity; }
-
-	// Messages types below this level will be ignored
-	void setMinVerbosity(Verbosity verbosity)     { mMinVerbosity     = verbosity; }
-	Verbosity getMinVerbosity()     const { return mMinVerbosity; }
-
-	///////////////////////////////////////////////////////////////////////////
-
-protected:
-	Log(MessageType verbosity = DEFAULT_VERBOSITY)
-		: mCurrentVerbosity(LEAST_VERBOSE),
-		mMinVerbosity(verbosity) { }
-
-private:
-	Verbosity mCurrentVerbosity;
-	Verbosity mMinVerbosity;
-	std::vector<std::string> mDeferredMessages;
-};
-
-///////////////////////////////////////////////////////////////////////////
-
-PX_INLINE std::ostream& operator<< (std::ostream& stream, const physx::PxVec3& vec)
-{
-	return stream << "(" << vec.x << ", " << vec.y << ", " << vec.z << ")";
-}
-
-template<typename T>
-Log& Log::log(const T& value, Log::MessageType messageType)
-{
-	if (TYPE_DEFERRED == messageType)
-	{
-		std::stringstream ss;
-		ss << value;
-		mDeferredMessages.push_back(ss.str());
-	}
-	else if(mMinVerbosity <= messageType)
-	{
-		std::cout << value;
-	}
-	return *this;
-}
-
-PX_INLINE Log& lout() { return Log::instance(); }
-
-template <typename T>
-PX_INLINE void fLog(const T& value, Log::MessageType messageType = Log::TYPE_INFO)
-{
-	lout().log<T>(value, messageType);
-}
-template <typename T>
-PX_INLINE Log& operator<<(Log& logger, const T& value)
-{
-	return logger.log<T>(value, logger.getCurrentVerbosity());
-}
-PX_INLINE Log& operator<<(Log& logger, Log::MessageType verbosity)
-{
-	logger.setCurrentVerbosity(verbosity);
-	return logger;
-}
-typedef std::ostream& (*ostream_manipulator)(std::ostream&);
-PX_INLINE Log& operator<<(Log& logger, ostream_manipulator pf)
-{
-	return operator<< <ostream_manipulator> (logger, pf);
-}
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif
+// 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-2018 NVIDIA Corporation. All rights reserved.

+

+

+#ifndef LOG_H

+#define LOG_H

+

+#include "Utils.h"

+#include "PxVec3.h"

+

+#include <sstream>

+

+namespace Nv

+{

+namespace Blast

+{

+

+

+//////////////////////////////////////////////////////////////////////////////

+

+void fLogf(const char* format, ...);

+

+class Log : public Singleton<Log>

+{

+	friend class Singleton<Log>;

+

+public:

+

+	enum MessageType {

+		TYPE_INFO = 0,

+		TYPE_WARNING,

+		TYPE_ERROR,

+		TYPE_DEFERRED,

+

+		NUM_TYPES,

+		MOST_VERBOSE  = TYPE_INFO,

+		LEAST_VERBOSE = TYPE_ERROR

+#if defined(_DEBUG)

+		, DEFAULT_VERBOSITY = MOST_VERBOSE

+#else

+		, DEFAULT_VERBOSITY = LEAST_VERBOSE

+#endif

+	};

+	typedef MessageType Verbosity;

+

+	///////////////////////////////////////////////////////////////////////////

+

+	template<typename T>

+	Log& log(const T& value, MessageType messageType);

+

+	void flushDeferredMessages();

+

+	///////////////////////////////////////////////////////////////////////////

+

+	void setCurrentVerbosity(Verbosity verbosity) { mCurrentVerbosity = verbosity; }

+	Verbosity getCurrentVerbosity() const { return mCurrentVerbosity; }

+

+	// Messages types below this level will be ignored

+	void setMinVerbosity(Verbosity verbosity)     { mMinVerbosity     = verbosity; }

+	Verbosity getMinVerbosity()     const { return mMinVerbosity; }

+

+	///////////////////////////////////////////////////////////////////////////

+

+protected:

+	Log(MessageType verbosity = DEFAULT_VERBOSITY)

+		: mCurrentVerbosity(LEAST_VERBOSE),

+		mMinVerbosity(verbosity) { }

+

+private:

+	Verbosity mCurrentVerbosity;

+	Verbosity mMinVerbosity;

+	std::vector<std::string> mDeferredMessages;

+};

+

+///////////////////////////////////////////////////////////////////////////

+

+PX_INLINE std::ostream& operator<< (std::ostream& stream, const physx::PxVec3& vec)

+{

+	return stream << "(" << vec.x << ", " << vec.y << ", " << vec.z << ")";

+}

+

+template<typename T>

+Log& Log::log(const T& value, Log::MessageType messageType)

+{

+	if (TYPE_DEFERRED == messageType)

+	{

+		std::stringstream ss;

+		ss << value;

+		mDeferredMessages.push_back(ss.str());

+	}

+	else if(mMinVerbosity <= messageType)

+	{

+		std::cout << value;

+	}

+	return *this;

+}

+

+PX_INLINE Log& lout() { return Log::instance(); }

+

+template <typename T>

+PX_INLINE void fLog(const T& value, Log::MessageType messageType = Log::TYPE_INFO)

+{

+	lout().log<T>(value, messageType);

+}

+template <typename T>

+PX_INLINE Log& operator<<(Log& logger, const T& value)

+{

+	return logger.log<T>(value, logger.getCurrentVerbosity());

+}

+PX_INLINE Log& operator<<(Log& logger, Log::MessageType verbosity)

+{

+	logger.setCurrentVerbosity(verbosity);

+	return logger;

+}

+typedef std::ostream& (*ostream_manipulator)(std::ostream&);

+PX_INLINE Log& operator<<(Log& logger, ostream_manipulator pf)

+{

+	return operator<< <ostream_manipulator> (logger, pf);

+}

+

+

+} // namespace Blast

+} // namespace Nv

+

+

+#endif

diff --git a/tools/common/Utils.cpp b/tools/common/Utils.cpp
index d42ed81..8355f48 100644..100755
--- a/tools/common/Utils.cpp
+++ b/tools/common/Utils.cpp
@@ -1,194 +1,194 @@
-// 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-2018 NVIDIA Corporation. All rights reserved.
-
-
-#include "Utils.h"
-
-#include "Log.h"
-
-#include <string.h>
-
-#if PX_WINDOWS_FAMILY
-#include <direct.h>
-#define getCwd _getcwd
-#else
-#include <unistd.h>
-#define getCwd getcwd
-#endif
-
-///////////////////////////////////////////////////////////////////////////
-
-namespace Nv
-{
-namespace Blast
-{
-
-//////////////////////////////////////////////////////////////////////////////
-
-static void addSlashToPath(std::string& path)
-{
-	if (path[path.length() - 1] != '/' && path[path.length() - 1] != '\\')
-	{
-		path.append("/");
-	}
-}
-
-FileUtils::FileUtils()
-{
-	mSearchPaths.push_back("");
-	char currentPathTemp[FILENAME_MAX];
-	if (getCwd(currentPathTemp, sizeof(currentPathTemp)))
-	{
-		std::string currentPath(currentPathTemp);
-		addSlashToPath(currentPath);
-		addAbsolutePath(currentPath);
-		mCurrentPath = currentPath;
-	}
-}
-
-std::string FileUtils::getDirectory(const std::string& filePath)
-{
-	return filePath.substr(0, filePath.find_last_of("/\\") + 1);
-}
-
-std::string FileUtils::getFilename(const std::string& filePath, bool bWithExtension)
-{
-	size_t p0 = filePath.find_last_of("/\\") + 1;
-	if (bWithExtension)
-	{
-		return filePath.substr(p0);
-	}
-	else
-	{
-		return filePath.substr(p0, filePath.find_last_of(".") - p0);
-	}
-}
-
-std::string FileUtils::getFileExtension(const std::string& filePath)
-{
-	std::string filename = getFilename(filePath);
-	size_t p0 = filename.find_last_of(".");
-	if (p0 != std::string::npos)
-		return filePath.substr(p0);// + 1);
-	return "";
-}
-
-void FileUtils::addAbsolutePath(const std::string& path)
-{
-	if (path.empty())
-	{
-		return;
-	}
-
-	std::string newPath = path;
-	addSlashToPath(newPath);
-
-	mSearchPaths.push_back(newPath);
-}
-
-void FileUtils::addRelativePath(const std::string& relPath)
-{
-	addAbsolutePath(mCurrentPath + relPath);
-}
-
-void FileUtils::clearPaths()
-{
-	mSearchPaths.clear();
-}
-
-FILE* FileUtils::findFile(const std::string& path, bool bVerbose)
-{
-	FILE* file;
-	if (find(path, &file, NULL, bVerbose))
-	{
-		return file;
-	}
-	else
-	{
-		return NULL;
-	}
-}
-
-std::string FileUtils::findPath(const std::string& path, bool bVerbose)
-{
-	std::string fullPath;
-	if (find(path, NULL, &fullPath, bVerbose))
-	{
-		return fullPath;
-	}
-	else
-	{
-		return path;
-	}
-}
-
-bool FileUtils::find(const std::string& path, FILE** ppFile, std::string* pFullPath, bool bVerbose)
-{
-	if (mSearchPaths.empty() || path.empty())
-	{
-		if (bVerbose)
-		{
-			lout() << Log::TYPE_ERROR << "Error: Invalid search path configuration.";
-		}
-		return false;
-	}
-
-	std::string fullPath;
-
-	FILE* file = NULL;
-	const uint32_t numSearchPaths = (uint32_t)mSearchPaths.size();
-	for (uint32_t i = 0; i < numSearchPaths; ++i)
-	{
-		fullPath = mSearchPaths[i] + path;
-		fopen_s(&file, fullPath.c_str(), "rb");
-		if (file)
-		{
-			break;
-		}
-	}
-
-	if (!file)
-	{
-		if (bVerbose)
-			lout() << Log::TYPE_ERROR << std::endl << "Error: Unable to find file " << path << std::endl;
-		return false;
-	}
-
-	if (ppFile)
-		*ppFile = file;
-	else
-		fclose(file);
-
-	if (pFullPath)
-		*pFullPath = fullPath;
-
-	return true;
-}
-
-
-} // namespace Blast
-} // namespace Nv
+// 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-2018 NVIDIA Corporation. All rights reserved.

+

+

+#include "Utils.h"

+

+#include "Log.h"

+

+#include <string.h>

+

+#if PX_WINDOWS_FAMILY

+#include <direct.h>

+#define getCwd _getcwd

+#else

+#include <unistd.h>

+#define getCwd getcwd

+#endif

+

+///////////////////////////////////////////////////////////////////////////

+

+namespace Nv

+{

+namespace Blast

+{

+

+//////////////////////////////////////////////////////////////////////////////

+

+static void addSlashToPath(std::string& path)

+{

+	if (path[path.length() - 1] != '/' && path[path.length() - 1] != '\\')

+	{

+		path.append("/");

+	}

+}

+

+FileUtils::FileUtils()

+{

+	mSearchPaths.push_back("");

+	char currentPathTemp[FILENAME_MAX];

+	if (getCwd(currentPathTemp, sizeof(currentPathTemp)))

+	{

+		std::string currentPath(currentPathTemp);

+		addSlashToPath(currentPath);

+		addAbsolutePath(currentPath);

+		mCurrentPath = currentPath;

+	}

+}

+

+std::string FileUtils::getDirectory(const std::string& filePath)

+{

+	return filePath.substr(0, filePath.find_last_of("/\\") + 1);

+}

+

+std::string FileUtils::getFilename(const std::string& filePath, bool bWithExtension)

+{

+	size_t p0 = filePath.find_last_of("/\\") + 1;

+	if (bWithExtension)

+	{

+		return filePath.substr(p0);

+	}

+	else

+	{

+		return filePath.substr(p0, filePath.find_last_of(".") - p0);

+	}

+}

+

+std::string FileUtils::getFileExtension(const std::string& filePath)

+{

+	std::string filename = getFilename(filePath);

+	size_t p0 = filename.find_last_of(".");

+	if (p0 != std::string::npos)

+		return filePath.substr(p0);// + 1);

+	return "";

+}

+

+void FileUtils::addAbsolutePath(const std::string& path)

+{

+	if (path.empty())

+	{

+		return;

+	}

+

+	std::string newPath = path;

+	addSlashToPath(newPath);

+

+	mSearchPaths.push_back(newPath);

+}

+

+void FileUtils::addRelativePath(const std::string& relPath)

+{

+	addAbsolutePath(mCurrentPath + relPath);

+}

+

+void FileUtils::clearPaths()

+{

+	mSearchPaths.clear();

+}

+

+FILE* FileUtils::findFile(const std::string& path, bool bVerbose)

+{

+	FILE* file;

+	if (find(path, &file, NULL, bVerbose))

+	{

+		return file;

+	}

+	else

+	{

+		return NULL;

+	}

+}

+

+std::string FileUtils::findPath(const std::string& path, bool bVerbose)

+{

+	std::string fullPath;

+	if (find(path, NULL, &fullPath, bVerbose))

+	{

+		return fullPath;

+	}

+	else

+	{

+		return path;

+	}

+}

+

+bool FileUtils::find(const std::string& path, FILE** ppFile, std::string* pFullPath, bool bVerbose)

+{

+	if (mSearchPaths.empty() || path.empty())

+	{

+		if (bVerbose)

+		{

+			lout() << Log::TYPE_ERROR << "Error: Invalid search path configuration.";

+		}

+		return false;

+	}

+

+	std::string fullPath;

+

+	FILE* file = NULL;

+	const uint32_t numSearchPaths = (uint32_t)mSearchPaths.size();

+	for (uint32_t i = 0; i < numSearchPaths; ++i)

+	{

+		fullPath = mSearchPaths[i] + path;

+		fopen_s(&file, fullPath.c_str(), "rb");

+		if (file)

+		{

+			break;

+		}

+	}

+

+	if (!file)

+	{

+		if (bVerbose)

+			lout() << Log::TYPE_ERROR << std::endl << "Error: Unable to find file " << path << std::endl;

+		return false;

+	}

+

+	if (ppFile)

+		*ppFile = file;

+	else

+		fclose(file);

+

+	if (pFullPath)

+		*pFullPath = fullPath;

+

+	return true;

+}

+

+

+} // namespace Blast

+} // namespace Nv

diff --git a/tools/common/Utils.h b/tools/common/Utils.h
index 5d01480..8eb3530 100644..100755
--- a/tools/common/Utils.h
+++ b/tools/common/Utils.h
@@ -1,141 +1,141 @@
-// 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-2018 NVIDIA Corporation. All rights reserved.
-
-
-#ifndef UTILS_H
-#define UTILS_H
-
-#include "PsString.h"
-
-#include <string>
-#include <iostream>
-#include <vector>
-#include <map>
-
-//////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////////////////////////
-
-namespace Nv
-{
-namespace Blast
-{
-
-///////////////////////////////////////////////////////////////////////////
-
-template<class T>
-PX_INLINE bool isNull(const T* p) { return nullptr == p; }
-
-template<class Releasable, class Releaser> class ScopedResource;
-template<class Releasable, class Releaser>
-PX_INLINE bool isNull(const ScopedResource<Releasable,Releaser>& p) { return !p; }
-
-PX_INLINE bool isNullString(const char* pString)
-{
-	return (nullptr == pString || pString[0] == '\0' || physx::shdfnd::strcmp(pString, "null") == 0);
-}
-
-template<class T>
-PX_INLINE bool isValid(const T& p) { return !isNull(p.get()); }
-
-PX_INLINE bool isValidString(const char* pString) { return !isNullString(pString); }
-
-///////////////////////////////////////////////////////////////////////////
-
-// Note: This is not a thread safe singleton class
-template <class T>
-class Singleton
-{
-	// The fact that I cannot declare T a friend directly is rather absurd...
-	typedef T Type;
-	friend typename Singleton<T>::Type;
-
-	//////////////////////////////////////////////////////////////////////////////
-
-public:
-	static T& instance()
-	{
-		static T _instance;
-		return _instance;
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-
-private:
-	Singleton() { }
-	~Singleton() { };
-	Singleton(const Singleton&);
-	Singleton& operator=(const Singleton&);
-};
-
-//////////////////////////////////////////////////////////////////////////////
-
-class FileUtils : public Singleton<FileUtils>
-{
-	friend class Singleton<FileUtils>;
-
-public:
-	void        addAbsolutePath(const std::string&);
-	void        addRelativePath(const std::string&);
-	void        clearPaths();
-
-	//////////////////////////////////////////////////////////////////////////////
-
-	FILE*       findFile(const std::string&, bool bVerbose = true);
-	std::string findPath(const std::string&, bool bVerbose = true);
-	bool        find(const std::string&, FILE**, std::string*, bool bVerbose = true);
-
-	//////////////////////////////////////////////////////////////////////////////
-
-	const std::string& getCurrentPath() const
-	{
-		return mCurrentPath;
-	}
-
-	//////////////////////////////////////////////////////////////////////////////
-
-	static std::string getDirectory(const std::string&);
-	static std::string getFilename(const std::string&, bool bWithExtension = true);
-	static std::string getFileExtension(const std::string&);
-
-	//////////////////////////////////////////////////////////////////////////////
-
-protected:
-	FileUtils();
-
-	//////////////////////////////////////////////////////////////////////////////
-
-	std::string              mCurrentPath;
-	std::vector<std::string> mSearchPaths;
-};
-
-
-} // namespace Blast
-} // namespace Nv
-
-
-#endif
+// 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-2018 NVIDIA Corporation. All rights reserved.

+

+

+#ifndef UTILS_H

+#define UTILS_H

+

+#include "PsString.h"

+

+#include <string>

+#include <iostream>

+#include <vector>

+#include <map>

+

+//////////////////////////////////////////////////////////////////////////////

+

+//////////////////////////////////////////////////////////////////////////////

+

+namespace Nv

+{

+namespace Blast

+{

+

+///////////////////////////////////////////////////////////////////////////

+

+template<class T>

+PX_INLINE bool isNull(const T* p) { return nullptr == p; }

+

+template<class Releasable, class Releaser> class ScopedResource;

+template<class Releasable, class Releaser>

+PX_INLINE bool isNull(const ScopedResource<Releasable,Releaser>& p) { return !p; }

+

+PX_INLINE bool isNullString(const char* pString)

+{

+	return (nullptr == pString || pString[0] == '\0' || physx::shdfnd::strcmp(pString, "null") == 0);

+}

+

+template<class T>

+PX_INLINE bool isValid(const T& p) { return !isNull(p.get()); }

+

+PX_INLINE bool isValidString(const char* pString) { return !isNullString(pString); }

+

+///////////////////////////////////////////////////////////////////////////

+

+// Note: This is not a thread safe singleton class

+template <class T>

+class Singleton

+{

+	// The fact that I cannot declare T a friend directly is rather absurd...

+	typedef T Type;

+	friend typename Singleton<T>::Type;

+

+	//////////////////////////////////////////////////////////////////////////////

+

+public:

+	static T& instance()

+	{

+		static T _instance;

+		return _instance;

+	}

+

+	//////////////////////////////////////////////////////////////////////////////

+

+private:

+	Singleton() { }

+	~Singleton() { };

+	Singleton(const Singleton&);

+	Singleton& operator=(const Singleton&);

+};

+

+//////////////////////////////////////////////////////////////////////////////

+

+class FileUtils : public Singleton<FileUtils>

+{

+	friend class Singleton<FileUtils>;

+

+public:

+	void        addAbsolutePath(const std::string&);

+	void        addRelativePath(const std::string&);

+	void        clearPaths();

+

+	//////////////////////////////////////////////////////////////////////////////

+

+	FILE*       findFile(const std::string&, bool bVerbose = true);

+	std::string findPath(const std::string&, bool bVerbose = true);

+	bool        find(const std::string&, FILE**, std::string*, bool bVerbose = true);

+

+	//////////////////////////////////////////////////////////////////////////////

+

+	const std::string& getCurrentPath() const

+	{

+		return mCurrentPath;

+	}

+

+	//////////////////////////////////////////////////////////////////////////////

+

+	static std::string getDirectory(const std::string&);

+	static std::string getFilename(const std::string&, bool bWithExtension = true);

+	static std::string getFileExtension(const std::string&);

+

+	//////////////////////////////////////////////////////////////////////////////

+

+protected:

+	FileUtils();

+

+	//////////////////////////////////////////////////////////////////////////////

+

+	std::string              mCurrentPath;

+	std::vector<std::string> mSearchPaths;

+};

+

+

+} // namespace Blast

+} // namespace Nv

+

+

+#endif