Blast 1.1 release (windows / linux)

see docs/release_notes.txt for details

6 files changed, 457 insertions, 81 deletions

diff --git a/sdk/extensions/serialization/include/NvBlastExtLlSerialization.h b/sdk/extensions/serialization/include/NvBlastExtLlSerialization.h
new file mode 100644
index 0000000..db90a1a
--- /dev/null
+++ b/sdk/extensions/serialization/include/NvBlastExtLlSerialization.h
@@ -0,0 +1,113 @@
+// 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.
+
+
+#pragma once
+
+#include "NvBlastGlobals.h"
+
+
+/**
+Blast Low-level serialization support.  Contains serializers which can be used by the ExtSerialization manager.
+*/
+
+
+// Forward declarations
+struct NvBlastAsset;
+struct NvBlastFamily;
+
+
+namespace Nv
+{
+namespace Blast
+{
+
+// Forward declarations
+class ExtSerialization;
+
+
+/** Standard Object Type IDs */
+struct LlObjectTypeID
+{
+	enum Enum
+	{
+		Asset =		NVBLAST_FOURCC('L', 'L', 'A', 'S'),
+		Family =	NVBLAST_FOURCC('L', 'L', 'F', 'A'),
+	};
+};
+
+}	// namespace Blast
+}	// namespace Nv
+
+
+/**
+Load all low-level serializers into the ExtSerialization manager.  *N.B.* This is done automatically when
+the ExtSerialization manager is created via NvBlastExtSerializationCreate(), so currently this public function
+is unnecessary.  Note also that other modules' serializers (ExtTkSerialization and ExtPxSerialization) are
+_not_ loaded automatically, and need to be explicitly loaded by the user using their respective load functions.
+
+It does no harm to call this function more than once; serializers already loaded will not be loaded again.
+
+\param[in]	serialization	Serialization manager into which to load serializers.
+
+\return the number of serializers loaded.
+*/
+NVBLAST_API	size_t		NvBlastExtLlSerializerLoadSet(Nv::Blast::ExtSerialization& serialization);
+
+
+/**
+Utility wrapper function to serialize an NvBlastAsset.  Allocates the buffer internally using the
+callack set in ExtSerialization::setBufferProvider.
+
+Equivalent to:
+
+	serialization.serializeIntoBuffer(buffer, asset, Nv::Blast::LlObjectTypeID::Asset);
+
+\param[out]	buffer			Pointer to the buffer created.
+\param[in]	serialization	Serialization manager.
+\param[in]	asset			Pointer to the NvBlastAsset to serialize.
+
+\return the number of bytes serialized into the buffer (zero if unsuccessful).
+*/
+NVBLAST_API	uint64_t	NvBlastExtSerializationSerializeAssetIntoBuffer(void*& buffer, Nv::Blast::ExtSerialization& serialization, const NvBlastAsset* asset);
+
+
+/**
+Utility wrapper function to serialize an NvBlastFamily.  Allocates the buffer internally using the
+callack set in ExtSerialization::setBufferProvider.
+
+Equivalent to:
+
+	serialization.serializeIntoBuffer(buffer, family, Nv::Blast::LlObjectTypeID::Family);
+
+\param[out]	buffer			Pointer to the buffer created.
+\param[in]	serialization	Serialization manager.
+\param[in]	family			Pointer to the NvBlastFamily to serialize.
+
+\return the number of bytes serialized into the buffer (zero if unsuccessful).
+*/
+NVBLAST_API	uint64_t	NvBlastExtSerializationSerializeFamilyIntoBuffer(void*& buffer, Nv::Blast::ExtSerialization& serialization, const NvBlastFamily* family);
diff --git a/sdk/extensions/serialization/include/NvBlastExtPxSerialization.h b/sdk/extensions/serialization/include/NvBlastExtPxSerialization.h
new file mode 100644
index 0000000..d3457ab
--- /dev/null
+++ b/sdk/extensions/serialization/include/NvBlastExtPxSerialization.h
@@ -0,0 +1,99 @@
+// 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.
+
+
+#pragma once
+
+#include "NvBlastGlobals.h"
+
+
+/**
+Blast serialization support for the ExtPhysX extension.  Contains serializers which can be used by the ExtSerialization manager.
+*/
+
+
+namespace Nv
+{
+namespace Blast
+{
+
+// Forward declarations
+class TkFramework;
+class ExtSerialization;
+class ExtPxAsset;
+
+
+/** Standard Object Type IDs */
+struct ExtPxObjectTypeID
+{
+	enum Enum
+	{
+		Asset =	NVBLAST_FOURCC('P', 'X', 'A', 'S'),
+	};
+};
+
+}	// namespace Blast
+}	// namespace Nv
+
+
+namespace physx
+{
+
+// Forward declarations
+class PxPhysics;
+class PxCooking;
+
+}	// namespace physx
+
+
+/**
+Load all ExtPhysX extension serializers into the ExtSerialization manager.
+
+It does no harm to call this function more than once; serializers already loaded will not be loaded again.
+
+\param[in]	serialization	Serialization manager into which to load serializers.
+
+\return the number of serializers loaded.
+*/
+NVBLAST_API	size_t		NvBlastExtPxSerializerLoadSet(Nv::Blast::TkFramework& framework, physx::PxPhysics& physics, physx::PxCooking& cooking, Nv::Blast::ExtSerialization& serialization);
+
+
+/**
+Utility wrapper function to serialize an ExtPxAsset.  Allocates the buffer internally using the
+callack set in ExtSerialization::setBufferProvider.
+
+Equivalent to:
+
+	serialization.serializeIntoBuffer(buffer, asset, Nv::Blast::ExtPxObjectTypeID::Asset);
+
+\param[out]	buffer			Pointer to the buffer created.
+\param[in]	serialization	Serialization manager.
+\param[in]	asset			Pointer to the ExtPxAsset to serialize.
+
+\return the number of bytes serialized into the buffer (zero if unsuccessful).
+*/
+NVBLAST_API	uint64_t	NvBlastExtSerializationSerializeExtPxAssetIntoBuffer(void*& buffer, Nv::Blast::ExtSerialization& serialization, const Nv::Blast::ExtPxAsset* asset);
diff --git a/sdk/extensions/serialization/include/NvBlastExtSerialization.h b/sdk/extensions/serialization/include/NvBlastExtSerialization.h
new file mode 100644
index 0000000..4225625
--- /dev/null
+++ b/sdk/extensions/serialization/include/NvBlastExtSerialization.h
@@ -0,0 +1,156 @@
+// 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.
+
+
+#pragma once
+
+#include "NvBlastGlobals.h"
+
+
+namespace Nv
+{
+namespace Blast
+{
+
+/**
+	Serialization manager interface
+*/
+class ExtSerialization
+{
+public:
+	/** Standard Encoding IDs */
+	struct EncodingID
+	{
+		enum Enum
+		{
+			CapnProtoBinary =	NVBLAST_FOURCC('C', 'P', 'N', 'B'),
+			RawBinary =			NVBLAST_FOURCC('R', 'A', 'W', ' '),
+		};
+	};
+
+	/** Buffer provider API, used to request a buffer for serialization. */
+	class BufferProvider
+	{
+	public:
+		virtual void*	requestBuffer(size_t size) = 0;
+	};
+
+	/**
+	Set the serialization encoding to use.  (See EncodingID.)
+
+	\return true iff successful.
+	*/
+	virtual bool		setSerializationEncoding(uint32_t encodingID) = 0;
+
+	/**
+	Retrieve the current serialization encoding being used.  Note, by default this is set to the encoding of the first
+	serializer registered by a module.  Currently this is done automatically by the NvBlastExtLlExtension module.
+
+	\return the current serialization encoding (zero if none is set).
+	*/
+	virtual uint32_t	getSerializationEncoding() const = 0;
+
+	/**
+	Set the buffer provider callback to use.  (See BufferProvider.)  If not set, a default provider using NVBLAST_ALLOC (see
+	NvBlastGlobals.h) is used, which may be freed using NvBLAST_FREE.
+
+	\param[in]	bufferProvider	Buffer provider callback to use.  If NULL, uses the default provider using the allocator given
+	in NvBlastGlobals.	
+	*/
+	virtual void		setBufferProvider(BufferProvider* bufferProvider) = 0;
+
+	/**
+	Reads information from a buffer, returning the contained object type ID, encoding ID, and data size.
+	\param[out]	objectTypeID	If not NULL, the object type ID is written to *objectTypeID.
+	\param[out]	encodingID		If not NULL, the encoding ID is written to *encodingID.
+	\param[out]	dataSize		If not NULL, the data size is written to *dataSize.  (Does not include the size of the header.)
+	\param[in]	buffer			Pointer to the buffer to read.
+	\param[in]	bufferSize		Size of the buffer to read.
+
+	\return true iff the header is successfully read.
+	*/
+	virtual bool		peekHeader(uint32_t* objectTypeID, uint32_t* encodingID, uint64_t* dataSize, const void* buffer, uint64_t bufferSize) = 0;
+
+	/**
+	Determines the current object in the buffer and returns the position in the buffer immediately after the object.
+
+	\param[in, out] bufferSize	Size of the buffer to read on input, on output the remaining buffer size given the return buffer value.
+	\param[in] buffer			Pointer to the buffer to read.
+
+	\return a pointer to the new position in the buffer after the skipped object if successful, NULL otherwise.  The bufferSize field is only updated if a valid pointer is returned.
+	*/
+	virtual const void*	skipObject(uint64_t& bufferSize, const void* buffer) = 0;
+
+	/**
+	Deserialize from a buffer into a newly allocated object.
+
+	\param[in]	buffer			Pointer to the buffer to read.
+	\param[in]	bufferSize		Size of the buffer to read.
+	\param[out]	objectTypeIDPtr	Optional, if not NULL then *objectTypeIDPtr will be filled with the deserialized object's
+								type ID if deserialization is successful, or 0 if unsuccessful.
+
+	\return object pointer; returns null if failed to deserialize.
+	*/
+	virtual void*		deserializeFromBuffer(const void* buffer, uint64_t bufferSize, uint32_t* objectTypeIDPtr = nullptr) = 0;
+
+	/**
+	Serialize into a buffer.  Allocates the buffer internally using the callack set in setBufferProvider.
+
+	\param[out]	buffer			Pointer to the buffer created.
+	\param[in]	object			Object pointer.
+	\param[in]	objectTypeID	Object type ID.
+
+	\return the number of bytes serialized into the buffer (zero if unsuccessful).
+	*/
+	virtual uint64_t	serializeIntoBuffer(void*& buffer, const void* object, uint32_t objectTypeID) = 0;
+
+	/**
+	Release the serialization manager and all contained objects.
+	*/
+	virtual void		release() = 0;
+
+protected:
+	/**
+	Destructor is virtual and not public - use the release() method instead of explicitly deleting the serialization manager
+	*/
+	virtual				~ExtSerialization() {}
+};
+
+}	// namespace Blast
+}	// namespace Nv
+
+
+//////// Global API to create serialization ////////
+
+/**
+Create a new serialization manager.  To release it, use its release() method.
+
+This uses the global allocator set in NvBlastGlobals.h.
+
+\return a new serialization manager.
+*/
+NVBLAST_API Nv::Blast::ExtSerialization*	NvBlastExtSerializationCreate();
diff --git a/sdk/extensions/serialization/include/NvBlastExtSerializationInterface.h b/sdk/extensions/serialization/include/NvBlastExtSerializationInterface.h
deleted file mode 100644
index e4f27e0..0000000
--- a/sdk/extensions/serialization/include/NvBlastExtSerializationInterface.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, 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.
-*/
-
-/*
-	Include this file to get the C interface to serialization for all asset types (LL, Tk and Ext)
-*/
-#pragma once
-#include <ostream>
-#include "NvBlastTkAsset.h"
-#include "NvBlastExtPxAsset.h"
-
-#include "NvBlastExtSerializationLLInterface.h"
-
-namespace physx
-{
-	class PxPhysics;
-}
-
-NVBLAST_API void setPhysXSDK(physx::PxPhysics* physXSDK);
-
-NVBLAST_API Nv::Blast::TkAsset* deserializeTkAsset(const unsigned char* input, uint32_t size);
-NVBLAST_API Nv::Blast::TkAsset* deserializeTkAssetFromStream(std::istream &inputStream);
-NVBLAST_API bool serializeTkAssetIntoStream(const Nv::Blast::TkAsset *asset, std::ostream &outputStream);
-NVBLAST_API bool serializeTkAssetIntoNewBuffer(const Nv::Blast::TkAsset *asset, unsigned char **outBuffer, uint32_t &outSize);
-NVBLAST_API bool serializeTkAssetIntoExistingBuffer(const Nv::Blast::TkAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize);
-
-NVBLAST_API Nv::Blast::ExtPxAsset* deserializeExtPxAsset(const unsigned char* input, uint32_t size);
-NVBLAST_API Nv::Blast::ExtPxAsset* deserializeExtPxAssetFromStream(std::istream &inputStream);
-NVBLAST_API bool serializeExtPxAssetIntoStream(const Nv::Blast::ExtPxAsset *asset, std::ostream &outputStream);
-NVBLAST_API bool serializeExtPxAssetIntoNewBuffer(const Nv::Blast::ExtPxAsset *asset, unsigned char **outBuffer, uint32_t &outSize);
-NVBLAST_API bool serializeExtPxAssetIntoExistingBuffer(const Nv::Blast::ExtPxAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize);
diff --git a/sdk/extensions/serialization/include/NvBlastExtSerializationLLInterface.h b/sdk/extensions/serialization/include/NvBlastExtSerializationLLInterface.h
deleted file mode 100644
index d21c7ca..0000000
--- a/sdk/extensions/serialization/include/NvBlastExtSerializationLLInterface.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
-* Copyright (c) 2017, NVIDIA CORPORATION.  All rights reserved.
-*
-* NVIDIA CORPORATION and its licensors retain all intellectual property
-* and proprietary rights in and to this software, 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.
-*/
-
-/*
-Include this file to access the C API for serialization, for Low Level assets only.
-
-For Serialization of Tk and Ext assets, include only NvBlastExtSerializationInterface.h, which will include this file as well.
-
-*/
-#pragma once
-#include <ostream>
-#include "NvBlastPreprocessor.h"
-#include "NvBlastTypes.h"
-
-#include "NvBlastExtGlobals.h"
-
-/*
-	Set a global NvBlastAlloc signature allocation function that the deserialization will use when required.
-
-	NOTE: This will NOT be used when using the combined serialization library, as it will use the TkFramework's allocation and logging
-*/
-NVBLAST_API void setAllocator(NvBlastExtAlloc alloc);
-
-/*
-	Set a global NvBlastLog signature allocation function that the library will use when required.
-
-	NOTE: This will NOT be used when using the combined serialization library, as it will use the TkFramework's allocation and logging
-*/
-NVBLAST_API void setLog(NvBlastLog log);
-
-
-NVBLAST_API NvBlastAsset* deserializeAsset(const unsigned char* input, uint32_t size);
-NVBLAST_API NvBlastAsset* deserializeAssetFromStream(std::istream &inputStream);
-NVBLAST_API bool serializeAssetIntoStream(const NvBlastAsset *asset, std::ostream &outputStream);
-NVBLAST_API bool serializeAssetIntoNewBuffer(const NvBlastAsset *asset, unsigned char **outBuffer, uint32_t &outSize);
-NVBLAST_API bool serializeAssetIntoExistingBuffer(const NvBlastAsset *asset, unsigned char *buffer, uint32_t maxSize, uint32_t &usedSize);
diff --git a/sdk/extensions/serialization/include/NvBlastExtTkSerialization.h b/sdk/extensions/serialization/include/NvBlastExtTkSerialization.h
new file mode 100644
index 0000000..2db4f4f
--- /dev/null
+++ b/sdk/extensions/serialization/include/NvBlastExtTkSerialization.h
@@ -0,0 +1,89 @@
+// 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.
+
+
+#pragma once
+
+#include "NvBlastGlobals.h"
+
+
+/**
+Blast High-level serialization support.  Contains serializers which can be used by the ExtSerialization manager.
+*/
+
+
+namespace Nv
+{
+namespace Blast
+{
+
+// Forward declarations
+class ExtSerialization;
+class TkFramework;
+class TkAsset;
+
+
+/** Standard Object Type IDs */
+struct TkObjectTypeID
+{
+	enum Enum
+	{
+		Asset =	NVBLAST_FOURCC('T', 'K', 'A', 'S'),
+	};
+};
+
+}	// namespace Blast
+}	// namespace Nv
+
+
+/**
+Load all high-level serializers into the ExtSerialization manager.
+
+It does no harm to call this function more than once; serializers already loaded will not be loaded again.
+
+\param[in]	serialization	Serialization manager into which to load serializers.
+
+\return the number of serializers loaded.
+*/
+NVBLAST_API	size_t		NvBlastExtTkSerializerLoadSet(Nv::Blast::TkFramework& framework, Nv::Blast::ExtSerialization& serialization);
+
+
+/**
+Utility wrapper function to serialize a TkAsset.  Allocates the buffer internally using the
+callack set in ExtSerialization::setBufferProvider.
+
+Equivalent to:
+
+	serialization.serializeIntoBuffer(buffer, asset, Nv::Blast::TkObjectTypeID::Asset);
+
+\param[out]	buffer			Pointer to the buffer created.
+\param[in]	serialization	Serialization manager.
+\param[in]	asset			Pointer to the TkAsset to serialize.
+
+\return the number of bytes serialized into the buffer (zero if unsuccessful).
+*/
+NVBLAST_API	uint64_t	NvBlastExtSerializationSerializeTkAssetIntoBuffer(void*& buffer, Nv::Blast::ExtSerialization& serialization, const Nv::Blast::TkAsset* asset);